run code formatting script

6 files changed, 78 insertions, 78 deletions

diff --git a/ports/nrf/supervisor/bluetooth.c b/ports/nrf/supervisor/bluetooth.c
index 8d89d6272..5ce737f6a 100644
--- a/ports/nrf/supervisor/bluetooth.c
+++ b/ports/nrf/supervisor/bluetooth.c
@@ -29,7 +29,7 @@
 
 // This happens in an interrupt so we need to be quick.
 bool supervisor_bluetooth_hook(ble_evt_t *ble_evt) {
-#if CIRCUITPY_BLE_FILE_SERVICE
+    #if CIRCUITPY_BLE_FILE_SERVICE
     // Catch writes to filename or contents. Length is read-only.
 
     bool done = false;
@@ -49,12 +49,12 @@ bool supervisor_bluetooth_hook(ble_evt_t *ble_evt) {
             // Event handle must match the handle for my characteristic.
             if (evt_write->handle == supervisor_ble_contents_characteristic.handle) {
                 // Handle events
-                //write_to_ringbuf(self, evt_write->data, evt_write->len);
+                // write_to_ringbuf(self, evt_write->data, evt_write->len);
                 // First packet includes a uint16_t le for length at the start.
-                uint16_t current_length = ((uint16_t*) current_command)[0];
-                memcpy(((uint8_t*) current_command) + current_offset, evt_write->data, evt_write->len);
+                uint16_t current_length = ((uint16_t *)current_command)[0];
+                memcpy(((uint8_t *)current_command) + current_offset, evt_write->data, evt_write->len);
                 current_offset += evt_write->len;
-                current_length = ((uint16_t*) current_command)[0];
+                current_length = ((uint16_t *)current_command)[0];
                 if (current_offset == current_length) {
                     run_ble_background = true;
                     done = true;
@@ -75,7 +75,7 @@ bool supervisor_bluetooth_hook(ble_evt_t *ble_evt) {
             break;
     }
     return done;
-#else
+    #else
     return false;
-#endif
+    #endif
 }
diff --git a/ports/nrf/supervisor/internal_flash.c b/ports/nrf/supervisor/internal_flash.c
index 93de0b2c4..cce48a4c3 100644
--- a/ports/nrf/supervisor/internal_flash.c
+++ b/ports/nrf/supervisor/internal_flash.c
@@ -45,7 +45,7 @@
 
 #define NO_CACHE        0xffffffff
 
-uint8_t  _flash_cache[FLASH_PAGE_SIZE] __attribute__((aligned(4)));
+uint8_t _flash_cache[FLASH_PAGE_SIZE] __attribute__((aligned(4)));
 uint32_t _flash_page_addr = NO_CACHE;
 
 
@@ -64,11 +64,13 @@ uint32_t supervisor_flash_get_block_size(void) {
 }
 
 uint32_t supervisor_flash_get_block_count(void) {
-    return CIRCUITPY_INTERNAL_FLASH_FILESYSTEM_SIZE / FILESYSTEM_BLOCK_SIZE ;
+    return CIRCUITPY_INTERNAL_FLASH_FILESYSTEM_SIZE / FILESYSTEM_BLOCK_SIZE;
 }
 
 void port_internal_flash_flush(void) {
-    if (_flash_page_addr == NO_CACHE) return;
+    if (_flash_page_addr == NO_CACHE) {
+        return;
+    }
 
     // Skip if data is the same
     if (memcmp(_flash_cache, (void *)_flash_page_addr, FLASH_PAGE_SIZE) != 0) {
@@ -83,13 +85,13 @@ mp_uint_t supervisor_flash_read_blocks(uint8_t *dest, uint32_t block, uint32_t n
     supervisor_flash_flush();
 
     uint32_t src = lba2addr(block);
-    memcpy(dest, (uint8_t*) src, FILESYSTEM_BLOCK_SIZE*num_blocks);
+    memcpy(dest, (uint8_t *)src, FILESYSTEM_BLOCK_SIZE * num_blocks);
     return 0; // success
 }
 
 mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t lba, uint32_t num_blocks) {
     while (num_blocks) {
-        uint32_t const addr      = lba2addr(lba);
+        uint32_t const addr = lba2addr(lba);
         uint32_t const page_addr = addr & ~(FLASH_PAGE_SIZE - 1);
 
         uint32_t count = 8 - (lba % 8); // up to page boundary
@@ -109,8 +111,8 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t lba, uint32
         memcpy(_flash_cache + (addr & (FLASH_PAGE_SIZE - 1)), src, count * FILESYSTEM_BLOCK_SIZE);
 
         // adjust for next run
-        lba        += count;
-        src        += count * FILESYSTEM_BLOCK_SIZE;
+        lba += count;
+        src += count * FILESYSTEM_BLOCK_SIZE;
         num_blocks -= count;
     }
 
diff --git a/ports/nrf/supervisor/port.c b/ports/nrf/supervisor/port.c
index 78bb20ce6..9a2acd5ca 100644
--- a/ports/nrf/supervisor/port.c
+++ b/ports/nrf/supervisor/port.c
@@ -94,7 +94,7 @@ void rtc_handler(nrfx_rtc_int_type_t int_type) {
     if (int_type == NRFX_RTC_INT_OVERFLOW) {
         // Our RTC is 24 bits and we're clocking it at 32.768khz which is 32 (2 ** 5) subticks per
         // tick.
-        overflow_tracker.overflowed_ticks += (1L<< (24 - 5));
+        overflow_tracker.overflowed_ticks += (1L << (24 - 5));
     } else if (int_type == NRFX_RTC_INT_TICK && nrfx_rtc_counter_get(&rtc_instance) % 32 == 0) {
         // Do things common to all ports when the tick occurs
         supervisor_tick();
@@ -145,13 +145,13 @@ safe_mode_t port_init(void) {
     // Configure millisecond timer initialization.
     tick_init();
 
-#if CIRCUITPY_RTC
+    #if CIRCUITPY_RTC
     common_hal_rtc_init();
-#endif
+    #endif
 
-#if CIRCUITPY_ANALOGIO
+    #if CIRCUITPY_ANALOGIO
     analogin_init();
-#endif
+    #endif
 
     // If the board was reset by the WatchDogTimer, we may
     // need to boot into safe mode. Reset the RESETREAS bit
@@ -172,51 +172,51 @@ safe_mode_t port_init(void) {
 }
 
 void reset_port(void) {
-#ifdef CIRCUITPY_GAMEPAD_TICKS
+    #ifdef CIRCUITPY_GAMEPAD_TICKS
     gamepad_reset();
-#endif
+    #endif
 
-#if CIRCUITPY_BUSIO
+    #if CIRCUITPY_BUSIO
     i2c_reset();
     spi_reset();
     uart_reset();
-#endif
+    #endif
 
-#if CIRCUITPY_NEOPIXEL_WRITE
+    #if CIRCUITPY_NEOPIXEL_WRITE
     neopixel_write_reset();
-#endif
+    #endif
 
-#if CIRCUITPY_AUDIOBUSIO
+    #if CIRCUITPY_AUDIOBUSIO
     i2s_reset();
-#endif
+    #endif
 
-#if CIRCUITPY_AUDIOPWMIO
+    #if CIRCUITPY_AUDIOPWMIO
     audiopwmout_reset();
-#endif
+    #endif
 
 
-#if CIRCUITPY_PULSEIO
+    #if CIRCUITPY_PULSEIO
     pulseout_reset();
     pulsein_reset();
-#endif
+    #endif
 
-#if CIRCUITPY_PWMIO
+    #if CIRCUITPY_PWMIO
     pwmout_reset();
-#endif
+    #endif
 
-#if CIRCUITPY_RTC
+    #if CIRCUITPY_RTC
     rtc_reset();
-#endif
+    #endif
 
     timers_reset();
 
-#if CIRCUITPY_BLEIO
+    #if CIRCUITPY_BLEIO
     bleio_reset();
-#endif
+    #endif
 
-#if CIRCUITPY_WATCHDOG
+    #if CIRCUITPY_WATCHDOG
     watchdog_reset();
-#endif
+    #endif
 
     reset_all_pins();
 }
@@ -273,7 +273,7 @@ uint32_t port_get_saved_word(void) {
     return _saved_word;
 }
 
-uint64_t port_get_raw_ticks(uint8_t* subticks) {
+uint64_t port_get_raw_ticks(uint8_t *subticks) {
     common_hal_mcu_disable_interrupts();
     uint32_t rtc = nrfx_rtc_counter_get(&rtc_instance);
     uint64_t overflow_count = overflow_tracker.overflowed_ticks;
@@ -308,14 +308,14 @@ void port_interrupt_after_ticks(uint32_t ticks) {
 }
 
 void port_idle_until_interrupt(void) {
-#if defined(MICROPY_QSPI_CS)
+    #if defined(MICROPY_QSPI_CS)
     qspi_disable();
-#endif
+    #endif
 
     // Clear the FPU interrupt because it can prevent us from sleeping.
     if (NVIC_GetPendingIRQ(FPU_IRQn)) {
-        __set_FPSCR(__get_FPSCR()  & ~(0x9f));
-        (void) __get_FPSCR();
+        __set_FPSCR(__get_FPSCR() & ~(0x9f));
+        (void)__get_FPSCR();
         NVIC_ClearPendingIRQ(FPU_IRQn);
     }
     uint8_t sd_enabled;
@@ -352,6 +352,6 @@ void port_idle_until_interrupt(void) {
 void HardFault_Handler(void) {
     reset_into_safe_mode(HARD_CRASH);
     while (true) {
-        asm("nop;");
+        asm ("nop;");
     }
 }
diff --git a/ports/nrf/supervisor/qspi_flash.c b/ports/nrf/supervisor/qspi_flash.c
index 7ca27d56c..1386af7c4 100644
--- a/ports/nrf/supervisor/qspi_flash.c
+++ b/ports/nrf/supervisor/qspi_flash.c
@@ -39,8 +39,7 @@
 #include "supervisor/shared/external_flash/qspi_flash.h"
 
 // When USB is disconnected, disable QSPI in sleep mode to save energy
-void qspi_disable(void)
-{
+void qspi_disable(void) {
     // If VBUS is detected, no need to disable QSPI
     if (NRF_QSPI->ENABLE && !(NRF_POWER->USBREGSTATUS & POWER_USBREGSTATUS_VBUSDETECT_Msk)) {
         // Keep CS high when QSPI is diabled
@@ -54,8 +53,7 @@ void qspi_disable(void)
     }
 }
 
-void qspi_enable(void)
-{
+void qspi_enable(void) {
     if (NRF_QSPI->ENABLE) {
         return;
     }
@@ -87,7 +85,7 @@ bool spi_flash_command(uint8_t command) {
     return nrfx_qspi_cinstr_xfer(&cinstr_cfg, NULL, NULL) == NRFX_SUCCESS;
 }
 
-bool spi_flash_read_command(uint8_t command, uint8_t* response, uint32_t length) {
+bool spi_flash_read_command(uint8_t command, uint8_t *response, uint32_t length) {
     qspi_enable();
     nrf_qspi_cinstr_conf_t cinstr_cfg = {
         .opcode = command,
@@ -101,7 +99,7 @@ bool spi_flash_read_command(uint8_t command, uint8_t* response, uint32_t length)
 
 }
 
-bool spi_flash_write_command(uint8_t command, uint8_t* data, uint32_t length) {
+bool spi_flash_write_command(uint8_t command, uint8_t *data, uint32_t length) {
     qspi_enable();
     nrf_qspi_cinstr_conf_t cinstr_cfg = {
         .opcode = command,
@@ -122,7 +120,7 @@ bool spi_flash_sector_command(uint8_t command, uint32_t address) {
     return nrfx_qspi_erase(NRF_QSPI_ERASE_LEN_4KB, address) == NRFX_SUCCESS;
 }
 
-bool spi_flash_write_data(uint32_t address, uint8_t* data, uint32_t length) {
+bool spi_flash_write_data(uint32_t address, uint8_t *data, uint32_t length) {
     qspi_enable();
     // TODO: In theory, this also needs to handle unaligned data and
     // non-multiple-of-4 length.  (in practice, I don't think the fat layer
@@ -130,17 +128,17 @@ bool spi_flash_write_data(uint32_t address, uint8_t* data, uint32_t length) {
     return nrfx_qspi_write(data, length, address) == NRFX_SUCCESS;
 }
 
-bool spi_flash_read_data(uint32_t address, uint8_t* data, uint32_t length) {
+bool spi_flash_read_data(uint32_t address, uint8_t *data, uint32_t length) {
     qspi_enable();
     int misaligned = ((intptr_t)data) & 3;
     // If the data is misaligned, we need to read 4 bytes
     // into an aligned buffer, and then copy 1, 2, or 3 bytes from the aligned
     // buffer to data.
-    if(misaligned) {
+    if (misaligned) {
         int sz = 4 - misaligned;
         __attribute__((aligned(4))) uint8_t buf[4];
 
-        if(nrfx_qspi_read(buf, 4, address) != NRFX_SUCCESS) {
+        if (nrfx_qspi_read(buf, 4, address) != NRFX_SUCCESS) {
             return false;
         }
         memcpy(data, buf, sz);
@@ -153,7 +151,7 @@ bool spi_flash_read_data(uint32_t address, uint8_t* data, uint32_t length) {
     // signal an error if sz is not a multiple of 4.  Read (directly into data)
     // all but the last 1, 2, or 3 bytes depending on the (remaining) length.
     uint32_t sz = length & ~(uint32_t)3;
-    if(nrfx_qspi_read(data, sz, address) != NRFX_SUCCESS) {
+    if (nrfx_qspi_read(data, sz, address) != NRFX_SUCCESS) {
         return false;
     }
     data += sz;
@@ -162,9 +160,9 @@ bool spi_flash_read_data(uint32_t address, uint8_t* data, uint32_t length) {
 
     // Now, if we have any bytes left over, we must do a final read of 4
     // bytes and copy 1, 2, or 3 bytes to data.
-    if(length) {
+    if (length) {
         __attribute__((aligned(4))) uint8_t buf[4];
-        if(nrfx_qspi_read(buf, 4, address) != NRFX_SUCCESS) {
+        if (nrfx_qspi_read(buf, 4, address) != NRFX_SUCCESS) {
             return false;
         }
         memcpy(data, buf, length);
@@ -201,23 +199,23 @@ void spi_flash_init(void) {
         .irq_priority = 7,
     };
 
-#if defined(EXTERNAL_FLASH_QSPI_DUAL)
+    #if defined(EXTERNAL_FLASH_QSPI_DUAL)
     qspi_cfg.pins.io1_pin = MICROPY_QSPI_DATA1;
     qspi_cfg.prot_if.readoc = NRF_QSPI_READOC_READ2O;
     qspi_cfg.prot_if.writeoc = NRF_QSPI_WRITEOC_PP2O;
-#else
+    #else
     qspi_cfg.pins.io1_pin = MICROPY_QSPI_DATA1;
     qspi_cfg.pins.io2_pin = MICROPY_QSPI_DATA2;
     qspi_cfg.pins.io3_pin = MICROPY_QSPI_DATA3;
     qspi_cfg.prot_if.readoc = NRF_QSPI_READOC_READ4IO;
     qspi_cfg.prot_if.writeoc = NRF_QSPI_WRITEOC_PP4O;
-#endif
+    #endif
 
     // No callback for blocking API
     nrfx_qspi_init(&qspi_cfg, NULL, NULL);
 }
 
-void spi_flash_init_device(const external_flash_device* device) {
+void spi_flash_init_device(const external_flash_device *device) {
     check_quad_enable(device);
 
     // Switch to single output line if the device doesn't support quad programs.
@@ -236,5 +234,5 @@ void spi_flash_init_device(const external_flash_device* device) {
         sckfreq += 1;
     }
     NRF_QSPI->IFCONFIG1 &= ~QSPI_IFCONFIG1_SCKFREQ_Msk;
-    NRF_QSPI->IFCONFIG1 |=  sckfreq << QSPI_IFCONFIG1_SCKFREQ_Pos;
+    NRF_QSPI->IFCONFIG1 |= sckfreq << QSPI_IFCONFIG1_SCKFREQ_Pos;
 }
diff --git a/ports/nrf/supervisor/serial.c b/ports/nrf/supervisor/serial.c
index 2c2c0116f..10bdb2819 100644
--- a/ports/nrf/supervisor/serial.c
+++ b/ports/nrf/supervisor/serial.c
@@ -47,7 +47,7 @@ bool serial_connected(void) {
 }
 
 char serial_read(void) {
-    return (char) ble_uart_rx_chr();
+    return (char)ble_uart_rx_chr();
 }
 
 bool serial_bytes_available(void) {
@@ -101,7 +101,7 @@ bool serial_bytes_available(void) {
     return nrf_uarte_event_check(serial_instance.p_reg, NRF_UARTE_EVENT_RXDRDY);
 }
 
-void serial_write(const char* text) {
+void serial_write(const char *text) {
     serial_write_substring(text, strlen(text));
 }
 
@@ -111,15 +111,15 @@ void serial_write_substring(const char *text, uint32_t len) {
     }
 
     // EasyDMA can only access SRAM
-    uint8_t * tx_buf = (uint8_t*) text;
-    if ( !nrfx_is_in_ram(text) ) {
-        tx_buf = (uint8_t *) m_malloc(len, false);
+    uint8_t *tx_buf = (uint8_t *)text;
+    if (!nrfx_is_in_ram(text)) {
+        tx_buf = (uint8_t *)m_malloc(len, false);
         memcpy(tx_buf, text, len);
     }
 
     nrfx_uarte_tx(&serial_instance, tx_buf, len);
 
-    if ( !nrfx_is_in_ram(text) ) {
+    if (!nrfx_is_in_ram(text)) {
         m_free(tx_buf);
     }
 }
diff --git a/ports/nrf/supervisor/usb.c b/ports/nrf/supervisor/usb.c
index 771e86ce0..3ca9b8365 100644
--- a/ports/nrf/supervisor/usb.c
+++ b/ports/nrf/supervisor/usb.c
@@ -53,25 +53,25 @@ void init_usb_hardware(void) {
     static bool first_call = true;
     uint32_t usb_reg;
 
-#ifdef SOFTDEVICE_PRESENT
+    #ifdef SOFTDEVICE_PRESENT
     uint8_t sd_en = false;
-    (void) sd_softdevice_is_enabled(&sd_en);
+    (void)sd_softdevice_is_enabled(&sd_en);
 
-    if ( sd_en ) {
+    if (sd_en) {
         sd_power_usbdetected_enable(true);
         sd_power_usbpwrrdy_enable(true);
         sd_power_usbremoved_enable(true);
 
         sd_power_usbregstatus_get(&usb_reg);
-    }else
-#endif
+    } else
+    #endif
     {
         // Power module init
         const nrfx_power_config_t pwr_cfg = { 0 };
         nrfx_power_init(&pwr_cfg);
 
         // Register tusb function as USB power handler
-        const nrfx_power_usbevt_config_t config = { .handler = (nrfx_power_usb_event_handler_t) tusb_hal_nrf_power_event };
+        const nrfx_power_usbevt_config_t config = { .handler = (nrfx_power_usb_event_handler_t)tusb_hal_nrf_power_event };
         nrfx_power_usbevt_init(&config);
 
         nrfx_power_usbevt_enable();
@@ -79,13 +79,13 @@ void init_usb_hardware(void) {
         usb_reg = NRF_POWER->USBREGSTATUS;
     }
 
-    if ( first_call ) {
+    if (first_call) {
         first_call = false;
-        if ( usb_reg & POWER_USBREGSTATUS_VBUSDETECT_Msk ) {
+        if (usb_reg & POWER_USBREGSTATUS_VBUSDETECT_Msk) {
             tusb_hal_nrf_power_event(NRFX_POWER_USB_EVT_DETECTED);
         }
 
-        if ( usb_reg & POWER_USBREGSTATUS_OUTPUTRDY_Msk ) {
+        if (usb_reg & POWER_USBREGSTATUS_OUTPUTRDY_Msk) {
             tusb_hal_nrf_power_event(NRFX_POWER_USB_EVT_READY);
         }
     }