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

62 files changed, 569 insertions, 573 deletions

diff --git a/ports/esp32s2/common-hal/alarm/SleepMemory.c b/ports/esp32s2/common-hal/alarm/SleepMemory.c
index 38e3de2b6..b25bf28d2 100644
--- a/ports/esp32s2/common-hal/alarm/SleepMemory.c
+++ b/ports/esp32s2/common-hal/alarm/SleepMemory.c
@@ -47,20 +47,20 @@ uint32_t common_hal_alarm_sleep_memory_get_length(alarm_sleep_memory_obj_t *self
     return sizeof(_sleep_mem);
 }
 
-bool common_hal_alarm_sleep_memory_set_bytes(alarm_sleep_memory_obj_t *self, uint32_t start_index, const uint8_t* values, uint32_t len) {
+bool common_hal_alarm_sleep_memory_set_bytes(alarm_sleep_memory_obj_t *self, uint32_t start_index, const uint8_t *values, uint32_t len) {
 
     if (start_index + len > sizeof(_sleep_mem)) {
         return false;
     }
 
-    memcpy((uint8_t *) (_sleep_mem + start_index), values, len);
+    memcpy((uint8_t *)(_sleep_mem + start_index), values, len);
     return true;
 }
 
-void common_hal_alarm_sleep_memory_get_bytes(alarm_sleep_memory_obj_t *self, uint32_t start_index, uint8_t* values, uint32_t len) {
+void common_hal_alarm_sleep_memory_get_bytes(alarm_sleep_memory_obj_t *self, uint32_t start_index, uint8_t *values, uint32_t len) {
 
     if (start_index + len > sizeof(_sleep_mem)) {
         return;
     }
-    memcpy(values, (uint8_t *) (_sleep_mem + start_index), len);
+    memcpy(values, (uint8_t *)(_sleep_mem + start_index), len);
 }
diff --git a/ports/esp32s2/common-hal/alarm/pin/PinAlarm.c b/ports/esp32s2/common-hal/alarm/pin/PinAlarm.c
index df8d10ef9..9ccb5700c 100644
--- a/ports/esp32s2/common-hal/alarm/pin/PinAlarm.c
+++ b/ports/esp32s2/common-hal/alarm/pin/PinAlarm.c
@@ -72,11 +72,11 @@ gpio_isr_handle_t gpio_interrupt_handle;
 static volatile uint32_t pin_31_0_status = 0;
 static volatile uint32_t pin_63_32_status = 0;
 void gpio_interrupt(void *arg) {
-    (void) arg;
+    (void)arg;
 
-    gpio_ll_get_intr_status(&GPIO, xPortGetCoreID(), (uint32_t*) &pin_31_0_status);
+    gpio_ll_get_intr_status(&GPIO, xPortGetCoreID(), (uint32_t *)&pin_31_0_status);
     gpio_ll_clear_intr_status(&GPIO, pin_31_0_status);
-    gpio_ll_get_intr_status_high(&GPIO, xPortGetCoreID(), (uint32_t*) &pin_63_32_status);
+    gpio_ll_get_intr_status_high(&GPIO, xPortGetCoreID(), (uint32_t *)&pin_63_32_status);
     gpio_ll_clear_intr_status_high(&GPIO, pin_63_32_status);
 
     // disable the interrupts that fired, maybe all of them
@@ -102,12 +102,12 @@ bool alarm_pin_pinalarm_woke_us_up(void) {
 
 mp_obj_t alarm_pin_pinalarm_get_wakeup_alarm(size_t n_alarms, const mp_obj_t *alarms) {
     // First, check to see if we match any given alarms.
-    uint64_t pin_status = ((uint64_t) pin_63_32_status) << 32 | pin_31_0_status;
+    uint64_t pin_status = ((uint64_t)pin_63_32_status) << 32 | pin_31_0_status;
     for (size_t i = 0; i < n_alarms; i++) {
         if (!MP_OBJ_IS_TYPE(alarms[i], &alarm_pin_pinalarm_type)) {
             continue;
         }
-        alarm_pin_pinalarm_obj_t *alarm  = MP_OBJ_TO_PTR(alarms[i]);
+        alarm_pin_pinalarm_obj_t *alarm = MP_OBJ_TO_PTR(alarms[i]);
         if ((pin_status & (1ull << alarm->pin->number)) != 0) {
             return alarms[i];
         }
@@ -136,8 +136,8 @@ mp_obj_t alarm_pin_pinalarm_get_wakeup_alarm(size_t n_alarms, const mp_obj_t *al
     alarm->pin = NULL;
     // Map the pin number back to a pin object.
     for (size_t i = 0; i < mcu_pin_globals.map.used; i++) {
-        const mcu_pin_obj_t* pin_obj = MP_OBJ_TO_PTR(mcu_pin_globals.map.table[i].value);
-        if ((size_t) pin_obj->number == pin_number) {
+        const mcu_pin_obj_t *pin_obj = MP_OBJ_TO_PTR(mcu_pin_globals.map.table[i].value);
+        if ((size_t)pin_obj->number == pin_number) {
             alarm->pin = mcu_pin_globals.map.table[i].value;
             break;
         }
@@ -182,7 +182,7 @@ void alarm_pin_pinalarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_ob
         if (!MP_OBJ_IS_TYPE(alarms[i], &alarm_pin_pinalarm_type)) {
             continue;
         }
-        alarm_pin_pinalarm_obj_t *alarm  = MP_OBJ_TO_PTR(alarms[i]);
+        alarm_pin_pinalarm_obj_t *alarm = MP_OBJ_TO_PTR(alarms[i]);
 
         gpio_num_t pin_number = alarm->pin->number;
         if (alarm->value) {
diff --git a/ports/esp32s2/common-hal/alarm/pin/__init__.c b/ports/esp32s2/common-hal/alarm/pin/__init__.c
index b39693c6a..ca8cfac7f 100644
--- a/ports/esp32s2/common-hal/alarm/pin/__init__.c
+++ b/ports/esp32s2/common-hal/alarm/pin/__init__.c
@@ -3,20 +3,20 @@
 #include "esp_sleep.h"
 #include "driver/rtc_io.h"
 
-mp_obj_t common_hal_alarm_io_pin_state (alarm_io_obj_t *self_in) {
+mp_obj_t common_hal_alarm_io_pin_state(alarm_io_obj_t *self_in) {
     if (!rtc_gpio_is_valid_gpio(self_in->gpio)) {
         mp_raise_ValueError(translate("io must be rtc io"));
     }
 
     if (self_in->pull && !self_in->level) {
-        for (uint8_t i = 0; i<=4; i+=2) {
+        for (uint8_t i = 0; i <= 4; i += 2) {
             if (self_in->gpio == i) {
                 mp_raise_ValueError(translate("IOs 0, 2 & 4 do not support internal pullup in sleep"));
             }
         }
     }
 
-    switch(esp_sleep_enable_ext0_wakeup(self_in->gpio, self_in->level)) {
+    switch (esp_sleep_enable_ext0_wakeup(self_in->gpio, self_in->level)) {
         case ESP_ERR_INVALID_ARG:
             mp_raise_ValueError(translate("trigger level must be 0 or 1"));
         case ESP_ERR_INVALID_STATE:
@@ -25,11 +25,13 @@ mp_obj_t common_hal_alarm_io_pin_state (alarm_io_obj_t *self_in) {
             break;
     }
 
-    if (self_in->pull) { (self_in->level) ? rtc_gpio_pulldown_en(self_in->gpio) : rtc_gpio_pullup_en(self_in->gpio); }
+    if (self_in->pull) {
+        (self_in->level) ? rtc_gpio_pulldown_en(self_in->gpio) : rtc_gpio_pullup_en(self_in->gpio);
+    }
 
     return self_in;
 }
 
-void common_hal_alarm_io_disable (void) {
+void common_hal_alarm_io_disable(void) {
     esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_EXT0 | ESP_SLEEP_WAKEUP_EXT1);
 }
diff --git a/ports/esp32s2/common-hal/alarm/time/TimeAlarm.c b/ports/esp32s2/common-hal/alarm/time/TimeAlarm.c
index bcde0ab3c..93e4f1809 100644
--- a/ports/esp32s2/common-hal/alarm/time/TimeAlarm.c
+++ b/ports/esp32s2/common-hal/alarm/time/TimeAlarm.c
@@ -61,7 +61,7 @@ STATIC bool woke_up = false;
 
 // This is run in the timer task. We use it to wake the main CircuitPython task.
 void timer_callback(void *arg) {
-    (void) arg;
+    (void)arg;
     woke_up = true;
     xTaskNotifyGive(circuitpython_task);
 }
@@ -88,7 +88,7 @@ void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_
         if (timealarm_set) {
             mp_raise_ValueError(translate("Only one alarm.time alarm can be set."));
         }
-        timealarm  = MP_OBJ_TO_PTR(alarms[i]);
+        timealarm = MP_OBJ_TO_PTR(alarms[i]);
         timealarm_set = true;
     }
     if (!timealarm_set) {
@@ -110,7 +110,7 @@ void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_
     // Compute how long to actually sleep, considering the time now.
     mp_float_t now_secs = uint64_to_float(common_hal_time_monotonic_ms()) / 1000.0f;
     mp_float_t wakeup_in_secs = MAX(0.0f, timealarm->monotonic_time - now_secs);
-    const uint64_t sleep_for_us = (uint64_t) (wakeup_in_secs * 1000000);
+    const uint64_t sleep_for_us = (uint64_t)(wakeup_in_secs * 1000000);
     esp_sleep_enable_timer_wakeup(sleep_for_us);
 
     // Also set the RTC interrupt so it can wake our task. This will be wiped out
diff --git a/ports/esp32s2/common-hal/alarm/touch/TouchAlarm.c b/ports/esp32s2/common-hal/alarm/touch/TouchAlarm.c
index 3095bc9e8..8c139afaf 100644
--- a/ports/esp32s2/common-hal/alarm/touch/TouchAlarm.c
+++ b/ports/esp32s2/common-hal/alarm/touch/TouchAlarm.c
@@ -62,7 +62,7 @@ mp_obj_t alarm_touch_touchalarm_get_wakeup_alarm(const size_t n_alarms, const mp
 
     // Map the pin number back to a pin object.
     for (size_t i = 0; i < mcu_pin_globals.map.used; i++) {
-        const mcu_pin_obj_t* pin_obj = MP_OBJ_TO_PTR(mcu_pin_globals.map.table[i].value);
+        const mcu_pin_obj_t *pin_obj = MP_OBJ_TO_PTR(mcu_pin_globals.map.table[i].value);
         if (pin_obj->touch_channel == wake_channel) {
             alarm->pin = mcu_pin_globals.map.table[i].value;
             break;
@@ -74,7 +74,7 @@ mp_obj_t alarm_touch_touchalarm_get_wakeup_alarm(const size_t n_alarms, const mp
 
 // This is used to wake the main CircuitPython task.
 void touch_interrupt(void *arg) {
-    (void) arg;
+    (void)arg;
     woke_up = true;
     BaseType_t task_wakeup;
     vTaskNotifyGiveFromISR(circuitpython_task, &task_wakeup);
@@ -121,7 +121,7 @@ void alarm_touch_touchalarm_set_alarm(const bool deep_sleep, const size_t n_alar
             // configure trigger threshold
             uint32_t touch_value;
             touch_pad_read_benchmark(touch_channel, &touch_value);
-            touch_pad_set_thresh(touch_channel, touch_value * 0.1); //10%
+            touch_pad_set_thresh(touch_channel, touch_value * 0.1); // 10%
         }
     }
 
@@ -161,7 +161,7 @@ void alarm_touch_touchalarm_prepare_for_deep_sleep(void) {
     // configure trigger threshold
     uint32_t touch_value;
     touch_pad_sleep_channel_read_smooth(touch_channel, &touch_value);
-    touch_pad_sleep_set_threshold(touch_channel, touch_value * 0.1); //10%
+    touch_pad_sleep_set_threshold(touch_channel, touch_value * 0.1); // 10%
 
     // enable touchpad wakeup
     esp_sleep_enable_touchpad_wakeup();
diff --git a/ports/esp32s2/common-hal/analogio/AnalogIn.c b/ports/esp32s2/common-hal/analogio/AnalogIn.c
index b2c09fc07..add4c3e14 100644
--- a/ports/esp32s2/common-hal/analogio/AnalogIn.c
+++ b/ports/esp32s2/common-hal/analogio/AnalogIn.c
@@ -41,8 +41,8 @@
 #define ATTENUATION         ADC_ATTEN_DB_11
 #define DATA_WIDTH          ADC_WIDTH_BIT_13
 
-void common_hal_analogio_analogin_construct(analogio_analogin_obj_t* self,
-        const mcu_pin_obj_t *pin) {
+void common_hal_analogio_analogin_construct(analogio_analogin_obj_t *self,
+    const mcu_pin_obj_t *pin) {
     if (pin->adc_index == 0 || pin->adc_channel == ADC_CHANNEL_MAX) {
         mp_raise_ValueError(translate("Pin does not have ADC capabilities"));
     }
@@ -78,14 +78,14 @@ uint16_t common_hal_analogio_analogin_get_value(analogio_analogin_obj_t *self) {
     esp_adc_cal_characterize(self->pin->adc_index, ATTENUATION, DATA_WIDTH, DEFAULT_VREF, &adc_chars);
 
     uint32_t adc_reading = 0;
-    //Multisampling
+    // Multisampling
     for (int i = 0; i < NO_OF_SAMPLES; i++) {
         if (self->pin->adc_index == ADC_UNIT_1) {
             adc_reading += adc1_get_raw((adc1_channel_t)self->pin->adc_channel);
         } else {
             int raw;
             esp_err_t r = adc2_get_raw((adc2_channel_t)self->pin->adc_channel, DATA_WIDTH, &raw);
-            if ( r != ESP_OK ) {
+            if (r != ESP_OK) {
                 mp_raise_ValueError(translate("ADC2 is being used by WiFi"));
             }
             adc_reading += raw;
@@ -95,7 +95,7 @@ uint16_t common_hal_analogio_analogin_get_value(analogio_analogin_obj_t *self) {
 
     // This corrects non-linear regions of the ADC range with a LUT, so it's a better reading than raw
     uint32_t voltage = esp_adc_cal_raw_to_voltage(adc_reading, &adc_chars);
-    return voltage * ((1 << 16) - 1)/3300;
+    return voltage * ((1 << 16) - 1) / 3300;
 }
 
 float common_hal_analogio_analogin_get_reference_voltage(analogio_analogin_obj_t *self) {
diff --git a/ports/esp32s2/common-hal/analogio/AnalogIn.h b/ports/esp32s2/common-hal/analogio/AnalogIn.h
index b9c4866f2..8c1f8a2ff 100644
--- a/ports/esp32s2/common-hal/analogio/AnalogIn.h
+++ b/ports/esp32s2/common-hal/analogio/AnalogIn.h
@@ -36,7 +36,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    const mcu_pin_obj_t * pin;
+    const mcu_pin_obj_t *pin;
 } analogio_analogin_obj_t;
 
 #endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_ANALOGIO_ANALOGIN_H
diff --git a/ports/esp32s2/common-hal/analogio/AnalogOut.c b/ports/esp32s2/common-hal/analogio/AnalogOut.c
index 080a01b04..589c477a7 100644
--- a/ports/esp32s2/common-hal/analogio/AnalogOut.c
+++ b/ports/esp32s2/common-hal/analogio/AnalogOut.c
@@ -39,8 +39,8 @@
 
 #include "common-hal/microcontroller/Pin.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) {
     if (pin == &pin_GPIO17) {
         self->channel = DAC_CHANNEL_1;
     } else if (pin == &pin_GPIO18) {
@@ -52,7 +52,7 @@ void common_hal_analogio_analogout_construct(analogio_analogout_obj_t* self,
 }
 
 bool common_hal_analogio_analogout_deinited(analogio_analogout_obj_t *self) {
-    return (self->channel == DAC_CHANNEL_MAX);
+    return self->channel == DAC_CHANNEL_MAX;
 }
 
 void common_hal_analogio_analogout_deinit(analogio_analogout_obj_t *self) {
@@ -61,7 +61,7 @@ void common_hal_analogio_analogout_deinit(analogio_analogout_obj_t *self) {
 }
 
 void common_hal_analogio_analogout_set_value(analogio_analogout_obj_t *self,
-        uint16_t value) {
+    uint16_t value) {
     uint8_t dac_value = (value * 255) / 65535;
     dac_output_enable(self->channel);
     dac_output_voltage(self->channel, dac_value);
diff --git a/ports/esp32s2/common-hal/analogio/AnalogOut.h b/ports/esp32s2/common-hal/analogio/AnalogOut.h
index 6285151ba..6dc823ce5 100644
--- a/ports/esp32s2/common-hal/analogio/AnalogOut.h
+++ b/ports/esp32s2/common-hal/analogio/AnalogOut.h
@@ -34,7 +34,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    const mcu_pin_obj_t * pin;
+    const mcu_pin_obj_t *pin;
     uint8_t channel;
 } analogio_analogout_obj_t;
 
diff --git a/ports/esp32s2/common-hal/audiobusio/I2SOut.c b/ports/esp32s2/common-hal/audiobusio/I2SOut.c
index eb9b6f8e1..6548f4607 100644
--- a/ports/esp32s2/common-hal/audiobusio/I2SOut.c
+++ b/ports/esp32s2/common-hal/audiobusio/I2SOut.c
@@ -47,9 +47,9 @@
 #include "driver/i2s.h"
 
 // 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) {
 
     port_i2s_allocate_init(&self->peripheral, left_justified);
 
@@ -68,11 +68,11 @@ void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t* self,
     claim_pin(data);
 }
 
-bool common_hal_audiobusio_i2sout_deinited(audiobusio_i2sout_obj_t* self) {
+bool common_hal_audiobusio_i2sout_deinited(audiobusio_i2sout_obj_t *self) {
     return self->peripheral.instance == -1;
 }
 
-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;
     }
@@ -98,31 +98,31 @@ void common_hal_audiobusio_i2sout_deinit(audiobusio_i2sout_obj_t* self) {
     self->peripheral.instance = -1;
 }
 
-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);
     }
     port_i2s_play(&self->peripheral, sample, loop);
 }
 
-void common_hal_audiobusio_i2sout_pause(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_pause(audiobusio_i2sout_obj_t *self) {
     port_i2s_pause(&self->peripheral);
 }
 
-void common_hal_audiobusio_i2sout_resume(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_resume(audiobusio_i2sout_obj_t *self) {
     port_i2s_resume(&self->peripheral);
 }
 
-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 port_i2s_paused(&self->peripheral);
 }
 
-void common_hal_audiobusio_i2sout_stop(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_stop(audiobusio_i2sout_obj_t *self) {
     port_i2s_stop(&self->peripheral);
 }
 
-bool common_hal_audiobusio_i2sout_get_playing(audiobusio_i2sout_obj_t* self) {
+bool common_hal_audiobusio_i2sout_get_playing(audiobusio_i2sout_obj_t *self) {
     return port_i2s_playing(&self->peripheral);
 }
 
diff --git a/ports/esp32s2/common-hal/audiobusio/__init__.c b/ports/esp32s2/common-hal/audiobusio/__init__.c
index 01c77c531..60d00aaa6 100644
--- a/ports/esp32s2/common-hal/audiobusio/__init__.c
+++ b/ports/esp32s2/common-hal/audiobusio/__init__.c
@@ -42,10 +42,14 @@ static QueueHandle_t i2s_queues[I2S_NUM_MAX];
 static TaskHandle_t i2s_tasks[I2S_NUM_MAX];
 
 static int8_t port_i2s_allocate(void) {
-#if defined(I2S_NUM_1)
-    if(!i2s_instance[1]) return 1;
-#endif
-    if(!i2s_instance[0]) return 0;
+    #if defined(I2S_NUM_1)
+    if (!i2s_instance[1]) {
+        return 1;
+    }
+    #endif
+    if (!i2s_instance[0]) {
+        return 0;
+    }
 
     mp_raise_RuntimeError(translate("Peripheral in use"));
 }
@@ -62,7 +66,7 @@ void port_i2s_reset_instance(int i) {
 }
 
 void i2s_reset(void) {
-    for (int i=0; i < I2S_NUM_MAX; i++) {
+    for (int i = 0; i < I2S_NUM_MAX; i++) {
         port_i2s_reset_instance(i);
     }
 }
@@ -88,7 +92,7 @@ static void i2s_fill_buffer(i2s_t *self) {
             uint32_t sample_buffer_length;
             audioio_get_buffer_result_t get_buffer_result =
                 audiosample_get_buffer(self->sample, false, 0,
-                                       &self->sample_data, &sample_buffer_length);
+                    &self->sample_data, &sample_buffer_length);
             self->sample_end = self->sample_data + sample_buffer_length;
             if (get_buffer_result == GET_BUFFER_DONE) {
                 if (self->loop) {
@@ -118,27 +122,27 @@ static void i2s_fill_buffer(i2s_t *self) {
             if (self->samples_signed) {
                 assert(self->channel_count == 1);
                 if (self->bytes_per_sample == 1) {
-                    audiosample_convert_s8m_s16s(signed_samples, (int8_t*)(void*)self->sample_data, framecount);
+                    audiosample_convert_s8m_s16s(signed_samples, (int8_t *)(void *)self->sample_data, framecount);
                 } else {
-                    audiosample_convert_s16m_s16s(signed_samples, (int16_t*)(void*)self->sample_data, framecount);
+                    audiosample_convert_s16m_s16s(signed_samples, (int16_t *)(void *)self->sample_data, framecount);
                 }
             } else {
                 if (self->channel_count == 1) {
                     if (self->bytes_per_sample == 1) {
-                        audiosample_convert_u8m_s16s(signed_samples, (uint8_t*)(void*)self->sample_data, framecount);
+                        audiosample_convert_u8m_s16s(signed_samples, (uint8_t *)(void *)self->sample_data, framecount);
                     } else {
-                        audiosample_convert_u16m_s16s(signed_samples, (uint16_t*)(void*)self->sample_data, framecount);
+                        audiosample_convert_u16m_s16s(signed_samples, (uint16_t *)(void *)self->sample_data, framecount);
                     }
                 } else {
                     if (self->bytes_per_sample == 1) {
-                        audiosample_convert_u8s_s16s(signed_samples, (uint8_t*)(void*)self->sample_data, framecount);
+                        audiosample_convert_u8s_s16s(signed_samples, (uint8_t *)(void *)self->sample_data, framecount);
                     } else {
-                        audiosample_convert_u16s_s16s(signed_samples, (uint16_t*)(void*)self->sample_data, framecount);
+                        audiosample_convert_u16s_s16s(signed_samples, (uint16_t *)(void *)self->sample_data, framecount);
                     }
                 }
             }
             size_t expanded_bytes_written = 0;
-            CHECK_ESP_RESULT(i2s_write(self->instance, signed_samples, bytes_per_output_frame*framecount, &expanded_bytes_written, 0));
+            CHECK_ESP_RESULT(i2s_write(self->instance, signed_samples, bytes_per_output_frame * framecount, &expanded_bytes_written, 0));
             assert(expanded_bytes_written % 4 == 0);
             bytes_written = expanded_bytes_written / bytes_per_output_frame * bytes_per_input_frame;
         }
@@ -157,7 +161,7 @@ static void i2s_callback_fun(void *self_in) {
 
 static void i2s_event_task(void *self_in) {
     i2s_t *self = self_in;
-    while(true) {
+    while (true) {
         i2s_event_type_t event;
         BaseType_t result = xQueueReceive(i2s_queues[self->instance], &event, portMAX_DELAY);
         if (result && event == I2S_EVENT_TX_DONE) {
@@ -199,7 +203,7 @@ void port_i2s_play(i2s_t *self, mp_obj_t sample, bool loop) {
     uint32_t max_buffer_length;
     uint8_t spacing;
     audiosample_get_buffer_structure(sample, false, &single_buffer, &samples_signed,
-                                     &max_buffer_length, &spacing);
+        &max_buffer_length, &spacing);
     self->samples_signed = samples_signed;
     self->playing = true;
     self->paused = false;
diff --git a/ports/esp32s2/common-hal/busio/I2C.c b/ports/esp32s2/common-hal/busio/I2C.c
index a1d0b8f9c..d97ccd9f1 100644
--- a/ports/esp32s2/common-hal/busio/I2C.c
+++ b/ports/esp32s2/common-hal/busio/I2C.c
@@ -55,7 +55,7 @@ void i2c_reset(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) {
     // Pins 45 and 46 are "strapping" pins that impact start up behavior. They usually need to
     // be pulled-down so pulling them up for I2C is a bad idea. To make this hard, we don't
     // support I2C on these pins.
@@ -65,7 +65,7 @@ void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
         mp_raise_ValueError(translate("Invalid pins"));
     }
 
-#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_direction(sda->number, GPIO_MODE_DEF_INPUT);
     gpio_set_direction(scl->number, GPIO_MODE_DEF_INPUT);
@@ -86,7 +86,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
 
 
     if (xSemaphoreCreateMutexStatic(&self->semaphore) != &self->semaphore) {
@@ -124,10 +124,10 @@ void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
     }
 
     if (i2c_driver_install(self->i2c_num,
-                           I2C_MODE_MASTER,
-                           0,
-                           0,
-                           0) != ESP_OK) {
+        I2C_MODE_MASTER,
+        0,
+        0,
+        0) != ESP_OK) {
         mp_raise_OSError(MP_EIO);
     }
 
@@ -182,11 +182,11 @@ 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) {
     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
     i2c_master_start(cmd);
     i2c_master_write_byte(cmd, addr << 1, true);
-    i2c_master_write(cmd, (uint8_t*) data, len, true);
+    i2c_master_write(cmd, (uint8_t *)data, len, true);
     if (transmit_stop_bit) {
         i2c_master_stop(cmd);
     }
@@ -202,7 +202,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) {
     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
     i2c_master_start(cmd);
     i2c_master_write_byte(cmd, addr << 1 | 1, true); // | 1 to indicate read
diff --git a/ports/esp32s2/common-hal/busio/I2C.h b/ports/esp32s2/common-hal/busio/I2C.h
index 1a989e30a..9629e7b18 100644
--- a/ports/esp32s2/common-hal/busio/I2C.h
+++ b/ports/esp32s2/common-hal/busio/I2C.h
@@ -36,8 +36,8 @@
 
 typedef struct {
     mp_obj_base_t base;
-    const mcu_pin_obj_t* scl_pin;
-    const mcu_pin_obj_t* sda_pin;
+    const mcu_pin_obj_t *scl_pin;
+    const mcu_pin_obj_t *sda_pin;
     i2c_port_t i2c_num;
     StaticSemaphore_t semaphore;
     bool has_lock;
diff --git a/ports/esp32s2/common-hal/busio/SPI.c b/ports/esp32s2/common-hal/busio/SPI.c
index c4d54ec81..917b39111 100644
--- a/ports/esp32s2/common-hal/busio/SPI.c
+++ b/ports/esp32s2/common-hal/busio/SPI.c
@@ -73,18 +73,27 @@ void spi_reset(void) {
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-static bool bus_uses_iomux_pins(spi_host_device_t host, const spi_bus_config_t* bus_config)
-{
-    if (bus_config->sclk_io_num>=0 &&
-        bus_config->sclk_io_num != spi_periph_signal[host].spiclk_iomux_pin) return false;
-    if (bus_config->quadwp_io_num>=0 &&
-        bus_config->quadwp_io_num != spi_periph_signal[host].spiwp_iomux_pin) return false;
-    if (bus_config->quadhd_io_num>=0 &&
-        bus_config->quadhd_io_num != spi_periph_signal[host].spihd_iomux_pin) return false;
+static bool bus_uses_iomux_pins(spi_host_device_t host, const spi_bus_config_t *bus_config) {
+    if (bus_config->sclk_io_num >= 0 &&
+        bus_config->sclk_io_num != spi_periph_signal[host].spiclk_iomux_pin) {
+        return false;
+    }
+    if (bus_config->quadwp_io_num >= 0 &&
+        bus_config->quadwp_io_num != spi_periph_signal[host].spiwp_iomux_pin) {
+        return false;
+    }
+    if (bus_config->quadhd_io_num >= 0 &&
+        bus_config->quadhd_io_num != spi_periph_signal[host].spihd_iomux_pin) {
+        return false;
+    }
     if (bus_config->mosi_io_num >= 0 &&
-        bus_config->mosi_io_num != spi_periph_signal[host].spid_iomux_pin) return false;
-    if (bus_config->miso_io_num>=0 &&
-        bus_config->miso_io_num != spi_periph_signal[host].spiq_iomux_pin) return false;
+        bus_config->mosi_io_num != spi_periph_signal[host].spid_iomux_pin) {
+        return false;
+    }
+    if (bus_config->miso_io_num >= 0 &&
+        bus_config->miso_io_num != spi_periph_signal[host].spiq_iomux_pin) {
+        return false;
+    }
 
     return true;
 }
@@ -100,20 +109,18 @@ static void spi_interrupt_handler(void *arg) {
 }
 
 // The interrupt may get invoked by the bus lock.
-static void spi_bus_intr_enable(void *self)
-{
+static void spi_bus_intr_enable(void *self) {
     esp_intr_enable(((busio_spi_obj_t *)self)->interrupt);
 }
 
 // The interrupt is always disabled by the ISR itself, not exposed
-static void spi_bus_intr_disable(void *self)
-{
+static void spi_bus_intr_disable(void *self) {
     esp_intr_disable(((busio_spi_obj_t *)self)->interrupt);
 }
 
 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) {
 
     spi_bus_config_t bus_config;
     bus_config.mosi_io_num = mosi != NULL ? mosi->number : -1;
@@ -123,8 +130,8 @@ void common_hal_busio_spi_construct(busio_spi_obj_t *self,
     bus_config.quadhd_io_num = -1;
     bus_config.max_transfer_sz = 0; // Uses the default
     bus_config.flags = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_SCLK |
-                       (mosi != NULL ? SPICOMMON_BUSFLAG_MOSI : 0) |
-                       (miso != NULL ? SPICOMMON_BUSFLAG_MISO : 0);
+        (mosi != NULL ? SPICOMMON_BUSFLAG_MOSI : 0) |
+        (miso != NULL ? SPICOMMON_BUSFLAG_MISO : 0);
     bus_config.intr_flags = 0;
 
     // RAM and Flash is often on SPI1 and is unsupported by the IDF so use it as
@@ -161,8 +168,8 @@ void common_hal_busio_spi_construct(busio_spi_obj_t *self,
     // The returned lock is stored in the bus lock but must be freed separately with
     // spi_bus_lock_unregister_dev.
     result = spi_bus_lock_register_dev(spi_bus_get_attr(host_id)->lock,
-                                       &config,
-                                       &self->lock);
+        &config,
+        &self->lock);
     if (result == ESP_ERR_NO_MEM) {
         common_hal_busio_spi_deinit(self);
         mp_raise_msg(&mp_type_MemoryError, translate("ESP-IDF memory allocation failed"));
@@ -170,8 +177,8 @@ void common_hal_busio_spi_construct(busio_spi_obj_t *self,
     lock_dev_handle[host_id] = self->lock;
 
     result = esp_intr_alloc(spicommon_irqsource_for_host(host_id),
-                            bus_config.intr_flags | ESP_INTR_FLAG_INTRDISABLED,
-                            spi_interrupt_handler, self, &self->interrupt);
+        bus_config.intr_flags | ESP_INTR_FLAG_INTRDISABLED,
+        spi_interrupt_handler, self, &self->interrupt);
     if (result == ESP_ERR_NO_MEM) {
         common_hal_busio_spi_deinit(self);
         mp_raise_msg(&mp_type_MemoryError, translate("ESP-IDF memory allocation failed"));
@@ -179,7 +186,7 @@ void common_hal_busio_spi_construct(busio_spi_obj_t *self,
     intr_handle[host_id] = self->interrupt;
     spi_bus_lock_set_bg_control(spi_bus_get_attr(host_id)->lock, spi_bus_intr_enable, spi_bus_intr_disable, self);
 
-    spi_hal_context_t* hal = &self->hal_context;
+    spi_hal_context_t *hal = &self->hal_context;
 
     // spi_hal_init clears the given hal context so set everything after.
     spi_hal_init(hal, host_id);
@@ -256,7 +263,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 &&
@@ -269,13 +276,13 @@ bool common_hal_busio_spi_configure(busio_spi_obj_t *self,
     self->bits = bits;
     self->target_frequency = baudrate;
     self->hal_context.timing_conf = &self->timing_conf;
-    esp_err_t result =  spi_hal_get_clock_conf(&self->hal_context,
-                                               self->target_frequency,
-                                               128 /* duty_cycle */,
-                                               self->connected_through_gpio,
-                                               0 /* input_delay_ns */,
-                                               &self->real_frequency,
-                                               &self->timing_conf);
+    esp_err_t result = spi_hal_get_clock_conf(&self->hal_context,
+        self->target_frequency,
+        128 /* duty_cycle */,
+        self->connected_through_gpio,
+        0 /* input_delay_ns */,
+        &self->real_frequency,
+        &self->timing_conf);
     if (result != ESP_OK) {
         return false;
     }
@@ -306,7 +313,7 @@ void common_hal_busio_spi_unlock(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) {
     if (self->MOSI_pin == NULL) {
         mp_raise_ValueError(translate("No MOSI Pin"));
     }
@@ -314,7 +321,7 @@ bool common_hal_busio_spi_write(busio_spi_obj_t *self,
 }
 
 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) {
 
     if (self->MISO_pin == NULL) {
         mp_raise_ValueError(translate("No MISO Pin"));
@@ -339,7 +346,7 @@ bool common_hal_busio_spi_transfer(busio_spi_obj_t *self, const uint8_t *data_ou
         mp_raise_ValueError(translate("No MISO Pin"));
     }
 
-    spi_hal_context_t* hal = &self->hal_context;
+    spi_hal_context_t *hal = &self->hal_context;
     hal->send_buffer = NULL;
     hal->rcv_buffer = NULL;
     // Reset timing_conf in case we've moved since the last time we used it.
@@ -377,7 +384,7 @@ bool common_hal_busio_spi_transfer(busio_spi_obj_t *self, const uint8_t *data_ou
         hal->tx_bitlen = this_length * self->bits;
         hal->rx_bitlen = this_length * self->bits;
         if (data_out != NULL) {
-            hal->send_buffer = (uint8_t*) data_out + offset;
+            hal->send_buffer = (uint8_t *)data_out + offset;
         }
         if (data_in != NULL) {
             hal->rcv_buffer = data_in + offset;
@@ -399,14 +406,14 @@ bool common_hal_busio_spi_transfer(busio_spi_obj_t *self, const uint8_t *data_ou
     return true;
 }
 
-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/esp32s2/common-hal/busio/SPI.h b/ports/esp32s2/common-hal/busio/SPI.h
index d6203feae..488c0954e 100644
--- a/ports/esp32s2/common-hal/busio/SPI.h
+++ b/ports/esp32s2/common-hal/busio/SPI.h
@@ -36,9 +36,9 @@
 
 typedef struct {
     mp_obj_base_t base;
-    const mcu_pin_obj_t* clock_pin;
-    const mcu_pin_obj_t* MOSI_pin;
-    const mcu_pin_obj_t* MISO_pin;
+    const mcu_pin_obj_t *clock_pin;
+    const mcu_pin_obj_t *MOSI_pin;
+    const mcu_pin_obj_t *MISO_pin;
     spi_host_device_t host_id;
     spi_bus_lock_dev_handle_t lock;
     spi_hal_context_t hal_context;
diff --git a/ports/esp32s2/common-hal/busio/UART.c b/ports/esp32s2/common-hal/busio/UART.c
index 98cebba67..7da5c0f94 100644
--- a/ports/esp32s2/common-hal/busio/UART.c
+++ b/ports/esp32s2/common-hal/busio/UART.c
@@ -53,11 +53,11 @@ void uart_reset(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,
+    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,
+    mp_float_t timeout, uint16_t receiver_buffer_size, byte *receiver_buffer,
     bool sigint_enabled) {
 
     if (bits > 8) {
@@ -163,7 +163,7 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
     uart_set_parity(self->uart_num, parity_mode);
 
     // Stop is 1 or 2 always.
-    uart_stop_bits_t stop_bits= UART_STOP_BITS_1;
+    uart_stop_bits_t stop_bits = UART_STOP_BITS_1;
     if (stop == 2) {
         stop_bits = UART_STOP_BITS_2;
     }
@@ -292,7 +292,7 @@ size_t common_hal_busio_uart_write(busio_uart_obj_t *self, const uint8_t *data,
     }
 
     while (len > 0) {
-        int count = uart_tx_chars(self->uart_num, (const char*) data, len);
+        int count = uart_tx_chars(self->uart_num, (const char *)data, len);
         if (count < 0) {
             *errcode = MP_EAGAIN;
             return MP_STREAM_ERROR;
@@ -322,7 +322,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) {
diff --git a/ports/esp32s2/common-hal/busio/UART.h b/ports/esp32s2/common-hal/busio/UART.h
index 751fb2e00..0d19221c8 100644
--- a/ports/esp32s2/common-hal/busio/UART.h
+++ b/ports/esp32s2/common-hal/busio/UART.h
@@ -34,10 +34,10 @@
 
 typedef struct {
     mp_obj_base_t base;
-    const mcu_pin_obj_t* rx_pin;
-    const mcu_pin_obj_t* tx_pin;
-    const mcu_pin_obj_t* rts_pin;
-    const mcu_pin_obj_t* cts_pin;
+    const mcu_pin_obj_t *rx_pin;
+    const mcu_pin_obj_t *tx_pin;
+    const mcu_pin_obj_t *rts_pin;
+    const mcu_pin_obj_t *cts_pin;
     uart_port_t uart_num;
     uint8_t character_bits;
     bool rx_error;
diff --git a/ports/esp32s2/common-hal/canio/CAN.c b/ports/esp32s2/common-hal/canio/CAN.c
index 768fde243..720034755 100644
--- a/ports/esp32s2/common-hal/canio/CAN.c
+++ b/ports/esp32s2/common-hal/canio/CAN.c
@@ -39,89 +39,74 @@
 STATIC bool reserved_can;
 
 twai_timing_config_t get_t_config(int baudrate) {
-    switch(baudrate) {
-    case 1000000:
-    {
-        // TWAI_TIMING_CONFIG_abc expands to a C designated initializer list
-        // { .brp = 4, ...}.  This is only acceptable to the compiler as an
-        // initializer and 'return TWAI_TIMING_CONFIG_1MBITS()` is not valid.
-        // Instead, introduce a temporary, named variable and return it.
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_1MBITS();
-        return t_config;
-    }
-    case 800000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_800KBITS();
-        return t_config;
-    }
-    case 500000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_500KBITS();
-        return t_config;
-    }
-    case 250000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_250KBITS();
-        return t_config;
-    }
-    case 125000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_125KBITS();
-        return t_config;
-    }
-    case 100000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_100KBITS();
-        return t_config;
-    }
-    case 50000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_50KBITS();
-        return t_config;
-    }
-    case 25000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_25KBITS();
-        return t_config;
-    }
-    case 20000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_20KBITS();
-        return t_config;
-    }
-    case 16000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_16KBITS();
-        return t_config;
-    }
-    case 12500:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_12_5KBITS();
-        return t_config;
-    }
-    case 10000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_10KBITS();
-        return t_config;
-    }
-    case 5000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_5KBITS();
-        return t_config;
-    }
-    case 1000:
-    {
-        twai_timing_config_t t_config = TWAI_TIMING_CONFIG_1KBITS();
-        return t_config;
-    }
-    default:
-        mp_raise_ValueError(translate("Baudrate not supported by peripheral"));
+    switch (baudrate) {
+        case 1000000: {
+            // TWAI_TIMING_CONFIG_abc expands to a C designated initializer list
+            // { .brp = 4, ...}.  This is only acceptable to the compiler as an
+            // initializer and 'return TWAI_TIMING_CONFIG_1MBITS()` is not valid.
+            // Instead, introduce a temporary, named variable and return it.
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_1MBITS();
+            return t_config;
+        }
+        case 800000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_800KBITS();
+            return t_config;
+        }
+        case 500000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_500KBITS();
+            return t_config;
+        }
+        case 250000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_250KBITS();
+            return t_config;
+        }
+        case 125000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_125KBITS();
+            return t_config;
+        }
+        case 100000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_100KBITS();
+            return t_config;
+        }
+        case 50000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_50KBITS();
+            return t_config;
+        }
+        case 25000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_25KBITS();
+            return t_config;
+        }
+        case 20000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_20KBITS();
+            return t_config;
+        }
+        case 16000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_16KBITS();
+            return t_config;
+        }
+        case 12500: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_12_5KBITS();
+            return t_config;
+        }
+        case 10000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_10KBITS();
+            return t_config;
+        }
+        case 5000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_5KBITS();
+            return t_config;
+        }
+        case 1000: {
+            twai_timing_config_t t_config = TWAI_TIMING_CONFIG_1KBITS();
+            return t_config;
+        }
+        default:
+            mp_raise_ValueError(translate("Baudrate not supported by peripheral"));
     }
 }
 
-void common_hal_canio_can_construct(canio_can_obj_t *self, mcu_pin_obj_t *tx, mcu_pin_obj_t *rx, int baudrate, bool loopback, bool silent)
-{
-#define DIV_ROUND(a, b) (((a) + (b)/2) / (b))
+void common_hal_canio_can_construct(canio_can_obj_t *self, mcu_pin_obj_t *tx, mcu_pin_obj_t *rx, int baudrate, bool loopback, bool silent) {
+#define DIV_ROUND(a, b) (((a) + (b) / 2) / (b))
 #define DIV_ROUND_UP(a, b) (((a) + (b) - 1) / (b))
     if (reserved_can) {
         mp_raise_ValueError(translate("All CAN peripherals are in use"));
@@ -170,25 +155,21 @@ void common_hal_canio_can_construct(canio_can_obj_t *self, mcu_pin_obj_t *tx, mc
     reserved_can = true;
 }
 
-bool common_hal_canio_can_loopback_get(canio_can_obj_t *self)
-{
+bool common_hal_canio_can_loopback_get(canio_can_obj_t *self) {
     return self->loopback;
 }
 
-int common_hal_canio_can_baudrate_get(canio_can_obj_t *self)
-{
+int common_hal_canio_can_baudrate_get(canio_can_obj_t *self) {
     return self->baudrate;
 }
 
-int common_hal_canio_can_transmit_error_count_get(canio_can_obj_t *self)
-{
+int common_hal_canio_can_transmit_error_count_get(canio_can_obj_t *self) {
     twai_status_info_t info;
     twai_get_status_info(&info);
     return info.tx_error_counter;
 }
 
-int common_hal_canio_can_receive_error_count_get(canio_can_obj_t *self)
-{
+int common_hal_canio_can_receive_error_count_get(canio_can_obj_t *self) {
     twai_status_info_t info;
     twai_get_status_info(&info);
     return info.rx_error_counter;
@@ -224,7 +205,9 @@ static void can_restart(void) {
 }
 
 void canio_maybe_auto_restart(canio_can_obj_t *self) {
-    if (self->auto_restart) can_restart();
+    if (self->auto_restart) {
+        can_restart();
+    }
 }
 
 void common_hal_canio_can_restart(canio_can_obj_t *self) {
@@ -242,8 +225,7 @@ void common_hal_canio_can_auto_restart_set(canio_can_obj_t *self, bool value) {
     canio_maybe_auto_restart(self);
 }
 
-void common_hal_canio_can_send(canio_can_obj_t *self, mp_obj_t message_in)
-{
+void common_hal_canio_can_send(canio_can_obj_t *self, mp_obj_t message_in) {
     canio_maybe_auto_restart(self);
     canio_message_obj_t *message = message_in;
     bool rtr = message->base.type == &canio_remote_transmission_request_type;
@@ -275,8 +257,7 @@ void common_hal_canio_can_check_for_deinit(canio_can_obj_t *self) {
     }
 }
 
-void common_hal_canio_can_deinit(canio_can_obj_t *self)
-{
+void common_hal_canio_can_deinit(canio_can_obj_t *self) {
     if (self->tx_pin) {
         (void)twai_stop();
         (void)twai_driver_uninstall();
diff --git a/ports/esp32s2/common-hal/canio/CAN.h b/ports/esp32s2/common-hal/canio/CAN.h
index 85fb6972b..82f30bc6f 100644
--- a/ports/esp32s2/common-hal/canio/CAN.h
+++ b/ports/esp32s2/common-hal/canio/CAN.h
@@ -42,8 +42,8 @@ typedef struct canio_can_obj {
     int baudrate;
     const mcu_pin_obj_t *rx_pin;
     const mcu_pin_obj_t *tx_pin;
-    bool loopback:1;
-    bool silent:1;
-    bool auto_restart:1;
-    bool fifo_in_use:1;
+    bool loopback : 1;
+    bool silent : 1;
+    bool auto_restart : 1;
+    bool fifo_in_use : 1;
 } canio_can_obj_t;
diff --git a/ports/esp32s2/common-hal/canio/Listener.c b/ports/esp32s2/common-hal/canio/Listener.c
index fddbfeb58..5e968f239 100644
--- a/ports/esp32s2/common-hal/canio/Listener.c
+++ b/ports/esp32s2/common-hal/canio/Listener.c
@@ -41,16 +41,15 @@
 
 // IDE = "extended ID" flag of packet header.  We always add this bit to the
 // mask because a match is always for just one kind of address length
-#define FILTER16_IDE (1<<3)
-#define FILTER32_IDE (1<<2)
+#define FILTER16_IDE (1 << 3)
+#define FILTER32_IDE (1 << 2)
 
 // Work around a problem reported at
 // https://github.com/espressif/esp-idf/issues/6020 where
 // twai_ll_set_acc_filter does not work under -Os optimization
 __attribute__((optimize("O0")))
 __attribute__((noinline))
-static void canio_set_acc_filter(twai_dev_t* hw, uint32_t code, uint32_t mask, bool single_filter)
-{
+static void canio_set_acc_filter(twai_dev_t *hw, uint32_t code, uint32_t mask, bool single_filter) {
     uint32_t code_swapped = __builtin_bswap32(code);
     uint32_t mask_swapped = __builtin_bswap32(mask);
     for (int i = 0; i < 4; i++) {
diff --git a/ports/esp32s2/common-hal/canio/Listener.h b/ports/esp32s2/common-hal/canio/Listener.h
index d24900e43..cc8545e37 100644
--- a/ports/esp32s2/common-hal/canio/Listener.h
+++ b/ports/esp32s2/common-hal/canio/Listener.h
@@ -32,9 +32,9 @@
 typedef struct canio_listener_obj {
     mp_obj_base_t base;
     canio_can_obj_t *can;
-    bool extended:1;
-    bool standard:1;
-    bool pending:1;
+    bool extended : 1;
+    bool standard : 1;
+    bool pending : 1;
     twai_message_t message_in;
     uint32_t timeout_ms;
 } canio_listener_obj_t;
diff --git a/ports/esp32s2/common-hal/countio/Counter.c b/ports/esp32s2/common-hal/countio/Counter.c
index fe52d93ad..bdc8b290f 100644
--- a/ports/esp32s2/common-hal/countio/Counter.c
+++ b/ports/esp32s2/common-hal/countio/Counter.c
@@ -30,8 +30,8 @@
 #include "py/runtime.h"
 #include "supervisor/shared/translate.h"
 
-void common_hal_countio_counter_construct(countio_counter_obj_t* self,
-    const mcu_pin_obj_t* pin) {
+void common_hal_countio_counter_construct(countio_counter_obj_t *self,
+    const mcu_pin_obj_t *pin) {
     claim_pin(pin);
 
     // Prepare configuration for the PCNT unit
@@ -55,11 +55,11 @@ void common_hal_countio_counter_construct(countio_counter_obj_t* self,
     self->unit = (pcnt_unit_t)unit;
 }
 
-bool common_hal_countio_counter_deinited(countio_counter_obj_t* self) {
+bool common_hal_countio_counter_deinited(countio_counter_obj_t *self) {
     return self->unit == PCNT_UNIT_MAX;
 }
 
-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;
     }
@@ -67,18 +67,18 @@ void common_hal_countio_counter_deinit(countio_counter_obj_t* self) {
     peripherals_pcnt_deinit(&self->unit);
 }
 
-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) {
     int16_t count;
     pcnt_get_counter_value(self->unit, &count);
-    return count+self->count;
+    return count + 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) {
     self->count = new_count;
     pcnt_counter_clear(self->unit);
 }
 
-void common_hal_countio_counter_reset(countio_counter_obj_t* self) {
-   common_hal_countio_counter_set_count(self, 0);
+void common_hal_countio_counter_reset(countio_counter_obj_t *self) {
+    common_hal_countio_counter_set_count(self, 0);
 }
diff --git a/ports/esp32s2/common-hal/countio/__init__.c b/ports/esp32s2/common-hal/countio/__init__.c
index b95b20d15..d47de33e5 100644
--- a/ports/esp32s2/common-hal/countio/__init__.c
+++ b/ports/esp32s2/common-hal/countio/__init__.c
@@ -1 +1 @@
-//No countio module functions
+// No countio module functions
diff --git a/ports/esp32s2/common-hal/digitalio/DigitalInOut.c b/ports/esp32s2/common-hal/digitalio/DigitalInOut.c
index a2a0209f9..f2c40ce9b 100644
--- a/ports/esp32s2/common-hal/digitalio/DigitalInOut.c
+++ b/ports/esp32s2/common-hal/digitalio/DigitalInOut.c
@@ -33,12 +33,12 @@
 #include "components/soc/include/hal/gpio_hal.h"
 
 void common_hal_digitalio_digitalinout_never_reset(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
     never_reset_pin_number(self->pin->number);
 }
 
 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;
 
@@ -69,20 +69,20 @@ 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) {
     common_hal_digitalio_digitalinout_set_pull(self, pull);
     gpio_set_direction(self->pin->number, GPIO_MODE_DEF_INPUT);
 }
 
 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) {
     common_hal_digitalio_digitalinout_set_value(self, value);
     return common_hal_digitalio_digitalinout_set_drive_mode(self, drive_mode);
 }
 
 digitalio_direction_t common_hal_digitalio_digitalinout_get_direction(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
     uint32_t iomux = READ_PERI_REG(GPIO_PIN_MUX_REG[self->pin->number]);
     if ((iomux & FUN_IE) != 0) {
         return DIRECTION_INPUT;
@@ -91,13 +91,13 @@ digitalio_direction_t common_hal_digitalio_digitalinout_get_direction(
 }
 
 void common_hal_digitalio_digitalinout_set_value(
-        digitalio_digitalinout_obj_t *self, bool value) {
+    digitalio_digitalinout_obj_t *self, bool value) {
     self->output_value = value;
     gpio_set_level(self->pin->number, value);
 }
 
 bool common_hal_digitalio_digitalinout_get_value(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
     if (common_hal_digitalio_digitalinout_get_direction(self) == DIRECTION_INPUT) {
         return gpio_get_level(self->pin->number) == 1;
     }
@@ -105,8 +105,8 @@ bool common_hal_digitalio_digitalinout_get_value(
 }
 
 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) {
     gpio_num_t number = self->pin->number;
     gpio_mode_t mode;
     if (drive_mode == DRIVE_MODE_OPEN_DRAIN) {
@@ -122,7 +122,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 (GPIO_HAL_GET_HW(GPIO_PORT_0)->pin[self->pin->number].pad_driver == 1) {
         return DRIVE_MODE_OPEN_DRAIN;
     }
@@ -130,7 +130,7 @@ 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) {
     gpio_num_t number = self->pin->number;
     gpio_pullup_dis(number);
     gpio_pulldown_dis(number);
@@ -142,7 +142,7 @@ void common_hal_digitalio_digitalinout_set_pull(
 }
 
 digitalio_pull_t common_hal_digitalio_digitalinout_get_pull(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
     gpio_num_t gpio_num = self->pin->number;
     if (REG_GET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PU) == 1) {
         return PULL_UP;
diff --git a/ports/esp32s2/common-hal/displayio/ParallelBus.c b/ports/esp32s2/common-hal/displayio/ParallelBus.c
index f77b37b57..5fd2be852 100644
--- a/ports/esp32s2/common-hal/displayio/ParallelBus.c
+++ b/ports/esp32s2/common-hal/displayio/ParallelBus.c
@@ -38,9 +38,9 @@
  *   - data0 pin must be byte aligned
  */
 
-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) {
 
     uint8_t data_pin = data0->number;
     if (data_pin % 8 != 0) {
@@ -59,8 +59,8 @@ void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t* sel
     // Enable pins with "enable_w1ts"
 
     for (uint8_t i = 0; i < 8; i++) {
-    	g->enable_w1ts = (0x1 << (data_pin + i));
-    	g->func_out_sel_cfg[data_pin + i].val= 256; /* setup output pin for simple GPIO Output, (0x100 = 256) */
+        g->enable_w1ts = (0x1 << (data_pin + i));
+        g->func_out_sel_cfg[data_pin + i].val = 256; /* setup output pin for simple GPIO Output, (0x100 = 256) */
 
     }
 
@@ -70,10 +70,10 @@ void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t* sel
 
 
     if (data_pin < 31) {
-		self->bus = (uint32_t*) &g->out; //pointer to GPIO output register (for pins 0-31)
-	} else {
-		self->bus = (uint32_t*) &g->out1.val; //pointer to GPIO output register (for pins >= 32)
-	}
+        self->bus = (uint32_t *)&g->out;         // pointer to GPIO output register (for pins 0-31)
+    } else {
+        self->bus = (uint32_t *)&g->out1.val;         // pointer to GPIO output register (for pins >= 32)
+    }
 
     /* SNIP - common setup of command, chip select, write and read pins, same as from SAMD and NRF ports */
     self->command.base.type = &digitalio_digitalinout_type;
@@ -95,20 +95,20 @@ void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t* sel
     self->data0_pin = data_pin;
 
     if (write->number < 32) {
-    	self->write_clear_register = (uint32_t*) &g->out_w1tc;
-    	self->write_set_register = (uint32_t*) &g->out_w1ts;
+        self->write_clear_register = (uint32_t *)&g->out_w1tc;
+        self->write_set_register = (uint32_t *)&g->out_w1ts;
     } else {
-    	self->write_clear_register = (uint32_t*) &g->out1_w1tc.val;
-    	self->write_set_register = (uint32_t*) &g->out1_w1ts.val;
+        self->write_clear_register = (uint32_t *)&g->out1_w1tc.val;
+        self->write_set_register = (uint32_t *)&g->out1_w1ts.val;
     }
 
     // Check to see if the data and write pins are on the same register:
-    if ( ( ((self->data0_pin < 32) && (write->number < 32)) ) ||
-    	 ( ((self->data0_pin > 31) && (write->number > 31)) )  ) {
-    		self->data_write_same_register = true; // data pins and write pin are on the same register
+    if ((((self->data0_pin < 32) && (write->number < 32))) ||
+        (((self->data0_pin > 31) && (write->number > 31)))) {
+        self->data_write_same_register = true;         // data pins and write pin are on the same register
     } else {
-    	self->data_write_same_register = false; // data pins and write pins are on different registers
-	}
+        self->data_write_same_register = false; // data pins and write pins are on different registers
+    }
 
 
     self->write_mask = 1 << (write->number % 32); /* the write pin triggers the LCD to latch the data */
@@ -133,8 +133,8 @@ void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t* sel
 
 }
 
-void common_hal_displayio_parallelbus_deinit(displayio_parallelbus_obj_t* self) {
-	/* SNIP - same as from SAMD and NRF ports */
+void common_hal_displayio_parallelbus_deinit(displayio_parallelbus_obj_t *self) {
+    /* SNIP - same as from SAMD and NRF ports */
     for (uint8_t i = 0; i < 8; i++) {
         reset_pin_number(self->data0_pin + i);
     }
@@ -147,8 +147,8 @@ void common_hal_displayio_parallelbus_deinit(displayio_parallelbus_obj_t* self)
 }
 
 bool common_hal_displayio_parallelbus_reset(mp_obj_t obj) {
-	/* SNIP - same as from SAMD and NRF ports */
-	displayio_parallelbus_obj_t* self = MP_OBJ_TO_PTR(obj);
+    /* SNIP - same as from SAMD and NRF ports */
+    displayio_parallelbus_obj_t *self = MP_OBJ_TO_PTR(obj);
     if (self->reset.base.type == &mp_type_NoneType) {
         return false;
     }
@@ -161,24 +161,24 @@ bool common_hal_displayio_parallelbus_reset(mp_obj_t obj) {
 }
 
 bool common_hal_displayio_parallelbus_bus_free(mp_obj_t obj) {
-	/* SNIP - same as from SAMD and NRF ports */
+    /* SNIP - same as from SAMD and NRF ports */
     return true;
 }
 
 bool common_hal_displayio_parallelbus_begin_transaction(mp_obj_t obj) {
-	/* SNIP - same as from SAMD and NRF ports */
-    displayio_parallelbus_obj_t* self = MP_OBJ_TO_PTR(obj);
+    /* SNIP - same as from SAMD and NRF ports */
+    displayio_parallelbus_obj_t *self = MP_OBJ_TO_PTR(obj);
     common_hal_digitalio_digitalinout_set_value(&self->chip_select, false);
     return true;
 }
 
 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) {
-    displayio_parallelbus_obj_t* self = MP_OBJ_TO_PTR(obj);
+    display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) {
+    displayio_parallelbus_obj_t *self = MP_OBJ_TO_PTR(obj);
     common_hal_digitalio_digitalinout_set_value(&self->command, byte_type == DISPLAY_DATA);
 
-    uint32_t* clear_write = self->write_clear_register;
-    uint32_t* set_write = self->write_set_register;
+    uint32_t *clear_write = self->write_clear_register;
+    uint32_t *set_write = self->write_set_register;
 
     const uint32_t mask = self->write_mask;
 
@@ -188,41 +188,40 @@ void common_hal_displayio_parallelbus_send(mp_obj_t obj, display_byte_type_t byt
      */
 
     *clear_write = mask; // Clear the write pin to prepare the registers before storing the
-    					 // register value into data_buffer
+    // register value into data_buffer
 
     const uint32_t data_buffer = *self->bus; // store the initial output register values into the data output buffer
-    uint8_t* data_address = ((uint8_t*) &data_buffer) + (self->data0_pin / 8); /* address inside data_buffer where
-    							* each data byte will be written to the data pin registers
-    							*/
-
-
-    if ( self->data_write_same_register ) { // data and write pins are on the same register
-	    for (uint32_t i = 0; i < data_length; i++) {
-
-	    	/* Note: If the write pin and data pins are controlled by the same GPIO register, we can eliminate
-	    	 * the "clear_write" step below, since the write pin is cleared when the data_buffer is written
-	    	 * to the bus.
-	    	 */
-
-	        *(data_address) = data[i]; // stuff the data byte into the data_buffer at the correct offset byte location
-	        *self->bus = data_buffer; // write the data to the output register
-	        *set_write = mask; // set the write pin
-	    }
-	}
-	else { // data and write pins are on different registers
-		for (uint32_t i = 0; i < data_length; i++) {
-			*clear_write = mask; // clear the write pin (See comment above, this may not be necessary).
-	        *(data_address) = data[i]; // stuff the data byte into the data_buffer at the correct offset byte location
-	        *self->bus = data_buffer; // write the data to the output register
-	        *set_write = mask; // set the write pin
-
-	    }
-	}
+    uint8_t *data_address = ((uint8_t *)&data_buffer) + (self->data0_pin / 8); /* address inside data_buffer where
+                                                        * each data byte will be written to the data pin registers
+                                                        */
+
+
+    if (self->data_write_same_register) {   // data and write pins are on the same register
+        for (uint32_t i = 0; i < data_length; i++) {
+
+            /* Note: If the write pin and data pins are controlled by the same GPIO register, we can eliminate
+                 * the "clear_write" step below, since the write pin is cleared when the data_buffer is written
+                 * to the bus.
+                 */
+
+            *(data_address) = data[i];     // stuff the data byte into the data_buffer at the correct offset byte location
+            *self->bus = data_buffer;     // write the data to the output register
+            *set_write = mask;     // set the write pin
+        }
+    } else {   // data and write pins are on different registers
+        for (uint32_t i = 0; i < data_length; i++) {
+            *clear_write = mask;             // clear the write pin (See comment above, this may not be necessary).
+            *(data_address) = data[i];     // stuff the data byte into the data_buffer at the correct offset byte location
+            *self->bus = data_buffer;     // write the data to the output register
+            *set_write = mask;     // set the write pin
+
+        }
+    }
 
 }
 
 void common_hal_displayio_parallelbus_end_transaction(mp_obj_t obj) {
-	/* SNIP - same as from SAMD and NRF ports */
-    displayio_parallelbus_obj_t* self = MP_OBJ_TO_PTR(obj);
+    /* SNIP - same as from SAMD and NRF ports */
+    displayio_parallelbus_obj_t *self = MP_OBJ_TO_PTR(obj);
     common_hal_digitalio_digitalinout_set_value(&self->chip_select, true);
 }
diff --git a/ports/esp32s2/common-hal/displayio/ParallelBus.h b/ports/esp32s2/common-hal/displayio/ParallelBus.h
index 84302118b..59eb64f34 100644
--- a/ports/esp32s2/common-hal/displayio/ParallelBus.h
+++ b/ports/esp32s2/common-hal/displayio/ParallelBus.h
@@ -31,7 +31,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    uint32_t* bus; // pointer where 8 bits of data are written to the display
+    uint32_t *bus; // pointer where 8 bits of data are written to the display
     digitalio_digitalinout_obj_t command;
     digitalio_digitalinout_obj_t chip_select;
     digitalio_digitalinout_obj_t reset;
@@ -39,8 +39,8 @@ typedef struct {
     digitalio_digitalinout_obj_t read;
     uint8_t data0_pin; // pin number for the lowest number data pin.  Must be 8-bit aligned
     bool data_write_same_register; // if data and write pins are in the sare
-    uint32_t* write_set_register; // pointer to the write group for setting the write bit to latch the data on the LCD
-    uint32_t* write_clear_register; // pointer to the write group for clearing the write bit to latch the data on the LCD
+    uint32_t *write_set_register; // pointer to the write group for setting the write bit to latch the data on the LCD
+    uint32_t *write_clear_register; // pointer to the write group for clearing the write bit to latch the data on the LCD
     uint32_t write_mask; // bit mask for the single bit for the write pin register
 } displayio_parallelbus_obj_t;
 
diff --git a/ports/esp32s2/common-hal/dualbank/__init__.c b/ports/esp32s2/common-hal/dualbank/__init__.c
index 1414f131d..04f5d6203 100644
--- a/ports/esp32s2/common-hal/dualbank/__init__.c
+++ b/ports/esp32s2/common-hal/dualbank/__init__.c
@@ -62,10 +62,10 @@ void common_hal_dualbank_flash(const void *buf, const size_t len, const size_t o
         update_partition = esp_ota_get_next_update_partition(NULL);
 
         ESP_LOGI(TAG, "Running partition type %d subtype %d (offset 0x%08x)",
-                running->type, running->subtype, running->address);
+            running->type, running->subtype, running->address);
 
         ESP_LOGI(TAG, "Writing partition type %d subtype %d (offset 0x%08x)\n",
-                update_partition->type, update_partition->subtype, update_partition->address);
+            update_partition->type, update_partition->subtype, update_partition->address);
 
         assert(update_partition != NULL);
     }
diff --git a/ports/esp32s2/common-hal/dualbank/__init__.h b/ports/esp32s2/common-hal/dualbank/__init__.h
index 8b18336c9..eb325b9fb 100644
--- a/ports/esp32s2/common-hal/dualbank/__init__.h
+++ b/ports/esp32s2/common-hal/dualbank/__init__.h
@@ -29,4 +29,4 @@
 
 extern void dualbank_reset(void);
 
-#endif //MICROPY_INCLUDED_ESP32S2_COMMON_HAL_DUALBANK___INIT___H
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_DUALBANK___INIT___H
diff --git a/ports/esp32s2/common-hal/frequencyio/FrequencyIn.c b/ports/esp32s2/common-hal/frequencyio/FrequencyIn.c
index 12d612abb..cd13cddc6 100644
--- a/ports/esp32s2/common-hal/frequencyio/FrequencyIn.c
+++ b/ports/esp32s2/common-hal/frequencyio/FrequencyIn.c
@@ -29,7 +29,7 @@
 #include "py/runtime.h"
 
 static void IRAM_ATTR pcnt_overflow_handler(void *self_in) {
-    frequencyio_frequencyin_obj_t * self = self_in;
+    frequencyio_frequencyin_obj_t *self = self_in;
     // reset counter
     pcnt_counter_clear(self->unit);
 
@@ -41,7 +41,7 @@ static void IRAM_ATTR pcnt_overflow_handler(void *self_in) {
 }
 
 static void IRAM_ATTR timer_interrupt_handler(void *self_in) {
-    frequencyio_frequencyin_obj_t * self = self_in;
+    frequencyio_frequencyin_obj_t *self = self_in;
     // get counter value
     int16_t count;
     pcnt_get_counter_value(self->unit, &count);
@@ -63,7 +63,7 @@ static void IRAM_ATTR timer_interrupt_handler(void *self_in) {
     device->hw_timer[self->timer.idx].config.alarm_en = 1;
 }
 
-static void init_pcnt(frequencyio_frequencyin_obj_t* self) {
+static void init_pcnt(frequencyio_frequencyin_obj_t *self) {
     // Prepare configuration for the PCNT unit
     const pcnt_config_t pcnt_config = {
         // Set PCNT input signal and control GPIOs
@@ -95,7 +95,7 @@ static void init_pcnt(frequencyio_frequencyin_obj_t* self) {
     pcnt_intr_enable(self->unit);
 }
 
-static void init_timer(frequencyio_frequencyin_obj_t* self) {
+static void init_timer(frequencyio_frequencyin_obj_t *self) {
     // Prepare configuration for the timer module
     const timer_config_t config = {
         .alarm_en = true,
@@ -124,8 +124,8 @@ static void init_timer(frequencyio_frequencyin_obj_t* self) {
     timer_start(self->timer.group, self->timer.idx);
 }
 
-void common_hal_frequencyio_frequencyin_construct(frequencyio_frequencyin_obj_t* self,
-        const mcu_pin_obj_t* pin, const uint16_t capture_period) {
+void common_hal_frequencyio_frequencyin_construct(frequencyio_frequencyin_obj_t *self,
+    const mcu_pin_obj_t *pin, const uint16_t capture_period) {
     if ((capture_period == 0) || (capture_period > 500)) {
         mp_raise_ValueError(translate("Invalid capture period. Valid range: 1 - 500"));
     }
@@ -142,11 +142,11 @@ void common_hal_frequencyio_frequencyin_construct(frequencyio_frequencyin_obj_t*
     claim_pin(pin);
 }
 
-bool common_hal_frequencyio_frequencyin_deinited(frequencyio_frequencyin_obj_t* self) {
+bool common_hal_frequencyio_frequencyin_deinited(frequencyio_frequencyin_obj_t *self) {
     return self->unit == PCNT_UNIT_MAX;
 }
 
-void common_hal_frequencyio_frequencyin_deinit(frequencyio_frequencyin_obj_t* self) {
+void common_hal_frequencyio_frequencyin_deinit(frequencyio_frequencyin_obj_t *self) {
     if (common_hal_frequencyio_frequencyin_deinited(self)) {
         return;
     }
@@ -159,21 +159,21 @@ void common_hal_frequencyio_frequencyin_deinit(frequencyio_frequencyin_obj_t* se
     }
 }
 
-uint32_t common_hal_frequencyio_frequencyin_get_item(frequencyio_frequencyin_obj_t* self) {
+uint32_t common_hal_frequencyio_frequencyin_get_item(frequencyio_frequencyin_obj_t *self) {
     return self->frequency;
 }
 
-void common_hal_frequencyio_frequencyin_pause(frequencyio_frequencyin_obj_t* self) {
+void common_hal_frequencyio_frequencyin_pause(frequencyio_frequencyin_obj_t *self) {
     pcnt_counter_pause(self->unit);
     timer_pause(self->timer.group, self->timer.idx);
 }
 
-void common_hal_frequencyio_frequencyin_resume(frequencyio_frequencyin_obj_t* self) {
+void common_hal_frequencyio_frequencyin_resume(frequencyio_frequencyin_obj_t *self) {
     pcnt_counter_resume(self->unit);
     timer_start(self->timer.group, self->timer.idx);
 }
 
-void common_hal_frequencyio_frequencyin_clear(frequencyio_frequencyin_obj_t* self) {
+void common_hal_frequencyio_frequencyin_clear(frequencyio_frequencyin_obj_t *self) {
     self->frequency = 0;
     pcnt_counter_clear(self->unit);
     timer_set_counter_value(self->timer.group, self->timer.idx, 0);
diff --git a/ports/esp32s2/common-hal/microcontroller/Pin.c b/ports/esp32s2/common-hal/microcontroller/Pin.c
index ff6d0ed35..5c00ca49e 100644
--- a/ports/esp32s2/common-hal/microcontroller/Pin.c
+++ b/ports/esp32s2/common-hal/microcontroller/Pin.c
@@ -59,20 +59,20 @@ STATIC void floating_gpio_reset(gpio_num_t pin_number) {
 }
 
 void never_reset_pin_number(gpio_num_t pin_number) {
-    if (pin_number == -1 ) {
-         return;
+    if (pin_number == -1) {
+        return;
     }
     never_reset_pins[pin_number / 32] |= 1 << pin_number % 32;
 }
 
-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);
 }
 
 // Mark pin as free and return it to a quiescent state.
 void reset_pin_number(gpio_num_t pin_number) {
-    if (pin_number == -1 ) {
-         return;
+    if (pin_number == -1) {
+        return;
     }
     never_reset_pins[pin_number / 32] &= ~(1 << pin_number % 32);
     in_use[pin_number / 32] &= ~(1 << pin_number % 32);
@@ -88,7 +88,7 @@ void reset_pin_number(gpio_num_t pin_number) {
     #endif
 }
 
-void common_hal_reset_pin(const mcu_pin_obj_t* pin) {
+void common_hal_reset_pin(const mcu_pin_obj_t *pin) {
     if (pin == NULL) {
         return;
     }
@@ -112,7 +112,7 @@ void reset_all_pins(void) {
     #endif
 }
 
-void claim_pin(const mcu_pin_obj_t* pin) {
+void claim_pin(const mcu_pin_obj_t *pin) {
     in_use[pin->number / 32] |= (1 << (pin->number % 32));
     #ifdef MICROPY_HW_NEOPIXEL
     if (pin == MICROPY_HW_NEOPIXEL) {
@@ -121,7 +121,7 @@ void claim_pin(const mcu_pin_obj_t* pin) {
     #endif
 }
 
-void common_hal_mcu_pin_claim(const mcu_pin_obj_t* pin) {
+void common_hal_mcu_pin_claim(const mcu_pin_obj_t *pin) {
     claim_pin(pin);
 }
 
diff --git a/ports/esp32s2/common-hal/microcontroller/Pin.h b/ports/esp32s2/common-hal/microcontroller/Pin.h
index f6c008703..e7b488f04 100644
--- a/ports/esp32s2/common-hal/microcontroller/Pin.h
+++ b/ports/esp32s2/common-hal/microcontroller/Pin.h
@@ -42,8 +42,8 @@ void reset_all_pins(void);
 // reset_pin_number takes the pin number instead of the pointer so that objects don't
 // need to store a full pointer.
 void reset_pin_number(gpio_num_t pin_number);
-void common_hal_reset_pin(const mcu_pin_obj_t* pin);
-void claim_pin(const mcu_pin_obj_t* pin);
+void common_hal_reset_pin(const mcu_pin_obj_t *pin);
+void claim_pin(const mcu_pin_obj_t *pin);
 bool pin_number_is_free(gpio_num_t pin_number);
 void never_reset_pin_number(gpio_num_t pin_number);
 
diff --git a/ports/esp32s2/common-hal/microcontroller/Processor.c b/ports/esp32s2/common-hal/microcontroller/Processor.c
index fffd1a1b1..eb65f2d10 100644
--- a/ports/esp32s2/common-hal/microcontroller/Processor.c
+++ b/ports/esp32s2/common-hal/microcontroller/Processor.c
@@ -66,17 +66,21 @@ STATIC uint8_t swap_nibbles(uint8_t v) {
 void common_hal_mcu_processor_get_uid(uint8_t raw_id[]) {
     memset(raw_id, 0, COMMON_HAL_MCU_PROCESSOR_UID_LENGTH);
 
-    uint8_t *ptr = &raw_id[COMMON_HAL_MCU_PROCESSOR_UID_LENGTH-1];
+    uint8_t *ptr = &raw_id[COMMON_HAL_MCU_PROCESSOR_UID_LENGTH - 1];
     // MAC address contains 48 bits (6 bytes), 32 in the low order word
     uint32_t mac_address_part = REG_READ(EFUSE_RD_MAC_SPI_SYS_0_REG);
-    *ptr-- = swap_nibbles(mac_address_part & 0xff); mac_address_part >>= 8;
-    *ptr-- = swap_nibbles(mac_address_part & 0xff); mac_address_part >>= 8;
-    *ptr-- = swap_nibbles(mac_address_part & 0xff); mac_address_part >>= 8;
+    *ptr-- = swap_nibbles(mac_address_part & 0xff);
+    mac_address_part >>= 8;
+    *ptr-- = swap_nibbles(mac_address_part & 0xff);
+    mac_address_part >>= 8;
+    *ptr-- = swap_nibbles(mac_address_part & 0xff);
+    mac_address_part >>= 8;
     *ptr-- = swap_nibbles(mac_address_part & 0xff);
 
     // and 16 in the high order word
     mac_address_part = REG_READ(EFUSE_RD_MAC_SPI_SYS_1_REG);
-    *ptr-- = swap_nibbles(mac_address_part & 0xff); mac_address_part >>= 8;
+    *ptr-- = swap_nibbles(mac_address_part & 0xff);
+    mac_address_part >>= 8;
     *ptr-- = swap_nibbles(mac_address_part & 0xff);
 }
 
diff --git a/ports/esp32s2/common-hal/microcontroller/__init__.c b/ports/esp32s2/common-hal/microcontroller/__init__.c
index e425cbf54..85eb0b522 100644
--- a/ports/esp32s2/common-hal/microcontroller/__init__.c
+++ b/ports/esp32s2/common-hal/microcontroller/__init__.c
@@ -68,12 +68,13 @@ void common_hal_mcu_enable_interrupts(void) {
 }
 
 void common_hal_mcu_on_next_reset(mcu_runmode_t runmode) {
-    if(runmode == RUNMODE_SAFE_MODE)
+    if (runmode == RUNMODE_SAFE_MODE) {
         safe_mode_on_next_reset(PROGRAMMATIC_SAFE_MODE);
+    }
 }
 
 void common_hal_mcu_reset(void) {
-    filesystem_flush(); //TODO: implement as part of flash improvements
+    filesystem_flush(); // TODO: implement as part of flash improvements
     esp_restart();
 }
 
@@ -91,7 +92,7 @@ const nvm_bytearray_obj_t common_hal_mcu_nvm_obj = {
     .base = {
         .type = &nvm_bytearray_type,
     },
-    .start_address = (uint8_t*) CIRCUITPY_INTERNAL_NVM_START_ADDR,
+    .start_address = (uint8_t *)CIRCUITPY_INTERNAL_NVM_START_ADDR,
     .len = CIRCUITPY_INTERNAL_NVM_SIZE,
 };
 #endif
diff --git a/ports/esp32s2/common-hal/neopixel_write/__init__.c b/ports/esp32s2/common-hal/neopixel_write/__init__.c
index 63d50bf14..89d90ae99 100644
--- a/ports/esp32s2/common-hal/neopixel_write/__init__.c
+++ b/ports/esp32s2/common-hal/neopixel_write/__init__.c
@@ -58,15 +58,14 @@ static uint32_t ws2812_t0l_ticks = 0;
 static uint32_t ws2812_t1l_ticks = 0;
 
 static void IRAM_ATTR ws2812_rmt_adapter(const void *src, rmt_item32_t *dest, size_t src_size,
-        size_t wanted_num, size_t *translated_size, size_t *item_num)
-{
+    size_t wanted_num, size_t *translated_size, size_t *item_num) {
     if (src == NULL || dest == NULL) {
         *translated_size = 0;
         *item_num = 0;
         return;
     }
-    const rmt_item32_t bit0 = {{{ ws2812_t0h_ticks, 1, ws2812_t0l_ticks, 0 }}}; //Logical 0
-    const rmt_item32_t bit1 = {{{ ws2812_t1h_ticks, 1, ws2812_t1l_ticks, 0 }}}; //Logical 1
+    const rmt_item32_t bit0 = {{{ ws2812_t0h_ticks, 1, ws2812_t0l_ticks, 0 }}}; // Logical 0
+    const rmt_item32_t bit1 = {{{ ws2812_t1h_ticks, 1, ws2812_t1l_ticks, 0 }}}; // Logical 1
     size_t size = 0;
     size_t num = 0;
     uint8_t *psrc = (uint8_t *)src;
@@ -75,9 +74,9 @@ static void IRAM_ATTR ws2812_rmt_adapter(const void *src, rmt_item32_t *dest, si
         for (int i = 0; i < 8; i++) {
             // MSB first
             if (*psrc & (1 << (7 - i))) {
-                pdest->val =  bit1.val;
+                pdest->val = bit1.val;
             } else {
-                pdest->val =  bit0.val;
+                pdest->val = bit0.val;
             }
             num++;
             pdest++;
@@ -89,7 +88,7 @@ static void IRAM_ATTR ws2812_rmt_adapter(const void *src, rmt_item32_t *dest, si
     *item_num = num;
 }
 
-void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout, uint8_t *pixels, uint32_t numBytes) {
+void common_hal_neopixel_write(const digitalio_digitalinout_obj_t *digitalinout, uint8_t *pixels, uint32_t numBytes) {
     // Reserve channel
     uint8_t number = digitalinout->pin->number;
     rmt_channel_t channel = esp32s2_peripherals_find_and_reserve_rmt();
@@ -118,7 +117,7 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
     rmt_translator_init(config.channel, ws2812_rmt_adapter);
 
     // Write and wait to finish
-    if(rmt_write_sample(config.channel, pixels, (size_t)numBytes, true) != ESP_OK) {
+    if (rmt_write_sample(config.channel, pixels, (size_t)numBytes, true) != ESP_OK) {
         mp_raise_RuntimeError(translate("Input/output error"));
     }
     rmt_wait_tx_done(config.channel, pdMS_TO_TICKS(100));
diff --git a/ports/esp32s2/common-hal/nvm/ByteArray.c b/ports/esp32s2/common-hal/nvm/ByteArray.c
index 71321e7e6..313087379 100644
--- a/ports/esp32s2/common-hal/nvm/ByteArray.c
+++ b/ports/esp32s2/common-hal/nvm/ByteArray.c
@@ -33,7 +33,7 @@ uint32_t common_hal_nvm_bytearray_get_length(nvm_bytearray_obj_t *self) {
     return self->len;
 }
 
-static void get_nvs_handle(nvs_handle_t * nvs_handle) {
+static void get_nvs_handle(nvs_handle_t *nvs_handle) {
     // Initialize NVS
     esp_err_t err = nvs_flash_init();
     if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
@@ -51,7 +51,7 @@ static void get_nvs_handle(nvs_handle_t * nvs_handle) {
 }
 
 bool common_hal_nvm_bytearray_set_bytes(nvm_bytearray_obj_t *self,
-        uint32_t start_index, uint8_t* values, uint32_t len) {
+    uint32_t start_index, uint8_t *values, uint32_t len) {
     char index[9];
 
     // start nvs
@@ -77,7 +77,7 @@ bool common_hal_nvm_bytearray_set_bytes(nvm_bytearray_obj_t *self,
 }
 
 void common_hal_nvm_bytearray_get_bytes(nvm_bytearray_obj_t *self,
-        uint32_t start_index, uint32_t len, uint8_t* values) {
+    uint32_t start_index, uint32_t len, uint8_t *values) {
     char index[9];
 
     // start nvs
diff --git a/ports/esp32s2/common-hal/nvm/ByteArray.h b/ports/esp32s2/common-hal/nvm/ByteArray.h
index 44b63d724..3bd5191fc 100644
--- a/ports/esp32s2/common-hal/nvm/ByteArray.h
+++ b/ports/esp32s2/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/esp32s2/common-hal/os/__init__.c b/ports/esp32s2/common-hal/os/__init__.c
index 4d6a6a2bf..ee53bec04 100644
--- a/ports/esp32s2/common-hal/os/__init__.c
+++ b/ports/esp32s2/common-hal/os/__init__.c
@@ -52,13 +52,13 @@ 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;
 }
 
-bool common_hal_os_urandom(uint8_t* buffer, uint32_t length) {
+bool common_hal_os_urandom(uint8_t *buffer, uint32_t length) {
     uint32_t i = 0;
     while (i < length) {
         uint32_t new_random = esp_random();
diff --git a/ports/esp32s2/common-hal/ps2io/Ps2.c b/ports/esp32s2/common-hal/ps2io/Ps2.c
index 003f0d827..f4845b0fa 100644
--- a/ports/esp32s2/common-hal/ps2io/Ps2.c
+++ b/ports/esp32s2/common-hal/ps2io/Ps2.c
@@ -62,7 +62,7 @@ static void IRAM_ATTR ps2_interrupt_handler(void *self_in) {
     // Grab the current time first.
     uint64_t current_tick = port_get_raw_ticks(NULL);
 
-    ps2io_ps2_obj_t * self = self_in;
+    ps2io_ps2_obj_t *self = self_in;
     int data_bit = gpio_get_level(self->data_pin) ? 1 : 0;
 
     // test for timeout
@@ -85,7 +85,7 @@ static void IRAM_ATTR ps2_interrupt_handler(void *self_in) {
             // start bit should be 0
             self->last_errors |= ERROR_STARTBIT;
             self->state = STATE_RECV_ERR;
-                } else {
+        } else {
             self->state = STATE_RECV;
         }
 
@@ -113,7 +113,7 @@ static void IRAM_ATTR ps2_interrupt_handler(void *self_in) {
 
     } else if (self->state == STATE_RECV_STOP) {
         ++self->bitcount;
-        if (! data_bit) {
+        if (!data_bit) {
             self->last_errors |= ERROR_STOPBIT;
         } else if (self->waiting_cmd_response) {
             self->cmd_response = self->bits;
@@ -135,31 +135,31 @@ static void IRAM_ATTR ps2_interrupt_handler(void *self_in) {
     }
 }
 
-static void enable_interrupt(ps2io_ps2_obj_t* self) {
+static void enable_interrupt(ps2io_ps2_obj_t *self) {
     // turn on falling edge interrupt
     gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
     gpio_set_intr_type(self->clk_pin, GPIO_INTR_NEGEDGE);
-    gpio_isr_handler_add(self->clk_pin, ps2_interrupt_handler, (void*)self);
+    gpio_isr_handler_add(self->clk_pin, ps2_interrupt_handler, (void *)self);
 }
 
-static void disable_interrupt(ps2io_ps2_obj_t* self) {
+static void disable_interrupt(ps2io_ps2_obj_t *self) {
     // turn off fallling edge interrupt
     gpio_isr_handler_remove(self->clk_pin);
 }
 
-static void resume_interrupt(ps2io_ps2_obj_t* self) {
+static void resume_interrupt(ps2io_ps2_obj_t *self) {
     self->state = STATE_IDLE;
-    gpio_isr_handler_add(self->clk_pin, ps2_interrupt_handler, (void*)self);
+    gpio_isr_handler_add(self->clk_pin, ps2_interrupt_handler, (void *)self);
 }
 
 /* gpio handling */
 
-static void clk_hi(ps2io_ps2_obj_t* self) {
+static void clk_hi(ps2io_ps2_obj_t *self) {
     // external pull-up
     gpio_set_direction(self->clk_pin, GPIO_MODE_INPUT);
 }
 
-static bool wait_clk_lo(ps2io_ps2_obj_t* self, uint32_t us) {
+static bool wait_clk_lo(ps2io_ps2_obj_t *self, uint32_t us) {
     clk_hi(self);
     delay_us(1);
     while (gpio_get_level(self->clk_pin) && us) {
@@ -169,7 +169,7 @@ static bool wait_clk_lo(ps2io_ps2_obj_t* self, uint32_t us) {
     return us;
 }
 
-static bool wait_clk_hi(ps2io_ps2_obj_t* self, uint32_t us) {
+static bool wait_clk_hi(ps2io_ps2_obj_t *self, uint32_t us) {
     clk_hi(self);
     delay_us(1);
     while (!gpio_get_level(self->clk_pin) && us) {
@@ -179,17 +179,17 @@ static bool wait_clk_hi(ps2io_ps2_obj_t* self, uint32_t us) {
     return us;
 }
 
-static void clk_lo(ps2io_ps2_obj_t* self) {
+static void clk_lo(ps2io_ps2_obj_t *self) {
     gpio_set_direction(self->clk_pin, GPIO_MODE_OUTPUT);
     gpio_set_level(self->clk_pin, 0);
 }
 
-static void data_hi(ps2io_ps2_obj_t* self) {
+static void data_hi(ps2io_ps2_obj_t *self) {
     // external pull-up
     gpio_set_direction(self->data_pin, GPIO_MODE_INPUT);
 }
 
-static bool wait_data_lo(ps2io_ps2_obj_t* self, uint32_t us) {
+static bool wait_data_lo(ps2io_ps2_obj_t *self, uint32_t us) {
     data_hi(self);
     delay_us(1);
     while (gpio_get_level(self->data_pin) && us) {
@@ -199,7 +199,7 @@ static bool wait_data_lo(ps2io_ps2_obj_t* self, uint32_t us) {
     return us;
 }
 
-static bool wait_data_hi(ps2io_ps2_obj_t* self, uint32_t us) {
+static bool wait_data_hi(ps2io_ps2_obj_t *self, uint32_t us) {
     data_hi(self);
     delay_us(1);
     while (!gpio_get_level(self->data_pin) && us) {
@@ -209,25 +209,25 @@ static bool wait_data_hi(ps2io_ps2_obj_t* self, uint32_t us) {
     return us;
 }
 
-static void data_lo(ps2io_ps2_obj_t* self) {
+static void data_lo(ps2io_ps2_obj_t *self) {
     gpio_set_direction(self->data_pin, GPIO_MODE_OUTPUT);
     gpio_set_level(self->data_pin, 0);
 }
 
-static void idle(ps2io_ps2_obj_t* self) {
+static void idle(ps2io_ps2_obj_t *self) {
     clk_hi(self);
     data_hi(self);
 }
 
-static void inhibit(ps2io_ps2_obj_t* self) {
+static void inhibit(ps2io_ps2_obj_t *self) {
     clk_lo(self);
     data_hi(self);
 }
 
 /* ps2io module functions */
 
-void common_hal_ps2io_ps2_construct(ps2io_ps2_obj_t* self,
-        const mcu_pin_obj_t* data_pin, const mcu_pin_obj_t* clk_pin) {
+void common_hal_ps2io_ps2_construct(ps2io_ps2_obj_t *self,
+    const mcu_pin_obj_t *data_pin, const mcu_pin_obj_t *clk_pin) {
     self->clk_pin = (gpio_num_t)clk_pin->number;
     self->data_pin = (gpio_num_t)data_pin->number;
     self->state = STATE_IDLE;
@@ -243,11 +243,11 @@ void common_hal_ps2io_ps2_construct(ps2io_ps2_obj_t* self,
     claim_pin(data_pin);
 }
 
-bool common_hal_ps2io_ps2_deinited(ps2io_ps2_obj_t* self) {
+bool common_hal_ps2io_ps2_deinited(ps2io_ps2_obj_t *self) {
     return self->clk_pin == GPIO_NUM_MAX;
 }
 
-void common_hal_ps2io_ps2_deinit(ps2io_ps2_obj_t* self) {
+void common_hal_ps2io_ps2_deinit(ps2io_ps2_obj_t *self) {
     if (common_hal_ps2io_ps2_deinited(self)) {
         return;
     }
@@ -258,11 +258,11 @@ void common_hal_ps2io_ps2_deinit(ps2io_ps2_obj_t* self) {
     self->data_pin = GPIO_NUM_MAX;
 }
 
-uint16_t common_hal_ps2io_ps2_get_len(ps2io_ps2_obj_t* self) {
+uint16_t common_hal_ps2io_ps2_get_len(ps2io_ps2_obj_t *self) {
     return self->bufcount;
 }
 
-int16_t common_hal_ps2io_ps2_popleft(ps2io_ps2_obj_t* self) {
+int16_t common_hal_ps2io_ps2_popleft(ps2io_ps2_obj_t *self) {
     common_hal_mcu_disable_interrupts();
     if (self->bufcount <= 0) {
         common_hal_mcu_enable_interrupts();
@@ -275,7 +275,7 @@ int16_t common_hal_ps2io_ps2_popleft(ps2io_ps2_obj_t* self) {
     return b;
 }
 
-uint16_t common_hal_ps2io_ps2_clear_errors(ps2io_ps2_obj_t* self) {
+uint16_t common_hal_ps2io_ps2_clear_errors(ps2io_ps2_obj_t *self) {
     common_hal_mcu_disable_interrupts();
     uint16_t errors = self->last_errors;
     self->last_errors = 0;
@@ -286,7 +286,7 @@ uint16_t common_hal_ps2io_ps2_clear_errors(ps2io_ps2_obj_t* self) {
 // Based upon TMK implementation of PS/2 protocol
 // https://github.com/tmk/tmk_keyboard/blob/master/tmk_core/protocol/ps2_interrupt.c
 
-int16_t common_hal_ps2io_ps2_sendcmd(ps2io_ps2_obj_t* self, uint8_t b) {
+int16_t common_hal_ps2io_ps2_sendcmd(ps2io_ps2_obj_t *self, uint8_t b) {
     disable_interrupt(self);
 
     /* terminate a transmission if we have */
diff --git a/ports/esp32s2/common-hal/pulseio/PulseIn.c b/ports/esp32s2/common-hal/pulseio/PulseIn.c
index 9feeea147..a9533179b 100644
--- a/ports/esp32s2/common-hal/pulseio/PulseIn.c
+++ b/ports/esp32s2/common-hal/pulseio/PulseIn.c
@@ -29,21 +29,21 @@
 #include "py/runtime.h"
 
 STATIC uint8_t refcount = 0;
-STATIC pulseio_pulsein_obj_t * handles[RMT_CHANNEL_MAX];
+STATIC pulseio_pulsein_obj_t *handles[RMT_CHANNEL_MAX];
 
 // Requires rmt.c void esp32s2_peripherals_reset_all(void) to reset
 
-STATIC void update_internal_buffer(pulseio_pulsein_obj_t* self) {
+STATIC void update_internal_buffer(pulseio_pulsein_obj_t *self) {
     uint32_t length = 0;
-    rmt_item32_t *items = (rmt_item32_t *) xRingbufferReceive(self->buf_handle, &length, 0);
+    rmt_item32_t *items = (rmt_item32_t *)xRingbufferReceive(self->buf_handle, &length, 0);
     if (items) {
         length /= 4;
-        for (size_t i=0; i < length; i++) {
+        for (size_t i = 0; i < length; i++) {
             uint16_t pos = (self->start + self->len) % self->maxlen;
             self->buffer[pos] = items[i].duration0 * 3;
             // Check if second item exists before incrementing
             if (items[i].duration1) {
-                self->buffer[pos+1] = items[i].duration1 * 3;
+                self->buffer[pos + 1] = items[i].duration1 * 3;
                 if (self->len < (self->maxlen - 1)) {
                     self->len += 2;
                 } else {
@@ -57,7 +57,7 @@ STATIC void update_internal_buffer(pulseio_pulsein_obj_t* self) {
                 }
             }
         }
-        vRingbufferReturnItem(self->buf_handle, (void *) items);
+        vRingbufferReturnItem(self->buf_handle, (void *)items);
     }
 }
 
@@ -83,9 +83,9 @@ void pulsein_reset(void) {
     refcount = 0;
 }
 
-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);
+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);
     if (self->buffer == NULL) {
         mp_raise_msg_varg(&mp_type_MemoryError, translate("Failed to allocate RX buffer of %d bytes"), maxlen * sizeof(uint16_t));
     }
@@ -115,7 +115,7 @@ void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self, const mcu
     config.rx_config.idle_threshold = 30000; // 30*3=90ms idle required to register a sequence
     config.clk_div = 240; // All measurements are divided by 3 to accomodate 65ms pulses
     rmt_config(&config);
-    rmt_driver_install(channel, 1000, 0); //TODO: pick a more specific buffer size?
+    rmt_driver_install(channel, 1000, 0); // TODO: pick a more specific buffer size?
 
     // Store this object and the buffer handle for background updates
     self->channel = channel;
@@ -130,11 +130,11 @@ void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self, const mcu
     }
 }
 
-bool common_hal_pulseio_pulsein_deinited(pulseio_pulsein_obj_t* self) {
+bool common_hal_pulseio_pulsein_deinited(pulseio_pulsein_obj_t *self) {
     return handles[self->channel] ? false : true;
 }
 
-void common_hal_pulseio_pulsein_deinit(pulseio_pulsein_obj_t* self) {
+void common_hal_pulseio_pulsein_deinit(pulseio_pulsein_obj_t *self) {
     handles[self->channel] = NULL;
     esp32s2_peripherals_free_rmt(self->channel);
     reset_pin_number(self->pin->number);
@@ -144,14 +144,14 @@ void common_hal_pulseio_pulsein_deinit(pulseio_pulsein_obj_t* self) {
     }
 }
 
-void common_hal_pulseio_pulsein_pause(pulseio_pulsein_obj_t* self) {
+void common_hal_pulseio_pulsein_pause(pulseio_pulsein_obj_t *self) {
     self->paused = true;
     rmt_rx_stop(self->channel);
 }
 
-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) {
     // Make sure we're paused.
-    if ( !self->paused ) {
+    if (!self->paused) {
         common_hal_pulseio_pulsein_pause(self);
     }
 
@@ -167,13 +167,13 @@ void common_hal_pulseio_pulsein_resume(pulseio_pulsein_obj_t* self, uint16_t tri
     rmt_rx_start(self->channel, false);
 }
 
-void common_hal_pulseio_pulsein_clear(pulseio_pulsein_obj_t* self) {
+void common_hal_pulseio_pulsein_clear(pulseio_pulsein_obj_t *self) {
     // Buffer only updates in BG tasks or fetches, so no extra protection is needed
     self->start = 0;
     self->len = 0;
 }
 
-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) {
     update_internal_buffer(self);
     if (index < 0) {
         index += self->len;
@@ -185,7 +185,7 @@ uint16_t common_hal_pulseio_pulsein_get_item(pulseio_pulsein_obj_t* self, int16_
     return value;
 }
 
-uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t* self) {
+uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t *self) {
     update_internal_buffer(self);
 
     if (self->len == 0) {
@@ -199,14 +199,14 @@ uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t* self) {
     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;
 }
 
-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 self->paused;
 }
 
-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;
 }
diff --git a/ports/esp32s2/common-hal/pulseio/PulseIn.h b/ports/esp32s2/common-hal/pulseio/PulseIn.h
index 289605ed0..3afd8db25 100644
--- a/ports/esp32s2/common-hal/pulseio/PulseIn.h
+++ b/ports/esp32s2/common-hal/pulseio/PulseIn.h
@@ -36,14 +36,14 @@
 typedef struct {
     mp_obj_base_t base;
 
-    const mcu_pin_obj_t* pin;
+    const mcu_pin_obj_t *pin;
     rmt_channel_t channel;
     bool idle_state;
     bool paused;
 
     RingbufHandle_t buf_handle;
 
-    uint16_t* buffer;
+    uint16_t *buffer;
     uint16_t maxlen;
 
     volatile uint16_t start;
diff --git a/ports/esp32s2/common-hal/pulseio/PulseOut.c b/ports/esp32s2/common-hal/pulseio/PulseOut.c
index e45492a89..d3490d181 100644
--- a/ports/esp32s2/common-hal/pulseio/PulseOut.c
+++ b/ports/esp32s2/common-hal/pulseio/PulseOut.c
@@ -31,11 +31,11 @@
 
 // Requires rmt.c void esp32s2_peripherals_reset_all(void) to reset
 
-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) {
+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) {
     if (carrier || !pin || !frequency) {
         mp_raise_NotImplementedError(translate("Port does not accept PWM carrier. Pass a pin, frequency and duty cycle instead"));
     }
@@ -48,7 +48,7 @@ void common_hal_pulseio_pulseout_construct(pulseio_pulseout_obj_t* self,
     // Configure Channel
     rmt_config_t config = RMT_DEFAULT_CONFIG_TX(pin->number, channel);
     config.tx_config.carrier_en = true;
-    config.tx_config.carrier_duty_percent = (duty_cycle * 100) / (1<<16);
+    config.tx_config.carrier_duty_percent = (duty_cycle * 100) / (1 << 16);
     config.tx_config.carrier_freq_hz = frequency;
     config.clk_div = 80;
 
@@ -58,17 +58,17 @@ void common_hal_pulseio_pulseout_construct(pulseio_pulseout_obj_t* self,
     self->channel = channel;
 }
 
-bool common_hal_pulseio_pulseout_deinited(pulseio_pulseout_obj_t* self) {
-    return (self->channel == RMT_CHANNEL_MAX);
+bool common_hal_pulseio_pulseout_deinited(pulseio_pulseout_obj_t *self) {
+    return self->channel == RMT_CHANNEL_MAX;
 }
 
-void common_hal_pulseio_pulseout_deinit(pulseio_pulseout_obj_t* self) {
+void common_hal_pulseio_pulseout_deinit(pulseio_pulseout_obj_t *self) {
     esp32s2_peripherals_free_rmt(self->channel);
     self->channel = RMT_CHANNEL_MAX;
 
 }
 
-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) {
     rmt_item32_t items[length];
 
     // Circuitpython allows 16 bit pulse values, while ESP32 only allows 15 bits
diff --git a/ports/esp32s2/common-hal/pwmio/PWMOut.c b/ports/esp32s2/common-hal/pwmio/PWMOut.c
index e1fdd4760..81af22606 100644
--- a/ports/esp32s2/common-hal/pwmio/PWMOut.c
+++ b/ports/esp32s2/common-hal/pwmio/PWMOut.c
@@ -39,7 +39,7 @@ STATIC bool never_reset_tim[LEDC_TIMER_MAX];
 STATIC bool never_reset_chan[LEDC_CHANNEL_MAX];
 
 void pwmout_reset(void) {
-    for (size_t i = 0; i < LEDC_CHANNEL_MAX; i++ ) {
+    for (size_t i = 0; i < LEDC_CHANNEL_MAX; i++) {
         if (reserved_channels[i] != INDEX_EMPTY && not_first_reset) {
             ledc_stop(LEDC_LOW_SPEED_MODE, i, 0);
         }
@@ -47,7 +47,7 @@ void pwmout_reset(void) {
             reserved_channels[i] = INDEX_EMPTY;
         }
     }
-    for (size_t i = 0; i < LEDC_TIMER_MAX; i++ ) {
+    for (size_t i = 0; i < LEDC_TIMER_MAX; i++) {
         if (reserved_timer_freq[i]) {
             ledc_timer_rst(LEDC_LOW_SPEED_MODE, i);
         }
@@ -58,16 +58,16 @@ void pwmout_reset(void) {
     not_first_reset = true;
 }
 
-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) {
     // Calculate duty cycle
     uint32_t duty_bits = 0;
-    uint32_t interval = LEDC_APB_CLK_HZ/frequency;
+    uint32_t interval = LEDC_APB_CLK_HZ / frequency;
     for (size_t i = 0; i < 32; i++) {
-        if(!(interval >> i)) {
+        if (!(interval >> i)) {
             duty_bits = i - 1;
             break;
         }
@@ -83,7 +83,7 @@ pwmout_result_t common_hal_pwmio_pwmout_construct(pwmio_pwmout_obj_t* self,
     size_t channel_index = INDEX_EMPTY;
     for (size_t i = 0; i < LEDC_TIMER_MAX; i++) {
         if ((reserved_timer_freq[i] == frequency) && !variable_frequency) {
-            //prioritize matched frequencies so we don't needlessly take slots
+            // prioritize matched frequencies so we don't needlessly take slots
             timer_index = i;
             break;
         } else if (reserved_timer_freq[i] == 0) {
@@ -155,11 +155,11 @@ void common_hal_pwmio_pwmout_reset_ok(pwmio_pwmout_obj_t *self) {
     never_reset_chan[self->chan_handle.channel] = false;
 }
 
-bool common_hal_pwmio_pwmout_deinited(pwmio_pwmout_obj_t* self) {
+bool common_hal_pwmio_pwmout_deinited(pwmio_pwmout_obj_t *self) {
     return self->deinited == true;
 }
 
-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;
     }
@@ -169,7 +169,7 @@ void common_hal_pwmio_pwmout_deinit(pwmio_pwmout_obj_t* self) {
     }
     // Search if any other channel is using the timer
     bool taken = false;
-    for (size_t i =0; i < LEDC_CHANNEL_MAX; i++) {
+    for (size_t i = 0; i < LEDC_CHANNEL_MAX; i++) {
         if (reserved_channels[i] == self->tim_handle.timer_num) {
             taken = true;
         }
@@ -186,23 +186,23 @@ void common_hal_pwmio_pwmout_deinit(pwmio_pwmout_obj_t* self) {
     self->deinited = true;
 }
 
-void common_hal_pwmio_pwmout_set_duty_cycle(pwmio_pwmout_obj_t* self, uint16_t duty) {
+void common_hal_pwmio_pwmout_set_duty_cycle(pwmio_pwmout_obj_t *self, uint16_t duty) {
     ledc_set_duty(LEDC_LOW_SPEED_MODE, self->chan_handle.channel, duty >> (16 - self->duty_resolution));
     ledc_update_duty(LEDC_LOW_SPEED_MODE, self->chan_handle.channel);
 }
 
-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 ledc_get_duty(LEDC_LOW_SPEED_MODE, self->chan_handle.channel) << (16 - self->duty_resolution);
 }
 
-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) {
     ledc_set_freq(LEDC_LOW_SPEED_MODE, self->tim_handle.timer_num, frequency);
 }
 
-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 ledc_get_freq(LEDC_LOW_SPEED_MODE, self->tim_handle.timer_num);
 }
 
-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/esp32s2/common-hal/pwmio/PWMOut.h b/ports/esp32s2/common-hal/pwmio/PWMOut.h
index 9055dee8e..9480b8885 100644
--- a/ports/esp32s2/common-hal/pwmio/PWMOut.h
+++ b/ports/esp32s2/common-hal/pwmio/PWMOut.h
@@ -36,8 +36,8 @@ typedef struct {
     ledc_channel_config_t chan_handle;
     uint16_t pin_number;
     uint8_t duty_resolution;
-    bool variable_frequency: 1;
-    bool deinited: 1;
+    bool variable_frequency : 1;
+    bool deinited : 1;
 } pwmio_pwmout_obj_t;
 
 void pwmout_reset(void);
diff --git a/ports/esp32s2/common-hal/rotaryio/IncrementalEncoder.c b/ports/esp32s2/common-hal/rotaryio/IncrementalEncoder.c
index 25529ac72..59fa54880 100644
--- a/ports/esp32s2/common-hal/rotaryio/IncrementalEncoder.c
+++ b/ports/esp32s2/common-hal/rotaryio/IncrementalEncoder.c
@@ -30,8 +30,8 @@
 #include "py/runtime.h"
 #include "supervisor/shared/translate.h"
 
-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) {
     claim_pin(pin_a);
     claim_pin(pin_b);
 
@@ -49,7 +49,7 @@ void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencode
         .hctrl_mode = PCNT_MODE_KEEP,    // Keep the primary counter mode if high
     };
 
-     // Initialize PCNT unit
+    // Initialize PCNT unit
     const int8_t unit = peripherals_pcnt_init(pcnt_config);
     if (unit == -1) {
         mp_raise_RuntimeError(translate("All PCNT units in use"));
@@ -60,11 +60,11 @@ void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencode
     self->unit = (pcnt_unit_t)unit;
 }
 
-bool common_hal_rotaryio_incrementalencoder_deinited(rotaryio_incrementalencoder_obj_t* self) {
+bool common_hal_rotaryio_incrementalencoder_deinited(rotaryio_incrementalencoder_obj_t *self) {
     return self->unit == PCNT_UNIT_MAX;
 }
 
-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;
     }
@@ -73,14 +73,14 @@ void common_hal_rotaryio_incrementalencoder_deinit(rotaryio_incrementalencoder_o
     peripherals_pcnt_deinit(&self->unit);
 }
 
-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) {
     int16_t count;
     pcnt_get_counter_value(self->unit, &count);
-    return (count/2)+self->position;
+    return (count / 2) + 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;
     pcnt_counter_clear(self->unit);
 }
diff --git a/ports/esp32s2/common-hal/socketpool/Socket.c b/ports/esp32s2/common-hal/socketpool/Socket.c
index 5f93807bb..385d71b54 100644
--- a/ports/esp32s2/common-hal/socketpool/Socket.c
+++ b/ports/esp32s2/common-hal/socketpool/Socket.c
@@ -37,7 +37,7 @@
 #include "components/lwip/lwip/src/include/lwip/sys.h"
 #include "components/lwip/lwip/src/include/lwip/netdb.h"
 
-STATIC socketpool_socket_obj_t * open_socket_handles[CONFIG_LWIP_MAX_SOCKETS];
+STATIC socketpool_socket_obj_t *open_socket_handles[CONFIG_LWIP_MAX_SOCKETS];
 
 void socket_reset(void) {
     for (size_t i = 0; i < MP_ARRAY_SIZE(open_socket_handles); i++) {
@@ -52,7 +52,7 @@ void socket_reset(void) {
     }
 }
 
-bool register_open_socket(socketpool_socket_obj_t* self) {
+bool register_open_socket(socketpool_socket_obj_t *self) {
     for (size_t i = 0; i < MP_ARRAY_SIZE(open_socket_handles); i++) {
         if (open_socket_handles[i] == NULL) {
             open_socket_handles[i] = self;
@@ -62,8 +62,8 @@ bool register_open_socket(socketpool_socket_obj_t* self) {
     return false;
 }
 
-socketpool_socket_obj_t* common_hal_socketpool_socket_accept(socketpool_socket_obj_t* self,
-                                        uint8_t* ip, uint32_t *port) {
+socketpool_socket_obj_t *common_hal_socketpool_socket_accept(socketpool_socket_obj_t *self,
+    uint8_t *ip, uint32_t *port) {
     struct sockaddr_in accept_addr;
     socklen_t socklen = sizeof(accept_addr);
     int newsoc = -1;
@@ -87,7 +87,7 @@ socketpool_socket_obj_t* common_hal_socketpool_socket_accept(socketpool_socket_o
 
     if (!timed_out) {
         // harmless on failure but avoiding memcpy is faster
-        memcpy((void *)ip, (void*)&accept_addr.sin_addr.s_addr, sizeof(accept_addr.sin_addr.s_addr));
+        memcpy((void *)ip, (void *)&accept_addr.sin_addr.s_addr, sizeof(accept_addr.sin_addr.s_addr));
         *port = accept_addr.sin_port;
     } else {
         mp_raise_OSError(ETIMEDOUT);
@@ -113,8 +113,8 @@ socketpool_socket_obj_t* common_hal_socketpool_socket_accept(socketpool_socket_o
     }
 }
 
-bool common_hal_socketpool_socket_bind(socketpool_socket_obj_t* self,
-                                        const char* host, size_t hostlen, uint32_t port) {
+bool common_hal_socketpool_socket_bind(socketpool_socket_obj_t *self,
+    const char *host, size_t hostlen, uint32_t port) {
     struct sockaddr_in bind_addr;
     bind_addr.sin_addr.s_addr = inet_addr(host);
     bind_addr.sin_family = AF_INET;
@@ -129,7 +129,7 @@ bool common_hal_socketpool_socket_bind(socketpool_socket_obj_t* self,
     return result;
 }
 
-void common_hal_socketpool_socket_close(socketpool_socket_obj_t* self) {
+void common_hal_socketpool_socket_close(socketpool_socket_obj_t *self) {
     self->connected = false;
     if (self->num >= 0) {
         lwip_shutdown(self->num, 0);
@@ -144,8 +144,8 @@ void common_hal_socketpool_socket_close(socketpool_socket_obj_t* self) {
     }
 }
 
-bool common_hal_socketpool_socket_connect(socketpool_socket_obj_t* self,
-                                            const char* host, size_t hostlen, uint32_t port) {
+bool common_hal_socketpool_socket_connect(socketpool_socket_obj_t *self,
+    const char *host, size_t hostlen, uint32_t port) {
     const struct addrinfo hints = {
         .ai_family = AF_INET,
         .ai_socktype = SOCK_STREAM,
@@ -190,20 +190,20 @@ bool common_hal_socketpool_socket_connect(socketpool_socket_obj_t* self,
     }
 }
 
-bool common_hal_socketpool_socket_get_closed(socketpool_socket_obj_t* self) {
+bool common_hal_socketpool_socket_get_closed(socketpool_socket_obj_t *self) {
     return self->num < 0;
 }
 
-bool common_hal_socketpool_socket_get_connected(socketpool_socket_obj_t* self) {
+bool common_hal_socketpool_socket_get_connected(socketpool_socket_obj_t *self) {
     return self->connected;
 }
 
-bool common_hal_socketpool_socket_listen(socketpool_socket_obj_t* self, int backlog) {
+bool common_hal_socketpool_socket_listen(socketpool_socket_obj_t *self, int backlog) {
     return lwip_listen(self->num, backlog) == 0;
 }
 
-mp_uint_t common_hal_socketpool_socket_recvfrom_into(socketpool_socket_obj_t* self,
-    uint8_t* buf, uint32_t len, uint8_t* ip, uint *port) {
+mp_uint_t common_hal_socketpool_socket_recvfrom_into(socketpool_socket_obj_t *self,
+    uint8_t *buf, uint32_t len, uint8_t *ip, uint *port) {
 
     struct sockaddr_in source_addr;
     socklen_t socklen = sizeof(source_addr);
@@ -213,9 +213,9 @@ mp_uint_t common_hal_socketpool_socket_recvfrom_into(socketpool_socket_obj_t* se
     int received = -1;
     bool timed_out = false;
     while (received == -1 &&
-            !timed_out &&
-            !mp_hal_is_interrupted()) {
-        if (self->timeout_ms != (uint)-1  && self->timeout_ms != 0) {
+           !timed_out &&
+           !mp_hal_is_interrupted()) {
+        if (self->timeout_ms != (uint)-1 && self->timeout_ms != 0) {
             timed_out = supervisor_ticks_ms64() - start_ticks >= self->timeout_ms;
         }
         RUN_BACKGROUND_TASKS;
@@ -228,7 +228,7 @@ mp_uint_t common_hal_socketpool_socket_recvfrom_into(socketpool_socket_obj_t* se
     }
 
     if (!timed_out) {
-        memcpy((void *)ip, (void*)&source_addr.sin_addr.s_addr, sizeof(source_addr.sin_addr.s_addr));
+        memcpy((void *)ip, (void *)&source_addr.sin_addr.s_addr, sizeof(source_addr.sin_addr.s_addr));
         *port = source_addr.sin_port;
     } else {
         mp_raise_OSError(ETIMEDOUT);
@@ -242,7 +242,7 @@ mp_uint_t common_hal_socketpool_socket_recvfrom_into(socketpool_socket_obj_t* se
     return received;
 }
 
-mp_uint_t common_hal_socketpool_socket_recv_into(socketpool_socket_obj_t* self, const uint8_t* buf, uint32_t len) {
+mp_uint_t common_hal_socketpool_socket_recv_into(socketpool_socket_obj_t *self, const uint8_t *buf, uint32_t len) {
     int received = 0;
     bool timed_out = false;
 
@@ -251,13 +251,13 @@ mp_uint_t common_hal_socketpool_socket_recv_into(socketpool_socket_obj_t* self,
         uint64_t start_ticks = supervisor_ticks_ms64();
         received = -1;
         while (received == -1 &&
-                !timed_out &&
-                !mp_hal_is_interrupted()) {
+               !timed_out &&
+               !mp_hal_is_interrupted()) {
             if (self->timeout_ms != (uint)-1 && self->timeout_ms != 0) {
                 timed_out = supervisor_ticks_ms64() - start_ticks >= self->timeout_ms;
             }
             RUN_BACKGROUND_TASKS;
-            received = lwip_recv(self->num, (void*) buf, len, 0);
+            received = lwip_recv(self->num, (void *)buf, len, 0);
 
             // In non-blocking mode, fail instead of looping
             if (received == -1 && self->timeout_ms == 0) {
@@ -274,7 +274,7 @@ mp_uint_t common_hal_socketpool_socket_recv_into(socketpool_socket_obj_t* self,
     return received;
 }
 
-mp_uint_t common_hal_socketpool_socket_send(socketpool_socket_obj_t* self, const uint8_t* buf, uint32_t len) {
+mp_uint_t common_hal_socketpool_socket_send(socketpool_socket_obj_t *self, const uint8_t *buf, uint32_t len) {
     int sent = -1;
     if (self->num != -1) {
         // LWIP Socket
@@ -290,8 +290,8 @@ mp_uint_t common_hal_socketpool_socket_send(socketpool_socket_obj_t* self, const
     return sent;
 }
 
-mp_uint_t common_hal_socketpool_socket_sendto(socketpool_socket_obj_t* self,
-    const char* host, size_t hostlen, uint32_t port, const uint8_t* buf, uint32_t len) {
+mp_uint_t common_hal_socketpool_socket_sendto(socketpool_socket_obj_t *self,
+    const char *host, size_t hostlen, uint32_t port, const uint8_t *buf, uint32_t len) {
 
     // Set parameters
     const struct addrinfo hints = {
@@ -323,6 +323,6 @@ mp_uint_t common_hal_socketpool_socket_sendto(socketpool_socket_obj_t* self,
     return bytes_sent;
 }
 
-void common_hal_socketpool_socket_settimeout(socketpool_socket_obj_t* self, uint32_t timeout_ms) {
+void common_hal_socketpool_socket_settimeout(socketpool_socket_obj_t *self, uint32_t timeout_ms) {
     self->timeout_ms = timeout_ms;
 }
diff --git a/ports/esp32s2/common-hal/socketpool/Socket.h b/ports/esp32s2/common-hal/socketpool/Socket.h
index b86f5597c..87f8b20db 100644
--- a/ports/esp32s2/common-hal/socketpool/Socket.h
+++ b/ports/esp32s2/common-hal/socketpool/Socket.h
@@ -41,11 +41,11 @@ typedef struct {
     int family;
     int ipproto;
     bool connected;
-    socketpool_socketpool_obj_t* pool;
+    socketpool_socketpool_obj_t *pool;
     mp_uint_t timeout_ms;
 } socketpool_socket_obj_t;
 
 void socket_reset(void);
-bool register_open_socket(socketpool_socket_obj_t* self);
+bool register_open_socket(socketpool_socket_obj_t *self);
 
 #endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL_SOCKET_H
diff --git a/ports/esp32s2/common-hal/socketpool/SocketPool.c b/ports/esp32s2/common-hal/socketpool/SocketPool.c
index fbd6dca7a..4cea95ec4 100644
--- a/ports/esp32s2/common-hal/socketpool/SocketPool.c
+++ b/ports/esp32s2/common-hal/socketpool/SocketPool.c
@@ -34,13 +34,13 @@
 
 #include "bindings/espidf/__init__.h"
 
-void common_hal_socketpool_socketpool_construct(socketpool_socketpool_obj_t* self, mp_obj_t radio) {
+void common_hal_socketpool_socketpool_construct(socketpool_socketpool_obj_t *self, mp_obj_t radio) {
     if (radio != MP_OBJ_FROM_PTR(&common_hal_wifi_radio_obj)) {
         mp_raise_ValueError(translate("SocketPool can only be used with wifi.radio"));
     }
 }
 
-socketpool_socket_obj_t* common_hal_socketpool_socket(socketpool_socketpool_obj_t* self,
+socketpool_socket_obj_t *common_hal_socketpool_socket(socketpool_socketpool_obj_t *self,
     socketpool_socketpool_addressfamily_t family, socketpool_socketpool_sock_t type) {
 
     int addr_family;
@@ -87,8 +87,8 @@ socketpool_socket_obj_t* common_hal_socketpool_socket(socketpool_socketpool_obj_
 }
 
 
-mp_obj_t common_hal_socketpool_socketpool_gethostbyname(socketpool_socketpool_obj_t* self,
-    const char* host) {
+mp_obj_t common_hal_socketpool_socketpool_gethostbyname(socketpool_socketpool_obj_t *self,
+    const char *host) {
 
     const struct addrinfo hints = {
         .ai_family = AF_INET,
diff --git a/ports/esp32s2/common-hal/ssl/SSLContext.c b/ports/esp32s2/common-hal/ssl/SSLContext.c
index afc3ecce2..a94c1df1e 100644
--- a/ports/esp32s2/common-hal/ssl/SSLContext.c
+++ b/ports/esp32s2/common-hal/ssl/SSLContext.c
@@ -31,12 +31,12 @@
 
 #include "py/runtime.h"
 
-void common_hal_ssl_sslcontext_construct(ssl_sslcontext_obj_t* self) {
+void common_hal_ssl_sslcontext_construct(ssl_sslcontext_obj_t *self) {
 
 }
 
-ssl_sslsocket_obj_t* common_hal_ssl_sslcontext_wrap_socket(ssl_sslcontext_obj_t* self,
-    socketpool_socket_obj_t* socket, bool server_side, const char* server_hostname) {
+ssl_sslsocket_obj_t *common_hal_ssl_sslcontext_wrap_socket(ssl_sslcontext_obj_t *self,
+    socketpool_socket_obj_t *socket, bool server_side, const char *server_hostname) {
 
     if (socket->type != SOCK_STREAM) {
         mp_raise_RuntimeError(translate("Invalid socket for TLS"));
@@ -47,7 +47,7 @@ ssl_sslsocket_obj_t* common_hal_ssl_sslcontext_wrap_socket(ssl_sslcontext_obj_t*
     sock->ssl_context = self;
     sock->sock = socket;
 
-    esp_tls_t* tls_handle = esp_tls_init();
+    esp_tls_t *tls_handle = esp_tls_init();
     if (tls_handle == NULL) {
         mp_raise_espidf_MemoryError();
     }
diff --git a/ports/esp32s2/common-hal/ssl/SSLSocket.c b/ports/esp32s2/common-hal/ssl/SSLSocket.c
index 10c29108c..724d2aac9 100644
--- a/ports/esp32s2/common-hal/ssl/SSLSocket.c
+++ b/ports/esp32s2/common-hal/ssl/SSLSocket.c
@@ -35,27 +35,27 @@
 #include "py/runtime.h"
 #include "supervisor/shared/tick.h"
 
-ssl_sslsocket_obj_t* common_hal_ssl_sslsocket_accept(ssl_sslsocket_obj_t* self,
-                                        uint8_t* ip, uint32_t *port) {
-    socketpool_socket_obj_t * sock = common_hal_socketpool_socket_accept(self->sock, ip, port);
-    ssl_sslsocket_obj_t * sslsock = common_hal_ssl_sslcontext_wrap_socket(self->ssl_context, sock, false, NULL);
+ssl_sslsocket_obj_t *common_hal_ssl_sslsocket_accept(ssl_sslsocket_obj_t *self,
+    uint8_t *ip, uint32_t *port) {
+    socketpool_socket_obj_t *sock = common_hal_socketpool_socket_accept(self->sock, ip, port);
+    ssl_sslsocket_obj_t *sslsock = common_hal_ssl_sslcontext_wrap_socket(self->ssl_context, sock, false, NULL);
     return sslsock;
 }
 
-bool common_hal_ssl_sslsocket_bind(ssl_sslsocket_obj_t* self,
-                                        const char* host, size_t hostlen, uint32_t port) {
+bool common_hal_ssl_sslsocket_bind(ssl_sslsocket_obj_t *self,
+    const char *host, size_t hostlen, uint32_t port) {
     return common_hal_socketpool_socket_bind(self->sock, host, hostlen, port);
 }
 
-void common_hal_ssl_sslsocket_close(ssl_sslsocket_obj_t* self) {
+void common_hal_ssl_sslsocket_close(ssl_sslsocket_obj_t *self) {
     common_hal_socketpool_socket_close(self->sock);
     esp_tls_conn_destroy(self->tls);
     self->tls = NULL;
 }
 
-bool common_hal_ssl_sslsocket_connect(ssl_sslsocket_obj_t* self,
-                                            const char* host, size_t hostlen, uint32_t port) {
-    esp_tls_cfg_t* tls_config = NULL;
+bool common_hal_ssl_sslsocket_connect(ssl_sslsocket_obj_t *self,
+    const char *host, size_t hostlen, uint32_t port) {
+    esp_tls_cfg_t *tls_config = NULL;
     tls_config = &self->ssl_context->ssl_config;
     int result = esp_tls_conn_new_sync(host, hostlen, port, tls_config, self->tls);
     self->sock->connected = result >= 0;
@@ -88,19 +88,19 @@ bool common_hal_ssl_sslsocket_connect(ssl_sslsocket_obj_t* self,
     return self->sock->connected;
 }
 
-bool common_hal_ssl_sslsocket_get_closed(ssl_sslsocket_obj_t* self) {
+bool common_hal_ssl_sslsocket_get_closed(ssl_sslsocket_obj_t *self) {
     return self->tls == NULL && self->sock->num < 0;
 }
 
-bool common_hal_ssl_sslsocket_get_connected(ssl_sslsocket_obj_t* self) {
+bool common_hal_ssl_sslsocket_get_connected(ssl_sslsocket_obj_t *self) {
     return self->sock->connected;
 }
 
-bool common_hal_ssl_sslsocket_listen(ssl_sslsocket_obj_t* self, int backlog) {
+bool common_hal_ssl_sslsocket_listen(ssl_sslsocket_obj_t *self, int backlog) {
     return common_hal_socketpool_socket_listen(self->sock, backlog);
 }
 
-mp_uint_t common_hal_ssl_sslsocket_recv_into(ssl_sslsocket_obj_t* self, const uint8_t* buf, uint32_t len) {
+mp_uint_t common_hal_ssl_sslsocket_recv_into(ssl_sslsocket_obj_t *self, const uint8_t *buf, uint32_t len) {
     int received = 0;
     bool timed_out = false;
     int status = 0;
@@ -129,7 +129,7 @@ mp_uint_t common_hal_ssl_sslsocket_recv_into(ssl_sslsocket_obj_t* self, const ui
             available = remaining;
         }
         if (available > 0) {
-            status = esp_tls_conn_read(self->tls, (void*) buf + received, available);
+            status = esp_tls_conn_read(self->tls, (void *)buf + received, available);
             if (status == 0) {
                 // Reading zero when something is available indicates a closed
                 // connection. (The available bytes could have been TLS internal.)
@@ -140,7 +140,7 @@ mp_uint_t common_hal_ssl_sslsocket_recv_into(ssl_sslsocket_obj_t* self, const ui
             }
         }
         // In non-blocking mode, fail instead of timing out
-        if (received==0 && self->sock->timeout_ms == 0) {
+        if (received == 0 && self->sock->timeout_ms == 0) {
             mp_raise_OSError(MP_EAGAIN);
         }
     }
@@ -151,7 +151,7 @@ mp_uint_t common_hal_ssl_sslsocket_recv_into(ssl_sslsocket_obj_t* self, const ui
     return received;
 }
 
-mp_uint_t common_hal_ssl_sslsocket_send(ssl_sslsocket_obj_t* self, const uint8_t* buf, uint32_t len) {
+mp_uint_t common_hal_ssl_sslsocket_send(ssl_sslsocket_obj_t *self, const uint8_t *buf, uint32_t len) {
     int sent = -1;
     sent = esp_tls_conn_write(self->tls, buf, len);
 
@@ -171,6 +171,6 @@ mp_uint_t common_hal_ssl_sslsocket_send(ssl_sslsocket_obj_t* self, const uint8_t
     return sent;
 }
 
-void common_hal_ssl_sslsocket_settimeout(ssl_sslsocket_obj_t* self, uint32_t timeout_ms) {
+void common_hal_ssl_sslsocket_settimeout(ssl_sslsocket_obj_t *self, uint32_t timeout_ms) {
     self->sock->timeout_ms = timeout_ms;
 }
diff --git a/ports/esp32s2/common-hal/ssl/SSLSocket.h b/ports/esp32s2/common-hal/ssl/SSLSocket.h
index e9e5bff06..b48578125 100644
--- a/ports/esp32s2/common-hal/ssl/SSLSocket.h
+++ b/ports/esp32s2/common-hal/ssl/SSLSocket.h
@@ -36,9 +36,9 @@
 
 typedef struct {
     mp_obj_base_t base;
-    socketpool_socket_obj_t * sock;
-    esp_tls_t* tls;
-    ssl_sslcontext_obj_t* ssl_context;
+    socketpool_socket_obj_t *sock;
+    esp_tls_t *tls;
+    ssl_sslcontext_obj_t *ssl_context;
 } ssl_sslsocket_obj_t;
 
 #endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SSL_SSLSOCKET_H
diff --git a/ports/esp32s2/common-hal/ssl/__init__.c b/ports/esp32s2/common-hal/ssl/__init__.c
index 8d386d0c3..a0886adda 100644
--- a/ports/esp32s2/common-hal/ssl/__init__.c
+++ b/ports/esp32s2/common-hal/ssl/__init__.c
@@ -28,7 +28,7 @@
 
 #include "components/mbedtls/esp_crt_bundle/include/esp_crt_bundle.h"
 
-void common_hal_ssl_create_default_context(ssl_sslcontext_obj_t* self) {
+void common_hal_ssl_create_default_context(ssl_sslcontext_obj_t *self) {
     memset(&self->ssl_config, 0, sizeof(esp_tls_cfg_t));
     self->ssl_config.crt_bundle_attach = esp_crt_bundle_attach;
 }
diff --git a/ports/esp32s2/common-hal/supervisor/Runtime.c b/ports/esp32s2/common-hal/supervisor/Runtime.c
index 974f26cec..f82765178 100644
--- a/ports/esp32s2/common-hal/supervisor/Runtime.c
+++ b/ports/esp32s2/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/esp32s2/common-hal/touchio/TouchIn.c b/ports/esp32s2/common-hal/touchio/TouchIn.c
index 401b84d5c..53bc335d3 100644
--- a/ports/esp32s2/common-hal/touchio/TouchIn.c
+++ b/ports/esp32s2/common-hal/touchio/TouchIn.c
@@ -38,8 +38,8 @@ static uint16_t get_raw_reading(touchio_touchin_obj_t *self) {
     return touch_value;
 }
 
-void common_hal_touchio_touchin_construct(touchio_touchin_obj_t* self,
-        const mcu_pin_obj_t *pin) {
+void common_hal_touchio_touchin_construct(touchio_touchin_obj_t *self,
+    const mcu_pin_obj_t *pin) {
     if (pin->touch_channel == TOUCH_PAD_MAX) {
         mp_raise_ValueError(translate("Invalid pin"));
     }
@@ -59,11 +59,11 @@ void common_hal_touchio_touchin_construct(touchio_touchin_obj_t* self,
     self->threshold = get_raw_reading(self) + 100;
 }
 
-bool common_hal_touchio_touchin_deinited(touchio_touchin_obj_t* self) {
+bool common_hal_touchio_touchin_deinited(touchio_touchin_obj_t *self) {
     return self->pin == NULL;
 }
 
-void common_hal_touchio_touchin_deinit(touchio_touchin_obj_t* self) {
+void common_hal_touchio_touchin_deinit(touchio_touchin_obj_t *self) {
     if (common_hal_touchio_touchin_deinited(self)) {
         return;
     }
diff --git a/ports/esp32s2/common-hal/touchio/TouchIn.h b/ports/esp32s2/common-hal/touchio/TouchIn.h
index 2f7c66d2b..d4ce2d8a5 100644
--- a/ports/esp32s2/common-hal/touchio/TouchIn.h
+++ b/ports/esp32s2/common-hal/touchio/TouchIn.h
@@ -32,7 +32,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    const mcu_pin_obj_t * pin;
+    const mcu_pin_obj_t *pin;
     uint16_t threshold;
 } touchio_touchin_obj_t;
 
diff --git a/ports/esp32s2/common-hal/watchdog/WatchDogTimer.c b/ports/esp32s2/common-hal/watchdog/WatchDogTimer.c
index 79a84ef59..f17a037ff 100644
--- a/ports/esp32s2/common-hal/watchdog/WatchDogTimer.c
+++ b/ports/esp32s2/common-hal/watchdog/WatchDogTimer.c
@@ -35,11 +35,11 @@
 void esp_task_wdt_isr_user_handler(void) {
     mp_obj_exception_clear_traceback(MP_OBJ_FROM_PTR(&mp_watchdog_timeout_exception));
     MP_STATE_VM(mp_pending_exception) = &mp_watchdog_timeout_exception;
-#if MICROPY_ENABLE_SCHEDULER
+    #if MICROPY_ENABLE_SCHEDULER
     if (MP_STATE_VM(sched_state) == MP_SCHED_IDLE) {
         MP_STATE_VM(sched_state) = MP_SCHED_PENDING;
     }
-#endif
+    #endif
 }
 
 void common_hal_watchdog_feed(watchdog_watchdogtimer_obj_t *self) {
@@ -55,7 +55,7 @@ void common_hal_watchdog_deinit(watchdog_watchdogtimer_obj_t *self) {
 }
 
 void watchdog_reset(void) {
-   common_hal_watchdog_deinit(&common_hal_mcu_watchdogtimer_obj);
+    common_hal_watchdog_deinit(&common_hal_mcu_watchdogtimer_obj);
 }
 
 static void wdt_config(watchdog_watchdogtimer_obj_t *self) {
diff --git a/ports/esp32s2/common-hal/watchdog/WatchDogTimer.h b/ports/esp32s2/common-hal/watchdog/WatchDogTimer.h
index 04d9aeee6..c26d14013 100644
--- a/ports/esp32s2/common-hal/watchdog/WatchDogTimer.h
+++ b/ports/esp32s2/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
diff --git a/ports/esp32s2/common-hal/wifi/Network.c b/ports/esp32s2/common-hal/wifi/Network.c
index b6eb6bb43..49507df0d 100644
--- a/ports/esp32s2/common-hal/wifi/Network.c
+++ b/ports/esp32s2/common-hal/wifi/Network.c
@@ -31,8 +31,8 @@
 #include "py/obj.h"
 
 mp_obj_t common_hal_wifi_network_get_ssid(wifi_network_obj_t *self) {
-    const char* cstr = (const char*) self->record.ssid;
-	return mp_obj_new_str(cstr, strlen(cstr));
+    const char *cstr = (const char *)self->record.ssid;
+    return mp_obj_new_str(cstr, strlen(cstr));
 }
 
 #define MAC_ADDRESS_LENGTH 6
@@ -50,13 +50,13 @@ mp_obj_t common_hal_wifi_network_get_channel(wifi_network_obj_t *self) {
 }
 
 mp_obj_t common_hal_wifi_network_get_country(wifi_network_obj_t *self) {
-    const char* cstr = (const char*) self->record.country.cc;
-        // 2 instead of strlen(cstr) as this gives us only the country-code
-        return mp_obj_new_str(cstr, 2);
+    const char *cstr = (const char *)self->record.country.cc;
+    // 2 instead of strlen(cstr) as this gives us only the country-code
+    return mp_obj_new_str(cstr, 2);
 }
 
 mp_obj_t common_hal_wifi_network_get_authmode(wifi_network_obj_t *self) {
-    const char* authmode = "";
+    const char *authmode = "";
     switch (self->record.authmode) {
         case WIFI_AUTH_OPEN:
             authmode = "OPEN";
@@ -86,5 +86,5 @@ mp_obj_t common_hal_wifi_network_get_authmode(wifi_network_obj_t *self) {
             authmode = "UNKNOWN";
             break;
     }
-        return mp_obj_new_str(authmode, strlen(authmode));
+    return mp_obj_new_str(authmode, strlen(authmode));
 }
diff --git a/ports/esp32s2/common-hal/wifi/Radio.c b/ports/esp32s2/common-hal/wifi/Radio.c
index 574bab0a1..9c8ccaf7f 100644
--- a/ports/esp32s2/common-hal/wifi/Radio.c
+++ b/ports/esp32s2/common-hal/wifi/Radio.c
@@ -71,7 +71,7 @@ void common_hal_wifi_radio_set_enabled(wifi_radio_obj_t *self, bool enabled) {
         return;
     }
     if (!self->started && enabled) {
-	// esp_wifi_start() would default to soft-AP, thus setting it to station
+        // esp_wifi_start() would default to soft-AP, thus setting it to station
         start_station(self);
         ESP_ERROR_CHECK(esp_wifi_start());
         self->started = true;
@@ -127,7 +127,7 @@ void common_hal_wifi_radio_set_hostname(wifi_radio_obj_t *self, const char *host
     esp_netif_set_hostname(self->netif, hostname);
 }
 
-wifi_radio_error_t common_hal_wifi_radio_connect(wifi_radio_obj_t *self, uint8_t* ssid, size_t ssid_len, uint8_t* password, size_t password_len, uint8_t channel, mp_float_t timeout, uint8_t* bssid, size_t bssid_len) {
+wifi_radio_error_t common_hal_wifi_radio_connect(wifi_radio_obj_t *self, uint8_t *ssid, size_t ssid_len, uint8_t *password, size_t password_len, uint8_t channel, mp_float_t timeout, uint8_t *bssid, size_t bssid_len) {
     if (!common_hal_wifi_radio_get_enabled(self)) {
         mp_raise_RuntimeError(translate("wifi is not enabled"));
     }
@@ -149,7 +149,7 @@ wifi_radio_error_t common_hal_wifi_radio_connect(wifi_radio_obj_t *self, uint8_t
     xEventGroupClearBits(self->event_group_handle, WIFI_DISCONNECTED_BIT);
     start_station(self);
 
-    wifi_config_t* config = &self->sta_config;
+    wifi_config_t *config = &self->sta_config;
     memcpy(&config->sta.ssid, ssid, ssid_len);
     config->sta.ssid[ssid_len] = 0;
     memcpy(&config->sta.password, password, password_len);
@@ -158,7 +158,7 @@ wifi_radio_error_t common_hal_wifi_radio_connect(wifi_radio_obj_t *self, uint8_t
     // From esp_wifi_types.h:
     //   Generally, station_config.bssid_set needs to be 0; and it needs
     //   to be 1 only when users need to check the MAC address of the AP
-    if (bssid_len > 0){
+    if (bssid_len > 0) {
         memcpy(&config->sta.bssid, bssid, bssid_len);
         config->sta.bssid[bssid_len] = 0;
         config->sta.bssid_set = true;
@@ -202,7 +202,7 @@ mp_obj_t common_hal_wifi_radio_get_ap_info(wifi_radio_obj_t *self) {
     }
 
     // Make sure the interface is in STA mode
-    if (!self->sta_mode){
+    if (!self->sta_mode) {
         return mp_const_none;
     }
 
@@ -212,7 +212,7 @@ mp_obj_t common_hal_wifi_radio_get_ap_info(wifi_radio_obj_t *self) {
     //    ESP_OK: succeed
     //    ESP_ERR_WIFI_CONN: The station interface don't initialized
     //    ESP_ERR_WIFI_NOT_CONNECT: The station is in disconnect status
-    if (esp_wifi_sta_get_ap_info(&self->ap_info.record) != ESP_OK){
+    if (esp_wifi_sta_get_ap_info(&self->ap_info.record) != ESP_OK) {
         return mp_const_none;
     } else {
         if (strlen(self->ap_info.record.country.cc) == 0) {
diff --git a/ports/esp32s2/common-hal/wifi/ScannedNetworks.c b/ports/esp32s2/common-hal/wifi/ScannedNetworks.c
index cc733308d..62ef62b7f 100644
--- a/ports/esp32s2/common-hal/wifi/ScannedNetworks.c
+++ b/ports/esp32s2/common-hal/wifi/ScannedNetworks.c
@@ -52,10 +52,10 @@ static void wifi_scannednetworks_done(wifi_scannednetworks_obj_t *self) {
 
 static bool wifi_scannednetworks_wait_for_scan(wifi_scannednetworks_obj_t *self) {
     EventBits_t bits = xEventGroupWaitBits(self->radio_event_group,
-            WIFI_SCAN_DONE_BIT,
-            pdTRUE,
-            pdTRUE,
-            0);
+        WIFI_SCAN_DONE_BIT,
+        pdTRUE,
+        pdTRUE,
+        0);
     while ((bits & WIFI_SCAN_DONE_BIT) == 0 && !mp_hal_is_interrupted()) {
         RUN_BACKGROUND_TASKS;
         bits = xEventGroupWaitBits(self->radio_event_group,
@@ -94,11 +94,11 @@ mp_obj_t common_hal_wifi_scannednetworks_next(wifi_scannednetworks_obj_t *self)
         }
         // If we need more space than we have, realloc.
         if (self->total_results > self->max_results) {
-            wifi_ap_record_t* results = m_renew_maybe(wifi_ap_record_t,
-                                                      self->results,
-                                                      self->max_results,
-                                                      self->total_results,
-                                                      true /* allow move */);
+            wifi_ap_record_t *results = m_renew_maybe(wifi_ap_record_t,
+                self->results,
+                self->max_results,
+                self->total_results,
+                true /* allow move */);
             if (results != NULL) {
                 self->results = results;
                 self->max_results = self->total_results;
@@ -157,7 +157,7 @@ void wifi_scannednetworks_scan_next_channel(wifi_scannednetworks_obj_t *self) {
     }
 }
 
-void wifi_scannednetworks_deinit(wifi_scannednetworks_obj_t* self) {
+void wifi_scannednetworks_deinit(wifi_scannednetworks_obj_t *self) {
     // if a scan is active, make sure and clean up the idf's buffer of results.
     if (self->scanning) {
         esp_wifi_scan_stop();
diff --git a/ports/esp32s2/common-hal/wifi/ScannedNetworks.h b/ports/esp32s2/common-hal/wifi/ScannedNetworks.h
index 36da387f2..9790c4ab3 100644
--- a/ports/esp32s2/common-hal/wifi/ScannedNetworks.h
+++ b/ports/esp32s2/common-hal/wifi/ScannedNetworks.h
@@ -43,7 +43,7 @@ typedef struct {
     EventGroupHandle_t radio_event_group;
 
     // Results from the last channel scan
-    wifi_ap_record_t* results;
+    wifi_ap_record_t *results;
     uint16_t current_result;
     uint16_t total_results;
     uint16_t max_results;
diff --git a/ports/esp32s2/common-hal/wifi/__init__.c b/ports/esp32s2/common-hal/wifi/__init__.c
index a3927b7c3..3ec4ebc24 100644
--- a/ports/esp32s2/common-hal/wifi/__init__.c
+++ b/ports/esp32s2/common-hal/wifi/__init__.c
@@ -39,11 +39,11 @@ wifi_radio_obj_t common_hal_wifi_radio_obj;
 
 #include "components/log/include/esp_log.h"
 
-static const char* TAG = "wifi";
+static const char *TAG = "wifi";
 
-static void event_handler(void* arg, esp_event_base_t event_base,
-                          int32_t event_id, void* event_data) {
-    wifi_radio_obj_t* radio = arg;
+static void event_handler(void *arg, esp_event_base_t event_base,
+    int32_t event_id, void *event_data) {
+    wifi_radio_obj_t *radio = arg;
     if (event_base == WIFI_EVENT) {
         switch (event_id) {
             case WIFI_EVENT_SCAN_DONE:
@@ -61,13 +61,13 @@ static void event_handler(void* arg, esp_event_base_t event_base,
                 break;
             case WIFI_EVENT_STA_DISCONNECTED: {
                 ESP_LOGW(TAG, "disconnected");
-                wifi_event_sta_disconnected_t* d = (wifi_event_sta_disconnected_t*) event_data;
+                wifi_event_sta_disconnected_t *d = (wifi_event_sta_disconnected_t *)event_data;
                 uint8_t reason = d->reason;
                 ESP_LOGW(TAG, "reason %d 0x%02x", reason, reason);
                 if (radio->retries_left > 0 &&
-                        reason != WIFI_REASON_AUTH_FAIL &&
-                        reason != WIFI_REASON_NO_AP_FOUND &&
-                        reason != WIFI_REASON_ASSOC_LEAVE) {
+                    reason != WIFI_REASON_AUTH_FAIL &&
+                    reason != WIFI_REASON_NO_AP_FOUND &&
+                    reason != WIFI_REASON_ASSOC_LEAVE) {
                     radio->retries_left--;
                     ESP_LOGI(TAG, "Retrying connect. %d retries remaining", radio->retries_left);
                     esp_wifi_connect();
@@ -107,7 +107,7 @@ void common_hal_wifi_init(void) {
     }
     wifi_ever_inited = true;
 
-    wifi_radio_obj_t* self = &common_hal_wifi_radio_obj;
+    wifi_radio_obj_t *self = &common_hal_wifi_radio_obj;
     self->netif = esp_netif_create_default_wifi_sta();
     self->started = false;
 
@@ -120,15 +120,15 @@ void common_hal_wifi_init(void) {
 
     self->event_group_handle = xEventGroupCreateStatic(&self->event_group);
     ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
-                                                        ESP_EVENT_ANY_ID,
-                                                        &event_handler,
-                                                        self,
-                                                        &self->handler_instance_all_wifi));
+        ESP_EVENT_ANY_ID,
+        &event_handler,
+        self,
+        &self->handler_instance_all_wifi));
     ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
-                                                        IP_EVENT_STA_GOT_IP,
-                                                        &event_handler,
-                                                        self,
-                                                        &self->handler_instance_got_ip));
+        IP_EVENT_STA_GOT_IP,
+        &event_handler,
+        self,
+        &self->handler_instance_got_ip));
 
     wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
     esp_err_t result = esp_wifi_init(&config);
@@ -144,26 +144,26 @@ void wifi_reset(void) {
     if (!wifi_inited) {
         return;
     }
-    wifi_radio_obj_t* radio = &common_hal_wifi_radio_obj;
+    wifi_radio_obj_t *radio = &common_hal_wifi_radio_obj;
     common_hal_wifi_radio_set_enabled(radio, false);
     ESP_ERROR_CHECK(esp_event_handler_instance_unregister(WIFI_EVENT,
-                                                          ESP_EVENT_ANY_ID,
-                                                          radio->handler_instance_all_wifi));
+        ESP_EVENT_ANY_ID,
+        radio->handler_instance_all_wifi));
     ESP_ERROR_CHECK(esp_event_handler_instance_unregister(IP_EVENT,
-                                                          IP_EVENT_STA_GOT_IP,
-                                                          radio->handler_instance_got_ip));
+        IP_EVENT_STA_GOT_IP,
+        radio->handler_instance_got_ip));
     ESP_ERROR_CHECK(esp_wifi_deinit());
     esp_netif_destroy(radio->netif);
     radio->netif = NULL;
 }
 
-void ipaddress_ipaddress_to_esp_idf(mp_obj_t ip_address, ip_addr_t* esp_ip_address) {
+void ipaddress_ipaddress_to_esp_idf(mp_obj_t ip_address, ip_addr_t *esp_ip_address) {
     if (!MP_OBJ_IS_TYPE(ip_address, &ipaddress_ipv4address_type)) {
         mp_raise_ValueError(translate("Only IPv4 addresses supported"));
     }
     mp_obj_t packed = common_hal_ipaddress_ipv4address_get_packed(ip_address);
     size_t len;
-    const char* bytes = mp_obj_str_get_data(packed, &len);
+    const char *bytes = mp_obj_str_get_data(packed, &len);
 
     IP_ADDR4(esp_ip_address, bytes[0], bytes[1], bytes[2], bytes[3]);
 }
diff --git a/ports/esp32s2/common-hal/wifi/__init__.h b/ports/esp32s2/common-hal/wifi/__init__.h
index d2bd06c57..1dbe50a04 100644
--- a/ports/esp32s2/common-hal/wifi/__init__.h
+++ b/ports/esp32s2/common-hal/wifi/__init__.h
@@ -33,6 +33,6 @@
 
 void wifi_reset(void);
 
-void ipaddress_ipaddress_to_esp_idf(mp_obj_t ip_address, ip_addr_t* esp_ip_address);
+void ipaddress_ipaddress_to_esp_idf(mp_obj_t ip_address, ip_addr_t *esp_ip_address);
 
 #endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI___INIT___H