// vim: set et: #include #include "tusb.h" #include "protocfg.h" #ifdef DBOARD_HAS_SERPROG #include "protos.h" #include "thread.h" #include "rtconf.h" #include "serprog.h" // TODO: refactor some of this stuff into another header & split off serprog // protocol handling from the SPI stuff. one thing we should think about // when performing this refactor is, would other boards support // parallell, LPC, or FWH, or only SPI? if only SPI, the entire proto // handler can just be made reusable verbatim. // kinda refactored this already but it still has a good note for non-SPI stuff, // so leaving it here for now static const uint8_t serprog_cmdmap[32] = { 0x3f, // cmd 00..05 not 0x06 (Q_CHIPSIZE) and 0x07 (Q_OPBUF), as this is a SPI-only device 0x01, // only cmd 08 0x1f, // cmd 10..15 supported 0, // 18..1f 0, // 20..27 0, // 28..2f 0, // 30..37 0, // 38..3f 0, // 40..47 0, // 48..4f (1<<3), // 50..57: enable 0x53 0, // 58..5f 0, // rest is 0 }; static const char serprog_pgmname[16] = { 'D','a','p','p','e','r','M','i','m','e','-','J','T','A','G',0 // TODO }; static uint8_t rx_buf[CFG_TUD_CDC_RX_BUFSIZE]; static uint8_t tx_buf[CFG_TUD_CDC_TX_BUFSIZE]; static uint32_t rxavail, rxpos; void cdc_serprog_init(void) { rxavail = 0; rxpos = 0; sp_spi_init(); } static uint8_t read_byte(void) { while (rxavail <= 0) { if (!tud_cdc_n_connected(CDC_N_SERPROG) || !tud_cdc_n_available(CDC_N_SERPROG)) { thread_yield(); continue; } rxpos = 0; rxavail = tud_cdc_n_read(CDC_N_SERPROG, rx_buf, sizeof rx_buf); if (rxavail == 0) thread_yield(); } uint8_t rv = rx_buf[rxpos]; ++rxpos; --rxavail; //printf("r %02x\n",rv); return rv; } static void handle_cmd(void) { uint32_t nresp = 0; uint8_t cmd = read_byte(); switch (cmd) { case S_CMD_NOP: //printf("nop\n"); tx_buf[0] = S_ACK; nresp = 1; break; case S_CMD_SYNCNOP: //printf("snop\n"); tx_buf[0] = S_NAK; tx_buf[1] = S_ACK; nresp = 2; break; case S_CMD_Q_IFACE: //printf("q_if\n"); tx_buf[0] = S_ACK; tx_buf[1] = SERPROG_IFACE_VERSION & 0xff; tx_buf[2] = (SERPROG_IFACE_VERSION >> 8) & 0xff; nresp = 3; break; case S_CMD_Q_CMDMAP: //printf("q_cmap\n"); tx_buf[0] = S_ACK; memcpy(&tx_buf[1], serprog_cmdmap, sizeof serprog_cmdmap); nresp = sizeof(serprog_cmdmap) + 1; break; case S_CMD_Q_PGMNAME: //printf("q_pgm\n"); tx_buf[0] = S_ACK; memcpy(&tx_buf[1], serprog_pgmname, sizeof serprog_pgmname); nresp = sizeof(serprog_pgmname) + 1; break; case S_CMD_Q_SERBUF: //printf("q_sbuf\n"); tx_buf[0] = S_ACK; tx_buf[1] = sizeof(rx_buf) & 0xff; tx_buf[2] = (sizeof(rx_buf) >> 8) & 0xff; nresp = 3; break; case S_CMD_Q_BUSTYPE: //printf("q_btyp\n"); tx_buf[0] = S_ACK; tx_buf[1] = 1<<3; // SPI only nresp = 2; break; case S_CMD_Q_WRNMAXLEN: //printf("q_wlen\n"); tx_buf[0] = S_ACK; tx_buf[1] = (sizeof(tx_buf)-1) & 0xff; tx_buf[2] = ((sizeof(tx_buf)-1) >> 8) & 0xff; tx_buf[3] = ((sizeof(tx_buf)-1) >>16) & 0xff; nresp = 4; break; case S_CMD_Q_RDNMAXLEN: //printf("q_rlen\n"); tx_buf[0] = S_ACK; tx_buf[1] = (sizeof(rx_buf)-1) & 0xff; tx_buf[2] = ((sizeof(rx_buf)-1) >> 8) & 0xff; tx_buf[3] = ((sizeof(rx_buf)-1) >>16) & 0xff; nresp = 4; break; case S_CMD_S_BUSTYPE: //printf("s_btyp\n"); if (read_byte()/* bus type to set */ == (1<<3)) { tx_buf[0] = S_ACK; } else { tx_buf[0] = S_NAK; } nresp = 1; break; case S_CMD_SPIOP: { //printf("spiop\n"); uint32_t slen, rlen; slen = (uint32_t)read_byte(); slen |= (uint32_t)read_byte() << 8; slen |= (uint32_t)read_byte() << 16; rlen = (uint32_t)read_byte(); rlen |= (uint32_t)read_byte() << 8; rlen |= (uint32_t)read_byte() << 16; sp_spi_op_begin(); size_t this_batch; // 1. write slen data bytes // we're going to use the tx buf for all operations here while (slen > 0) { this_batch = sizeof(tx_buf); if (this_batch > slen) this_batch = slen; for (size_t i = 0; i < this_batch; ++i) tx_buf[i] = read_byte(); sp_spi_op_write(this_batch, tx_buf); slen -= this_batch; } // 2. write data // first, do a batch of 63, because we also need to send an ACK byte this_batch = sizeof(tx_buf)-1; if (this_batch > rlen) this_batch = rlen; sp_spi_op_read(this_batch, &tx_buf[1]); tx_buf[0] = S_ACK; tud_cdc_n_write(CDC_N_SERPROG, tx_buf, this_batch+1); rlen -= this_batch; // now do in batches of 64 while (rlen > 0) { this_batch = sizeof(tx_buf); if (this_batch > rlen) this_batch = rlen; sp_spi_op_read(this_batch, tx_buf); tud_cdc_n_write(CDC_N_SERPROG, tx_buf, this_batch); rlen -= this_batch; } tud_cdc_n_write_flush(CDC_N_SERPROG); // that's it! sp_spi_op_end(); nresp = 0; // we sent our own response manually } break; case S_CMD_S_SPI_FREQ: { //printf("s_spi_freq\n"); uint32_t freq; freq = (uint32_t)read_byte(); freq |= (uint32_t)read_byte() << 8; freq |= (uint32_t)read_byte() << 16; freq |= (uint32_t)read_byte() << 24; uint32_t nfreq = sp_spi_set_freq(freq); tx_buf[0] = S_ACK; tx_buf[1] = nfreq & 0xff; tx_buf[2] = (nfreq >> 8) & 0xff; tx_buf[3] = (nfreq >> 16) & 0xff; tx_buf[4] = (nfreq >> 24) & 0xff; nresp = 5; } break; case S_CMD_S_PINSTATE: { //printf("s_pins\n"); if (read_byte() == 0) sp_spi_cs_deselect(); else sp_spi_cs_select(); tx_buf[0] = S_ACK; nresp = 1; } break; case S_CMD_MAGIC_SETTINGS: { uint8_t a = read_byte(); uint8_t b = read_byte(); tx_buf[0] = S_ACK; tx_buf[1] = rtconf_do(a, b); nresp = 2; } break; default: //printf("ill %d\n", cmd); tx_buf[0] = S_NAK; nresp = 1; break; } if (nresp > 0) { tud_cdc_n_write(CDC_N_SERPROG, tx_buf, nresp); tud_cdc_n_write_flush(CDC_N_SERPROG); } } void cdc_serprog_task(void) { handle_cmd(); //printf("d\n"); } #endif /* DBOARD_HAS_SERPROG */