Use SDK API function to turn PIO index into PIO pointer

Author: jepler

ports/raspberrypi/common-hal/picodvi/Framebuffer_RP2040.c

@@ -25,8 +25,6 @@
 
 picodvi_framebuffer_obj_t *active_picodvi = NULL;
 
-static PIO pio_instances[2] = {pio0, pio1};
-
 static void __not_in_flash_func(core1_main)(void) {
     // The MPU is reset before this starts.
 
@@ -184,7 +182,7 @@ void common_hal_picodvi_framebuffer_construct(picodvi_framebuffer_obj_t *self,
     size_t pio_index = NUM_PIOS;
     int free_state_machines[4]; // We may find all four free. We only use the first three.
     for (size_t i = 0; i < NUM_PIOS; i++) {
-        PIO pio = pio_instances[i];
+        PIO pio = pio_get_instance(i);
         uint8_t free_count = 0;
         for (size_t sm = 0; sm < NUM_PIO_STATE_MACHINES; sm++) {
             if (!pio_sm_is_claimed(pio, sm)) {
@@ -244,7 +242,7 @@ void common_hal_picodvi_framebuffer_construct(picodvi_framebuffer_obj_t *self,
     }
 
     for (size_t i = 0; i < 3; i++) {
-        rp2pio_statemachine_never_reset(pio_instances[pio_index], free_state_machines[i]);
+        rp2pio_statemachine_never_reset(pio_get_instance(pio_index), free_state_machines[i]);
     }
 
     // For the output.
@@ -253,7 +251,7 @@ void common_hal_picodvi_framebuffer_construct(picodvi_framebuffer_obj_t *self,
     self->color_depth = color_depth;
 
     self->dvi.timing = timing;
-    self->dvi.ser_cfg.pio = pio_instances[pio_index];
+    self->dvi.ser_cfg.pio = pio_get_instance(pio_index);
     self->dvi.ser_cfg.sm_tmds[0] = free_state_machines[0];
     self->dvi.ser_cfg.sm_tmds[1] = free_state_machines[1];
     self->dvi.ser_cfg.sm_tmds[2] = free_state_machines[2];

ports/raspberrypi/common-hal/rp2pio/StateMachine.c

@@ -51,13 +51,6 @@ static int8_t _sm_dma_plus_one_read[NUM_PIOS][NUM_PIO_STATE_MACHINES];
 #define SM_DMA_CLEAR_CHANNEL_READ(pio_index, sm) (_sm_dma_plus_one_read[(pio_index)][(sm)] = 0)
 #define SM_DMA_SET_CHANNEL_READ(pio_index, sm, channel) (_sm_dma_plus_one_read[(pio_index)][(sm)] = (channel) + 1)
 
-static PIO pio_instances[NUM_PIOS] = {
-    pio0,
-    pio1
-    #if NUM_PIOS == 3
-    , pio2
-    #endif
-};
 typedef void (*interrupt_handler_type)(void *);
 static interrupt_handler_type _interrupt_handler[NUM_PIOS][NUM_PIO_STATE_MACHINES];
 static void *_interrupt_arg[NUM_PIOS][NUM_PIO_STATE_MACHINES];
@@ -162,7 +155,7 @@ static void _reset_statemachine(PIO pio, uint8_t sm, bool leave_pins) {
 
 void reset_rp2pio_statemachine(void) {
     for (size_t i = 0; i < NUM_PIOS; i++) {
-        PIO pio = pio_instances[i];
+        PIO pio = pio_get_instance(i);
         for (size_t j = 0; j < NUM_PIO_STATE_MACHINES; j++) {
             if (_never_reset[i][j]) {
                 continue;
@@ -252,7 +245,7 @@ static bool use_existing_program(PIO *pio_out, uint *sm_out, int *offset_inout,
     }
 
     for (size_t i = 0; i < NUM_PIOS; i++) {
-        PIO pio = pio_instances[i];
+        PIO pio = pio_get_instance(i);
         if (!is_gpio_compatible(pio, required_gpio_ranges)) {
             continue;
         }
@@ -1097,7 +1090,7 @@ void common_hal_rp2pio_statemachine_set_interrupt_handler(rp2pio_statemachine_ob
 
 static void rp2pio_statemachine_interrupt_handler(void) {
     for (size_t pio_index = 0; pio_index < NUM_PIOS; pio_index++) {
-        PIO pio = pio_instances[pio_index];
+        PIO pio = pio_get_instance(pio_index);
         for (size_t sm = 0; sm < NUM_PIO_STATE_MACHINES; sm++) {
             if (!_interrupt_handler[pio_index][sm]) {
                 continue;
@@ -1452,7 +1445,7 @@ int common_hal_rp2pio_statemachine_get_offset(rp2pio_statemachine_obj_t *self) {
 
 int common_hal_rp2pio_statemachine_get_pc(rp2pio_statemachine_obj_t *self) {
     uint8_t pio_index = pio_get_index(self->pio);
-    PIO pio = pio_instances[pio_index];
+    PIO pio = pio_get_instance(pio_index);
     uint8_t sm = self->state_machine;
     return pio_sm_get_pc(pio, sm);
 }

ports/raspberrypi/common-hal/usb_host/Port.c

@@ -33,7 +33,6 @@
 
 usb_host_port_obj_t usb_host_instance;
 
-static PIO pio_instances[2] = {pio0, pio1};
 volatile bool _core1_ready = false;
 
 static void __not_in_flash_func(core1_main)(void) {
@@ -76,7 +75,7 @@ static void __not_in_flash_func(core1_main)(void) {
 }
 
 static uint8_t _sm_free_count(uint8_t pio_index) {
-    PIO pio = pio_instances[pio_index];
+    PIO pio = pio_get_instance(pio_index);
     uint8_t free_count = 0;
     for (size_t j = 0; j < NUM_PIO_STATE_MACHINES; j++) {
         if (!pio_sm_is_claimed(pio, j)) {
@@ -87,7 +86,7 @@ static uint8_t _sm_free_count(uint8_t pio_index) {
 }
 
 static bool _has_program_room(uint8_t pio_index, uint8_t program_size) {
-    PIO pio = pio_instances[pio_index];
+    PIO pio = pio_get_instance(pio_index);
     pio_program_t program_struct = {
         .instructions = NULL,
         .length = program_size,
@@ -148,7 +147,7 @@ usb_host_port_obj_t *common_hal_usb_host_port_construct(const mcu_pin_obj_t *dp,
     self->dp = dp;
     self->dm = dm;
 
-    PIO pio = pio_instances[pio_cfg.pio_tx_num];
+    PIO pio = pio_get_instance(pio_cfg.pio_tx_num);
 
     // Unclaim everything so that the library can.
     dma_channel_unclaim(pio_cfg.tx_ch);