Merge remote-tracking branch 'origin/main' into bitmap-read-2

39 files changed, 346 insertions, 344 deletions

diff --git a/ports/raspberrypi/common-hal/analogio/AnalogIn.c b/ports/raspberrypi/common-hal/analogio/AnalogIn.c
index c51a74929..7db2956b0 100644
--- a/ports/raspberrypi/common-hal/analogio/AnalogIn.c
+++ b/ports/raspberrypi/common-hal/analogio/AnalogIn.c
@@ -64,7 +64,7 @@ uint16_t common_hal_analogio_analogin_get_value(analogio_analogin_obj_t *self) {
     uint16_t value = adc_read();
 
     // Map value to from 12 to 16 bits
-    return (value << 4);
+    return value << 4;
 }
 
 float common_hal_analogio_analogin_get_reference_voltage(analogio_analogin_obj_t *self) {
diff --git a/ports/raspberrypi/common-hal/analogio/AnalogIn.h b/ports/raspberrypi/common-hal/analogio/AnalogIn.h
index ee9976e34..c322a6776 100644
--- a/ports/raspberrypi/common-hal/analogio/AnalogIn.h
+++ b/ports/raspberrypi/common-hal/analogio/AnalogIn.h
@@ -33,7 +33,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    const mcu_pin_obj_t * pin;
+    const mcu_pin_obj_t *pin;
 } analogio_analogin_obj_t;
 
 void analogin_init(void);
diff --git a/ports/raspberrypi/common-hal/analogio/AnalogOut.c b/ports/raspberrypi/common-hal/analogio/AnalogOut.c
index adafa15d5..7afa773d3 100644
--- a/ports/raspberrypi/common-hal/analogio/AnalogOut.c
+++ b/ports/raspberrypi/common-hal/analogio/AnalogOut.c
@@ -33,7 +33,7 @@
 #include "py/runtime.h"
 #include "supervisor/shared/translate.h"
 
-void common_hal_analogio_analogout_construct(analogio_analogout_obj_t* self, const mcu_pin_obj_t *pin) {
+void common_hal_analogio_analogout_construct(analogio_analogout_obj_t *self, const mcu_pin_obj_t *pin) {
     mp_raise_RuntimeError(translate("AnalogOut functionality not supported"));
 }
 
diff --git a/ports/raspberrypi/common-hal/audiobusio/I2SOut.c b/ports/raspberrypi/common-hal/audiobusio/I2SOut.c
index fa5852fce..5f77a74a5 100644
--- a/ports/raspberrypi/common-hal/audiobusio/I2SOut.c
+++ b/ports/raspberrypi/common-hal/audiobusio/I2SOut.c
@@ -101,18 +101,19 @@ void i2sout_reset(void) {
 }
 
 // Caller validates that pins are free.
-void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t* self,
-        const mcu_pin_obj_t* bit_clock, const mcu_pin_obj_t* word_select,
-        const mcu_pin_obj_t* data, bool left_justified) {
+void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t *self,
+    const mcu_pin_obj_t *bit_clock, const mcu_pin_obj_t *word_select,
+    const mcu_pin_obj_t *data, bool left_justified) {
     if (bit_clock->number != word_select->number - 1) {
         mp_raise_ValueError(translate("Bit clock and word select must be sequential pins"));
     }
 
-    const uint16_t* program = i2s_program;
+    const uint16_t *program = i2s_program;
     size_t program_len = sizeof(i2s_program) / sizeof(i2s_program[0]);
     if (left_justified) {
         program = i2s_program_left_justified;
-        program_len = sizeof(i2s_program_left_justified) / sizeof(i2s_program_left_justified[0]);;
+        program_len = sizeof(i2s_program_left_justified) / sizeof(i2s_program_left_justified[0]);
+        ;
     }
 
     // Use the state machine to manage pins.
@@ -134,11 +135,11 @@ void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t* self,
     audio_dma_init(&self->dma);
 }
 
-bool common_hal_audiobusio_i2sout_deinited(audiobusio_i2sout_obj_t* self) {
+bool common_hal_audiobusio_i2sout_deinited(audiobusio_i2sout_obj_t *self) {
     return common_hal_rp2pio_statemachine_deinited(&self->state_machine);
 }
 
-void common_hal_audiobusio_i2sout_deinit(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_deinit(audiobusio_i2sout_obj_t *self) {
     if (common_hal_audiobusio_i2sout_deinited(self)) {
         return;
     }
@@ -146,8 +147,8 @@ void common_hal_audiobusio_i2sout_deinit(audiobusio_i2sout_obj_t* self) {
     common_hal_rp2pio_statemachine_deinit(&self->state_machine);
 }
 
-void common_hal_audiobusio_i2sout_play(audiobusio_i2sout_obj_t* self,
-                                       mp_obj_t sample, bool loop) {
+void common_hal_audiobusio_i2sout_play(audiobusio_i2sout_obj_t *self,
+    mp_obj_t sample, bool loop) {
     if (common_hal_audiobusio_i2sout_get_playing(self)) {
         common_hal_audiobusio_i2sout_stop(self);
     }
@@ -178,7 +179,7 @@ void common_hal_audiobusio_i2sout_play(audiobusio_i2sout_obj_t* self,
         0, // audio channel
         true,  // output signed
         bits_per_sample,
-        (uint32_t) &self->state_machine.pio->txf[self->state_machine.state_machine], // output register
+        (uint32_t)&self->state_machine.pio->txf[self->state_machine.state_machine],  // output register
         self->state_machine.tx_dreq); // data request line
 
     if (result == AUDIO_DMA_DMA_BUSY) {
@@ -194,21 +195,21 @@ void common_hal_audiobusio_i2sout_play(audiobusio_i2sout_obj_t* self,
     self->playing = true;
 }
 
-void common_hal_audiobusio_i2sout_pause(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_pause(audiobusio_i2sout_obj_t *self) {
     audio_dma_pause(&self->dma);
 }
 
-void common_hal_audiobusio_i2sout_resume(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_resume(audiobusio_i2sout_obj_t *self) {
     // Maybe: Clear any overrun/underrun errors
 
     audio_dma_resume(&self->dma);
 }
 
-bool common_hal_audiobusio_i2sout_get_paused(audiobusio_i2sout_obj_t* self) {
+bool common_hal_audiobusio_i2sout_get_paused(audiobusio_i2sout_obj_t *self) {
     return audio_dma_get_paused(&self->dma);
 }
 
-void common_hal_audiobusio_i2sout_stop(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_stop(audiobusio_i2sout_obj_t *self) {
     audio_dma_stop(&self->dma);
 
     common_hal_rp2pio_statemachine_stop(&self->state_machine);
@@ -216,7 +217,7 @@ void common_hal_audiobusio_i2sout_stop(audiobusio_i2sout_obj_t* self) {
     self->playing = false;
 }
 
-bool common_hal_audiobusio_i2sout_get_playing(audiobusio_i2sout_obj_t* self) {
+bool common_hal_audiobusio_i2sout_get_playing(audiobusio_i2sout_obj_t *self) {
     bool playing = audio_dma_get_playing(&self->dma);
     if (!playing && self->playing) {
         common_hal_audiobusio_i2sout_stop(self);
diff --git a/ports/raspberrypi/common-hal/audiobusio/PDMIn.c b/ports/raspberrypi/common-hal/audiobusio/PDMIn.c
index 883660271..bbcfbb805 100644
--- a/ports/raspberrypi/common-hal/audiobusio/PDMIn.c
+++ b/ports/raspberrypi/common-hal/audiobusio/PDMIn.c
@@ -50,13 +50,13 @@ const uint16_t pdmin[] = {
 };
 
 // Caller validates that pins are free.
-void common_hal_audiobusio_pdmin_construct(audiobusio_pdmin_obj_t* self,
-                                           const mcu_pin_obj_t* clock_pin,
-                                           const mcu_pin_obj_t* data_pin,
-                                           uint32_t sample_rate,
-                                           uint8_t bit_depth,
-                                           bool mono,
-                                           uint8_t oversample) {
+void common_hal_audiobusio_pdmin_construct(audiobusio_pdmin_obj_t *self,
+    const mcu_pin_obj_t *clock_pin,
+    const mcu_pin_obj_t *data_pin,
+    uint32_t sample_rate,
+    uint8_t bit_depth,
+    bool mono,
+    uint8_t oversample) {
     if (!(bit_depth == 16 || bit_depth == 8) || !mono || oversample != OVERSAMPLING) {
         mp_raise_NotImplementedError(translate("Only 8 or 16 bit mono with " MP_STRINGIFY(OVERSAMPLING) "x oversampling is supported."));
     }
@@ -77,30 +77,30 @@ void common_hal_audiobusio_pdmin_construct(audiobusio_pdmin_obj_t* self,
         false, 32, true); // in settings
 
     uint32_t actual_frequency = common_hal_rp2pio_statemachine_get_frequency(&self->state_machine);
-    if (actual_frequency <  MIN_MIC_CLOCK) {
+    if (actual_frequency < MIN_MIC_CLOCK) {
         mp_raise_ValueError(translate("sampling rate out of range"));
     }
 
-    self->sample_rate =  actual_frequency / oversample;
+    self->sample_rate = actual_frequency / oversample;
     self->bit_depth = bit_depth;
 }
 
-bool common_hal_audiobusio_pdmin_deinited(audiobusio_pdmin_obj_t* self) {
+bool common_hal_audiobusio_pdmin_deinited(audiobusio_pdmin_obj_t *self) {
     return common_hal_rp2pio_statemachine_deinited(&self->state_machine);
 }
 
-void common_hal_audiobusio_pdmin_deinit(audiobusio_pdmin_obj_t* self) {
+void common_hal_audiobusio_pdmin_deinit(audiobusio_pdmin_obj_t *self) {
     if (common_hal_audiobusio_pdmin_deinited(self)) {
         return;
     }
     return common_hal_rp2pio_statemachine_deinit(&self->state_machine);
 }
 
-uint8_t common_hal_audiobusio_pdmin_get_bit_depth(audiobusio_pdmin_obj_t* self) {
+uint8_t common_hal_audiobusio_pdmin_get_bit_depth(audiobusio_pdmin_obj_t *self) {
     return self->bit_depth;
 }
 
-uint32_t common_hal_audiobusio_pdmin_get_sample_rate(audiobusio_pdmin_obj_t* self) {
+uint32_t common_hal_audiobusio_pdmin_get_sample_rate(audiobusio_pdmin_obj_t *self) {
     return self->sample_rate;
 }
 
@@ -114,7 +114,7 @@ uint32_t common_hal_audiobusio_pdmin_get_sample_rate(audiobusio_pdmin_obj_t* sel
 // higher sample rate than specified.  Then after the audio is
 // recorded, a more expensive filter non-real-time filter could be
 // used to down-sample and low-pass.
-const uint16_t sinc_filter [OVERSAMPLING] = {
+const uint16_t sinc_filter[OVERSAMPLING] = {
     0, 2, 9, 21, 39, 63, 94, 132,
     179, 236, 302, 379, 467, 565, 674, 792,
     920, 1055, 1196, 1341, 1487, 1633, 1776, 1913,
@@ -125,20 +125,20 @@ const uint16_t sinc_filter [OVERSAMPLING] = {
     94, 63, 39, 21, 9, 2, 0, 0
 };
 
-#define REPEAT_32_TIMES(X) do { X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X } while(0)
+#define REPEAT_32_TIMES(X) do { X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X } while (0)
 
 static uint16_t filter_sample(uint32_t pdm_samples[2]) {
     uint16_t running_sum = 0;
     const uint16_t *filter_ptr = sinc_filter;
     for (uint8_t i = 0; i < 2; i++) {
         uint32_t pdm_sample = pdm_samples[i];
-        REPEAT_32_TIMES( {
-                if (pdm_sample & 0x1) {
-                    running_sum += *filter_ptr;
-                }
-                filter_ptr++;
-                pdm_sample >>= 1;
+        REPEAT_32_TIMES({
+            if (pdm_sample & 0x1) {
+                running_sum += *filter_ptr;
             }
+            filter_ptr++;
+            pdm_sample >>= 1;
+        }
             );
     }
     return running_sum;
@@ -146,20 +146,20 @@ static uint16_t filter_sample(uint32_t pdm_samples[2]) {
 
 // output_buffer may be a byte buffer or a halfword buffer.
 // output_buffer_length is the number of slots, not the number of bytes.
-uint32_t common_hal_audiobusio_pdmin_record_to_buffer(audiobusio_pdmin_obj_t* self,
-        uint16_t* output_buffer, uint32_t output_buffer_length) {
+uint32_t common_hal_audiobusio_pdmin_record_to_buffer(audiobusio_pdmin_obj_t *self,
+    uint16_t *output_buffer, uint32_t output_buffer_length) {
     uint32_t samples[2];
     size_t output_count = 0;
     common_hal_rp2pio_statemachine_clear_rxfifo(&self->state_machine);
     // Do one read to get the mic going and throw it away.
-    common_hal_rp2pio_statemachine_readinto(&self->state_machine, (uint8_t*) samples, 2 * sizeof(uint32_t), sizeof(uint32_t));
+    common_hal_rp2pio_statemachine_readinto(&self->state_machine, (uint8_t *)samples, 2 * sizeof(uint32_t), sizeof(uint32_t));
     while (output_count < output_buffer_length && !common_hal_rp2pio_statemachine_get_rxstall(&self->state_machine)) {
-        common_hal_rp2pio_statemachine_readinto(&self->state_machine, (uint8_t*) samples, 2 * sizeof(uint32_t), sizeof(uint32_t));
+        common_hal_rp2pio_statemachine_readinto(&self->state_machine, (uint8_t *)samples, 2 * sizeof(uint32_t), sizeof(uint32_t));
         // Call filter_sample just one place so it can be inlined.
         uint16_t value = filter_sample(samples);
         if (self->bit_depth == 8) {
             // Truncate to 8 bits.
-            ((uint8_t*) output_buffer)[output_count] = value >> 8;
+            ((uint8_t *)output_buffer)[output_count] = value >> 8;
         } else {
             output_buffer[output_count] = value;
         }
@@ -169,6 +169,6 @@ uint32_t common_hal_audiobusio_pdmin_record_to_buffer(audiobusio_pdmin_obj_t* se
     return output_count;
 }
 
-void common_hal_audiobusio_pdmin_record_to_file(audiobusio_pdmin_obj_t* self, uint8_t* buffer, uint32_t length) {
+void common_hal_audiobusio_pdmin_record_to_file(audiobusio_pdmin_obj_t *self, uint8_t *buffer, uint32_t length) {
 
 }
diff --git a/ports/raspberrypi/common-hal/audiopwmio/PWMAudioOut.c b/ports/raspberrypi/common-hal/audiopwmio/PWMAudioOut.c
index 57605a1fb..4fef53ff0 100644
--- a/ports/raspberrypi/common-hal/audiopwmio/PWMAudioOut.c
+++ b/ports/raspberrypi/common-hal/audiopwmio/PWMAudioOut.c
@@ -53,8 +53,8 @@ void audiopwmout_reset() {
 }
 
 // Caller validates that pins are free.
-void common_hal_audiopwmio_pwmaudioout_construct(audiopwmio_pwmaudioout_obj_t* self,
-        const mcu_pin_obj_t* left_channel, const mcu_pin_obj_t* right_channel, uint16_t quiescent_value) {
+void common_hal_audiopwmio_pwmaudioout_construct(audiopwmio_pwmaudioout_obj_t *self,
+    const mcu_pin_obj_t *left_channel, const mcu_pin_obj_t *right_channel, uint16_t quiescent_value) {
     if (left_channel != NULL && right_channel != NULL) {
         if (pwm_gpio_to_slice_num(left_channel->number) != pwm_gpio_to_slice_num(right_channel->number)) {
             mp_raise_ValueError(translate("Pins must share PWM slice"));
@@ -106,11 +106,11 @@ void common_hal_audiopwmio_pwmaudioout_construct(audiopwmio_pwmaudioout_obj_t* s
     self->quiescent_value = quiescent_value;
 }
 
-bool common_hal_audiopwmio_pwmaudioout_deinited(audiopwmio_pwmaudioout_obj_t* self) {
+bool common_hal_audiopwmio_pwmaudioout_deinited(audiopwmio_pwmaudioout_obj_t *self) {
     return common_hal_pwmio_pwmout_deinited(&self->left_pwm);
 }
 
-void common_hal_audiopwmio_pwmaudioout_deinit(audiopwmio_pwmaudioout_obj_t* self) {
+void common_hal_audiopwmio_pwmaudioout_deinit(audiopwmio_pwmaudioout_obj_t *self) {
     if (common_hal_audiopwmio_pwmaudioout_deinited(self)) {
         return;
     }
@@ -125,7 +125,7 @@ void common_hal_audiopwmio_pwmaudioout_deinit(audiopwmio_pwmaudioout_obj_t* self
     audio_dma_deinit(&self->dma);
 }
 
-void common_hal_audiopwmio_pwmaudioout_play(audiopwmio_pwmaudioout_obj_t* self, mp_obj_t sample, bool loop) {
+void common_hal_audiopwmio_pwmaudioout_play(audiopwmio_pwmaudioout_obj_t *self, mp_obj_t sample, bool loop) {
     if (common_hal_audiopwmio_pwmaudioout_get_playing(self)) {
         common_hal_audiopwmio_pwmaudioout_stop(self);
     }
@@ -141,7 +141,7 @@ void common_hal_audiopwmio_pwmaudioout_play(audiopwmio_pwmaudioout_obj_t* self,
     if (pacing_timer == NUM_DMA_TIMERS) {
         mp_raise_RuntimeError(translate("No DMA pacing timer found"));
     }
-    uint32_t tx_register = (uint32_t) &pwm_hw->slice[self->left_pwm.slice].cc;
+    uint32_t tx_register = (uint32_t)&pwm_hw->slice[self->left_pwm.slice].cc;
     if (common_hal_pwmio_pwmout_deinited(&self->right_pwm)) {
         // Shift the destination if we are outputting to the second PWM channel.
         tx_register += self->left_pwm.channel * sizeof(uint16_t);
@@ -157,7 +157,7 @@ void common_hal_audiopwmio_pwmaudioout_play(audiopwmio_pwmaudioout_obj_t* self,
         0, // audio channel
         false,  // output signed
         10,
-        (uint32_t) tx_register, // output register
+        (uint32_t)tx_register,  // output register
         0x3b + pacing_timer); // data request line
 
     if (result == AUDIO_DMA_DMA_BUSY) {
@@ -206,14 +206,14 @@ void common_hal_audiopwmio_pwmaudioout_play(audiopwmio_pwmaudioout_obj_t* self,
     dma_hw->timer[pacing_timer] = best_numerator << 16 | best_denominator;
 }
 
-void common_hal_audiopwmio_pwmaudioout_stop(audiopwmio_pwmaudioout_obj_t* self) {
+void common_hal_audiopwmio_pwmaudioout_stop(audiopwmio_pwmaudioout_obj_t *self) {
     dma_hw->timer[self->pacing_timer] = 0;
     self->pacing_timer = NUM_DMA_TIMERS;
 
     audio_dma_stop(&self->dma);
 }
 
-bool common_hal_audiopwmio_pwmaudioout_get_playing(audiopwmio_pwmaudioout_obj_t* self) {
+bool common_hal_audiopwmio_pwmaudioout_get_playing(audiopwmio_pwmaudioout_obj_t *self) {
     bool playing = audio_dma_get_playing(&self->dma);
     if (!playing && self->pacing_timer < NUM_DMA_TIMERS) {
         dma_hw->timer[self->pacing_timer] = 0;
@@ -222,14 +222,14 @@ bool common_hal_audiopwmio_pwmaudioout_get_playing(audiopwmio_pwmaudioout_obj_t*
     return playing;
 }
 
-void common_hal_audiopwmio_pwmaudioout_pause(audiopwmio_pwmaudioout_obj_t* self) {
+void common_hal_audiopwmio_pwmaudioout_pause(audiopwmio_pwmaudioout_obj_t *self) {
     audio_dma_pause(&self->dma);
 }
 
-void common_hal_audiopwmio_pwmaudioout_resume(audiopwmio_pwmaudioout_obj_t* self) {
+void common_hal_audiopwmio_pwmaudioout_resume(audiopwmio_pwmaudioout_obj_t *self) {
     audio_dma_resume(&self->dma);
 }
 
-bool common_hal_audiopwmio_pwmaudioout_get_paused(audiopwmio_pwmaudioout_obj_t* self) {
+bool common_hal_audiopwmio_pwmaudioout_get_paused(audiopwmio_pwmaudioout_obj_t *self) {
     return audio_dma_get_paused(&self->dma);
 }
diff --git a/ports/raspberrypi/common-hal/busio/I2C.c b/ports/raspberrypi/common-hal/busio/I2C.c
index cb0d73e75..c9f89fadd 100644
--- a/ports/raspberrypi/common-hal/busio/I2C.c
+++ b/ports/raspberrypi/common-hal/busio/I2C.c
@@ -42,7 +42,7 @@
 #define BUS_TIMEOUT_US 1000000
 
 STATIC bool never_reset_i2c[2];
-STATIC i2c_inst_t* i2c[2] = {i2c0, i2c1};
+STATIC i2c_inst_t *i2c[2] = {i2c0, i2c1};
 
 void reset_i2c(void) {
     for (size_t i = 0; i < 2; i++) {
@@ -55,7 +55,7 @@ void reset_i2c(void) {
 }
 
 void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
-        const mcu_pin_obj_t* scl, const mcu_pin_obj_t* sda, uint32_t frequency, uint32_t timeout) {
+    const mcu_pin_obj_t *scl, const mcu_pin_obj_t *sda, uint32_t frequency, uint32_t timeout) {
     self->peripheral = NULL;
     // I2C pins have a regular pattern. SCL is always odd and SDA is even. They match up in pairs
     // so we can divide by two to get the instance. This pattern repeats.
@@ -73,7 +73,7 @@ void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
         mp_raise_ValueError(translate("Unsupported baudrate"));
     }
 
-#if CIRCUITPY_REQUIRE_I2C_PULLUPS
+    #if CIRCUITPY_REQUIRE_I2C_PULLUPS
     // Test that the pins are in a high state. (Hopefully indicating they are pulled up.)
     gpio_set_function(sda->number, GPIO_FUNC_SIO);
     gpio_set_function(scl->number, GPIO_FUNC_SIO);
@@ -96,7 +96,7 @@ void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
         reset_pin_number(scl->number);
         mp_raise_RuntimeError(translate("No pull up found on SDA or SCL; check your wiring"));
     }
-#endif
+    #endif
 
     // Create a bitbangio.I2C object to do short writes.
     // Must be done before setting up the I2C pins, since they will be
@@ -104,7 +104,7 @@ void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
     //
     // Sets pins to open drain, high, and input.
     shared_module_bitbangio_i2c_construct(&self->bitbangio_i2c, scl, sda,
-                                          frequency, timeout);
+        frequency, timeout);
 
     self->baudrate = i2c_init(self->peripheral, frequency);
 
@@ -157,7 +157,7 @@ void common_hal_busio_i2c_unlock(busio_i2c_obj_t *self) {
 }
 
 uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t addr,
-                                   const uint8_t *data, size_t len, bool transmit_stop_bit) {
+    const uint8_t *data, size_t len, bool transmit_stop_bit) {
     if (len <= 2) {
         // The RP2040 I2C peripheral will not do writes 2 bytes or less long.
         // So use bitbangio.I2C to do the write.
@@ -170,7 +170,7 @@ uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t addr,
         gpio_put(self->sda_pin, false);
 
         uint8_t status = shared_module_bitbangio_i2c_write(&self->bitbangio_i2c,
-                                                           addr, data, len, transmit_stop_bit);
+            addr, data, len, transmit_stop_bit);
 
         // The pins must be set back to GPIO_FUNC_I2C in the order given here,
         // SCL first, otherwise reads will hang.
@@ -195,7 +195,7 @@ uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t addr,
 }
 
 uint8_t common_hal_busio_i2c_read(busio_i2c_obj_t *self, uint16_t addr,
-        uint8_t *data, size_t len) {
+    uint8_t *data, size_t len) {
     int result = i2c_read_timeout_us(self->peripheral, addr, data, len, false, BUS_TIMEOUT_US);
     if (result == len) {
         return 0;
diff --git a/ports/raspberrypi/common-hal/busio/I2C.h b/ports/raspberrypi/common-hal/busio/I2C.h
index 651054a04..dbaede1f5 100644
--- a/ports/raspberrypi/common-hal/busio/I2C.h
+++ b/ports/raspberrypi/common-hal/busio/I2C.h
@@ -36,7 +36,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    i2c_inst_t * peripheral;
+    i2c_inst_t *peripheral;
     bitbangio_i2c_obj_t bitbangio_i2c;
     bool has_lock;
     uint baudrate;
diff --git a/ports/raspberrypi/common-hal/busio/SPI.c b/ports/raspberrypi/common-hal/busio/SPI.c
index b157ae3eb..0fc71136e 100644
--- a/ports/raspberrypi/common-hal/busio/SPI.c
+++ b/ports/raspberrypi/common-hal/busio/SPI.c
@@ -41,7 +41,7 @@
 #define NO_INSTANCE 0xff
 
 STATIC bool never_reset_spi[2];
-STATIC spi_inst_t* spi[2] = {spi0, spi1};
+STATIC spi_inst_t *spi[2] = {spi0, spi1};
 
 void reset_spi(void) {
     for (size_t i = 0; i < 2; i++) {
@@ -54,8 +54,8 @@ void reset_spi(void) {
 }
 
 void common_hal_busio_spi_construct(busio_spi_obj_t *self,
-        const mcu_pin_obj_t * clock, const mcu_pin_obj_t * mosi,
-        const mcu_pin_obj_t * miso) {
+    const mcu_pin_obj_t *clock, const mcu_pin_obj_t *mosi,
+    const mcu_pin_obj_t *miso) {
     size_t instance_index = NO_INSTANCE;
     if (clock->number % 4 == 2) {
         instance_index = (clock->number / 8) % 2;
@@ -136,7 +136,7 @@ void common_hal_busio_spi_deinit(busio_spi_obj_t *self) {
 }
 
 bool common_hal_busio_spi_configure(busio_spi_obj_t *self,
-        uint32_t baudrate, uint8_t polarity, uint8_t phase, uint8_t bits) {
+    uint32_t baudrate, uint8_t polarity, uint8_t phase, uint8_t bits) {
     if (baudrate == self->target_frequency &&
         polarity == self->polarity &&
         phase == self->phase &&
@@ -244,7 +244,7 @@ static bool _transfer(busio_spi_obj_t *self,
 
         while (!mp_hal_is_interrupted() && (rx_remaining || tx_remaining)) {
             if (tx_remaining && spi_is_writable(self->peripheral) && rx_remaining - tx_remaining < fifo_depth) {
-                spi_get_hw(self->peripheral)->dr = (uint32_t) *data_out;
+                spi_get_hw(self->peripheral)->dr = (uint32_t)*data_out;
                 // Increment only if the buffer is the transfer length. It's 1 otherwise.
                 if (out_len == len) {
                     data_out++;
@@ -252,7 +252,7 @@ static bool _transfer(busio_spi_obj_t *self,
                 --tx_remaining;
             }
             if (rx_remaining && spi_is_readable(self->peripheral)) {
-                *data_in = (uint8_t) spi_get_hw(self->peripheral)->dr;
+                *data_in = (uint8_t)spi_get_hw(self->peripheral)->dr;
                 // Increment only if the buffer is the transfer length. It's 1 otherwise.
                 if (in_len == len) {
                     data_in++;
@@ -266,29 +266,29 @@ static bool _transfer(busio_spi_obj_t *self,
 }
 
 bool common_hal_busio_spi_write(busio_spi_obj_t *self,
-        const uint8_t *data, size_t len) {
+    const uint8_t *data, size_t len) {
     uint32_t data_in;
-    return _transfer(self, data, len, (uint8_t*) &data_in, MIN(len, 4));
+    return _transfer(self, data, len, (uint8_t *)&data_in, MIN(len, 4));
 }
 
 bool common_hal_busio_spi_read(busio_spi_obj_t *self,
-        uint8_t *data, size_t len, uint8_t write_value) {
+    uint8_t *data, size_t len, uint8_t write_value) {
     uint32_t data_out = write_value << 24 | write_value << 16 | write_value << 8 | write_value;
-    return _transfer(self, (const uint8_t*) &data_out, MIN(4, len), data, len);
+    return _transfer(self, (const uint8_t *)&data_out, MIN(4, len), data, len);
 }
 
 bool common_hal_busio_spi_transfer(busio_spi_obj_t *self, const uint8_t *data_out, uint8_t *data_in, size_t len) {
     return _transfer(self, data_out, len, data_in, len);
 }
 
-uint32_t common_hal_busio_spi_get_frequency(busio_spi_obj_t* self) {
+uint32_t common_hal_busio_spi_get_frequency(busio_spi_obj_t *self) {
     return self->real_frequency;
 }
 
-uint8_t common_hal_busio_spi_get_phase(busio_spi_obj_t* self) {
+uint8_t common_hal_busio_spi_get_phase(busio_spi_obj_t *self) {
     return self->phase;
 }
 
-uint8_t common_hal_busio_spi_get_polarity(busio_spi_obj_t* self) {
+uint8_t common_hal_busio_spi_get_polarity(busio_spi_obj_t *self) {
     return self->polarity;
 }
diff --git a/ports/raspberrypi/common-hal/busio/SPI.h b/ports/raspberrypi/common-hal/busio/SPI.h
index 981db46d4..b76dbbf9d 100644
--- a/ports/raspberrypi/common-hal/busio/SPI.h
+++ b/ports/raspberrypi/common-hal/busio/SPI.h
@@ -35,11 +35,11 @@
 
 typedef struct {
     mp_obj_base_t base;
-    spi_inst_t * peripheral;
+    spi_inst_t *peripheral;
     bool has_lock;
-    const mcu_pin_obj_t* clock;
-    const mcu_pin_obj_t* MOSI;
-    const mcu_pin_obj_t* MISO;
+    const mcu_pin_obj_t *clock;
+    const mcu_pin_obj_t *MOSI;
+    const mcu_pin_obj_t *MISO;
     uint32_t target_frequency;
     int32_t real_frequency;
     uint8_t polarity;
diff --git a/ports/raspberrypi/common-hal/busio/UART.c b/ports/raspberrypi/common-hal/busio/UART.c
index 1bc121177..2d8ff099e 100644
--- a/ports/raspberrypi/common-hal/busio/UART.c
+++ b/ports/raspberrypi/common-hal/busio/UART.c
@@ -61,7 +61,7 @@ void never_reset_uart(uint8_t num) {
     uart_status[num] = STATUS_NEVER_RESET;
 }
 
-static uint8_t pin_init(const uint8_t uart, const mcu_pin_obj_t * pin, const uint8_t pin_type) {
+static uint8_t pin_init(const uint8_t uart, const mcu_pin_obj_t *pin, const uint8_t pin_type) {
     if (pin == NULL) {
         return NO_PIN;
     }
@@ -73,11 +73,11 @@ static uint8_t pin_init(const uint8_t uart, const mcu_pin_obj_t * pin, const uin
     return pin->number;
 }
 
-static busio_uart_obj_t* active_uarts[NUM_UARTS];
+static busio_uart_obj_t *active_uarts[NUM_UARTS];
 
-static void _copy_into_ringbuf(ringbuf_t* r, uart_inst_t* uart) {
+static void _copy_into_ringbuf(ringbuf_t *r, uart_inst_t *uart) {
     while (uart_is_readable(uart) && ringbuf_num_empty(r) > 0) {
-        ringbuf_put(r, (uint8_t) uart_get_hw(uart)->dr);
+        ringbuf_put(r, (uint8_t)uart_get_hw(uart)->dr);
     }
 }
 
@@ -97,12 +97,12 @@ static void uart1_callback(void) {
 }
 
 void common_hal_busio_uart_construct(busio_uart_obj_t *self,
-        const mcu_pin_obj_t * tx, const mcu_pin_obj_t * rx,
-        const mcu_pin_obj_t * rts, const mcu_pin_obj_t * cts,
-        const mcu_pin_obj_t * rs485_dir, bool rs485_invert,
-        uint32_t baudrate, uint8_t bits, busio_uart_parity_t parity, uint8_t stop,
-        mp_float_t timeout, uint16_t receiver_buffer_size, byte* receiver_buffer,
-        bool sigint_enabled) {
+    const mcu_pin_obj_t *tx, const mcu_pin_obj_t *rx,
+    const mcu_pin_obj_t *rts, const mcu_pin_obj_t *cts,
+    const mcu_pin_obj_t *rs485_dir, bool rs485_invert,
+    uint32_t baudrate, uint8_t bits, busio_uart_parity_t parity, uint8_t stop,
+    mp_float_t timeout, uint16_t receiver_buffer_size, byte *receiver_buffer,
+    bool sigint_enabled) {
 
     if (bits > 8) {
         mp_raise_ValueError(translate("Invalid word/bit length"));
@@ -223,7 +223,7 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
 
     // Check if we still need to read more data.
     if (len > total_read) {
-        len-=total_read;
+        len -= total_read;
         uint64_t start_ticks = supervisor_ticks_ms64();
         // Busy-wait until timeout or until we've read enough chars.
         while (len > 0 && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms)) {
@@ -272,7 +272,7 @@ void common_hal_busio_uart_set_baudrate(busio_uart_obj_t *self, uint32_t baudrat
 }
 
 mp_float_t common_hal_busio_uart_get_timeout(busio_uart_obj_t *self) {
-    return (mp_float_t) (self->timeout_ms / 1000.0f);
+    return (mp_float_t)(self->timeout_ms / 1000.0f);
 }
 
 void common_hal_busio_uart_set_timeout(busio_uart_obj_t *self, mp_float_t timeout) {
@@ -296,7 +296,7 @@ void common_hal_busio_uart_clear_rx_buffer(busio_uart_obj_t *self) {
 
     // Throw away the FIFO contents too.
     while (uart_is_readable(self->uart)) {
-        (void) uart_get_hw(self->uart)->dr;
+        (void)uart_get_hw(self->uart)->dr;
     }
     irq_set_enabled(self->uart_irq_id, true);
 }
diff --git a/ports/raspberrypi/common-hal/busio/UART.h b/ports/raspberrypi/common-hal/busio/UART.h
index 4c07de240..f6978fd1d 100644
--- a/ports/raspberrypi/common-hal/busio/UART.h
+++ b/ports/raspberrypi/common-hal/busio/UART.h
@@ -42,7 +42,7 @@ typedef struct {
     uint8_t uart_irq_id;
     uint32_t baudrate;
     uint32_t timeout_ms;
-    uart_inst_t * uart;
+    uart_inst_t *uart;
     ringbuf_t ringbuf;
 } busio_uart_obj_t;
 
diff --git a/ports/raspberrypi/common-hal/countio/Counter.c b/ports/raspberrypi/common-hal/countio/Counter.c
index 69629a084..2dcd1de12 100644
--- a/ports/raspberrypi/common-hal/countio/Counter.c
+++ b/ports/raspberrypi/common-hal/countio/Counter.c
@@ -11,8 +11,8 @@
 #include "src/rp2_common/hardware_irq/include/hardware/irq.h"
 
 
-void common_hal_countio_counter_construct(countio_counter_obj_t* self,
-    const mcu_pin_obj_t* pin_a) {
+void common_hal_countio_counter_construct(countio_counter_obj_t *self,
+    const mcu_pin_obj_t *pin_a) {
 
     if (pwm_gpio_to_channel(pin_a->number) != PWM_CHAN_B) {
         mp_raise_RuntimeError(translate("Pin must be on PWM Channel B"));
@@ -48,11 +48,11 @@ void common_hal_countio_counter_construct(countio_counter_obj_t* self,
     pwm_set_enabled(self->slice_num, true);
 }
 
-bool common_hal_countio_counter_deinited(countio_counter_obj_t* self) {
+bool common_hal_countio_counter_deinited(countio_counter_obj_t *self) {
     return self->pin_a == 0;
 }
 
-void common_hal_countio_counter_deinit(countio_counter_obj_t* self) {
+void common_hal_countio_counter_deinit(countio_counter_obj_t *self) {
     if (common_hal_countio_counter_deinited(self)) {
         return;
     }
@@ -69,19 +69,19 @@ void common_hal_countio_counter_deinit(countio_counter_obj_t* self) {
     self->slice_num = 0;
 }
 
-mp_int_t common_hal_countio_counter_get_count(countio_counter_obj_t* self) {
+mp_int_t common_hal_countio_counter_get_count(countio_counter_obj_t *self) {
     self->count += pwm_get_counter(self->slice_num);
     pwm_set_counter(self->slice_num, 0);
     return self->count;
 }
 
-void common_hal_countio_counter_set_count(countio_counter_obj_t* self,
-        mp_int_t new_count) {
+void common_hal_countio_counter_set_count(countio_counter_obj_t *self,
+    mp_int_t new_count) {
     pwm_set_counter(self->slice_num, 0);
     self->count = new_count;
 }
 
-void common_hal_countio_counter_reset(countio_counter_obj_t* self){
+void common_hal_countio_counter_reset(countio_counter_obj_t *self) {
     pwm_set_counter(self->slice_num, 0);
     self->count = 0;
 }
@@ -95,7 +95,7 @@ void counter_interrupt_handler() {
         ++pos;
     }
 
-    countio_counter_obj_t *self = MP_STATE_PORT(counting)[pos-1];
+    countio_counter_obj_t *self = MP_STATE_PORT(counting)[pos - 1];
     if (self != NULL) {
         pwm_clear_irq(self->slice_num);
         self->count += 65536;
diff --git a/ports/raspberrypi/common-hal/countio/__init__.c b/ports/raspberrypi/common-hal/countio/__init__.c
index b95b20d15..d47de33e5 100644
--- a/ports/raspberrypi/common-hal/countio/__init__.c
+++ b/ports/raspberrypi/common-hal/countio/__init__.c
@@ -1 +1 @@
-//No countio module functions
+// No countio module functions
diff --git a/ports/raspberrypi/common-hal/digitalio/DigitalInOut.c b/ports/raspberrypi/common-hal/digitalio/DigitalInOut.c
index a1a23b9ab..22a61afa3 100644
--- a/ports/raspberrypi/common-hal/digitalio/DigitalInOut.c
+++ b/ports/raspberrypi/common-hal/digitalio/DigitalInOut.c
@@ -37,7 +37,7 @@
 #include "src/rp2_common/hardware_gpio/include/hardware/gpio.h"
 
 digitalinout_result_t common_hal_digitalio_digitalinout_construct(
-        digitalio_digitalinout_obj_t* self, const mcu_pin_obj_t* pin) {
+    digitalio_digitalinout_obj_t *self, const mcu_pin_obj_t *pin) {
     claim_pin(pin);
     self->pin = pin;
     self->output = false;
@@ -49,15 +49,15 @@ digitalinout_result_t common_hal_digitalio_digitalinout_construct(
 }
 
 void common_hal_digitalio_digitalinout_never_reset(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
     never_reset_pin_number(self->pin->number);
 }
 
-bool common_hal_digitalio_digitalinout_deinited(digitalio_digitalinout_obj_t* self) {
+bool common_hal_digitalio_digitalinout_deinited(digitalio_digitalinout_obj_t *self) {
     return self->pin == NULL;
 }
 
-void common_hal_digitalio_digitalinout_deinit(digitalio_digitalinout_obj_t* self) {
+void common_hal_digitalio_digitalinout_deinit(digitalio_digitalinout_obj_t *self) {
     if (common_hal_digitalio_digitalinout_deinited(self)) {
         return;
     }
@@ -66,22 +66,22 @@ void common_hal_digitalio_digitalinout_deinit(digitalio_digitalinout_obj_t* self
 }
 
 void common_hal_digitalio_digitalinout_switch_to_input(
-        digitalio_digitalinout_obj_t* self, digitalio_pull_t pull) {
+    digitalio_digitalinout_obj_t *self, digitalio_pull_t pull) {
     self->output = false;
     // This also sets direction to input.
     common_hal_digitalio_digitalinout_set_pull(self, pull);
 }
 
 digitalinout_result_t common_hal_digitalio_digitalinout_switch_to_output(
-        digitalio_digitalinout_obj_t* self, bool value,
-        digitalio_drive_mode_t drive_mode) {
+    digitalio_digitalinout_obj_t *self, bool value,
+    digitalio_drive_mode_t drive_mode) {
     const uint8_t pin = self->pin->number;
     gpio_disable_pulls(pin);
 
     // Turn on "strong" pin driving (more current available).
     hw_write_masked(&padsbank0_hw->io[pin],
-                    PADS_BANK0_GPIO0_DRIVE_VALUE_12MA << PADS_BANK0_GPIO0_DRIVE_LSB,
-                    PADS_BANK0_GPIO0_DRIVE_BITS);
+        PADS_BANK0_GPIO0_DRIVE_VALUE_12MA << PADS_BANK0_GPIO0_DRIVE_LSB,
+            PADS_BANK0_GPIO0_DRIVE_BITS);
 
     self->output = true;
     self->open_drain = drive_mode == DRIVE_MODE_OPEN_DRAIN;
@@ -92,12 +92,12 @@ digitalinout_result_t common_hal_digitalio_digitalinout_switch_to_output(
 }
 
 digitalio_direction_t common_hal_digitalio_digitalinout_get_direction(
-        digitalio_digitalinout_obj_t* self) {
+    digitalio_digitalinout_obj_t *self) {
     return self->output ? DIRECTION_OUTPUT : DIRECTION_INPUT;
 }
 
 void common_hal_digitalio_digitalinout_set_value(
-        digitalio_digitalinout_obj_t* self, bool value) {
+    digitalio_digitalinout_obj_t *self, bool value) {
     const uint8_t pin = self->pin->number;
     if (self->open_drain && value) {
         // If true and open-drain, set the direction -before- setting
@@ -115,13 +115,13 @@ void common_hal_digitalio_digitalinout_set_value(
 }
 
 bool common_hal_digitalio_digitalinout_get_value(
-        digitalio_digitalinout_obj_t* self) {
+    digitalio_digitalinout_obj_t *self) {
     return gpio_get(self->pin->number);
 }
 
 digitalinout_result_t common_hal_digitalio_digitalinout_set_drive_mode(
-        digitalio_digitalinout_obj_t* self,
-        digitalio_drive_mode_t drive_mode) {
+    digitalio_digitalinout_obj_t *self,
+    digitalio_drive_mode_t drive_mode) {
     const uint8_t pin = self->pin->number;
     bool value = common_hal_digitalio_digitalinout_get_value(self);
     self->open_drain = drive_mode == DRIVE_MODE_OPEN_DRAIN;
@@ -134,7 +134,7 @@ digitalinout_result_t common_hal_digitalio_digitalinout_set_drive_mode(
 }
 
 digitalio_drive_mode_t common_hal_digitalio_digitalinout_get_drive_mode(
-        digitalio_digitalinout_obj_t* self) {
+    digitalio_digitalinout_obj_t *self) {
     if (self->open_drain) {
         return DRIVE_MODE_OPEN_DRAIN;
     } else {
@@ -143,14 +143,14 @@ digitalio_drive_mode_t common_hal_digitalio_digitalinout_get_drive_mode(
 }
 
 void common_hal_digitalio_digitalinout_set_pull(
-        digitalio_digitalinout_obj_t* self, digitalio_pull_t pull) {
+    digitalio_digitalinout_obj_t *self, digitalio_pull_t pull) {
     const uint8_t pin = self->pin->number;
     gpio_set_pulls(pin, pull == PULL_UP, pull == PULL_DOWN);
     gpio_set_dir(pin, GPIO_IN);
 }
 
 digitalio_pull_t common_hal_digitalio_digitalinout_get_pull(
-        digitalio_digitalinout_obj_t* self) {
+    digitalio_digitalinout_obj_t *self) {
     uint32_t pin = self->pin->number;
     if (self->output) {
         mp_raise_AttributeError(translate("Cannot get pull while in output mode"));
diff --git a/ports/raspberrypi/common-hal/digitalio/DigitalInOut.h b/ports/raspberrypi/common-hal/digitalio/DigitalInOut.h
index 8b14bbad8..d656f607f 100644
--- a/ports/raspberrypi/common-hal/digitalio/DigitalInOut.h
+++ b/ports/raspberrypi/common-hal/digitalio/DigitalInOut.h
@@ -32,7 +32,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    const mcu_pin_obj_t * pin;
+    const mcu_pin_obj_t *pin;
     bool output;
     bool open_drain;
 } digitalio_digitalinout_obj_t;
diff --git a/ports/raspberrypi/common-hal/displayio/ParallelBus.c b/ports/raspberrypi/common-hal/displayio/ParallelBus.c
index 57b2ffc36..6060c4668 100644
--- a/ports/raspberrypi/common-hal/displayio/ParallelBus.c
+++ b/ports/raspberrypi/common-hal/displayio/ParallelBus.c
@@ -33,20 +33,20 @@
 #include "shared-bindings/digitalio/DigitalInOut.h"
 #include "shared-bindings/microcontroller/__init__.h"
 
-void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t* self,
-    const mcu_pin_obj_t* data0, const mcu_pin_obj_t* command, const mcu_pin_obj_t* chip_select,
-    const mcu_pin_obj_t* write, const mcu_pin_obj_t* read, const mcu_pin_obj_t* reset) {
+void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t *self,
+    const mcu_pin_obj_t *data0, const mcu_pin_obj_t *command, const mcu_pin_obj_t *chip_select,
+    const mcu_pin_obj_t *write, const mcu_pin_obj_t *read, const mcu_pin_obj_t *reset) {
 
     mp_raise_NotImplementedError(translate("ParallelBus not yet supported"));
     // TODO: Implement with PIO and DMA.
 }
 
-void common_hal_displayio_parallelbus_deinit(displayio_parallelbus_obj_t* self) {
+void common_hal_displayio_parallelbus_deinit(displayio_parallelbus_obj_t *self) {
 
 }
 
 bool common_hal_displayio_parallelbus_reset(mp_obj_t obj) {
-	return false;
+    return false;
 }
 
 bool common_hal_displayio_parallelbus_bus_free(mp_obj_t obj) {
@@ -59,7 +59,7 @@ bool common_hal_displayio_parallelbus_begin_transaction(mp_obj_t obj) {
 }
 
 void common_hal_displayio_parallelbus_send(mp_obj_t obj, display_byte_type_t byte_type,
-        display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) {
+    display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) {
 
 }
 
diff --git a/ports/raspberrypi/common-hal/microcontroller/Pin.c b/ports/raspberrypi/common-hal/microcontroller/Pin.c
index ca5cf5a04..271966c2f 100644
--- a/ports/raspberrypi/common-hal/microcontroller/Pin.c
+++ b/ports/raspberrypi/common-hal/microcontroller/Pin.c
@@ -74,8 +74,8 @@ void reset_pin_number(uint8_t pin_number) {
     // disabled and both buffers are as well.
     gpio_init(pin_number);
     hw_clear_bits(&padsbank0_hw->io[pin_number], PADS_BANK0_GPIO0_IE_BITS |
-                                                 PADS_BANK0_GPIO0_PUE_BITS |
-                                                 PADS_BANK0_GPIO0_PDE_BITS);
+        PADS_BANK0_GPIO0_PUE_BITS |
+        PADS_BANK0_GPIO0_PDE_BITS);
     hw_set_bits(&padsbank0_hw->io[pin_number], PADS_BANK0_GPIO0_OD_BITS);
 
     #ifdef MICROPY_HW_NEOPIXEL
@@ -104,15 +104,15 @@ void reset_pin_number(uint8_t pin_number) {
     #endif
 }
 
-void common_hal_never_reset_pin(const mcu_pin_obj_t* pin) {
+void common_hal_never_reset_pin(const mcu_pin_obj_t *pin) {
     never_reset_pin_number(pin->number);
 }
 
-void common_hal_reset_pin(const mcu_pin_obj_t* pin) {
+void common_hal_reset_pin(const mcu_pin_obj_t *pin) {
     reset_pin_number(pin->number);
 }
 
-void claim_pin(const mcu_pin_obj_t* pin) {
+void claim_pin(const mcu_pin_obj_t *pin) {
     #ifdef MICROPY_HW_NEOPIXEL
     if (pin == MICROPY_HW_NEOPIXEL) {
         neopixel_in_use = true;
@@ -144,7 +144,7 @@ bool pin_number_is_free(uint8_t pin_number) {
            (pad_state & PADS_BANK0_GPIO0_OD_BITS) != 0;
 }
 
-bool common_hal_mcu_pin_is_free(const mcu_pin_obj_t* pin) {
+bool common_hal_mcu_pin_is_free(const mcu_pin_obj_t *pin) {
     #ifdef MICROPY_HW_NEOPIXEL
     if (pin == MICROPY_HW_NEOPIXEL) {
         return !neopixel_in_use;
@@ -168,11 +168,11 @@ bool common_hal_mcu_pin_is_free(const mcu_pin_obj_t* pin) {
     return pin_number_is_free(pin->number);
 }
 
-uint8_t common_hal_mcu_pin_number(const mcu_pin_obj_t* pin) {
+uint8_t common_hal_mcu_pin_number(const mcu_pin_obj_t *pin) {
     return pin->number;
 }
 
-void common_hal_mcu_pin_claim(const mcu_pin_obj_t* pin) {
+void common_hal_mcu_pin_claim(const mcu_pin_obj_t *pin) {
     return claim_pin(pin);
 }
 
diff --git a/ports/raspberrypi/common-hal/microcontroller/Pin.h b/ports/raspberrypi/common-hal/microcontroller/Pin.h
index 07c321185..7da3a2b88 100644
--- a/ports/raspberrypi/common-hal/microcontroller/Pin.h
+++ b/ports/raspberrypi/common-hal/microcontroller/Pin.h
@@ -47,7 +47,7 @@ void reset_all_pins(void);
 // need to store a full pointer.
 void reset_pin_number(uint8_t pin_number);
 void never_reset_pin_number(uint8_t pin_number);
-void claim_pin(const mcu_pin_obj_t* pin);
+void claim_pin(const mcu_pin_obj_t *pin);
 bool pin_number_is_free(uint8_t pin_number);
 
 #endif // MICROPY_INCLUDED_RASPBERRYPI_COMMON_HAL_MICROCONTROLLER_PIN_H
diff --git a/ports/raspberrypi/common-hal/microcontroller/__init__.c b/ports/raspberrypi/common-hal/microcontroller/__init__.c
index bfea8b2d9..6b5cb9b0d 100644
--- a/ports/raspberrypi/common-hal/microcontroller/__init__.c
+++ b/ports/raspberrypi/common-hal/microcontroller/__init__.c
@@ -129,7 +129,7 @@ const nvm_bytearray_obj_t common_hal_mcu_nvm_obj = {
         .type = &nvm_bytearray_type,
     },
     .len = CIRCUITPY_INTERNAL_NVM_SIZE,
-    .start_address = (uint8_t*) (CIRCUITPY_INTERNAL_NVM_START_ADDR)
+    .start_address = (uint8_t *)(CIRCUITPY_INTERNAL_NVM_START_ADDR)
 };
 #endif
 
diff --git a/ports/raspberrypi/common-hal/neopixel_write/__init__.c b/ports/raspberrypi/common-hal/neopixel_write/__init__.c
index b57cb2bde..d1d872843 100644
--- a/ports/raspberrypi/common-hal/neopixel_write/__init__.c
+++ b/ports/raspberrypi/common-hal/neopixel_write/__init__.c
@@ -54,7 +54,7 @@ const uint16_t neopixel_program[] = {
     0xa142
 };
 
-void common_hal_neopixel_write(const digitalio_digitalinout_obj_t* digitalinout, uint8_t *pixels, uint32_t num_bytes) {
+void common_hal_neopixel_write(const digitalio_digitalinout_obj_t *digitalinout, uint8_t *pixels, uint32_t num_bytes) {
     // Set everything up.
     rp2pio_statemachine_obj_t state_machine;
 
@@ -83,7 +83,8 @@ void common_hal_neopixel_write(const digitalio_digitalinout_obj_t* digitalinout,
 
     // Wait to make sure we don't append onto the last transmission. This should only be a tick or
     // two.
-    while (port_get_raw_ticks(NULL) < next_start_raw_ticks) {}
+    while (port_get_raw_ticks(NULL) < next_start_raw_ticks) {
+    }
 
     common_hal_rp2pio_statemachine_write(&state_machine, pixels, num_bytes, 1 /* stride in bytes */);
 
@@ -92,7 +93,7 @@ void common_hal_neopixel_write(const digitalio_digitalinout_obj_t* digitalinout,
 
     // Reset the pin and release it from the PIO
     gpio_init(digitalinout->pin->number);
-    common_hal_digitalio_digitalinout_switch_to_output((digitalio_digitalinout_obj_t*)digitalinout, false, DRIVE_MODE_PUSH_PULL);
+    common_hal_digitalio_digitalinout_switch_to_output((digitalio_digitalinout_obj_t *)digitalinout, false, DRIVE_MODE_PUSH_PULL);
 
     // Update the next start.
     next_start_raw_ticks = port_get_raw_ticks(NULL) + 1;
diff --git a/ports/raspberrypi/common-hal/nvm/ByteArray.c b/ports/raspberrypi/common-hal/nvm/ByteArray.c
index fdc2c6080..94d98d686 100644
--- a/ports/raspberrypi/common-hal/nvm/ByteArray.c
+++ b/ports/raspberrypi/common-hal/nvm/ByteArray.c
@@ -32,44 +32,44 @@
 #include "src/rp2_common/hardware_flash/include/hardware/flash.h"
 
 extern uint32_t __flash_binary_start;
-static const uint32_t flash_binary_start = (uint32_t) &__flash_binary_start;
+static const uint32_t flash_binary_start = (uint32_t)&__flash_binary_start;
 
 #define RMV_OFFSET(addr) addr - flash_binary_start
 
-uint32_t common_hal_nvm_bytearray_get_length(nvm_bytearray_obj_t* self) {
+uint32_t common_hal_nvm_bytearray_get_length(nvm_bytearray_obj_t *self) {
     return self->len;
 }
 
-static void write_page(uint32_t page_addr, uint32_t offset, uint32_t len, uint8_t* bytes) {
+static void write_page(uint32_t page_addr, uint32_t offset, uint32_t len, uint8_t *bytes) {
     // Write a whole page to flash, buffering it first and then erasing and rewriting it
     // since we can only write a whole page at a time.
     if (offset == 0 && len == FLASH_PAGE_SIZE) {
         flash_range_program(RMV_OFFSET(page_addr), bytes, FLASH_PAGE_SIZE);
     } else {
         uint8_t buffer[FLASH_PAGE_SIZE];
-        memcpy(buffer, (uint8_t*) page_addr, FLASH_PAGE_SIZE);
+        memcpy(buffer, (uint8_t *)page_addr, FLASH_PAGE_SIZE);
         memcpy(buffer + offset, bytes, len);
         flash_range_program(RMV_OFFSET(page_addr), buffer, FLASH_PAGE_SIZE);
     }
 }
 
-static void erase_and_write_sector(uint32_t address, uint32_t len, uint8_t* bytes) {
+static void erase_and_write_sector(uint32_t address, uint32_t len, uint8_t *bytes) {
     // Write a whole sector to flash, buffering it first and then erasing and rewriting it
     // since we can only erase a whole sector at a time.
     uint8_t buffer[FLASH_SECTOR_SIZE];
-    memcpy(buffer, (uint8_t*) CIRCUITPY_INTERNAL_NVM_START_ADDR, FLASH_SECTOR_SIZE);
+    memcpy(buffer, (uint8_t *)CIRCUITPY_INTERNAL_NVM_START_ADDR, FLASH_SECTOR_SIZE);
     memcpy(buffer + address, bytes, len);
     flash_range_erase(RMV_OFFSET(CIRCUITPY_INTERNAL_NVM_START_ADDR), FLASH_SECTOR_SIZE);
     flash_range_program(RMV_OFFSET(CIRCUITPY_INTERNAL_NVM_START_ADDR), buffer, FLASH_SECTOR_SIZE);
 }
 
-void common_hal_nvm_bytearray_get_bytes(nvm_bytearray_obj_t* self,
-        uint32_t start_index, uint32_t len, uint8_t* values) {
+void common_hal_nvm_bytearray_get_bytes(nvm_bytearray_obj_t *self,
+    uint32_t start_index, uint32_t len, uint8_t *values) {
     memcpy(values, self->start_address + start_index, len);
 }
 
-bool common_hal_nvm_bytearray_set_bytes(nvm_bytearray_obj_t* self,
-        uint32_t start_index, uint8_t* values, uint32_t len) {
+bool common_hal_nvm_bytearray_set_bytes(nvm_bytearray_obj_t *self,
+    uint32_t start_index, uint8_t *values, uint32_t len) {
     uint8_t values_in[len];
     common_hal_nvm_bytearray_get_bytes(self, start_index, len, values_in);
 
@@ -82,7 +82,7 @@ bool common_hal_nvm_bytearray_set_bytes(nvm_bytearray_obj_t* self,
     }
 
     if (all_ones) {
-        uint32_t address = (uint32_t) self->start_address + start_index;
+        uint32_t address = (uint32_t)self->start_address + start_index;
         uint32_t offset = address % FLASH_PAGE_SIZE;
         uint32_t page_addr = address - offset;
 
diff --git a/ports/raspberrypi/common-hal/nvm/ByteArray.h b/ports/raspberrypi/common-hal/nvm/ByteArray.h
index a2a904fea..4667e6b23 100644
--- a/ports/raspberrypi/common-hal/nvm/ByteArray.h
+++ b/ports/raspberrypi/common-hal/nvm/ByteArray.h
@@ -31,7 +31,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    uint8_t * start_address;
+    uint8_t *start_address;
     uint32_t len;
 } nvm_bytearray_obj_t;
 
diff --git a/ports/raspberrypi/common-hal/os/__init__.c b/ports/raspberrypi/common-hal/os/__init__.c
index 0df7653d3..3352cef12 100644
--- a/ports/raspberrypi/common-hal/os/__init__.c
+++ b/ports/raspberrypi/common-hal/os/__init__.c
@@ -56,7 +56,7 @@ STATIC MP_DEFINE_ATTRTUPLE(
     (mp_obj_t)&os_uname_info_release_obj,
     (mp_obj_t)&os_uname_info_version_obj,
     (mp_obj_t)&os_uname_info_machine_obj
-);
+    );
 
 mp_obj_t common_hal_os_uname(void) {
     return (mp_obj_t)&os_uname_info_obj;
@@ -82,10 +82,10 @@ static BYTE random_state[SHA256_BLOCK_SIZE];
 static void seed_random_bits(BYTE out[SHA256_BLOCK_SIZE]) {
     CRYAL_SHA256_CTX context;
     sha256_init(&context);
-    for (int i=0; i<2*RANDOM_SAFETY_MARGIN; i++) {
-        for(int j=0; j<SHA256_BLOCK_SIZE; j++) {
+    for (int i = 0; i < 2 * RANDOM_SAFETY_MARGIN; i++) {
+        for (int j = 0; j < SHA256_BLOCK_SIZE; j++) {
             out[j] = rosc_hw->randombit & 1;
-            for(int k=0; k<8; k++) {
+            for (int k = 0; k < 8; k++) {
                 out[j] = (out[j] << 1) ^ (rosc_hw->randombit & 1);
             }
         }
@@ -104,12 +104,12 @@ static void get_random_bits(BYTE out[SHA256_BLOCK_SIZE]) {
     sha256_final(&context, out);
 }
 
-bool common_hal_os_urandom(uint8_t* buffer, uint32_t length) {
+bool common_hal_os_urandom(uint8_t *buffer, uint32_t length) {
 #define ROSC_POWER_SAVE (1) // assume ROSC is not necessarily active all the time
-#if ROSC_POWER_SAVE
+    #if ROSC_POWER_SAVE
     uint32_t old_rosc_ctrl = rosc_hw->ctrl;
     rosc_hw->ctrl = (old_rosc_ctrl & ~ROSC_CTRL_ENABLE_BITS) | (ROSC_CTRL_ENABLE_VALUE_ENABLE << 12);
-#endif
+    #endif
     while (length) {
         size_t n = MIN(length, SHA256_BLOCK_SIZE);
         BYTE sha_buf[SHA256_BLOCK_SIZE];
@@ -118,8 +118,8 @@ bool common_hal_os_urandom(uint8_t* buffer, uint32_t length) {
         buffer += n;
         length -= n;
     }
-#if ROSC_POWER_SAVE
+    #if ROSC_POWER_SAVE
     rosc_hw->ctrl = old_rosc_ctrl;
-#endif
+    #endif
     return true;
 }
diff --git a/ports/raspberrypi/common-hal/pulseio/PulseIn.c b/ports/raspberrypi/common-hal/pulseio/PulseIn.c
index e05b35536..278c0cd66 100644
--- a/ports/raspberrypi/common-hal/pulseio/PulseIn.c
+++ b/ports/raspberrypi/common-hal/pulseio/PulseIn.c
@@ -36,7 +36,7 @@
 #include "bindings/rp2pio/StateMachine.h"
 #include "common-hal/pulseio/PulseIn.h"
 
-pulseio_pulsein_obj_t* save_self;
+pulseio_pulsein_obj_t *save_self;
 
 #define NO_PIN 0xff
 volatile bool last_level;
@@ -48,10 +48,10 @@ uint16_t pulsein_program[] = {
     0x4001, //  1: in     pins, 1
 };
 
-void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self,
-        const mcu_pin_obj_t* pin, uint16_t maxlen, bool idle_state) {
+void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t *self,
+    const mcu_pin_obj_t *pin, uint16_t maxlen, bool idle_state) {
 
-    self->buffer = (uint16_t *) m_malloc(maxlen * sizeof(uint16_t), false);
+    self->buffer = (uint16_t *)m_malloc(maxlen * sizeof(uint16_t), false);
     if (self->buffer == NULL) {
         mp_raise_msg_varg(&mp_type_MemoryError, translate("Failed to allocate RX buffer of %d bytes"), maxlen * sizeof(uint16_t));
     }
@@ -76,10 +76,10 @@ void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self,
         NULL, 0,
         1, 0,
         1 << self->pin, false, true,
-        false, 8, false, // TX, unused
-        false,
-        true, 32, true, // RX auto-push every 32 bits
-        false); // claim pins
+            false, 8, false, // TX, unused
+            false,
+            true, 32, true, // RX auto-push every 32 bits
+            false); // claim pins
     pio_sm_set_enabled(state_machine.pio,state_machine.state_machine, false);
     self->state_machine.pio = state_machine.pio;
     self->state_machine.state_machine = state_machine.state_machine;
@@ -96,79 +96,79 @@ void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self,
 
     // exec a set pindirs to 0 for input
     pio_sm_exec(state_machine.pio,state_machine.state_machine,0xe080);
-    //exec the appropriate wait for pin
-    if (self->idle_state == true ) {
-       pio_sm_exec(self->state_machine.pio,self->state_machine.state_machine,0x2020);
+    // exec the appropriate wait for pin
+    if (self->idle_state == true) {
+        pio_sm_exec(self->state_machine.pio,self->state_machine.state_machine,0x2020);
     } else {
-       pio_sm_exec(self->state_machine.pio,self->state_machine.state_machine,0x20a0);
+        pio_sm_exec(self->state_machine.pio,self->state_machine.state_machine,0x20a0);
     }
     pio_sm_set_enabled(state_machine.pio, state_machine.state_machine, true);
 }
 
-bool common_hal_pulseio_pulsein_deinited(pulseio_pulsein_obj_t* self) {
+bool common_hal_pulseio_pulsein_deinited(pulseio_pulsein_obj_t *self) {
     return self->pin == NO_PIN;
 }
 
-void common_hal_pulseio_pulsein_deinit(pulseio_pulsein_obj_t* self) {
+void common_hal_pulseio_pulsein_deinit(pulseio_pulsein_obj_t *self) {
     if (common_hal_pulseio_pulsein_deinited(self)) {
         return;
     }
     pio_sm_set_enabled(self->state_machine.pio, self->state_machine.state_machine, false);
-    pio_sm_unclaim (self->state_machine.pio, self->state_machine.state_machine);
+    pio_sm_unclaim(self->state_machine.pio, self->state_machine.state_machine);
     m_free(self->buffer);
     self->pin = NO_PIN;
 }
 
-void common_hal_pulseio_pulsein_pause(pulseio_pulsein_obj_t* self) {
+void common_hal_pulseio_pulsein_pause(pulseio_pulsein_obj_t *self) {
     pio_sm_set_enabled(self->state_machine.pio, self->state_machine.state_machine, false);
 }
 
 void common_hal_pulseio_pulsein_interrupt() {
 
-    pulseio_pulsein_obj_t* self = save_self;
+    pulseio_pulsein_obj_t *self = save_self;
     uint32_t rxfifo = 0;
 
     rxfifo = pio_sm_get_blocking(self->state_machine.pio, self->state_machine.state_machine);
     // translate from fifo to buffer
     for (uint i = 0; i < 32; i++) {
         bool level = (rxfifo & (1 << i)) >> i;
-        if (level == last_level ) {
-            level_count ++;
+        if (level == last_level) {
+            level_count++;
         } else {
-           result = level_count;
-           last_level = level;
-           level_count = 1;
-           // ignore pulses that are too long and too short
-           if (result < 4000 && result > 10) {
-               self->buffer[buf_index] = result;
-               buf_index++;
-               self->len++;
-             }
-           }
-       }
+            result = level_count;
+            last_level = level;
+            level_count = 1;
+            // ignore pulses that are too long and too short
+            if (result < 4000 && result > 10) {
+                self->buffer[buf_index] = result;
+                buf_index++;
+                self->len++;
+            }
+        }
+    }
 // check for a pulse thats too long (4000 us) or maxlen reached,  and reset
-    if (( level_count > 4000 ) || (buf_index >= self->maxlen)) {
-       pio_sm_set_enabled(self->state_machine.pio, self->state_machine.state_machine, false);
-       pio_sm_init(self->state_machine.pio, self->state_machine.state_machine, self->state_machine.offset, &self->state_machine.sm_config);
-       pio_sm_restart(self->state_machine.pio,self->state_machine.state_machine);
-       pio_sm_set_enabled(self->state_machine.pio, self->state_machine.state_machine, true);
+    if ((level_count > 4000) || (buf_index >= self->maxlen)) {
+        pio_sm_set_enabled(self->state_machine.pio, self->state_machine.state_machine, false);
+        pio_sm_init(self->state_machine.pio, self->state_machine.state_machine, self->state_machine.offset, &self->state_machine.sm_config);
+        pio_sm_restart(self->state_machine.pio,self->state_machine.state_machine);
+        pio_sm_set_enabled(self->state_machine.pio, self->state_machine.state_machine, true);
     }
 }
-void common_hal_pulseio_pulsein_resume(pulseio_pulsein_obj_t* self,
-        uint16_t trigger_duration) {
+void common_hal_pulseio_pulsein_resume(pulseio_pulsein_obj_t *self,
+    uint16_t trigger_duration) {
     // exec a wait for the selected pin to change state
-    if (self->idle_state == true ) {
-       pio_sm_exec(self->state_machine.pio,self->state_machine.state_machine,0x2020);
+    if (self->idle_state == true) {
+        pio_sm_exec(self->state_machine.pio,self->state_machine.state_machine,0x2020);
     } else {
-       pio_sm_exec(self->state_machine.pio,self->state_machine.state_machine,0x20a0);
+        pio_sm_exec(self->state_machine.pio,self->state_machine.state_machine,0x20a0);
     }
     // Send the trigger pulse.
     if (trigger_duration > 0) {
-        gpio_set_function(self->pin ,GPIO_FUNC_SIO);
+        gpio_set_function(self->pin,GPIO_FUNC_SIO);
         gpio_set_dir(self->pin,true);
         gpio_put(self->pin, !self->idle_state);
         common_hal_mcu_delay_us((uint32_t)trigger_duration);
-        gpio_set_function(self->pin ,GPIO_FUNC_PIO0);
+        gpio_set_function(self->pin,GPIO_FUNC_PIO0);
         common_hal_mcu_delay_us(225);
     }
 
@@ -177,12 +177,12 @@ void common_hal_pulseio_pulsein_resume(pulseio_pulsein_obj_t* self,
     pio_sm_set_enabled(self->state_machine.pio, self->state_machine.state_machine, true);
 }
 
-void common_hal_pulseio_pulsein_clear(pulseio_pulsein_obj_t* self) {
+void common_hal_pulseio_pulsein_clear(pulseio_pulsein_obj_t *self) {
     self->start = 0;
     self->len = 0;
 }
 
-uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t* self) {
+uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t *self) {
     if (self->len == 0) {
         mp_raise_IndexError_varg(translate("pop from empty %q"), MP_QSTR_PulseIn);
     }
@@ -190,28 +190,28 @@ uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t* self) {
     self->start = (self->start + 1) % self->maxlen;
     self->len--;
     // if we are empty reset buffer pointer and counters
-    if (self->len == 0 ) {
-         self->start = 0;
-         buf_index = 0;
-         level_count = 0;
+    if (self->len == 0) {
+        self->start = 0;
+        buf_index = 0;
+        level_count = 0;
     }
     return value;
 }
 
-uint16_t common_hal_pulseio_pulsein_get_maxlen(pulseio_pulsein_obj_t* self) {
+uint16_t common_hal_pulseio_pulsein_get_maxlen(pulseio_pulsein_obj_t *self) {
     return self->maxlen;
 }
 
-uint16_t common_hal_pulseio_pulsein_get_len(pulseio_pulsein_obj_t* self) {
+uint16_t common_hal_pulseio_pulsein_get_len(pulseio_pulsein_obj_t *self) {
     return self->len;
 }
 
-bool common_hal_pulseio_pulsein_get_paused(pulseio_pulsein_obj_t* self) {
+bool common_hal_pulseio_pulsein_get_paused(pulseio_pulsein_obj_t *self) {
     return true;
 }
 
-uint16_t common_hal_pulseio_pulsein_get_item(pulseio_pulsein_obj_t* self,
-        int16_t index) {
+uint16_t common_hal_pulseio_pulsein_get_item(pulseio_pulsein_obj_t *self,
+    int16_t index) {
     if (index < 0) {
         index += self->len;
     }
diff --git a/ports/raspberrypi/common-hal/pulseio/PulseIn.h b/ports/raspberrypi/common-hal/pulseio/PulseIn.h
index c83a86fca..b68a2238d 100644
--- a/ports/raspberrypi/common-hal/pulseio/PulseIn.h
+++ b/ports/raspberrypi/common-hal/pulseio/PulseIn.h
@@ -36,7 +36,7 @@
 typedef struct {
     mp_obj_base_t base;
     uint8_t pin;
-    uint16_t* buffer;
+    uint16_t *buffer;
     uint16_t maxlen;
     bool idle_state;
     volatile uint16_t start;
diff --git a/ports/raspberrypi/common-hal/pulseio/PulseOut.c b/ports/raspberrypi/common-hal/pulseio/PulseOut.c
index e284cd46a..c3536af04 100644
--- a/ports/raspberrypi/common-hal/pulseio/PulseOut.c
+++ b/ports/raspberrypi/common-hal/pulseio/PulseOut.c
@@ -58,12 +58,12 @@ void pulseout_reset() {
     refcount = 0;
 }
 
-void common_hal_pulseio_pulseout_construct(pulseio_pulseout_obj_t* self,
-                                            const pwmio_pwmout_obj_t* carrier,
-                                            const mcu_pin_obj_t* pin,
-                                            uint32_t frequency,
-                                            uint16_t duty_cycle) {
-        mp_raise_NotImplementedError(translate("Unsupported operation"));
+void common_hal_pulseio_pulseout_construct(pulseio_pulseout_obj_t *self,
+    const pwmio_pwmout_obj_t *carrier,
+    const mcu_pin_obj_t *pin,
+    uint32_t frequency,
+    uint16_t duty_cycle) {
+    mp_raise_NotImplementedError(translate("Unsupported operation"));
 
     refcount++;
 
@@ -71,11 +71,11 @@ void common_hal_pulseio_pulseout_construct(pulseio_pulseout_obj_t* self,
 
 }
 
-bool common_hal_pulseio_pulseout_deinited(pulseio_pulseout_obj_t* self) {
+bool common_hal_pulseio_pulseout_deinited(pulseio_pulseout_obj_t *self) {
     return self->pin == NO_PIN;
 }
 
-void common_hal_pulseio_pulseout_deinit(pulseio_pulseout_obj_t* self) {
+void common_hal_pulseio_pulseout_deinit(pulseio_pulseout_obj_t *self) {
     if (common_hal_pulseio_pulseout_deinited(self)) {
         return;
     }
@@ -85,7 +85,7 @@ void common_hal_pulseio_pulseout_deinit(pulseio_pulseout_obj_t* self) {
     self->pin = NO_PIN;
 }
 
-void common_hal_pulseio_pulseout_send(pulseio_pulseout_obj_t* self, uint16_t* pulses, uint16_t length) {
+void common_hal_pulseio_pulseout_send(pulseio_pulseout_obj_t *self, uint16_t *pulses, uint16_t length) {
     pulse_buffer = pulses;
     pulse_index = 0;
     pulse_length = length;
diff --git a/ports/raspberrypi/common-hal/pwmio/PWMOut.c b/ports/raspberrypi/common-hal/pwmio/PWMOut.c
index fd85fbf55..9695a8fdf 100644
--- a/ports/raspberrypi/common-hal/pwmio/PWMOut.c
+++ b/ports/raspberrypi/common-hal/pwmio/PWMOut.c
@@ -154,11 +154,11 @@ pwmout_result_t pwmout_allocate(uint8_t slice, uint8_t channel, bool variable_fr
     return PWMOUT_OK;
 }
 
-pwmout_result_t common_hal_pwmio_pwmout_construct(pwmio_pwmout_obj_t* self,
-                                                    const mcu_pin_obj_t* pin,
-                                                    uint16_t duty,
-                                                    uint32_t frequency,
-                                                    bool variable_frequency) {
+pwmout_result_t common_hal_pwmio_pwmout_construct(pwmio_pwmout_obj_t *self,
+    const mcu_pin_obj_t *pin,
+    uint16_t duty,
+    uint32_t frequency,
+    bool variable_frequency) {
     self->pin = pin;
     self->variable_frequency = variable_frequency;
     self->duty_cycle = duty;
@@ -195,7 +195,7 @@ pwmout_result_t common_hal_pwmio_pwmout_construct(pwmio_pwmout_obj_t* self,
     return PWMOUT_OK;
 }
 
-bool common_hal_pwmio_pwmout_deinited(pwmio_pwmout_obj_t* self) {
+bool common_hal_pwmio_pwmout_deinited(pwmio_pwmout_obj_t *self) {
     return self->pin == NULL;
 }
 
@@ -211,7 +211,7 @@ void pwmout_free(uint8_t slice, uint8_t channel) {
     }
 }
 
-void common_hal_pwmio_pwmout_deinit(pwmio_pwmout_obj_t* self) {
+void common_hal_pwmio_pwmout_deinit(pwmio_pwmout_obj_t *self) {
     if (common_hal_pwmio_pwmout_deinited(self)) {
         return;
     }
@@ -220,33 +220,33 @@ void common_hal_pwmio_pwmout_deinit(pwmio_pwmout_obj_t* self) {
     self->pin = NULL;
 }
 
-extern void common_hal_pwmio_pwmout_set_duty_cycle(pwmio_pwmout_obj_t* self, uint16_t duty) {
+extern void common_hal_pwmio_pwmout_set_duty_cycle(pwmio_pwmout_obj_t *self, uint16_t duty) {
     self->duty_cycle = duty;
     // Do arithmetic in 32 bits to prevent overflow.
     uint16_t compare_count;
     if (duty == 65535) {
         // Ensure that 100% duty cycle is 100% full on and not rounded down,
         // but do MIN() to keep value in range, just in case.
-        compare_count = MIN(UINT16_MAX, (uint32_t) self->top + 1);
+        compare_count = MIN(UINT16_MAX, (uint32_t)self->top + 1);
     } else {
-        compare_count= ((uint32_t) duty * self->top + MAX_TOP / 2) / MAX_TOP;
+        compare_count = ((uint32_t)duty * self->top + MAX_TOP / 2) / MAX_TOP;
     }
     // compare_count is the CC register value, which should be TOP+1 for 100% duty cycle.
     pwm_set_chan_level(self->slice, self->channel, compare_count);
 }
 
-uint16_t common_hal_pwmio_pwmout_get_duty_cycle(pwmio_pwmout_obj_t* self) {
+uint16_t common_hal_pwmio_pwmout_get_duty_cycle(pwmio_pwmout_obj_t *self) {
     return self->duty_cycle;
 }
 
-void pwmio_pwmout_set_top(pwmio_pwmout_obj_t* self, uint16_t top) {
+void pwmio_pwmout_set_top(pwmio_pwmout_obj_t *self, uint16_t top) {
     self->actual_frequency = common_hal_mcu_processor_get_frequency() / top;
     self->top = top;
     pwm_set_clkdiv_int_frac(self->slice, 1, 0);
     pwm_set_wrap(self->slice, self->top);
 }
 
-void common_hal_pwmio_pwmout_set_frequency(pwmio_pwmout_obj_t* self, uint32_t frequency) {
+void common_hal_pwmio_pwmout_set_frequency(pwmio_pwmout_obj_t *self, uint32_t frequency) {
     if (frequency == 0 || frequency > (common_hal_mcu_processor_get_frequency() / 2)) {
         mp_raise_ValueError(translate("Invalid PWM frequency"));
     }
@@ -258,7 +258,7 @@ void common_hal_pwmio_pwmout_set_frequency(pwmio_pwmout_obj_t* self, uint32_t fr
         // Compute the divisor. It's an 8 bit integer and 4 bit fraction. Therefore,
         // we compute everything * 16 for the fractional part.
         // This is 1 << 12 because 4 bits are the * 16.
-        uint64_t frequency16 = ((uint64_t) clock_get_hz(clk_sys)) / (1 << 12);
+        uint64_t frequency16 = ((uint64_t)clock_get_hz(clk_sys)) / (1 << 12);
         uint64_t div16 = frequency16 / frequency;
         // Round the divisor to try and get closest to the target frequency. We could
         // also always round up and use TOP to get us closer. We may not need that though.
@@ -283,10 +283,10 @@ void common_hal_pwmio_pwmout_set_frequency(pwmio_pwmout_obj_t* self, uint32_t fr
     common_hal_pwmio_pwmout_set_duty_cycle(self, self->duty_cycle);
 }
 
-uint32_t common_hal_pwmio_pwmout_get_frequency(pwmio_pwmout_obj_t* self) {
+uint32_t common_hal_pwmio_pwmout_get_frequency(pwmio_pwmout_obj_t *self) {
     return self->actual_frequency;
 }
 
-bool common_hal_pwmio_pwmout_get_variable_frequency(pwmio_pwmout_obj_t* self) {
+bool common_hal_pwmio_pwmout_get_variable_frequency(pwmio_pwmout_obj_t *self) {
     return self->variable_frequency;
 }
diff --git a/ports/raspberrypi/common-hal/pwmio/PWMOut.h b/ports/raspberrypi/common-hal/pwmio/PWMOut.h
index 41da81010..c7707762e 100644
--- a/ports/raspberrypi/common-hal/pwmio/PWMOut.h
+++ b/ports/raspberrypi/common-hal/pwmio/PWMOut.h
@@ -44,7 +44,7 @@ typedef struct {
 
 void pwmout_reset(void);
 // Private API for AudioPWMOut.
-void pwmio_pwmout_set_top(pwmio_pwmout_obj_t* self, uint16_t top);
+void pwmio_pwmout_set_top(pwmio_pwmout_obj_t *self, uint16_t top);
 // Private APIs for RGBMatrix
 enum pwmout_result_t pwmout_allocate(uint8_t slice, uint8_t channel, bool variable_frequency, uint32_t frequency);
 void pwmout_free(uint8_t slice, uint8_t channel);
diff --git a/ports/raspberrypi/common-hal/rgbmatrix/RGBMatrix.c b/ports/raspberrypi/common-hal/rgbmatrix/RGBMatrix.c
index 657c7f0a6..f150422e3 100644
--- a/ports/raspberrypi/common-hal/rgbmatrix/RGBMatrix.c
+++ b/ports/raspberrypi/common-hal/rgbmatrix/RGBMatrix.c
@@ -38,29 +38,29 @@ void *common_hal_rgbmatrix_timer_allocate(rgbmatrix_rgbmatrix_obj_t *self) {
     // Choose a PWM channel based on the first RGB pin
     uint8_t slice = pwm_gpio_to_slice_num(self->rgb_pins[0]);
     uint8_t channel = pwm_gpio_to_channel(self->rgb_pins[0]);
-    int result = pwmout_allocate(slice, channel, true, 125000000/3);
+    int result = pwmout_allocate(slice, channel, true, 125000000 / 3);
     if (result == PWMOUT_OK) {
         // return value must be nonzero (but slice and channel can both be
         // zero), so set bit 16...
         pwmout_never_reset(slice, channel);
-        return (void*)(intptr_t)(slice | (channel << 8) | 0x10000);
+        return (void *)(intptr_t)(slice | (channel << 8) | 0x10000);
     }
     return NULL;
 }
 
-void common_hal_rgbmatrix_timer_enable(void* ptr) {
+void common_hal_rgbmatrix_timer_enable(void *ptr) {
     int8_t slice = ((intptr_t)ptr) & 0xff;
     pwm_set_enabled(slice, false);
     pwm_clear_irq(slice);
     pwm_set_enabled(slice, true);
 }
 
-void common_hal_rgbmatrix_timer_disable(void* ptr) {
+void common_hal_rgbmatrix_timer_disable(void *ptr) {
     int8_t slice = ((intptr_t)ptr) & 0xff;
     pwm_set_enabled(slice, false);
 }
 
-void common_hal_rgbmatrix_timer_free(void* ptr) {
+void common_hal_rgbmatrix_timer_free(void *ptr) {
     intptr_t value = (intptr_t)ptr;
     uint8_t slice = value & 0xff;
     uint8_t channel = value >> 8;
diff --git a/ports/raspberrypi/common-hal/rgbmatrix/RGBMatrix.h b/ports/raspberrypi/common-hal/rgbmatrix/RGBMatrix.h
index 2378cf173..d14cd9b08 100644
--- a/ports/raspberrypi/common-hal/rgbmatrix/RGBMatrix.h
+++ b/ports/raspberrypi/common-hal/rgbmatrix/RGBMatrix.h
@@ -30,8 +30,8 @@
 #include "shared-module/rgbmatrix/RGBMatrix.h"
 
 void *common_hal_rgbmatrix_timer_allocate(rgbmatrix_rgbmatrix_obj_t *self);
-void common_hal_rgbmatrix_timer_enable(void*);
-void common_hal_rgbmatrix_timer_disable(void*);
-void common_hal_rgbmatrix_timer_free(void*);
+void common_hal_rgbmatrix_timer_enable(void *);
+void common_hal_rgbmatrix_timer_disable(void *);
+void common_hal_rgbmatrix_timer_free(void *);
 
 #endif
diff --git a/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.c b/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.c
index b2225991d..30b3ac619 100644
--- a/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.c
+++ b/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.c
@@ -57,8 +57,8 @@ STATIC const uint16_t encoder_init[] = {
 
 STATIC void incrementalencoder_interrupt_handler(void *self_in);
 
-void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencoder_obj_t* self,
-    const mcu_pin_obj_t* pin_a, const mcu_pin_obj_t* pin_b) {
+void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencoder_obj_t *self,
+    const mcu_pin_obj_t *pin_a, const mcu_pin_obj_t *pin_b) {
     mp_obj_t pins[] = {MP_OBJ_FROM_PTR(pin_a), MP_OBJ_FROM_PTR(pin_b)};
     if (!common_hal_rp2pio_pins_are_sequential(2, pins)) {
         mp_raise_RuntimeError(translate("Pins must be sequential"));
@@ -93,28 +93,28 @@ void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencode
     common_hal_rp2pio_statemachine_set_interrupt_handler(&self->state_machine, incrementalencoder_interrupt_handler, self, PIO_IRQ0_INTF_SM0_RXNEMPTY_BITS);
 }
 
-bool common_hal_rotaryio_incrementalencoder_deinited(rotaryio_incrementalencoder_obj_t* self) {
+bool common_hal_rotaryio_incrementalencoder_deinited(rotaryio_incrementalencoder_obj_t *self) {
     return common_hal_rp2pio_statemachine_deinited(&self->state_machine);
 }
 
-void common_hal_rotaryio_incrementalencoder_deinit(rotaryio_incrementalencoder_obj_t* self) {
+void common_hal_rotaryio_incrementalencoder_deinit(rotaryio_incrementalencoder_obj_t *self) {
     if (common_hal_rotaryio_incrementalencoder_deinited(self)) {
         return;
     }
     common_hal_rp2pio_statemachine_deinit(&self->state_machine);
 }
 
-mp_int_t common_hal_rotaryio_incrementalencoder_get_position(rotaryio_incrementalencoder_obj_t* self) {
+mp_int_t common_hal_rotaryio_incrementalencoder_get_position(rotaryio_incrementalencoder_obj_t *self) {
     return self->position;
 }
 
-void common_hal_rotaryio_incrementalencoder_set_position(rotaryio_incrementalencoder_obj_t* self,
-        mp_int_t new_position) {
+void common_hal_rotaryio_incrementalencoder_set_position(rotaryio_incrementalencoder_obj_t *self,
+    mp_int_t new_position) {
     self->position = new_position;
 }
 
 STATIC void incrementalencoder_interrupt_handler(void *self_in) {
-    rotaryio_incrementalencoder_obj_t* self = self_in;
+    rotaryio_incrementalencoder_obj_t *self = self_in;
     // This table also works for detent both at 11 and 00
     // For 11 at detent:
     // Turning cw: 11->01->00->10->11
diff --git a/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.h b/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.h
index ff5c874c8..83fe97d31 100644
--- a/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.h
+++ b/ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.h
@@ -34,7 +34,7 @@
 typedef struct {
     mp_obj_base_t base;
     rp2pio_statemachine_obj_t state_machine;
-    uint8_t last_state:4;   // <old A><old B><new A><new B>
-    int8_t quarter_count:4; // count intermediate transitions between detents
+    uint8_t last_state : 4;   // <old A><old B><new A><new B>
+    int8_t quarter_count : 4; // count intermediate transitions between detents
     mp_int_t position;
 } rotaryio_incrementalencoder_obj_t;
diff --git a/ports/raspberrypi/common-hal/rp2pio/StateMachine.c b/ports/raspberrypi/common-hal/rp2pio/StateMachine.c
index 56a7ab668..716693228 100644
--- a/ports/raspberrypi/common-hal/rp2pio/StateMachine.c
+++ b/ports/raspberrypi/common-hal/rp2pio/StateMachine.c
@@ -53,16 +53,16 @@ STATIC uint32_t _current_pins[NUM_PIOS];
 STATIC uint32_t _current_sm_pins[NUM_PIOS][NUM_PIO_STATE_MACHINES];
 
 STATIC PIO pio_instances[2] = {pio0, pio1};
-typedef void (*interrupt_handler_type)(void*);
+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];
 
 STATIC void rp2pio_statemachine_interrupt_handler(void);
 
 static void rp2pio_statemachine_set_pull(uint32_t pull_pin_up, uint32_t pull_pin_down, uint32_t pins_we_use) {
-    for (int i=0; i<TOTAL_GPIO_COUNT; i++) {
+    for (int i = 0; i < TOTAL_GPIO_COUNT; i++) {
         bool used = pins_we_use & (1 << i);
-        if(used) {
+        if (used) {
             bool pull_up = pull_pin_up & (1 << i);
             bool pull_down = pull_pin_down & (1 << i);
             gpio_set_pulls(i, pull_up, pull_down);
@@ -120,16 +120,16 @@ void reset_rp2pio_statemachine(void) {
             _reset_statemachine(pio, j, false);
         }
     }
-    for (uint8_t irq=PIO0_IRQ_0; irq <= PIO1_IRQ_1; irq++) {
-       irq_handler_t int_handler = irq_get_exclusive_handler(irq);
-       if (int_handler > 0) {
-          irq_set_enabled (irq, false);
-          irq_remove_handler(irq,int_handler);
-       }
-   }
+    for (uint8_t irq = PIO0_IRQ_0; irq <= PIO1_IRQ_1; irq++) {
+        irq_handler_t int_handler = irq_get_exclusive_handler(irq);
+        if (int_handler > 0) {
+            irq_set_enabled(irq, false);
+            irq_remove_handler(irq,int_handler);
+        }
+    }
 }
 
-STATIC uint32_t _check_pins_free(const mcu_pin_obj_t * first_pin, uint8_t pin_count, bool exclusive_pin_use) {
+STATIC uint32_t _check_pins_free(const mcu_pin_obj_t *first_pin, uint8_t pin_count, bool exclusive_pin_use) {
     uint32_t pins_we_use = 0;
     if (first_pin != NULL) {
         for (size_t i = 0; i < pin_count; i++) {
@@ -137,7 +137,7 @@ STATIC uint32_t _check_pins_free(const mcu_pin_obj_t * first_pin, uint8_t pin_co
             if (pin_number >= TOTAL_GPIO_COUNT) {
                 mp_raise_ValueError(translate("Pin count too large"));
             }
-            const mcu_pin_obj_t * pin = mcu_pin_global_dict_table[pin_number].value;
+            const mcu_pin_obj_t *pin = mcu_pin_global_dict_table[pin_number].value;
             if (exclusive_pin_use || _pin_reference_count[pin_number] == 0) {
                 assert_pin_free(pin);
             }
@@ -149,14 +149,14 @@ STATIC uint32_t _check_pins_free(const mcu_pin_obj_t * first_pin, uint8_t pin_co
 
 
 bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
-    const uint16_t* program, size_t program_len,
+    const uint16_t *program, size_t program_len,
     size_t frequency,
-    const uint16_t* init, size_t init_len,
-    const mcu_pin_obj_t * first_out_pin, uint8_t out_pin_count,
-    const mcu_pin_obj_t * first_in_pin, uint8_t in_pin_count,
+    const uint16_t *init, size_t init_len,
+    const mcu_pin_obj_t *first_out_pin, uint8_t out_pin_count,
+    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,
-    const mcu_pin_obj_t * first_sideset_pin, uint8_t sideset_pin_count,
+    const mcu_pin_obj_t *first_set_pin, uint8_t set_pin_count,
+    const mcu_pin_obj_t *first_sideset_pin, uint8_t sideset_pin_count,
     uint32_t initial_pin_state, uint32_t initial_pin_direction,
     uint32_t pins_we_use, bool tx_fifo, bool rx_fifo,
     bool auto_pull, uint8_t pull_threshold, bool out_shift_right,
@@ -164,15 +164,15 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     bool auto_push, uint8_t push_threshold, bool in_shift_right,
     bool claim_pins) {
     // 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);
+    uint32_t program_id = ~((uint32_t)program);
 
     // Next, find a PIO and state machine to use.
     size_t pio_index = NUM_PIOS;
     uint8_t program_offset = 32;
     pio_program_t program_struct = {
-        .instructions = (uint16_t*) program,
+        .instructions = (uint16_t *)program,
         .length = program_len,
-        .origin = 0
+        .origin = -1
     };
     for (size_t i = 0; i < NUM_PIOS; i++) {
         PIO pio = pio_instances[i];
@@ -242,7 +242,7 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
             continue;
         }
         _pin_reference_count[pin_number]++;
-        const mcu_pin_obj_t * pin = mcu_pin_global_dict_table[pin_number].value;
+        const mcu_pin_obj_t *pin = mcu_pin_global_dict_table[pin_number].value;
         // Also claim the pin at the top level when we're the first to grab it.
         if (_pin_reference_count[pin_number] == 1) {
             if (claim_pins) {
@@ -257,7 +257,7 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     if (frequency == 0) {
         frequency = clock_get_hz(clk_sys);
     }
-    uint64_t frequency256 = ((uint64_t) clock_get_hz(clk_sys)) * 256;
+    uint64_t frequency256 = ((uint64_t)clock_get_hz(clk_sys)) * 256;
     uint64_t div256 = frequency256 / frequency;
     if (frequency256 % div256 > 0) {
         div256 += 1;
@@ -314,21 +314,21 @@ bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     return true;
 }
 
-static uint32_t mask_and_rotate(const mcu_pin_obj_t* first_pin, uint32_t bit_count, uint32_t value) {
+static uint32_t mask_and_rotate(const mcu_pin_obj_t *first_pin, uint32_t bit_count, uint32_t value) {
     value = value & ((1 << bit_count) - 1);
     uint32_t shift = first_pin->number;
     return value << shift | value >> (32 - shift);
 }
 
 void common_hal_rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
-    const uint16_t* program, size_t program_len,
+    const uint16_t *program, size_t program_len,
     size_t frequency,
-    const uint16_t* init, size_t init_len,
-    const mcu_pin_obj_t * first_out_pin, uint8_t out_pin_count, uint32_t initial_out_pin_state, uint32_t initial_out_pin_direction,
-    const mcu_pin_obj_t * first_in_pin, uint8_t in_pin_count,
+    const uint16_t *init, size_t init_len,
+    const mcu_pin_obj_t *first_out_pin, uint8_t out_pin_count, uint32_t initial_out_pin_state, uint32_t initial_out_pin_direction,
+    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,
+    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,
     bool exclusive_pin_use,
     bool auto_pull, uint8_t pull_threshold, bool out_shift_right,
     bool wait_for_txstall,
@@ -453,7 +453,7 @@ void common_hal_rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     initial_set_pin_state = mask_and_rotate(first_set_pin, set_pin_count, initial_set_pin_state);
     initial_set_pin_direction = mask_and_rotate(first_set_pin, set_pin_count, initial_set_pin_direction);
     uint32_t set_out_overlap = mask_and_rotate(first_out_pin, out_pin_count, 0xffffffff) &
-                               mask_and_rotate(first_set_pin, set_pin_count, 0xffffffff);
+        mask_and_rotate(first_set_pin, set_pin_count, 0xffffffff);
     // Check that OUT and SET settings agree because we don't have a way of picking one over the other.
     if ((initial_pin_state & set_out_overlap) != (initial_set_pin_state & set_out_overlap)) {
         mp_raise_ValueError(translate("Initial set pin state conflicts with initial out pin state"));
@@ -517,15 +517,15 @@ void common_hal_rp2pio_statemachine_run(rp2pio_statemachine_obj_t *self, const u
     }
 }
 
-uint32_t common_hal_rp2pio_statemachine_get_frequency(rp2pio_statemachine_obj_t* self) {
+uint32_t common_hal_rp2pio_statemachine_get_frequency(rp2pio_statemachine_obj_t *self) {
     return self->actual_frequency;
 }
 
-void common_hal_rp2pio_statemachine_set_frequency(rp2pio_statemachine_obj_t* self, uint32_t frequency) {
+void common_hal_rp2pio_statemachine_set_frequency(rp2pio_statemachine_obj_t *self, uint32_t frequency) {
     if (frequency == 0) {
         frequency = clock_get_hz(clk_sys);
     }
-    uint64_t frequency256 = ((uint64_t) clock_get_hz(clk_sys)) * 256;
+    uint64_t frequency256 = ((uint64_t)clock_get_hz(clk_sys)) * 256;
     uint64_t div256 = frequency256 / frequency;
     if (frequency256 % div256 > 0) {
         div256 += 1;
@@ -602,16 +602,16 @@ static bool _transfer(rp2pio_statemachine_obj_t *self,
             chan_rx = dma_claim_unused_channel(false);
         }
     }
-    volatile uint8_t* tx_destination = NULL;
-    const volatile uint8_t* rx_source = NULL;
+    volatile uint8_t *tx_destination = NULL;
+    const volatile uint8_t *rx_source = NULL;
     if (tx) {
-        tx_destination = (volatile uint8_t*) &self->pio->txf[self->state_machine];
+        tx_destination = (volatile uint8_t *)&self->pio->txf[self->state_machine];
         if (!self->out_shift_right) {
             tx_destination += 4 - out_stride_in_bytes;
         }
     }
     if (rx) {
-        rx_source = (const volatile uint8_t*) &self->pio->rxf[self->state_machine];
+        rx_source = (const volatile uint8_t *)&self->pio->rxf[self->state_machine];
         if (self->in_shift_right) {
             rx_source += 4 - in_stride_in_bytes;
         }
@@ -686,20 +686,20 @@ static bool _transfer(rp2pio_statemachine_obj_t *self,
                 if (out_stride_in_bytes == 1) {
                     *tx_destination = *data_out;
                 } else if (out_stride_in_bytes == 2) {
-                    *((uint16_t*) tx_destination) =  *((uint16_t*) data_out);
+                    *((uint16_t *)tx_destination) = *((uint16_t *)data_out);
                 } else if (out_stride_in_bytes == 4) {
-                    *((uint32_t*) tx_destination) = *((uint32_t*) data_out);
+                    *((uint32_t *)tx_destination) = *((uint32_t *)data_out);
                 }
                 data_out += out_stride_in_bytes;
                 --tx_remaining;
             }
             while (rx_remaining && !pio_sm_is_rx_fifo_empty(self->pio, self->state_machine)) {
                 if (in_stride_in_bytes == 1) {
-                    *data_in = (uint8_t) *rx_source;
+                    *data_in = (uint8_t)*rx_source;
                 } else if (in_stride_in_bytes == 2) {
-                    *((uint16_t*) data_in) = *((uint16_t*) rx_source);
+                    *((uint16_t *)data_in) = *((uint16_t *)rx_source);
                 } else if (in_stride_in_bytes == 4) {
-                    *((uint32_t*) data_in) = *((uint32_t*) rx_source);
+                    *((uint32_t *)data_in) = *((uint32_t *)rx_source);
                 }
                 data_in += in_stride_in_bytes;
                 --rx_remaining;
@@ -744,15 +744,15 @@ bool common_hal_rp2pio_statemachine_readinto(rp2pio_statemachine_obj_t *self, ui
 }
 
 bool common_hal_rp2pio_statemachine_write_readinto(rp2pio_statemachine_obj_t *self,
-                                                   const uint8_t *data_out, size_t out_len, uint8_t out_stride_in_bytes,
-                                                   uint8_t *data_in, size_t in_len, uint8_t in_stride_in_bytes) {
+    const uint8_t *data_out, size_t out_len, uint8_t out_stride_in_bytes,
+    uint8_t *data_in, size_t in_len, uint8_t in_stride_in_bytes) {
     if (!self->in || !self->out) {
         mp_raise_RuntimeError(translate("No in or out in program"));
     }
     return _transfer(self, data_out, out_len, out_stride_in_bytes, data_in, in_len, in_stride_in_bytes);
 }
 
-bool common_hal_rp2pio_statemachine_get_rxstall(rp2pio_statemachine_obj_t* self) {
+bool common_hal_rp2pio_statemachine_get_rxstall(rp2pio_statemachine_obj_t *self) {
     uint32_t stall_mask = 1 << (PIO_FDEBUG_RXSTALL_LSB + self->state_machine);
     return (self->pio->fdebug & stall_mask) != 0;
 }
@@ -761,7 +761,7 @@ void common_hal_rp2pio_statemachine_clear_rxfifo(rp2pio_statemachine_obj_t *self
     uint8_t level = pio_sm_get_rx_fifo_level(self->pio, self->state_machine);
     uint32_t stall_mask = 1 << (PIO_FDEBUG_RXSTALL_LSB + self->state_machine);
     for (size_t i = 0; i < level; i++) {
-        (void) self->pio->rxf[self->state_machine];
+        (void)self->pio->rxf[self->state_machine];
     }
     self->pio->fdebug = stall_mask;
 }
@@ -771,7 +771,7 @@ size_t common_hal_rp2pio_statemachine_get_in_waiting(rp2pio_statemachine_obj_t *
     return level;
 }
 
-void common_hal_rp2pio_statemachine_set_interrupt_handler(rp2pio_statemachine_obj_t *self, void(*handler)(void*), void *arg, int mask) {
+void common_hal_rp2pio_statemachine_set_interrupt_handler(rp2pio_statemachine_obj_t *self, void (*handler)(void *), void *arg, int mask) {
     uint8_t pio_index = pio_get_index(self->pio);
     uint8_t sm = self->state_machine;
 
diff --git a/ports/raspberrypi/common-hal/rp2pio/StateMachine.h b/ports/raspberrypi/common-hal/rp2pio/StateMachine.h
index 15bc2a346..38410a362 100644
--- a/ports/raspberrypi/common-hal/rp2pio/StateMachine.h
+++ b/ports/raspberrypi/common-hal/rp2pio/StateMachine.h
@@ -37,7 +37,7 @@ typedef struct {
     uint32_t pins; // Bitmask of what pins this state machine uses.
     int state_machine;
     PIO pio;
-    const uint16_t* init;
+    const uint16_t *init;
     size_t init_len;
     uint32_t initial_pin_state;
     uint32_t initial_pin_direction;
@@ -59,14 +59,14 @@ void reset_rp2pio_statemachine(void);
 
 // Minimal internal version that only fails on pin error (not in use) or full PIO.
 bool rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
-    const uint16_t* program, size_t program_len,
+    const uint16_t *program, size_t program_len,
     size_t frequency,
-    const uint16_t* init, size_t init_len,
-    const mcu_pin_obj_t * first_out_pin, uint8_t out_pin_count,
-    const mcu_pin_obj_t * first_in_pin, uint8_t in_pin_count,
+    const uint16_t *init, size_t init_len,
+    const mcu_pin_obj_t *first_out_pin, uint8_t out_pin_count,
+    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,
-    const mcu_pin_obj_t * first_sideset_pin, uint8_t sideset_pin_count,
+    const mcu_pin_obj_t *first_set_pin, uint8_t set_pin_count,
+    const mcu_pin_obj_t *first_sideset_pin, uint8_t sideset_pin_count,
     uint32_t initial_pin_state, uint32_t initial_pin_direction,
     uint32_t pins_we_use, bool tx_fifo, bool rx_fifo,
     bool auto_pull, uint8_t pull_threshold, bool out_shift_right,
diff --git a/ports/raspberrypi/common-hal/rp2pio/__init__.c b/ports/raspberrypi/common-hal/rp2pio/__init__.c
index 5ad52c751..ae4cb93d1 100644
--- a/ports/raspberrypi/common-hal/rp2pio/__init__.c
+++ b/ports/raspberrypi/common-hal/rp2pio/__init__.c
@@ -29,11 +29,11 @@
 #include "bindings/rp2pio/__init__.h"
 
 bool common_hal_rp2pio_pins_are_sequential(size_t len, mp_obj_t *items) {
-    if(len == 0) {
+    if (len == 0) {
         return true;
     }
     mcu_pin_obj_t *last_pin = validate_obj_is_pin(items[0]);
-    for(int i=1; i<len; i++) {
+    for (int i = 1; i < len; i++) {
         mcu_pin_obj_t *pin = validate_obj_is_pin(items[i]);
         if (pin->number != last_pin->number + 1) {
             return false;
diff --git a/ports/raspberrypi/common-hal/rtc/RTC.c b/ports/raspberrypi/common-hal/rtc/RTC.c
index e6c5d8871..8647fc246 100644
--- a/ports/raspberrypi/common-hal/rtc/RTC.c
+++ b/ports/raspberrypi/common-hal/rtc/RTC.c
@@ -33,13 +33,13 @@
 
 void common_hal_rtc_init(void) {
     datetime_t t = {
-            .year  = 2020,
-            .month = 1,
-            .day   = 1,
-            .dotw  = 3, // 0 is Sunday, so 3 is Wednesday
-            .hour  = 0,
-            .min   = 0,
-            .sec   = 0
+        .year = 2020,
+        .month = 1,
+        .day = 1,
+        .dotw = 3,      // 0 is Sunday, so 3 is Wednesday
+        .hour = 0,
+        .min = 0,
+        .sec = 0
     };
 
     // Start the RTC
@@ -53,17 +53,17 @@ void common_hal_rtc_get_time(timeutils_struct_time_t *tm) {
     rtc_get_datetime(&t);
 
     tm->tm_year = t.year;
-    tm->tm_mon  = t.month;
+    tm->tm_mon = t.month;
     tm->tm_mday = t.day;
     tm->tm_wday = t.dotw;
     tm->tm_hour = t.hour;
-    tm->tm_min  = t.min;
-    tm->tm_sec  = t.sec;
+    tm->tm_min = t.min;
+    tm->tm_sec = t.sec;
 
     if (tm->tm_wday == 0) {
         tm->tm_wday = 6;
     } else {
-        tm->tm_wday-=1;
+        tm->tm_wday -= 1;
     }
 }
 
@@ -71,17 +71,17 @@ void common_hal_rtc_set_time(timeutils_struct_time_t *tm) {
     if (tm->tm_wday == 6) {
         tm->tm_wday = 0;
     } else {
-        tm->tm_wday+=1;
+        tm->tm_wday += 1;
     }
 
     datetime_t t = {
-        .year   =   tm->tm_year,
-        .month  =   tm->tm_mon,
-        .day    =   tm->tm_mday,
-        .dotw   =   tm->tm_wday,
-        .hour   =   tm->tm_hour,
-        .min    =   tm->tm_min,
-        .sec    =   tm->tm_sec
+        .year = tm->tm_year,
+        .month = tm->tm_mon,
+        .day = tm->tm_mday,
+        .dotw = tm->tm_wday,
+        .hour = tm->tm_hour,
+        .min = tm->tm_min,
+        .sec = tm->tm_sec
     };
     rtc_set_datetime(&t);
 }
diff --git a/ports/raspberrypi/common-hal/supervisor/Runtime.c b/ports/raspberrypi/common-hal/supervisor/Runtime.c
index 974f26cec..f82765178 100755..100644
--- a/ports/raspberrypi/common-hal/supervisor/Runtime.c
+++ b/ports/raspberrypi/common-hal/supervisor/Runtime.c
@@ -29,9 +29,9 @@
 #include "supervisor/serial.h"
 
 bool common_hal_supervisor_runtime_get_serial_connected(void) {
-    return (bool) serial_connected();
+    return (bool)serial_connected();
 }
 
 bool common_hal_supervisor_runtime_get_serial_bytes_available(void) {
-    return (bool) serial_bytes_available();
+    return (bool)serial_bytes_available();
 }
diff --git a/ports/raspberrypi/common-hal/watchdog/WatchDogTimer.h b/ports/raspberrypi/common-hal/watchdog/WatchDogTimer.h
index ec1e2f659..ce34f0b8a 100644
--- a/ports/raspberrypi/common-hal/watchdog/WatchDogTimer.h
+++ b/ports/raspberrypi/common-hal/watchdog/WatchDogTimer.h
@@ -32,9 +32,9 @@
 #include "shared-bindings/watchdog/WatchDogTimer.h"
 
 struct _watchdog_watchdogtimer_obj_t {
-  mp_obj_base_t base;
-  mp_float_t timeout;
-  watchdog_watchdogmode_t mode;
+    mp_obj_base_t base;
+    mp_float_t timeout;
+    watchdog_watchdogmode_t mode;
 };
 
 // This needs to be called in order to disable the watchdog