fw/icE1usb: Import firmware for the icE1usb and icE1usb-proto boards
Currently only the icE1usb-proto is supported. Adaptation for the
final production hardware is yet to be done.
Signed-off-by: Sylvain Munaut <tnt@246tNt.com>
diff --git a/firmware/ice40-riscv/icE1usb/usb_e1.c b/firmware/ice40-riscv/icE1usb/usb_e1.c
new file mode 100644
index 0000000..52fb53b
--- /dev/null
+++ b/firmware/ice40-riscv/icE1usb/usb_e1.c
@@ -0,0 +1,264 @@
+/*
+ * usb_e1.c
+ *
+ * Copyright (C) 2019-2020 Sylvain Munaut <tnt@246tNt.com>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include <no2usb/usb_hw.h>
+#include <no2usb/usb_priv.h>
+
+#include "console.h"
+#include "misc.h"
+
+struct {
+ bool running;
+ int out_bdi;
+ int in_bdi;
+} g_usb_e1;
+
+
+/* Hack */
+unsigned int e1_rx_need_data(unsigned int usb_addr, unsigned int max_len);
+unsigned int e1_tx_feed_data(unsigned int usb_addr, unsigned int len);
+unsigned int e1_tx_level(void);
+unsigned int e1_rx_level(void);
+/* ---- */
+
+bool
+usb_ep_boot(const struct usb_intf_desc *intf, uint8_t ep_addr, bool dual_bd);
+
+static void
+_usb_fill_feedback_ep(void)
+{
+ static uint16_t ticks_prev = 0;
+ uint16_t ticks;
+ uint32_t val = 8192;
+ unsigned int level;
+
+ /* Compute real E1 tick count (with safety agains bad values) */
+ ticks = e1_tick_read();
+ val = (ticks - ticks_prev) & 0xffff;
+ ticks_prev = ticks;
+ if ((val < 7168) | (val > 9216))
+ val = 8192;
+
+ /* Bias depending on TX fifo level */
+ level = e1_tx_level();
+ if (level < (3 * 16))
+ val += 256;
+ else if (level > (8 * 16))
+ val -= 256;
+
+ /* Prepare buffer */
+ usb_data_write(64, &val, 4);
+ usb_ep_regs[1].in.bd[0].ptr = 64;
+ usb_ep_regs[1].in.bd[0].csr = USB_BD_STATE_RDY_DATA | USB_BD_LEN(3);
+}
+
+
+void
+usb_e1_run(void)
+{
+ int bdi;
+
+ if (!g_usb_e1.running)
+ return;
+
+ /* EP2 IN */
+ bdi = g_usb_e1.in_bdi;
+
+ while ((usb_ep_regs[2].in.bd[bdi].csr & USB_BD_STATE_MSK) != USB_BD_STATE_RDY_DATA)
+ {
+ uint32_t ptr = usb_ep_regs[2].in.bd[bdi].ptr;
+ uint32_t hdr;
+
+ /* Error check */
+ if ((usb_ep_regs[2].in.bd[bdi].csr & USB_BD_STATE_MSK) == USB_BD_STATE_DONE_ERR)
+ puts("Err EP2 IN\n");
+
+ /* Get some data from E1 */
+ int n = e1_rx_level();
+
+ if (n > 64)
+ n = 12;
+ else if (n > 32)
+ n = 10;
+ else if (n > 8)
+ n = 8;
+ else if (!n)
+ break;
+
+ n = e1_rx_need_data((ptr >> 2) + 1, n);
+
+ /* Write header */
+ hdr = 0x616b00b5;
+ usb_data_write(ptr, &hdr, 4);
+
+ /* Resubmit */
+ usb_ep_regs[2].in.bd[bdi].csr = USB_BD_STATE_RDY_DATA | USB_BD_LEN((n * 32) + 4);
+
+ /* Next BDI */
+ bdi ^= 1;
+ g_usb_e1.in_bdi = bdi;
+ }
+
+ /* EP1 OUT */
+ bdi = g_usb_e1.out_bdi;
+
+ while ((usb_ep_regs[1].out.bd[bdi].csr & USB_BD_STATE_MSK) != USB_BD_STATE_RDY_DATA)
+ {
+ uint32_t ptr = usb_ep_regs[1].out.bd[bdi].ptr;
+ uint32_t csr = usb_ep_regs[1].out.bd[bdi].csr;
+ uint32_t hdr;
+
+ /* Error check */
+ if ((csr & USB_BD_STATE_MSK) == USB_BD_STATE_DONE_ERR) {
+ puts("Err EP1 OUT\n");
+ goto refill;
+ }
+
+ /* Grab header */
+ usb_data_read(&hdr, ptr, 4);
+
+ /* Empty data into the FIFO */
+ int n = ((csr & USB_BD_LEN_MSK) - 4) / 32;
+ n = e1_tx_feed_data((ptr >> 2) + 1, n);
+
+refill:
+ /* Refill it */
+ usb_ep_regs[1].out.bd[bdi].csr = USB_BD_STATE_RDY_DATA | USB_BD_LEN(388);
+
+ /* Next BDI */
+ bdi ^= 1;
+ g_usb_e1.out_bdi = bdi;
+
+ static int x = 0;
+ if ((x++ & 0xff) == 0xff)
+ puts(".");
+ }
+
+ /* EP1 IN */
+ if ((usb_ep_regs[1].in.bd[0].csr & USB_BD_STATE_MSK) != USB_BD_STATE_RDY_DATA)
+ {
+ _usb_fill_feedback_ep();
+ }
+}
+
+static const struct usb_intf_desc *
+_find_intf(const struct usb_conf_desc *conf, uint8_t idx)
+{
+ const struct usb_intf_desc *intf = NULL;
+ const void *sod, *eod;
+
+ if (!conf)
+ return NULL;
+
+ sod = conf;
+ eod = sod + conf->wTotalLength;
+
+ while (1) {
+ sod = usb_desc_find(sod, eod, USB_DT_INTF);
+ if (!sod)
+ break;
+
+ intf = (void*)sod;
+ if (intf->bInterfaceNumber == idx)
+ return intf;
+
+ sod = usb_desc_next(sod);
+ }
+
+ return NULL;
+}
+enum usb_fnd_resp
+_e1_set_conf(const struct usb_conf_desc *conf)
+{
+ const struct usb_intf_desc *intf;
+
+ printf("e1 set_conf %08x\n", conf);
+ if (!conf)
+ return USB_FND_SUCCESS;
+
+ intf = _find_intf(conf, 0);
+ if (!intf)
+ return USB_FND_ERROR;
+
+ printf("e1 set_conf %08x\n", intf);
+
+ usb_ep_boot(intf, 0x01, true);
+ usb_ep_boot(intf, 0x81, true);
+ usb_ep_boot(intf, 0x82, true);
+
+ return USB_FND_SUCCESS;
+}
+
+enum usb_fnd_resp
+_e1_set_intf(const struct usb_intf_desc *base, const struct usb_intf_desc *sel)
+{
+ if (base->bInterfaceNumber != 0)
+ return USB_FND_CONTINUE;
+
+ if (sel->bAlternateSetting != 1)
+ return USB_FND_SUCCESS;
+
+ /* Hack to avoid re-setting while running ... avoid BD desync */
+ if (g_usb_e1.running)
+ return USB_FND_SUCCESS;
+
+ g_usb_e1.running = true;
+
+ /* Configure EP1 OUT / EP2 IN */
+ usb_ep_regs[1].out.status = USB_EP_TYPE_ISOC | USB_EP_BD_DUAL; /* Type=Isochronous, dual buffered */
+ usb_ep_regs[2].in.status = USB_EP_TYPE_ISOC | USB_EP_BD_DUAL; /* Type=Isochronous, dual buffered */
+
+ /* Configure EP1 IN (feedback) */
+ usb_ep_regs[1].in.status = USB_EP_TYPE_ISOC; /* Type=Isochronous, single buffered */
+
+ /* EP2 IN: Prepare two buffers */
+ usb_ep_regs[2].in.bd[0].ptr = 1024;
+ usb_ep_regs[2].in.bd[0].csr = 0;
+
+ usb_ep_regs[2].in.bd[1].ptr = 1536;
+ usb_ep_regs[2].in.bd[1].csr = 0;
+
+ /* EP1 OUT: Queue two buffers */
+ usb_ep_regs[1].out.bd[0].ptr = 1024;
+ usb_ep_regs[1].out.bd[0].csr = USB_BD_STATE_RDY_DATA | USB_BD_LEN(388);
+
+ usb_ep_regs[1].out.bd[1].ptr = 1536;
+ usb_ep_regs[1].out.bd[1].csr = USB_BD_STATE_RDY_DATA | USB_BD_LEN(388);
+
+ /* EP1 IN: Queue buffer */
+ _usb_fill_feedback_ep();
+
+ return USB_FND_SUCCESS;
+}
+
+enum usb_fnd_resp
+_e1_get_intf(const struct usb_intf_desc *base, uint8_t *alt)
+{
+ if (base->bInterfaceNumber != 0)
+ return USB_FND_CONTINUE;
+
+ *alt = g_usb_e1.running ? 1 : 0;
+
+ return USB_FND_SUCCESS;
+}
+
+static struct usb_fn_drv _e1_drv = {
+ .set_conf = _e1_set_conf,
+ .set_intf = _e1_set_intf,
+ .get_intf = _e1_get_intf,
+};
+
+void
+usb_e1_init(void)
+{
+ memset(&g_usb_e1, 0x00, sizeof(g_usb_e1));
+ usb_register_function_driver(&_e1_drv);
+}