raspberrypi: Implement ParallelImageCapture using PIO

.. based on code from Phil B.

ports/raspberrypi/bindings/rp2pio/StateMachine.c

@@ -241,6 +241,7 @@ STATIC mp_obj_t rp2pio_statemachine_make_new(const mp_obj_type_t *type, size_t n
         first_in_pin, args[ARG_in_pin_count].u_int, args[ARG_pull_in_pin_up].u_int, args[ARG_pull_in_pin_down].u_int,
         first_set_pin, args[ARG_set_pin_count].u_int, args[ARG_initial_set_pin_state].u_int, args[ARG_initial_set_pin_direction].u_int,
         first_sideset_pin, args[ARG_sideset_pin_count].u_int, args[ARG_initial_sideset_pin_state].u_int, args[ARG_initial_sideset_pin_direction].u_int,
+        0,
         args[ARG_exclusive_pin_use].u_bool,
         args[ARG_auto_pull].u_bool, pull_threshold, args[ARG_out_shift_right].u_bool,
         args[ARG_wait_for_txstall].u_bool,

ports/raspberrypi/bindings/rp2pio/StateMachine.h

@@ -44,6 +44,7 @@ void common_hal_rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     const mcu_pin_obj_t *first_in_pin, uint8_t in_pin_count, uint32_t pull_pin_up, uint32_t pull_pin_down,
     const mcu_pin_obj_t *first_set_pin, uint8_t set_pin_count, uint32_t initial_set_pin_state, uint32_t initial_set_pin_direction,
     const mcu_pin_obj_t *first_sideset_pin, uint8_t sideset_pin_count, uint32_t initial_sideset_pin_state, uint32_t initial_sideset_pin_direction,
+    uint32_t wait_gpio_mask,
     bool exclusive_pin_use,
     bool auto_pull, uint8_t pull_threshold, bool out_shift_right,
     bool wait_for_txstall,

ports/raspberrypi/common-hal/audiobusio/I2SOut.c

@@ -126,6 +126,7 @@ void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t *self,
         0, 0, // in pulls
         NULL, 0, 0, 0x1f, // set pins
         bit_clock, 2, 0, 0x1f, // sideset pins
+        0, // wait gpio pins
         true, // exclusive pin use
         false, 32, false, // shift out left to start with MSB
         false, // Wait for txstall

ports/raspberrypi/common-hal/audiobusio/PDMIn.c

@@ -71,6 +71,7 @@ void common_hal_audiobusio_pdmin_construct(audiobusio_pdmin_obj_t *self,
         0, 0, // in pulls
         NULL, 0, 0, 0x1f, // set pins
         clock_pin, 1, 0, 0x1f, // sideset pins
+        0, // wait gpio pins
         true, // exclusive pin use
         false, 32, false, // out settings
         false, // Wait for txstall

ports/raspberrypi/common-hal/displayio/ParallelBus.c

@@ -99,6 +99,7 @@ void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t *sel
         NULL, 0, 0, 0, // first in pin, # in pins
         NULL, 0, 0, 0, // first set pin
         write, 1, 0, 1, // first sideset pin
+        0, // wait gpio pins
         true, // exclusive pin usage
         true, 8, true, // TX, auto pull every 8 bits. shift left to output msb first
         false, // wait for TX stall

ports/raspberrypi/common-hal/imagecapture/ParallelImageCapture.c

@@ -0,0 +1,140 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Jeff Epler for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/obj.h"
+#include "py/runtime.h"
+
+#include "lib/utils/context_manager_helpers.h"
+#include "lib/utils/interrupt_char.h"
+
+#include "bindings/rp2pio/StateMachine.h"
+#include "bindings/rp2pio/__init__.h"
+#include "common-hal/imagecapture/ParallelImageCapture.h"
+#include "shared-bindings/imagecapture/ParallelImageCapture.h"
+#include "shared-bindings/microcontroller/Pin.h"
+#include "shared-bindings/microcontroller/Processor.h"
+#include "shared-bindings/microcontroller/__init__.h"
+
+#include "src/rp2_common/hardware_pio/include/hardware/pio.h"
+#include "src/rp2_common/hardware_pio/include/hardware/pio_instructions.h"
+
+// Define this to (1), and you can scope the instruction-pointer of the state machine on D26..28 (note the weird encoding though!)
+#define DEBUG_STATE_MACHINE (0)
+#if DEBUG_STATE_MACHINE
+#define SIDE(x) ((x)<<8)
+#else
+#define SIDE(x) (0)
+#endif
+
+#define _0 SIDE(0b11100)
+#define _1 SIDE(0b00000)
+#define _2 SIDE(0b10000)
+#define _3 SIDE(0b10100)
+#define _4 SIDE(0b11000)
+#define _5 SIDE(0b10100)
+
+#define IMAGECAPTURE_CODE(width, pclk, vsync, href) \
+    { \
+/* 0 */ pio_encode_wait_gpio(0, vsync) | _0, \
+/* 1 */ pio_encode_wait_gpio(1, vsync) | _1, \
+        /* .wrap_target */  \
+/* 2 */ pio_encode_wait_gpio(1, href)  | _2, \
+/* 3 */ pio_encode_wait_gpio(1, pclk)  | _3, \
+/* 4 */ pio_encode_in(pio_pins, width) | _4, \
+/* 5 */ pio_encode_wait_gpio(0, pclk)  | _5, \
+        /* .wrap */ \
+    }
+
+void common_hal_imagecapture_parallelimagecapture_construct(imagecapture_parallelimagecapture_obj_t *self,
+    const mcu_pin_obj_t *data0,
+    const mcu_pin_obj_t *data_clock,
+    const mcu_pin_obj_t *vertical_sync,
+    const mcu_pin_obj_t *horizontal_reference,
+    int data_count)
+{
+
+    uint16_t imagecapture_code[] = IMAGECAPTURE_CODE(data_count, data_clock->number, vertical_sync->number, horizontal_reference->number);
+
+for(size_t i=0; i<MP_ARRAY_SIZE(imagecapture_code); i++) {
+mp_printf(&mp_plat_print, "[%2d]  %04x\n", i, imagecapture_code[i]);
+}
+
+    common_hal_rp2pio_statemachine_construct(&self->state_machine,
+        imagecapture_code, MP_ARRAY_SIZE(imagecapture_code),
+        // common_hal_mcu_processor_get_frequency(), // full speed (4 instructions per loop -> max pclk 30MHz @ 120MHz)
+        12000000, // 12MHz -> fine for pixel clock 1MHz
+        0, 0, // init
+        NULL, 0, 0, 0, // out pins
+        data0, data_count, // in pins
+        0, 0, // in pulls
+        NULL, 0, 0, 0, // set pins
+#if DEBUG_STATE_MACHINE
+        &pin_GPIO26, 3, 7, 7, // sideset pins
+#else
+        NULL, 0, 0, 0, // sideset pins
+#endif
+        (1<<vertical_sync->number) | (1<<horizontal_reference->number) | (1<<data_clock->number), // wait gpio pins
+        true, // exclusive pin use
+        false, 32, false, // out settings
+        false, // wait for txstall
+        true, 16, true); // in settings
+
+    PIO pio = self->state_machine.pio;
+    uint8_t pio_index = pio_get_index(pio);
+    uint sm = self->state_machine.state_machine;
+    rp2pio_statemachine_set_wrap(&self->state_machine, 2, 5);
+}
+
+void common_hal_imagecapture_parallelimagecapture_deinit(imagecapture_parallelimagecapture_obj_t *self)
+{
+    if (common_hal_imagecapture_parallelimagecapture_deinited(self)) {
+        return;
+    }
+    return common_hal_rp2pio_statemachine_deinit(&self->state_machine);
+}
+
+bool common_hal_imagecapture_parallelimagecapture_deinited(imagecapture_parallelimagecapture_obj_t *self)
+{
+    return common_hal_rp2pio_statemachine_deinited(&self->state_machine);
+}
+
+void common_hal_imagecapture_parallelimagecapture_capture(imagecapture_parallelimagecapture_obj_t *self, void *buffer, size_t bufsize)
+{
+    PIO pio = self->state_machine.pio;
+    uint sm = self->state_machine.state_machine;
+    uint8_t offset = rp2pio_statemachine_program_offset(&self->state_machine);
+
+    pio_sm_set_enabled(pio, sm, false);
+    pio_sm_clear_fifos(pio, sm);
+
+    pio_sm_restart(pio, sm);
+    pio_sm_exec(pio, sm, pio_encode_jmp(offset));
+    pio_sm_set_enabled(pio, sm, true);
+
+    common_hal_rp2pio_statemachine_readinto(&self->state_machine, buffer, bufsize, 2);
+
+    pio_sm_set_enabled(pio, sm, false);
+}

ports/raspberrypi/common-hal/imagecapture/ParallelImageCapture.h

@@ -0,0 +1,35 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Jeff Epler for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#pragma once
+
+#include "common-hal/rp2pio/StateMachine.h"
+#include "shared-bindings/imagecapture/ParallelImageCapture.h"
+
+struct imagecapture_parallelimagecapture_obj {
+    mp_obj_base_t base;
+    rp2pio_statemachine_obj_t state_machine;
+};

ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.c

@@ -84,6 +84,7 @@ void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencode
         3, 0, // in pulls
         NULL, 0, 0, 0x1f, // set pins
         NULL, 0, 0, 0x1f, // sideset pins
+        0, // wait gpio pins
         true, // exclusive pin use
         false, 32, false, // out settings
         false, // Wait for txstall

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

@@ -248,6 +248,7 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
             if (claim_pins) {
                 claim_pin(pin);
             }
+mp_printf(&mp_plat_print, "pio_gpio_init %d\n", pin_number);
             pio_gpio_init(self->pio, pin_number);
         }
     }
@@ -329,13 +330,14 @@ void common_hal_rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     uint32_t pull_pin_up, uint32_t pull_pin_down,
     const mcu_pin_obj_t *first_set_pin, uint8_t set_pin_count, uint32_t initial_set_pin_state, uint32_t initial_set_pin_direction,
     const mcu_pin_obj_t *first_sideset_pin, uint8_t sideset_pin_count, uint32_t initial_sideset_pin_state, uint32_t initial_sideset_pin_direction,
+    uint32_t wait_gpio_mask,
     bool exclusive_pin_use,
     bool auto_pull, uint8_t pull_threshold, bool out_shift_right,
     bool wait_for_txstall,
     bool auto_push, uint8_t push_threshold, bool in_shift_right) {
 
     // 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 = 0;
+    uint32_t pins_we_use = wait_gpio_mask;
     pins_we_use |= _check_pins_free(first_out_pin, out_pin_count, exclusive_pin_use);
     pins_we_use |= _check_pins_free(first_in_pin, in_pin_count, exclusive_pin_use);
     pins_we_use |= _check_pins_free(first_set_pin, set_pin_count, exclusive_pin_use);
@@ -369,6 +371,7 @@ void common_hal_rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
         if (instruction == pio_instr_bits_wait) {
             uint16_t wait_source = (full_instruction & 0x0060) >> 5;
             uint16_t wait_index = full_instruction & 0x001f;
+mp_printf(&mp_plat_print, "checking wait@%d source=%d index=%d\n", i, wait_source, wait_index);
             if (wait_source == 0 && (pins_we_use & (1 << wait_index)) == 0) { // GPIO
                 mp_raise_ValueError_varg(translate("Instruction %d uses extra pin"), i);
             }
@@ -801,3 +804,16 @@ STATIC void rp2pio_statemachine_interrupt_handler(void) {
         }
     }
 }
+
+uint8_t rp2pio_statemachine_program_offset(rp2pio_statemachine_obj_t *self) {
+    uint8_t pio_index = pio_get_index(self->pio);
+    uint8_t sm = self->state_machine;
+    return _current_program_offset[pio_index][sm];
+}
+
+void rp2pio_statemachine_set_wrap(rp2pio_statemachine_obj_t *self, uint wrap_target, uint wrap) {
+    uint8_t sm = self->state_machine;
+    uint8_t offset = rp2pio_statemachine_program_offset(self);
+
+    pio_sm_set_wrap(self->pio, sm, offset+wrap_target, offset+wrap);
+}

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

@@ -74,6 +74,9 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     bool auto_push, uint8_t push_threshold, bool in_shift_right,
     bool claim_pins);
 
+uint8_t rp2pio_statemachine_program_offset(rp2pio_statemachine_obj_t *self);
+void rp2pio_statemachine_set_wrap(rp2pio_statemachine_obj_t *self, uint wrap_target, uint wrap);
+
 void rp2pio_statemachine_deinit(rp2pio_statemachine_obj_t *self, bool leave_pins);
 
 extern const mp_obj_type_t rp2pio_statemachine_type;

ports/raspberrypi/mpconfigport.mk

@@ -23,6 +23,7 @@ CIRCUITPY_FRAMEBUFFERIO ?= 1
 CIRCUITPY_FULL_BUILD ?= 1
 CIRCUITPY_AUDIOMP3 ?= 1
 CIRCUITPY_BITOPS ?= 1
+CIRCUITPY_IMAGECAPTURE ?= 1
 CIRCUITPY_PWMIO ?= 1
 CIRCUITPY_RGBMATRIX ?= 1
 CIRCUITPY_ROTARYIO ?= 1