piolib: IRQ support, dmactrl access, FIFO flags etc.

piolib/examples/CMakeLists.txt

@@ -54,3 +54,38 @@ add_executable(quadenc quadrature_encoder.c)
 target_include_directories(quadenc PRIVATE ../include)
 target_link_libraries(quadenc pio)
 install(TARGETS quadenc RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+add_executable(txcount txcount.c)
+target_include_directories(txcount PRIVATE ../include)
+target_link_libraries(txcount pio)
+install(TARGETS txcount RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+add_executable(blockingtest blockingtest.c)
+target_include_directories(blockingtest PRIVATE ../include)
+target_link_libraries(blockingtest pio pthread)
+install(TARGETS blockingtest RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+add_executable(rxsource rxsource.c)
+target_include_directories(rxsource PRIVATE ../include)
+target_link_libraries(rxsource pio)
+install(TARGETS rxsource RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+add_executable(irqtest irqtest.c)
+target_include_directories(irqtest PRIVATE ../include ../../pinctrl)
+target_link_libraries(irqtest pio gpiolib)
+install(TARGETS irqtest RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+add_executable(irqhog irqhog.c)
+target_include_directories(irqhog PRIVATE ../include)
+target_link_libraries(irqhog pio)
+install(TARGETS irqhog RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+add_executable(irqtest2 irqtest2.c)
+target_include_directories(irqtest2 PRIVATE ../include ../../pinctrl)
+target_link_libraries(irqtest2 pio gpiolib)
+install(TARGETS irqtest2 RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+add_executable(txsink txsink.c)
+target_include_directories(txsink PRIVATE ../include)
+target_link_libraries(txsink pio)
+install(TARGETS txsink RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

piolib/examples/apitest.c

@@ -16,11 +16,17 @@
 
 #define DATA_WORDS 16
 
+static void check(const char *label, bool value) {
+    if (!value)
+        pio_panic(label);
+}
+
 int main(int argc, const char **argv) {
     uint32_t databuf[DATA_WORDS];
     bool use_dma = true;
     int ret = 0;
     int i, j;
+    uint32_t temp;
     uint16_t dummy_program_instructions[1];
     struct pio_program dummy_program = {
         .instructions = dummy_program_instructions,
@@ -38,72 +44,62 @@ int main(int argc, const char **argv) {
     pio_enable_fatal_errors(pio, false);
 
     for (sm = 0; sm < pio_get_sm_count(pio); sm++) {
-        if (pio_sm_is_claimed(pio, sm))
-            pio_panic("SM claimed (1)");
+        check("SM claimed (1)", !pio_sm_is_claimed(pio, sm));
 
         pio_sm_claim(pio, sm);
-        if (pio_get_error(pio))
-            pio_panic("SM claim failed");
+        check("SM claim failed", !pio_get_error(pio));
 
-        if (!pio_sm_is_claimed(pio, sm))
-            pio_panic("SM not claimed (1)");
+        check("SM not claimed (1)", pio_sm_is_claimed(pio, sm));
 
         pio_sm_claim(pio, sm);
-        if (!pio_get_error(pio))
-            pio_panic("SM not claimed (2)");
+        check("SM not claimed (2)", pio_get_error(pio));
         pio_clear_error(pio);
     }
 
     for (sm = 0; sm < pio_get_sm_count(pio); sm++) {
         pio_sm_unclaim(pio, sm);
-        if (pio_sm_is_claimed(pio, sm))
-            pio_panic("SM still claimed");
+        check("SM still claimed", !pio_sm_is_claimed(pio, sm));
     }
 
     pio_claim_sm_mask(pio, (1 << (pio_get_sm_count(pio) - 1)) - 1);
-    if (pio_get_error(pio))
-        pio_panic("masked claim failed");
-    if ((uint)pio_claim_unused_sm(pio, false) != pio_get_sm_count(pio) - 1)
-        pio_panic("wrong SM (expected the last)");
+    check("masked claim failed", !pio_get_error(pio));
+    check("wrong SM (expected the last)",
+          (uint)pio_claim_unused_sm(pio, false) == pio_get_sm_count(pio) - 1);
 
     for (sm = 0; sm < pio_get_sm_count(pio); sm++) {
         pio_sm_unclaim(pio, sm);
-        if (pio_sm_is_claimed(pio, sm))
-            pio_panic("SM still claimed");
+        check("SM still claimed", !pio_sm_is_claimed(pio, sm));
     }
 
     sm = pio_claim_unused_sm(pio, true);
 
     for (offset = 0; offset < pio_get_instruction_count(pio); offset++) {
         dummy_program_instructions[0] = offset + 1;
-        if (!pio_can_add_program(pio, &dummy_program))
-            pio_panic("can't add program");
-        if (pio_add_program(pio, &dummy_program) == PIO_ORIGIN_ANY)
-            pio_panic("failed to add program (1)");
+        check("can't add program", pio_can_add_program(pio, &dummy_program));
+        check("failed to add program (1)",
+              pio_add_program(pio, &dummy_program) != PIO_ORIGIN_ANY);
+        check("can't add program again", pio_can_add_program(pio, &dummy_program));
     }
 
     dummy_program_instructions[0] = offset + 1;
 
-    if (pio_can_add_program(pio, &dummy_program))
-        pio_panic("can add program");
-    if (pio_add_program(pio, &dummy_program) != PIO_ORIGIN_INVALID)
-        pio_panic("added program again");
+    check("can add program", !pio_can_add_program(pio, &dummy_program));
+    check("added program again",
+          pio_add_program(pio, &dummy_program) == PIO_ORIGIN_INVALID);
     pio_clear_error(pio);
 
     for (offset = 0; offset < pio_get_instruction_count(pio); offset++) {
         pio_remove_program(pio, &dummy_program, offset);
-        if (pio_get_error(pio))
-            pio_panic("remove program failed");
+        check("remove program failed", !pio_get_error(pio));
         pio_remove_program(pio, &dummy_program, offset);
-        if (!pio_get_error(pio))
-            pio_panic("removed program again");
+        check("removed program again", pio_get_error(pio));
         pio_clear_error(pio);
     }
 
     for (offset = 0; offset < pio_get_instruction_count(pio); offset++) {
         dummy_program_instructions[0] = offset + 1;
-        if (!pio_can_add_program_at_offset(pio, &dummy_program, offset))
-            pio_panic("can't add program at offset");
+        check("can't add program at offset",
+              pio_can_add_program_at_offset(pio, &dummy_program, offset));
         pio_add_program_at_offset(pio, &dummy_program, offset);
     }
 
@@ -119,79 +115,83 @@ int main(int argc, const char **argv) {
 
     pio_sm_put(pio, sm, 0);
 
-    if (pio_sm_is_tx_fifo_empty(pio, sm))
-        pio_panic("TX FIFO is empty (1)");
+    check("TX FIFO is empty (1)", !pio_sm_is_tx_fifo_empty(pio, sm));
 
     pio_sm_clear_fifos(pio, sm);
+    pio_sm_clear_flags(pio, sm, PIO_SM_FLAG_ALL);
+
+    check("TX FIFO is not empty (1)", pio_sm_is_tx_fifo_empty(pio, sm));
+    check("TX FIFO level is not zero", pio_sm_get_tx_fifo_level(pio, sm) == 0);
+    check("FIFO flags are non-zero", pio_sm_get_flags(pio, sm, PIO_SM_FLAG_ALL, false) == 0);
+    pio_sm_get(pio, sm);
+    check("FIFO flags not RXUNDER",
+          pio_sm_get_flags(pio, sm, PIO_SM_FLAG_ALL, true) == PIO_SM_FLAG_RXUNDER);
+
+    printf("%d: %08x\n", 0, pio_sm_get_dmactrl(pio, sm, true));
+
+    temp = pio_sm_get_dmactrl(pio, sm, true);
+    pio_sm_set_dmactrl(pio, sm, true, (temp & ~0x1f) | (pio_get_fifo_depth(pio) - 2));
 
-    if (!pio_sm_is_tx_fifo_empty(pio, sm))
-        pio_panic("TX FIFO is not empty (1)");
-    if (pio_sm_get_tx_fifo_level(pio, sm) != 0)
-        pio_panic("TX FIFO level is not zero");
     for (i = 1; i <= (int)pio_get_fifo_depth(pio); i++)
     {
-        if (pio_sm_is_tx_fifo_full(pio, sm))
-            pio_panic("TX FIFO is full (1)");
+        // Set the DREQ threshold to deassert when the FIFO level is i
+        pio_sm_set_dmactrl(pio, sm, true, (temp & ~0x1f) | (i - 1));
+        printf("%d: %08x\n", i, pio_sm_get_dmactrl(pio, sm, true));
+        check("TX FIFO is full (1)", !pio_sm_is_tx_fifo_full(pio, sm));
         pio_sm_put(pio, sm, i);
-        if (pio_sm_is_tx_fifo_empty(pio, sm))
-            pio_panic("TX FIFO is empty (2)");
-        if ((int)pio_sm_get_tx_fifo_level(pio, sm) != i)
-            pio_panic("Wrong TX FIFO level");
+        check("TX FIFO is empty (2)", !pio_sm_is_tx_fifo_empty(pio, sm));
+        check("Wrong TX FIFO level", (int)pio_sm_get_tx_fifo_level(pio, sm) == i);
+        printf(" -> %08x\n", pio_sm_get_dmactrl(pio, sm, true));
     }
 
-    if (!pio_sm_is_tx_fifo_full(pio, sm))
-        pio_panic("TX FIFO is not full (1)");
+    check("TX FIFO is not full (1)", pio_sm_is_tx_fifo_full(pio, sm));
 
     pio_sm_drain_tx_fifo(pio, sm);
 
-    if (!pio_sm_is_tx_fifo_empty(pio, sm))
-        pio_panic("TX FIFO is not empty (2)");
+    check("TX FIFO is not empty (2)", pio_sm_is_tx_fifo_empty(pio, sm));
 
     for (i = 1; i <= (int)pio_get_fifo_depth(pio); i++)
         pio_sm_put(pio, sm, i);
 
-    if (!pio_sm_is_tx_fifo_full(pio, sm))
-        pio_panic("TX FIFO is not full (2)");
+    check("TX FIFO is not full (2)", pio_sm_is_tx_fifo_full(pio, sm));
 
-    if (!pio_sm_is_rx_fifo_empty(pio, sm))
-        pio_panic("RX FIFO not empty");
+    check("RX FIFO not empty", pio_sm_is_rx_fifo_empty(pio, sm));
 
-    if ((int)pio_sm_get_rx_fifo_level(pio, sm) != 0)
-        pio_panic("RX FIFO level not 0");
+    check("RX FIFO level not 0", (int)pio_sm_get_rx_fifo_level(pio, sm) == 0);
 
     pio_sm_set_enabled(pio, sm, true);
 
-    if (!pio_sm_is_tx_fifo_empty(pio, sm))
-        pio_panic("TX FIFO is not empty (3)");
+    check("TX FIFO is not empty (3)", pio_sm_is_tx_fifo_empty(pio, sm));
 
-    if (!pio_sm_is_rx_fifo_full(pio, sm))
-        pio_panic("RX FIFO is not full");
+    check("RX FIFO is not full", pio_sm_is_rx_fifo_full(pio, sm));
 
-    if (pio_sm_get_rx_fifo_level(pio, sm) != pio_get_fifo_depth(pio))
-        pio_panic("RX FIFO level not the maximum");
+    check("RX FIFO level not the maximum",
+          pio_sm_get_rx_fifo_level(pio, sm) == pio_get_fifo_depth(pio));
 
+    temp = pio_sm_get_dmactrl(pio, sm, false);
     for (i = pio_get_fifo_depth(pio) - 1; i >= 0; i--)
     {
-        if (pio_sm_is_rx_fifo_empty(pio, sm))
-            pio_panic("RX FIFO is empty");
-        if (pio_sm_get(pio, sm) != (uint)(pio_get_fifo_depth(pio) - i))
-            pio_panic("wrong RX data");
-        if ((int)pio_sm_get_rx_fifo_level(pio, sm) != i)
-            pio_panic("wrong RX FIFO level");
+        // Set the DREQ threshold to deassert when the FIFO level is i
+        pio_sm_set_dmactrl(pio, sm, false, (temp & ~0x1f) | (i + 1));
+        printf("%d: %08x\n", i, pio_sm_get_dmactrl(pio, sm, false));
+        check("RX FIFO is empty", !pio_sm_is_rx_fifo_empty(pio, sm));
+        check("wrong RX data",
+              pio_sm_get(pio, sm) == (uint)(pio_get_fifo_depth(pio) - i));
+        check("wrong RX FIFO level", (int)pio_sm_get_rx_fifo_level(pio, sm) == i);
+        printf(" -> %08x\n", pio_sm_get_dmactrl(pio, sm, false));
     }
 
-    if (!pio_sm_is_rx_fifo_empty(pio, sm))
-        pio_panic("RX FIFO is not empty");
+    check("RX FIFO is not empty", pio_sm_is_rx_fifo_empty(pio, sm));
 
     offset = pio_add_program(pio, &genseq_program);
 
-    if (!pio_sm_config_xfer(pio, sm, PIO_DIR_FROM_SM, 4096, 0))
-        pio_panic("DMA configuration didn't fail");
-    if (!pio_sm_xfer_data(pio, sm, PIO_DIR_FROM_SM, 4, NULL) ||
-        !pio_sm_xfer_data(pio, sm, PIO_DIR_FROM_SM, 0, databuf))
-        pio_panic("DMA transfer didn't fail");
-    if (pio_sm_config_xfer(pio, sm, PIO_DIR_FROM_SM, 4096, 2))
-        pio_panic("DMA configuration failed");
+    check("DMA configuration didn't fail",
+          pio_sm_config_xfer(pio, sm, PIO_DIR_FROM_SM, 4096, 0));
+    check("DMA transfer didn't fail",
+          pio_sm_xfer_data(pio, sm, PIO_DIR_FROM_SM, 4, NULL) &&
+          pio_sm_xfer_data(pio, sm, PIO_DIR_FROM_SM, 0, databuf));
+    check("DMA configuration failed",
+          !pio_sm_config_xfer(pio, sm, PIO_DIR_FROM_SM, 4096, 2));
 
     pio_gpio_init(pio, gpio);
     pio_sm_set_consecutive_pindirs(pio, sm, gpio, 1, true);