From 84e276f7127177c38f9411a420110ba7d4760ad7 Mon Sep 17 00:00:00 2001 From: bunnie Date: Sat, 24 Jan 2026 23:55:22 +0800 Subject: [PATCH] add BIO sketch for qspi to 8080 converter quick feasibility study to confirm that BIO can convert a QSPI video stream into 8080-style display stream support. One of those quirky weird applications that I think BIO is kind of perfect for. I think it should work, at the speeds required, but nothing compares to actual hardware testing. --- libs/bio-lib/src/qspi_to_8080.rs | 141 +++++++++++++++++++++++++++++++ 1 file changed, 141 insertions(+) create mode 100644 libs/bio-lib/src/qspi_to_8080.rs diff --git a/libs/bio-lib/src/qspi_to_8080.rs b/libs/bio-lib/src/qspi_to_8080.rs new file mode 100644 index 000000000..bfa6ff3bb --- /dev/null +++ b/libs/bio-lib/src/qspi_to_8080.rs @@ -0,0 +1,141 @@ +/// Notional sketch code that can take a QSPI data stream and turn it into 8080 panel data +/// +/// The goal is to run a 320x320 panel at 16bpp and 60fps +/// +/// The architecture is as follows: +/// +/// - BIO core0 is the core Rx loop from SPI. There is some placeholder code for the 1-bit SPI stuff +/// that happens before QSPI mode, and it's assumed we don't have to understand it or do anything +/// with it. Once we hit QSPI mode, the loop waits for a value to come in on FIFO1 (x17) and every +/// time a value arrives there it shifts the incoming 4-bit data into an 8-bit packet, which it shoves +/// into FIFO0 (x16). It also checks if x17 is non-zero; if it is not 0, it exits the loop so you can +/// go back to the 1-bit SPI mode at the start of next frame +/// - BIO core1 generates the synchronization for cores 0 and 3 from the clock stream. It's configured +/// to trigger off of the rising clock edge on the incoming SPI bus. Every clock edge, it puts a zero +/// into x17 (FIFO1), and every two edges, it puts a zero into x18 (FIFO2). These zero-values synchronize +/// the Tx and Rx sides. +/// - BIO core2 interprets the CS line. It fully asynchronously just watches the CS line. It waits for +/// the line to go high, then low, and then once it goes high again, it sticks a *non-zero* value into +/// x17/x18. This takes advantage of the fact that you can multiple writes to every FIFO. So during +/// data transmission, the clock pules causes 0's to be shoved into x17/x18, and on the rising edge +/// of CS, a non-zero value is put into x17/x18, allowing for loop termination. +/// - BIO core3 transmits the 8080 data. There is a placeholder where data is expected to arrive +/// on x18 (FIFO2 - maybe we could use a different fifo for this?) from the *host*. This initial +/// data is currently ignored but notionally this could be commands destined for the panel to set +/// up its registers. Once this phase is done, it enters a loop where first it automatically sends +/// the "write burst" command, and then goes into data mode. In data mode it grabs data from FIFO0 (x16) +/// and blasts it to the 8080, toggling the write pulse every time, and then checking for the termination +/// condition on x18. Once it terminates, it goes back to the top of the loop where depending on the +/// host considerations we could code it to automatically arm for another frame, or we could wait +/// until the host initiates another transfer. +/// +/// This is estimated to meet timing (but just barely) at 700MHz BIO speeds. If we're missing timing by a hair, +/// we could set the clock to 800MHz on the BIO core, as the core should overclock pretty well. + +#[rustfmt::skip] +bio_code!(qspi_rx, QSPI_RX_START, QSPI_RX_END, + // core is configured to clock off of rising edge on SPI clk + "li x1, 0xF", // this loads the GPIO mask +"1:", + "stuff", // do stuff that handles the single-bit SPI stuff. Assuming we can ignore the contents +"10:", + "mv x8, x17", // x17 is a cleaned-up version of CS coming from a BIO that does that exclusively + "bne x8, x0, 20f", // exit the loop if CS != 0 + "mv x2, x21", // read the GPIO + "and x3, x2, x1", // mask out unused bits and put in x3 + "slli x3, x3, 4", // shift into place + + "mv x8, x17", // x17 is a cleaned-up version of CS coming from a BIO that does that exclusively + "bne x8, x0, 20f", // exit the loop if CS != 0 + "mv x2, x21", // read the GPIO + "and x4, x2, x1", // mask out unused bits + "or x3, x3, x4", // combine bits + "mv x16, x3", // send byte to FIFO + "j 10b" // loop + // 9 arith + 1 loop = 9 * 4 + 1 * 5 = 34 MHz rate (17 MHz per two edges) + // max time between edges = 5 arith + 1 loop = 5 * 4 + 1 * 5 = 28 MHz max edge rate +"20:", + "cleanup" // cleanup code +); + +/// This core generates the reads off of clock edge +#[rustfmt::skip] +bio_code!(qspi_clocker, QSPI_CLK_START, QSPI_CLK_END, + // core is configured to clock off of rising edge on SPI clk +"10:", + "mv x20, x0", // wait for clock edge + "mv x17, x0", // send a 0 into the spi CS fifo to initiate read + "mv x20, x0", // wait for clock edge + "mv x17, x0", // send a 0 into the spi CS fifo to initiate read + "mv x18, x0", // send a 0 into 8080 CS fifo to continue writes + "j 10b" +); + +/// This core generates the chip select termination pulse +#[rustfmt::skip] +bio_code!(qspi_cs, QSPI_CS_START, QSPI_CS_END, + "li x1, 0x10", // notional chip select on bit 4 +"10:", + "mv x2, x21", // read GPIO + "and x3, x2, x1", // mask out the CS line + "bne x3, x0, 20f", // wait for high + "j 10b", +"20:", // initial high found + "mv x2, x21", // read GPIO + "and x3, x2, x1", // mask out the CS line + "beq x3, x0, 30f", // wait for low + "j 20b", +"30:", // now the CS is low, wait for it to go high + "mv x2, x21", // read GPIO + "and x3, x2, x1", // mask out the CS line + "bne x3, x0, 30f", // wait for high + "mv x17, x1", // put a non-zero value into x17, which terminates the receive loop + "mv x18, x1", // put a non-zero value into x18, which terminates the transmit loop + "j 20b" // return to searching for CS low +); + +#[rustfmt::skip] +bio_code!(i8080_tx, I8080_TX_START, I8080_RX_END, + // core runs full speed whenever data comes into the FIFO + "li x1, 8", // data shift into place for GPIO + "li x2, 0x0FF0", // data pins mask, just made up for now + "li x3, 0x1000", // CSX set + "li x4, 0xFFFFEFFF", // CSX clear + "li x5, 0x2000", // DCX set + "li x6, 0xFFFFDFFF", // DCX clear + "li x7, 0x4000", // RD set + "li x8, 0x8000", // WR set + "li x9, 0xFFFF7FFF", // WR clear + "li x10 0xFFF0", // all GPIO pins mask + + "mv x0, x18", // block on FIFO2 data - host sends this to setup 8080 tx loop + // later on x18 will have data automatically put in it by the CS interpreter + + // setup control signals + "mv x22, x3," // set CSX + "mv x23, x6," // clear DCX + "mv x22, x7," // set RD + "mv x23, x9," // clear WR +"10:", + "mv x23, x4," // clear CSX + "li x12, 0x2C", // 8080 page write command + "slli x12, x12, x1", // shift into place + "mv x21, x12", // set 8080 page write bits + "mv x22, x8", // ** WR rising edge ** + "mv x0, x0, x0", // NOP for wr high time requirement + "mv x23, x9,", // WR edge drop + "mv x22, x5", // set DCX +"20:", // main transmit loop + "mv x15, x16", // blocks until a byte arrives in the FIFO + "sll x15, x15, x1", // shift data into place + "mv x26, x2", // set GPIO pin set mask + "mv x21, x15", // change just the data pins + "mv x26, x10", // allow control pins to change + "mv x22, x8", // ** WR rising edge ** + "mv x13, x18", // check termination condition while allowing WR hold time + "mv x23, x9,", // WR edge drop + "beq x13, x0, 20b", // go back if the termination condition is 0 + // 9 inst + 1 br = 9 * 4 + 1 *5 = 41 cycles = 58ns total time, 17MHz tx rate + + "loop cleanup", // do other 8080 commands to cleanup the panel and setup for next initiation +);