feat(hal): update lcd functions

* Make transfer callbacks IRAM_ATTR
* Make lcd_write function use queued transactions instead of polling transactions so that all lcd comms is using the same mechanisms
* Change the max transfer size to be more representative of what is actually being sent

Author: finger563

components/box-emu-hal/src/spi_lcd.cpp

@@ -10,6 +10,7 @@
 using namespace box_hal;
 
 static spi_device_handle_t spi;
+static spi_device_interface_config_t devcfg;
 
 static constexpr size_t pixel_buffer_size = display_width*NUM_ROWS_IN_FRAME_BUFFER;
 std::shared_ptr<espp::Display> display;
@@ -24,12 +25,10 @@ static uint8_t *frame_buffer1;
 static constexpr int FLUSH_BIT = (1 << (int)espp::display_drivers::Flags::FLUSH_BIT);
 static constexpr int DC_LEVEL_BIT = (1 << (int)espp::display_drivers::Flags::DC_LEVEL_BIT);
 
-static void lcd_wait_lines();
-
 // This function is called (in irq context!) just before a transmission starts.
 // It will set the D/C line to the value indicated in the user field
 // (DC_LEVEL_BIT).
-static void lcd_spi_pre_transfer_callback(spi_transaction_t *t)
+static void IRAM_ATTR lcd_spi_pre_transfer_callback(spi_transaction_t *t)
 {
     uint32_t user_flags = (uint32_t)(t->user);
     bool dc_level = user_flags & DC_LEVEL_BIT;
@@ -39,7 +38,7 @@ static void lcd_spi_pre_transfer_callback(spi_transaction_t *t)
 // This function is called (in irq context!) just after a transmission ends. It
 // will indicate to lvgl that the next flush is ready to be done if the
 // FLUSH_BIT is set.
-static void lcd_spi_post_transfer_callback(spi_transaction_t *t)
+static void IRAM_ATTR lcd_spi_post_transfer_callback(spi_transaction_t *t)
 {
     uint16_t user_flags = (uint32_t)(t->user);
     bool should_flush = user_flags & FLUSH_BIT;
@@ -48,24 +47,6 @@ static void lcd_spi_post_transfer_callback(spi_transaction_t *t)
         lv_disp_flush_ready(disp->driver);
     }
 }
-
-extern "C" void lcd_write(const uint8_t *data, size_t length, uint32_t user_data) {
-    if (length == 0) {
-        return;
-    }
-    lcd_wait_lines();
-    esp_err_t ret;
-    static spi_transaction_t t;
-    memset(&t, 0, sizeof(t));
-    t.length = length * 8;
-    t.tx_buffer = data;
-    t.user = (void*)user_data;
-    ret = spi_device_polling_transmit(spi, &t);
-    if (ret != ESP_OK) {
-        fmt::print("Could not transmit: {} '{}'\n", ret, esp_err_to_name(ret));
-    }
-}
-
 // Transaction descriptors. Declared static so they're not allocated on the
 // stack; we need this memory even when this function is finished because the
 // SPI driver needs access to it even while we're already calculating the next
@@ -80,7 +61,7 @@ static void lcd_wait_lines() {
     // fmt::print("Waiting for {} queued transactions\n", num_queued_trans);
     // Wait for all transactions to be done and get back the results.
     while (num_queued_trans) {
-        ret=spi_device_get_trans_result(spi, &rtrans, 10 / portTICK_PERIOD_MS);
+        ret = spi_device_get_trans_result(spi, &rtrans, 10 / portTICK_PERIOD_MS);
         if (ret != ESP_OK) {
             fmt::print("Could not get trans result: {} '{}'\n", ret, esp_err_to_name(ret));
         }
@@ -89,6 +70,27 @@ static void lcd_wait_lines() {
     }
 }
 
+
+extern "C" void lcd_write(const uint8_t *data, size_t length, uint32_t user_data) {
+    if (length == 0) {
+        return;
+    }
+    lcd_wait_lines();
+    esp_err_t ret;
+    trans[0].length = length * 8;
+    trans[0].user = (void*)user_data;
+    trans[0].tx_buffer = data;
+    trans[0].flags = 0; // maybe look at the length of data (<=32 bits) and see
+                        // if we should use SPI_TRANS_USE_TXDATA and copy the
+                        // data into the tx_data field
+    ret = spi_device_queue_trans(spi, &trans[0], 10 / portTICK_PERIOD_MS);
+    if (ret != ESP_OK) {
+        fmt::print("Couldn't queue trans: {} '{}'\n", ret, esp_err_to_name(ret));
+    } else {
+        num_queued_trans++;
+    }
+}
+
 extern "C" void lcd_send_lines(int xs, int ys, int xe, int ye, const uint8_t *data, uint32_t user_data) {
     // if we haven't waited by now, wait here...
     lcd_wait_lines();
@@ -125,7 +127,7 @@ extern "C" void lcd_send_lines(int xs, int ys, int xe, int ye, const uint8_t *da
     trans[5].tx_buffer = data;
     trans[5].length = length*8;
     // undo SPI_TRANS_USE_TXDATA flag
-    trans[5].flags = 0; // SPI_TRANS_DMA_BUFFER_ALIGN_MANUAL;
+    trans[5].flags = SPI_TRANS_DMA_BUFFER_ALIGN_MANUAL;
     // we need to keep the dc bit set, but also add our flags
     trans[5].user = (void*)(DC_LEVEL_BIT | user_data);
     //Queue all transactions.
@@ -194,9 +196,8 @@ extern "C" void lcd_init() {
     buscfg.sclk_io_num = lcd_sclk;
     buscfg.quadwp_io_num = -1;
     buscfg.quadhd_io_num = -1;
-    buscfg.max_transfer_sz = display_width * display_height * sizeof(lv_color_t) + 8;
+    buscfg.max_transfer_sz = pixel_buffer_size * sizeof(lv_color_t) + 10;
 
-    static spi_device_interface_config_t devcfg;
     memset(&devcfg, 0, sizeof(devcfg));
     devcfg.mode = 0;
     // devcfg.flags = SPI_DEVICE_NO_RETURN_RESULT;