rp2pio: Support PIOv1 features

jepler · jepler · commit 2796fe843897 · 2024-09-10T13:58:05.000-05:00
This is needed to fully support the .mov_status and .fifo directives,
as well as checking for PIO version compatibility between program &amp;
runtime hardware.
diff --git a/ports/raspberrypi/bindings/rp2pio/StateMachine.c b/ports/raspberrypi/bindings/rp2pio/StateMachine.c
@@ -22,6 +22,11 @@
 #include "py/runtime.h"
 
 
+//| FifoType = Literal["auto", "txrx", "tx", "rx", "txput", "txget", "putget"]
+//| FifoType_piov0 = Literal["auto", "txrx", "tx", "rx"]
+//| MovStatusType = Literal["txfifo", "rxfifo", "irq"]
+//| MovStatusType_piov0 = Literal["txfifo"]
+//|
 //| class StateMachine:
 //|     """A single PIO StateMachine
 //|
@@ -41,6 +46,7 @@
 //|         program: ReadableBuffer,
 //|         frequency: int,
 //|         *,
+//|         pio_version: int = 0,
 //|         may_exec: Optional[ReadableBuffer] = None,
 //|         init: Optional[ReadableBuffer] = None,
 //|         first_out_pin: Optional[microcontroller.Pin] = None,
@@ -74,13 +80,17 @@
 //|         wrap_target: int = 0,
 //|         wrap: int = -1,
 //|         offset: int = -1,
+//|         fifo_type: FifoType = "auto",
+//|         mov_status_type: MovStatusType = "txfifo",
+//|         mov_status_n: int = 0,
 //|     ) -> None:
 //|         """Construct a StateMachine object on the given pins with the given program.
 //|
 //|         :param ReadableBuffer program: the program to run with the state machine
 //|         :param int frequency: the target clock frequency of the state machine. Actual may be less. Use 0 for system clock speed.
 //|         :param ReadableBuffer init: a program to run once at start up. This is run after program
 //|              is started so instructions may be intermingled
+//|         :param int pio_version: The version of the PIO peripheral required by the program. The constructor will raise an error if the actual hardware is not compatible with this program version.
 //|         :param ReadableBuffer may_exec: Instructions that may be executed via `StateMachine.run` calls.
 //|             Some elements of the `StateMachine`'s configuration are inferred from the instructions used;
 //|             for instance, if there is no ``in`` or ``push`` instruction, then the `StateMachine` is configured without a receive FIFO.
@@ -134,12 +144,25 @@
 //|         :param int offset: A specific offset in the state machine's program memory where the program must be loaded.
 //|             The default value, -1, allows the program to be loaded at any offset.
 //|             This is appropriate for most programs.
+//|         :param FifoType fifo_type: How the program accessess the FIFOs. PIO version 0 only supports a subset of values.
+//|         :param MovStatusType mov_status_type: What condition the ``mov status`` instruction checks. PIO version 0 only supports a subset of values.
+//|         :param MovStatusType mov_status_n: The FIFO depth or IRQ the ``mov status`` instruction checks for. For ``mov_status irq`` this includes the encoding of the ``next``/``prev`` selection bits.
 //|         """
 //|         ...
 
+static int one_of(qstr_short_t what, mp_obj_t arg, size_t n_options, const qstr_short_t options[], const int values[]) {
+    for (size_t i = 0; i < n_options; i++) {
+        mp_obj_t option_str = MP_OBJ_NEW_QSTR(options[i]);
+        if (mp_obj_equal(arg, option_str)) {
+            return values[i];
+        }
+    }
+    mp_raise_ValueError_varg(MP_ERROR_TEXT("Invalid %q"), what);
+}
+
 static mp_obj_t rp2pio_statemachine_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
     rp2pio_statemachine_obj_t *self = mp_obj_malloc(rp2pio_statemachine_obj_t, &rp2pio_statemachine_type);
-    enum { ARG_program, ARG_frequency, ARG_init, ARG_may_exec,
+    enum { ARG_program, ARG_frequency, ARG_init, ARG_pio_version, ARG_may_exec,
            ARG_first_out_pin, ARG_out_pin_count, ARG_initial_out_pin_state, ARG_initial_out_pin_direction,
            ARG_first_in_pin, ARG_in_pin_count,
            ARG_pull_in_pin_up, ARG_pull_in_pin_down,
@@ -154,11 +177,15 @@ static mp_obj_t rp2pio_statemachine_make_new(const mp_obj_type_t *type, size_t n
            ARG_user_interruptible,
            ARG_wrap_target,
            ARG_wrap,
-           ARG_offset, };
+           ARG_offset,
+           ARG_fifo_type,
+           ARG_mov_status_type,
+           ARG_mov_status_n, };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_program, MP_ARG_REQUIRED | MP_ARG_OBJ },
         { MP_QSTR_frequency, MP_ARG_REQUIRED | MP_ARG_INT },
         { MP_QSTR_init, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_pio_version, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_may_exec, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
 
         { MP_QSTR_first_out_pin, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
@@ -198,11 +225,18 @@ static mp_obj_t rp2pio_statemachine_make_new(const mp_obj_type_t *type, size_t n
 
         { MP_QSTR_wrap_target, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_wrap, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
-        { MP_QSTR_offset, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+
+        { MP_QSTR_offset, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PIO_ANY_OFFSET} },
+
+        { MP_QSTR_fifo_type, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_obj = MP_ROM_QSTR(MP_QSTR_rxtx) } },
+        { MP_QSTR_mov_status_type, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_obj = MP_ROM_QSTR(MP_QSTR_txfifo) } },
+        { MP_QSTR_mov_status_n, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
+    (void)mp_arg_validate_int_max(args[ARG_pio_version].u_int, PICO_PIO_VERSION, MP_QSTR_out_pin_count);
+
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[ARG_program].u_obj, &bufinfo, MP_BUFFER_READ);
 
@@ -254,6 +288,30 @@ static mp_obj_t rp2pio_statemachine_make_new(const mp_obj_type_t *type, size_t n
     int wrap = args[ARG_wrap].u_int;
     int wrap_target = args[ARG_wrap_target].u_int;
 
+    const qstr_short_t fifo_alternatives[] = { MP_QSTR_auto, MP_QSTR_txrx, MP_QSTR_tx, MP_QSTR_rx,
+                                               #if PICO_PIO_VERSION > 0
+                                               MP_QSTR_txput, MP_QSTR_txget, MP_QSTR_putget
+                                               #endif
+    };
+    const int fifo_values[] = { PIO_FIFO_JOIN_AUTO, PIO_FIFO_JOIN_NONE, PIO_FIFO_JOIN_TX, PIO_FIFO_JOIN_RX,
+                                #if PICO_PIO_VERSION > 0
+                                PIO_FIFO_JOIN_TXPUT, PIO_FIFO_JOIN_PUTGET
+                                #endif
+    };
+    int fifo_type = one_of(MP_QSTR_fifo_type, args[ARG_fifo_type].u_obj, MP_ARRAY_SIZE(fifo_alternatives), fifo_alternatives, fifo_values);
+
+    const qstr_short_t mov_status_alternatives[] = { MP_QSTR_txfifo, MP_QSTR_rxfifo,
+                                                     #if PICO_PIO_VERSION > 0
+                                                     MP_QSTR_IRQ
+                                                     #endif
+    };
+    const int mov_status_values[] = { STATUS_TX_LESSTHAN, STATUS_RX_LESSTHAN,
+                                      #if PICO_PIO_VERSION > 0
+                                      STATUS_IRQ_SET
+                                      #endif
+    };
+    int mov_status_type = one_of(MP_QSTR_mov_status_type, args[ARG_mov_status_type].u_obj, MP_ARRAY_SIZE(mov_status_alternatives), mov_status_alternatives, mov_status_values);
+
     common_hal_rp2pio_statemachine_construct(self,
         bufinfo.buf, bufinfo.len / 2,
         args[ARG_frequency].u_int,
@@ -271,7 +329,10 @@ static mp_obj_t rp2pio_statemachine_make_new(const mp_obj_type_t *type, size_t n
         args[ARG_wait_for_txstall].u_bool,
         args[ARG_auto_push].u_bool, push_threshold, args[ARG_in_shift_right].u_bool,
         args[ARG_user_interruptible].u_bool,
-        wrap_target, wrap, args[ARG_offset].u_int);
+        wrap_target, wrap, args[ARG_offset].u_int,
+        fifo_type,
+        mov_status_type, args[ARG_mov_status_n].u_int
+        );
     return MP_OBJ_FROM_PTR(self);
 }
 
diff --git a/ports/raspberrypi/bindings/rp2pio/StateMachine.h b/ports/raspberrypi/bindings/rp2pio/StateMachine.h
@@ -34,7 +34,10 @@ void common_hal_rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     bool auto_push, uint8_t push_threshold, bool in_shift_right,
     bool user_interruptible,
     int wrap_taget, int wrap,
-    int offset);
+    int offset,
+    int fifo_type,
+    int mov_status_type,
+    int mov_status_n);
 
 void common_hal_rp2pio_statemachine_deinit(rp2pio_statemachine_obj_t *self);
 bool common_hal_rp2pio_statemachine_deinited(rp2pio_statemachine_obj_t *self);
diff --git a/ports/raspberrypi/common-hal/audiobusio/I2SOut.c b/ports/raspberrypi/common-hal/audiobusio/I2SOut.c
@@ -198,7 +198,11 @@ void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t *self,
         false, 32, false, // in settings
         false, // Not user-interruptible.
         0, -1, // wrap settings
-        PIO_ANY_OFFSET);
+        PIO_ANY_OFFSET,
+        PIO_FIFO_TYPE_DEFAULT,
+        PIO_MOV_STATUS_DEFAULT,
+        PIO_MOV_N_DEFAULT
+        );
 
     self->playing = false;
     audio_dma_init(&self->dma);
diff --git a/ports/raspberrypi/common-hal/audiobusio/PDMIn.c b/ports/raspberrypi/common-hal/audiobusio/PDMIn.c
@@ -60,7 +60,9 @@ void common_hal_audiobusio_pdmin_construct(audiobusio_pdmin_obj_t *self,
         false, 32, true, // in settings
         false, // Not user-interruptible.
         0, -1, // wrap settings
-        PIO_ANY_OFFSET);
+        PIO_ANY_OFFSET,
+        PIO_FIFO_TYPE_DEFAULT,
+        PIO_MOV_STATUS_DEFAULT, PIO_MOV_N_DEFAULT);
     uint32_t actual_frequency = common_hal_rp2pio_statemachine_get_frequency(&self->state_machine);
     if (actual_frequency < MIN_MIC_CLOCK) {
         mp_raise_ValueError(MP_ERROR_TEXT("sampling rate out of range"));
diff --git a/ports/raspberrypi/common-hal/floppyio/__init__.c b/ports/raspberrypi/common-hal/floppyio/__init__.c
@@ -99,7 +99,9 @@ int common_hal_floppyio_flux_readinto(void *buf, size_t len, digitalio_digitalin
         false, // Not user-interruptible.
         false, // No sideset enable
         0, -1, // wrap
-        PIO_ANY_OFFSET  // offset
+        PIO_ANY_OFFSET,  // offset
+        PIO_FIFO_TYPE_DEFAULT,
+        PIO_MOV_STATUS_DEFAULT, PIO_MOV_N_DEFAULT
         );
     if (!ok) {
         mp_raise_RuntimeError(MP_ERROR_TEXT("All state machines in use"));
diff --git a/ports/raspberrypi/common-hal/imagecapture/ParallelImageCapture.c b/ports/raspberrypi/common-hal/imagecapture/ParallelImageCapture.c
@@ -101,7 +101,9 @@ void common_hal_imagecapture_parallelimagecapture_construct(imagecapture_paralle
         true, 32, true,  // in settings
         false, // Not user-interruptible.
         2, 5, // wrap settings
-        PIO_ANY_OFFSET);
+        PIO_ANY_OFFSET,
+        PIO_FIFO_TYPE_DEFAULT,
+        PIO_MOV_STATUS_DEFAULT, PIO_MOV_N_DEFAULT);
 }
 
 void common_hal_imagecapture_parallelimagecapture_deinit(imagecapture_parallelimagecapture_obj_t *self) {
diff --git a/ports/raspberrypi/common-hal/neopixel_write/__init__.c b/ports/raspberrypi/common-hal/neopixel_write/__init__.c
@@ -60,8 +60,9 @@ void common_hal_neopixel_write(const digitalio_digitalinout_obj_t *digitalinout,
         false, // Not user-interruptible.
         false, // No sideset enable
         0, -1, // wrap
-        PIO_ANY_OFFSET  // offset
-        );
+        PIO_ANY_OFFSET,  // offset
+        PIO_FIFO_TYPE_DEFAULT,
+        PIO_MOV_STATUS_DEFAULT, PIO_MOV_N_DEFAULT);
     if (!ok) {
         // Do nothing. Maybe bitbang?
         return;
diff --git a/ports/raspberrypi/common-hal/paralleldisplaybus/ParallelBus.c b/ports/raspberrypi/common-hal/paralleldisplaybus/ParallelBus.c
@@ -92,7 +92,9 @@ void common_hal_paralleldisplaybus_parallelbus_construct(paralleldisplaybus_para
         false, 32, true, // RX setting we don't use
         false, // Not user-interruptible.
         0, -1, // wrap settings
-        PIO_ANY_OFFSET);
+        PIO_ANY_OFFSET,
+        PIO_FIFO_TYPE_DEFAULT,
+        PIO_MOV_STATUS_DEFAULT, PIO_MOV_N_DEFAULT);
 
     common_hal_rp2pio_statemachine_never_reset(&self->state_machine);
 }
diff --git a/ports/raspberrypi/common-hal/pulseio/PulseIn.c b/ports/raspberrypi/common-hal/pulseio/PulseIn.c
@@ -54,7 +54,9 @@ void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t *self,
         true, 32, true, // RX auto pull every 32 bits. shift left to output msb first
         false, // Not user-interruptible.
         0, -1, // wrap settings
-        PIO_ANY_OFFSET);
+        PIO_ANY_OFFSET,
+        PIO_FIFO_TYPE_DEFAULT,
+        PIO_MOV_STATUS_DEFAULT, PIO_MOV_N_DEFAULT);
 
     common_hal_pulseio_pulsein_pause(self);
 
diff --git a/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.c b/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.c
@@ -76,8 +76,9 @@ void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencode
         false, 32, false, // in settings
         false, // Not user-interruptible.
         0, MP_ARRAY_SIZE(encoder) - 1, // wrap settings
-        PIO_ANY_OFFSET
-        );
+        PIO_ANY_OFFSET,
+        PIO_FIFO_TYPE_DEFAULT,
+        PIO_MOV_STATUS_DEFAULT, PIO_MOV_N_DEFAULT);
 
     // We're guaranteed by the init code that some output will be available promptly
     uint8_t quiescent_state;
diff --git a/ports/raspberrypi/common-hal/rp2pio/StateMachine.c b/ports/raspberrypi/common-hal/rp2pio/StateMachine.c
@@ -199,7 +199,9 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     bool user_interruptible,
     bool sideset_enable,
     int wrap_target, int wrap,
-    int offset
+    int offset,
+    int fifo_type,
+    int mov_status_type, int mov_status_n
     ) {
     // Create a program id that isn't the pointer so we can store it without storing the original object.
     uint32_t program_id = ~((uint32_t)program);
@@ -343,15 +345,25 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
 
     sm_config_set_wrap(&c, wrap_target, wrap);
     sm_config_set_in_shift(&c, in_shift_right, auto_push, push_threshold);
+    #if PICO_PIO_VERSION > 0
+    sm_config_set_in_pin_count(&c, in_pin_count);
+    #endif
+
     sm_config_set_out_shift(&c, out_shift_right, auto_pull, pull_threshold);
+    sm_config_set_out_pin_count(&c, out_pin_count);
 
-    enum pio_fifo_join join = PIO_FIFO_JOIN_NONE;
-    if (!rx_fifo) {
-        join = PIO_FIFO_JOIN_TX;
-    } else if (!tx_fifo) {
-        join = PIO_FIFO_JOIN_RX;
-    }
-    self->fifo_depth = (join == PIO_FIFO_JOIN_NONE) ? 4 : 8;
+    sm_config_set_set_pin_count(&c, set_pin_count);
+
+    enum pio_fifo_join join =
+        fifo_type != PIO_FIFO_JOIN_AUTO ? fifo_type
+        : !rx_fifo ? PIO_FIFO_JOIN_TX
+        : !tx_fifo ? PIO_FIFO_JOIN_RX
+        : PIO_FIFO_JOIN_NONE;
+    self->fifo_depth = (join == PIO_FIFO_JOIN_TX || join == PIO_FIFO_JOIN_RX) ? 8
+        #if PICO_PIO_VERSION > 0
+        : (join == PIO_FIFO_JOIN_PUTGET) ? 0
+        #endif
+        : 4;
 
     if (rx_fifo) {
         self->rx_dreq = pio_get_dreq(self->pio, self->state_machine, false);
@@ -370,6 +382,11 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     self->init_len = init_len;
 
     sm_config_set_fifo_join(&c, join);
+
+    // TODO: these arguments
+    // int mov_status_type, int mov_status_n,
+    // int set_count, int out_count
+
     self->sm_config = c;
 
     // no DMA allocated
@@ -519,7 +536,10 @@ void common_hal_rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     bool auto_push, uint8_t push_threshold, bool in_shift_right,
     bool user_interruptible,
     int wrap_target, int wrap,
-    int offset) {
+    int offset,
+    int fifo_type,
+    int mov_status_type,
+    int mov_status_n) {
 
     // First, check that all pins are free OR already in use by any PIO if exclusive_pin_use is false.
     uint32_t pins_we_use = wait_gpio_mask;
@@ -610,7 +630,9 @@ void common_hal_rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
         true /* claim pins */,
         user_interruptible,
         sideset_enable,
-        wrap_target, wrap, offset);
+        wrap_target, wrap, offset,
+        PIO_FIFO_TYPE_DEFAULT,
+        PIO_MOV_STATUS_DEFAULT, PIO_MOV_N_DEFAULT);
     if (!ok) {
         mp_raise_RuntimeError(MP_ERROR_TEXT("All state machines in use"));
     }
diff --git a/ports/raspberrypi/common-hal/rp2pio/StateMachine.h b/ports/raspberrypi/common-hal/rp2pio/StateMachine.h
@@ -12,6 +12,9 @@
 #include "src/rp2_common/hardware_pio/include/hardware/pio.h"
 
 enum { PIO_ANY_OFFSET = -1 };
+enum { PIO_FIFO_JOIN_AUTO = -1, PIO_FIFO_TYPE_DEFAULT = PIO_FIFO_JOIN_AUTO };
+enum { PIO_MOV_STATUS_DEFAULT = STATUS_TX_LESSTHAN };
+enum { PIO_MOV_N_DEFAULT = 0 };
 
 typedef struct sm_buf_info {
     mp_obj_t obj;
@@ -70,7 +73,10 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     bool claim_pins,
     bool interruptible,
     bool sideset_enable,
-    int wrap_target, int wrap, int offset);
+    int wrap_target, int wrap, int offset,
+    int fifo_type,
+    int mov_status_type, int mov_status_n
+    );
 
 uint8_t rp2pio_statemachine_program_offset(rp2pio_statemachine_obj_t *self);
 
