Merge pull request #4362 from microDev1/code-formatting

Add code formatting and translations check

27 files changed, 441 insertions, 441 deletions

diff --git a/shared-module/displayio/Bitmap.c b/shared-module/displayio/Bitmap.c
index 1831ac697..f03ade84b 100644
--- a/shared-module/displayio/Bitmap.c
+++ b/shared-module/displayio/Bitmap.c
@@ -57,7 +57,7 @@ void common_hal_displayio_bitmap_construct(displayio_bitmap_t *self, uint32_t wi
     self->x_shift = 0; // Used to divide the index by the number of pixels per word. Its used in a
                        // shift which effectively divides by 2 ** x_shift.
     uint32_t power_of_two = 1;
-    while (power_of_two < align_bits / bits_per_value ) {
+    while (power_of_two < align_bits / bits_per_value) {
         self->x_shift++;
         power_of_two <<= 1;
     }
@@ -93,13 +93,13 @@ uint32_t common_hal_displayio_bitmap_get_pixel(displayio_bitmap_t *self, int16_t
 
         return (word >> (sizeof(size_t) * 8 - ((x & self->x_mask) + 1) * self->bits_per_value)) & self->bitmask;
     } else {
-        size_t* row = self->data + row_start;
+        size_t *row = self->data + row_start;
         if (bytes_per_value == 1) {
-            return ((uint8_t*) row)[x];
+            return ((uint8_t *)row)[x];
         } else if (bytes_per_value == 2) {
-            return ((uint16_t*) row)[x];
+            return ((uint16_t *)row)[x];
         } else if (bytes_per_value == 4) {
-            return ((uint32_t*) row)[x];
+            return ((uint32_t *)row)[x];
         }
     }
     return 0;
@@ -157,19 +157,19 @@ void displayio_bitmap_write_pixel(displayio_bitmap_t *self, int16_t x, int16_t y
         word |= (value & self->bitmask) << bit_position;
         self->data[index] = word;
     } else {
-        size_t* row = self->data + row_start;
+        size_t *row = self->data + row_start;
         if (bytes_per_value == 1) {
-            ((uint8_t*) row)[x] = value;
+            ((uint8_t *)row)[x] = value;
         } else if (bytes_per_value == 2) {
-            ((uint16_t*) row)[x] = value;
+            ((uint16_t *)row)[x] = value;
         } else if (bytes_per_value == 4) {
-            ((uint32_t*) row)[x] = value;
+            ((uint32_t *)row)[x] = value;
         }
     }
 }
 
 void common_hal_displayio_bitmap_blit(displayio_bitmap_t *self, int16_t x, int16_t y, displayio_bitmap_t *source,
-                            int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint32_t skip_index, bool skip_index_none) {
+    int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint32_t skip_index, bool skip_index_none) {
     // Copy region of "source" bitmap into "self" bitmap at location x,y in the "self"
     // If skip_value is encountered in the source bitmap, it will not be copied.
     // If skip_value is `None`, then all pixels are copied.
@@ -180,11 +180,11 @@ void common_hal_displayio_bitmap_blit(displayio_bitmap_t *self, int16_t x, int16
     }
 
     // Update the dirty area
-    int16_t dirty_x_max = (x + (x2-x1));
+    int16_t dirty_x_max = (x + (x2 - x1));
     if (dirty_x_max > self->width) {
         dirty_x_max = self->width;
     }
-    int16_t dirty_y_max = y + (y2-y1);
+    int16_t dirty_y_max = y + (y2 - y1);
     if (dirty_y_max > self->height) {
         dirty_y_max = self->height;
     }
@@ -203,21 +203,21 @@ void common_hal_displayio_bitmap_blit(displayio_bitmap_t *self, int16_t x, int16
     }
 
     // simplest version - use internal functions for get/set pixels
-    for (int16_t i=0; i < (x2-x1); i++) {
+    for (int16_t i = 0; i < (x2 - x1); i++) {
 
-        const int xs_index = x_reverse ? ( (x2) - i - 1) : x1+i; // x-index into the source bitmap
-        const int xd_index = x_reverse ? ((x + (x2-x1)) - i - 1) : x+i; // x-index into the destination bitmap
+        const int xs_index = x_reverse ? ((x2) - i - 1) : x1 + i; // x-index into the source bitmap
+        const int xd_index = x_reverse ? ((x + (x2 - x1)) - i - 1) : x + i; // x-index into the destination bitmap
 
-        if ( (xd_index >= 0) && (xd_index < self->width) ) {
-            for (int16_t j=0; j < (y2-y1) ; j++){
+        if ((xd_index >= 0) && (xd_index < self->width)) {
+            for (int16_t j = 0; j < (y2 - y1); j++) {
 
-                const int ys_index = y_reverse ? ( (y2 ) - j - 1) : y1+j ; // y-index into the source bitmap
-                const int yd_index = y_reverse ? ((y + (y2-y1)) - j - 1) : y+j ; // y-index into the destination bitmap
+                const int ys_index = y_reverse ? ((y2) - j - 1) : y1 + j;  // y-index into the source bitmap
+                const int yd_index = y_reverse ? ((y + (y2 - y1)) - j - 1) : y + j; // y-index into the destination bitmap
 
-                if ((yd_index >= 0) && (yd_index < self->height) ) {
+                if ((yd_index >= 0) && (yd_index < self->height)) {
                     uint32_t value = common_hal_displayio_bitmap_get_pixel(source, xs_index, ys_index);
-                    if ( (skip_index_none) || (value != skip_index) ) { // write if skip_value_none is True
-                            displayio_bitmap_write_pixel(self, xd_index, yd_index, value);
+                    if ((skip_index_none) || (value != skip_index)) {   // write if skip_value_none is True
+                        displayio_bitmap_write_pixel(self, xd_index, yd_index, value);
                     }
                 }
             }
@@ -231,14 +231,14 @@ void common_hal_displayio_bitmap_set_pixel(displayio_bitmap_t *self, int16_t x,
     }
 
     // update the dirty region
-    displayio_bitmap_set_dirty_area(self, x, y, x+1, y+1);
+    displayio_bitmap_set_dirty_area(self, x, y, x + 1, y + 1);
 
     // write the pixel
     displayio_bitmap_write_pixel(self, x, y, value);
 
 }
 
-displayio_area_t* displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t* tail) {
+displayio_area_t *displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t *tail) {
     if (self->dirty_area.x1 == self->dirty_area.x2) {
         return tail;
     }
@@ -263,11 +263,11 @@ void common_hal_displayio_bitmap_fill(displayio_bitmap_t *self, uint32_t value)
 
     // build the packed word
     uint32_t word = 0;
-    for (uint8_t i=0; i<32 / self->bits_per_value; i++) {
-        word |= (value & self->bitmask) << (32 - ((i+1)*self->bits_per_value));
+    for (uint8_t i = 0; i < 32 / self->bits_per_value; i++) {
+        word |= (value & self->bitmask) << (32 - ((i + 1) * self->bits_per_value));
     }
     // copy it in
-    for (uint32_t i=0; i<self->stride * self->height; i++) {
+    for (uint32_t i = 0; i < self->stride * self->height; i++) {
         self->data[i] = word;
     }
 }
diff --git a/shared-module/displayio/Bitmap.h b/shared-module/displayio/Bitmap.h
index d6aaaa8ba..c1ce9612b 100644
--- a/shared-module/displayio/Bitmap.h
+++ b/shared-module/displayio/Bitmap.h
@@ -37,7 +37,7 @@ typedef struct {
     mp_obj_base_t base;
     uint16_t width;
     uint16_t height;
-    size_t* data;
+    size_t *data;
     uint16_t stride; // size_t's
     uint8_t bits_per_value;
     uint8_t x_shift;
@@ -48,7 +48,7 @@ typedef struct {
 } displayio_bitmap_t;
 
 void displayio_bitmap_finish_refresh(displayio_bitmap_t *self);
-displayio_area_t* displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t* tail);
+displayio_area_t *displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t *tail);
 void displayio_bitmap_set_dirty_area(displayio_bitmap_t *self, int16_t x1, int16_t y1, int16_t x2, int16_t y2);
 void displayio_bitmap_write_pixel(displayio_bitmap_t *self, int16_t x, int16_t y, uint32_t value);
 
diff --git a/shared-module/displayio/ColorConverter.c b/shared-module/displayio/ColorConverter.c
index 40dcd9d16..be9e9dc1a 100644
--- a/shared-module/displayio/ColorConverter.c
+++ b/shared-module/displayio/ColorConverter.c
@@ -31,18 +31,17 @@
 
 #define NO_TRANSPARENT_COLOR (0x1000000)
 
-uint32_t displayio_colorconverter_dither_noise_1 (uint32_t n)
-{
-  n = (n >> 13) ^ n;
-  int nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
-  return (uint32_t) (((float)nn / (1073741824.0f*2)) * 255);
+uint32_t displayio_colorconverter_dither_noise_1(uint32_t n) {
+    n = (n >> 13) ^ n;
+    int nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
+    return (uint32_t)(((float)nn / (1073741824.0f * 2)) * 255);
 }
 
 uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y) {
     return displayio_colorconverter_dither_noise_1(x + y * 0xFFFF);
 }
 
-void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self, bool dither) {
+void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t *self, bool dither) {
     self->dither = dither;
     self->transparent_color = NO_TRANSPARENT_COLOR;
 }
@@ -83,11 +82,11 @@ uint8_t displayio_colorconverter_compute_hue(uint32_t color_rgb888) {
 
     int32_t hue = 0;
     if (max == r8) {
-        hue = (((int32_t) (g8 - b8) * 40) / c) % 240;
+        hue = (((int32_t)(g8 - b8) * 40) / c) % 240;
     } else if (max == g8) {
-        hue = (((int32_t) (b8 - r8) + (2 * c)) * 40) / c;
+        hue = (((int32_t)(b8 - r8) + (2 * c)) * 40) / c;
     } else if (max == b8) {
-        hue = (((int32_t) (r8 - g8) + (4 * c)) * 40) / c;
+        hue = (((int32_t)(r8 - g8) + (4 * c)) * 40) / c;
     }
     if (hue < 0) {
         hue += 240;
@@ -96,7 +95,7 @@ uint8_t displayio_colorconverter_compute_hue(uint32_t color_rgb888) {
     return hue;
 }
 
-void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t* colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t*  color) {
+void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t *colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t *color) {
 
     int16_t hue_diff = colorspace->tricolor_hue - pixel_hue;
     if ((-10 <= hue_diff && hue_diff <= 10) || hue_diff <= -220 || hue_diff >= 220) {
@@ -110,7 +109,7 @@ void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t* co
     }
 }
 
-void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color) {
+void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t *colorspace, uint32_t input_color, uint32_t *output_color) {
     displayio_input_pixel_t input_pixel;
     input_pixel.pixel = input_color;
     input_pixel.x = input_pixel.y = input_pixel.tile = input_pixel.tile_x = input_pixel.tile_y = 0;
@@ -124,28 +123,28 @@ void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *sel
     (*output_color) = output_pixel.pixel;
 }
 
-void common_hal_displayio_colorconverter_set_dither(displayio_colorconverter_t* self, bool dither) {
+void common_hal_displayio_colorconverter_set_dither(displayio_colorconverter_t *self, bool dither) {
     self->dither = dither;
 }
 
-bool common_hal_displayio_colorconverter_get_dither(displayio_colorconverter_t* self) {
+bool common_hal_displayio_colorconverter_get_dither(displayio_colorconverter_t *self) {
     return self->dither;
 }
 
-void common_hal_displayio_colorconverter_make_transparent(displayio_colorconverter_t* self, uint32_t transparent_color) {
+void common_hal_displayio_colorconverter_make_transparent(displayio_colorconverter_t *self, uint32_t transparent_color) {
     if (self->transparent_color != NO_TRANSPARENT_COLOR) {
         mp_raise_RuntimeError(translate("Only one color can be transparent at a time"));
     }
     self->transparent_color = transparent_color;
 }
 
-void common_hal_displayio_colorconverter_make_opaque(displayio_colorconverter_t* self, uint32_t transparent_color) {
-    (void) transparent_color;
+void common_hal_displayio_colorconverter_make_opaque(displayio_colorconverter_t *self, uint32_t transparent_color) {
+    (void)transparent_color;
     // NO_TRANSPARENT_COLOR will never equal a valid color
     self->transparent_color = NO_TRANSPARENT_COLOR;
 }
 
-void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color) {
+void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t *colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color) {
     uint32_t pixel = input_pixel->pixel;
 
     if (self->transparent_color == pixel) {
@@ -153,19 +152,19 @@ void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _d
         return;
     }
 
-    if (self->dither){
+    if (self->dither) {
         uint8_t randr = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y));
-        uint8_t randg = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x+33,input_pixel->tile_y));
-        uint8_t randb = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y+33));
+        uint8_t randg = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x + 33,input_pixel->tile_y));
+        uint8_t randb = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y + 33));
 
         uint32_t r8 = (pixel >> 16);
         uint32_t g8 = (pixel >> 8) & 0xff;
         uint32_t b8 = pixel & 0xff;
 
         if (colorspace->depth == 16) {
-            b8 = MIN(255,b8 + (randb&0x07));
-            r8 = MIN(255,r8 + (randr&0x07));
-            g8 = MIN(255,g8 + (randg&0x03));
+            b8 = MIN(255,b8 + (randb & 0x07));
+            r8 = MIN(255,r8 + (randr & 0x07));
+            g8 = MIN(255,g8 + (randg & 0x03));
         } else {
             int bitmask = 0xFF >> colorspace->depth;
             b8 = MIN(255,b8 + (randb & bitmask));
@@ -197,7 +196,7 @@ void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _d
         uint8_t pixel_hue = displayio_colorconverter_compute_hue(pixel);
         displayio_colorconverter_compute_tricolor(colorspace, pixel_hue, luma, &output_color->pixel);
         return;
-    }  else if (colorspace->grayscale && colorspace->depth <= 8) {
+    } else if (colorspace->grayscale && colorspace->depth <= 8) {
         uint8_t luma = displayio_colorconverter_compute_luma(pixel);
         size_t bitmask = (1 << colorspace->depth) - 1;
         output_color->pixel = (luma >> colorspace->grayscale_bit) & bitmask;
diff --git a/shared-module/displayio/ColorConverter.h b/shared-module/displayio/ColorConverter.h
index b402625ef..ebe4b2719 100644
--- a/shared-module/displayio/ColorConverter.h
+++ b/shared-module/displayio/ColorConverter.h
@@ -41,15 +41,15 @@ typedef struct {
 
 bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self);
 void displayio_colorconverter_finish_refresh(displayio_colorconverter_t *self);
-void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color);
+void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t *colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color);
 
-uint32_t displayio_colorconverter_dither_noise_1 (uint32_t n);
+uint32_t displayio_colorconverter_dither_noise_1(uint32_t n);
 uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y);
 
 uint16_t displayio_colorconverter_compute_rgb565(uint32_t color_rgb888);
 uint8_t displayio_colorconverter_compute_luma(uint32_t color_rgb888);
 uint8_t displayio_colorconverter_compute_chroma(uint32_t color_rgb888);
 uint8_t displayio_colorconverter_compute_hue(uint32_t color_rgb888);
-void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t* colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t*  color);
+void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t *colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t *color);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_COLORCONVERTER_H
diff --git a/shared-module/displayio/Display.c b/shared-module/displayio/Display.c
index 7c8c9280b..63e098e08 100644
--- a/shared-module/displayio/Display.c
+++ b/shared-module/displayio/Display.c
@@ -41,15 +41,15 @@
 #include <stdint.h>
 #include <string.h>
 
-void common_hal_displayio_display_construct(displayio_display_obj_t* self,
-        mp_obj_t bus, uint16_t width, uint16_t height, int16_t colstart, int16_t rowstart,
-        uint16_t rotation, uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row,
-        uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word, uint8_t set_column_command,
-        uint8_t set_row_command, uint8_t write_ram_command, uint8_t set_vertical_scroll,
-        uint8_t* init_sequence, uint16_t init_sequence_len, const mcu_pin_obj_t* backlight_pin,
-        uint16_t brightness_command, mp_float_t brightness, bool auto_brightness,
-        bool single_byte_bounds, bool data_as_commands, bool auto_refresh, uint16_t native_frames_per_second,
-        bool backlight_on_high, bool SH1107_addressing) {
+void common_hal_displayio_display_construct(displayio_display_obj_t *self,
+    mp_obj_t bus, uint16_t width, uint16_t height, int16_t colstart, int16_t rowstart,
+    uint16_t rotation, uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row,
+    uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word, uint8_t set_column_command,
+    uint8_t set_row_command, uint8_t write_ram_command, uint8_t set_vertical_scroll,
+    uint8_t *init_sequence, uint16_t init_sequence_len, const mcu_pin_obj_t *backlight_pin,
+    uint16_t brightness_command, mp_float_t brightness, bool auto_brightness,
+    bool single_byte_bounds, bool data_as_commands, bool auto_refresh, uint16_t native_frames_per_second,
+    bool backlight_on_high, bool SH1107_addressing) {
 
     // Turn off auto-refresh as we init.
     self->auto_refresh = false;
@@ -141,34 +141,34 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
     common_hal_displayio_display_set_auto_refresh(self, auto_refresh);
 }
 
-bool common_hal_displayio_display_show(displayio_display_obj_t* self, displayio_group_t* root_group) {
+bool common_hal_displayio_display_show(displayio_display_obj_t *self, displayio_group_t *root_group) {
     return displayio_display_core_show(&self->core, root_group);
 }
 
-uint16_t common_hal_displayio_display_get_width(displayio_display_obj_t* self){
+uint16_t common_hal_displayio_display_get_width(displayio_display_obj_t *self) {
     return displayio_display_core_get_width(&self->core);
 }
 
-uint16_t common_hal_displayio_display_get_height(displayio_display_obj_t* self){
+uint16_t common_hal_displayio_display_get_height(displayio_display_obj_t *self) {
     return displayio_display_core_get_height(&self->core);
 }
 
-bool common_hal_displayio_display_get_auto_brightness(displayio_display_obj_t* self) {
+bool common_hal_displayio_display_get_auto_brightness(displayio_display_obj_t *self) {
     return self->auto_brightness;
 }
 
-void common_hal_displayio_display_set_auto_brightness(displayio_display_obj_t* self, bool auto_brightness) {
+void common_hal_displayio_display_set_auto_brightness(displayio_display_obj_t *self, bool auto_brightness) {
     self->auto_brightness = auto_brightness;
 }
 
-mp_float_t common_hal_displayio_display_get_brightness(displayio_display_obj_t* self) {
+mp_float_t common_hal_displayio_display_get_brightness(displayio_display_obj_t *self) {
     return self->current_brightness;
 }
 
-bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self, mp_float_t brightness) {
+bool common_hal_displayio_display_set_brightness(displayio_display_obj_t *self, mp_float_t brightness) {
     self->updating_backlight = true;
-    if (!self->backlight_on_high){
-        brightness = 1.0-brightness;
+    if (!self->backlight_on_high) {
+        brightness = 1.0 - brightness;
     }
     bool ok = false;
 
@@ -181,7 +181,7 @@ bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self,
 
     if (ispwm) {
         #if (CIRCUITPY_PULSEIO)
-        common_hal_pwmio_pwmout_set_duty_cycle(&self->backlight_pwm, (uint16_t) (0xffff * brightness));
+        common_hal_pwmio_pwmout_set_duty_cycle(&self->backlight_pwm, (uint16_t)(0xffff * brightness));
         ok = true;
         #else
         ok = false;
@@ -193,7 +193,7 @@ bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self,
         ok = displayio_display_core_begin_transaction(&self->core);
         if (ok) {
             if (self->data_as_commands) {
-                uint8_t set_brightness[2] = {self->brightness_command, (uint8_t) (0xff * brightness)};
+                uint8_t set_brightness[2] = {self->brightness_command, (uint8_t)(0xff * brightness)};
                 self->core.send(self->core.bus, DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, set_brightness, 2);
             } else {
                 uint8_t command = self->brightness_command;
@@ -212,11 +212,11 @@ bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self,
     return ok;
 }
 
-mp_obj_t common_hal_displayio_display_get_bus(displayio_display_obj_t* self) {
+mp_obj_t common_hal_displayio_display_get_bus(displayio_display_obj_t *self) {
     return self->core.bus;
 }
 
-STATIC const displayio_area_t* _get_refresh_areas(displayio_display_obj_t *self) {
+STATIC const displayio_area_t *_get_refresh_areas(displayio_display_obj_t *self) {
     if (self->core.full_refresh) {
         self->core.area.next = NULL;
         return &self->core.area;
@@ -226,14 +226,14 @@ STATIC const displayio_area_t* _get_refresh_areas(displayio_display_obj_t *self)
     return NULL;
 }
 
-STATIC void _send_pixels(displayio_display_obj_t* self, uint8_t* pixels, uint32_t length) {
+STATIC void _send_pixels(displayio_display_obj_t *self, uint8_t *pixels, uint32_t length) {
     if (!self->data_as_commands) {
         self->core.send(self->core.bus, DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, &self->write_ram_command, 1);
     }
     self->core.send(self->core.bus, DISPLAY_DATA, CHIP_SELECT_UNTOUCHED, pixels, length);
 }
 
-STATIC bool _refresh_area(displayio_display_obj_t* self, const displayio_area_t* area) {
+STATIC bool _refresh_area(displayio_display_obj_t *self, const displayio_area_t *area) {
     uint16_t buffer_size = 128; // In uint32_ts
 
     displayio_area_t clipped;
@@ -294,8 +294,8 @@ STATIC bool _refresh_area(displayio_display_obj_t* self, const displayio_area_t*
         remaining_rows -= rows_per_buffer;
 
         displayio_display_core_set_region_to_update(&self->core, self->set_column_command,
-              self->set_row_command, NO_COMMAND, NO_COMMAND, self->data_as_commands, false,
-              &subrectangle, self->SH1107_addressing);
+            self->set_row_command, NO_COMMAND, NO_COMMAND, self->data_as_commands, false,
+            &subrectangle, self->SH1107_addressing);
 
         uint16_t subrectangle_size_bytes;
         if (self->core.colorspace.depth >= 8) {
@@ -315,7 +315,7 @@ STATIC bool _refresh_area(displayio_display_obj_t* self, const displayio_area_t*
         }
 
         displayio_display_core_begin_transaction(&self->core);
-        _send_pixels(self, (uint8_t*) buffer, subrectangle_size_bytes);
+        _send_pixels(self, (uint8_t *)buffer, subrectangle_size_bytes);
         displayio_display_core_end_transaction(&self->core);
 
         // TODO(tannewt): Make refresh displays faster so we don't starve other
@@ -325,12 +325,12 @@ STATIC bool _refresh_area(displayio_display_obj_t* self, const displayio_area_t*
     return true;
 }
 
-STATIC void _refresh_display(displayio_display_obj_t* self) {
+STATIC void _refresh_display(displayio_display_obj_t *self) {
     if (!displayio_display_core_start_refresh(&self->core)) {
         // A refresh on this bus is already in progress.  Try next display.
         return;
     }
-    const displayio_area_t* current_area = _get_refresh_areas(self);
+    const displayio_area_t *current_area = _get_refresh_areas(self);
     while (current_area != NULL) {
         _refresh_area(self, current_area);
         current_area = current_area->next;
@@ -338,10 +338,10 @@ STATIC void _refresh_display(displayio_display_obj_t* self) {
     displayio_display_core_finish_refresh(&self->core);
 }
 
-void common_hal_displayio_display_set_rotation(displayio_display_obj_t* self, int rotation){
+void common_hal_displayio_display_set_rotation(displayio_display_obj_t *self, int rotation) {
     bool transposed = (self->core.rotation == 90 || self->core.rotation == 270);
     bool will_transposed = (rotation == 90 || rotation == 270);
-    if(transposed != will_transposed) {
+    if (transposed != will_transposed) {
         int tmp = self->core.width;
         self->core.width = self->core.height;
         self->core.height = tmp;
@@ -356,13 +356,13 @@ void common_hal_displayio_display_set_rotation(displayio_display_obj_t* self, in
     }
 }
 
-uint16_t common_hal_displayio_display_get_rotation(displayio_display_obj_t* self){
+uint16_t common_hal_displayio_display_get_rotation(displayio_display_obj_t *self) {
     return self->core.rotation;
 }
 
 
-bool common_hal_displayio_display_refresh(displayio_display_obj_t* self, uint32_t target_ms_per_frame, uint32_t maximum_ms_per_real_frame) {
-    if (!self->auto_refresh && !self->first_manual_refresh && (target_ms_per_frame != 0xffffffff) ) {
+bool common_hal_displayio_display_refresh(displayio_display_obj_t *self, uint32_t target_ms_per_frame, uint32_t maximum_ms_per_real_frame) {
+    if (!self->auto_refresh && !self->first_manual_refresh && (target_ms_per_frame != 0xffffffff)) {
         uint64_t current_time = supervisor_ticks_ms64();
         uint32_t current_ms_since_real_refresh = current_time - self->core.last_refresh;
         // Test to see if the real frame time is below our minimum.
@@ -386,12 +386,12 @@ bool common_hal_displayio_display_refresh(displayio_display_obj_t* self, uint32_
     return true;
 }
 
-bool common_hal_displayio_display_get_auto_refresh(displayio_display_obj_t* self) {
+bool common_hal_displayio_display_get_auto_refresh(displayio_display_obj_t *self) {
     return self->auto_refresh;
 }
 
-void common_hal_displayio_display_set_auto_refresh(displayio_display_obj_t* self,
-                                                   bool auto_refresh) {
+void common_hal_displayio_display_set_auto_refresh(displayio_display_obj_t *self,
+    bool auto_refresh) {
     self->first_manual_refresh = !auto_refresh;
     if (auto_refresh != self->auto_refresh) {
         if (auto_refresh) {
@@ -403,7 +403,7 @@ void common_hal_displayio_display_set_auto_refresh(displayio_display_obj_t* self
     self->auto_refresh = auto_refresh;
 }
 
-STATIC void _update_backlight(displayio_display_obj_t* self) {
+STATIC void _update_backlight(displayio_display_obj_t *self) {
     if (!self->auto_brightness || self->updating_backlight) {
         return;
     }
@@ -417,7 +417,7 @@ STATIC void _update_backlight(displayio_display_obj_t* self) {
     self->last_backlight_refresh = supervisor_ticks_ms64();
 }
 
-void displayio_display_background(displayio_display_obj_t* self) {
+void displayio_display_background(displayio_display_obj_t *self) {
     _update_backlight(self);
 
     if (self->auto_refresh && (supervisor_ticks_ms64() - self->core.last_refresh) > self->native_ms_per_frame) {
@@ -425,7 +425,7 @@ void displayio_display_background(displayio_display_obj_t* self) {
     }
 }
 
-void release_display(displayio_display_obj_t* self) {
+void release_display(displayio_display_obj_t *self) {
     common_hal_displayio_display_set_auto_refresh(self, false);
     release_display_core(&self->core);
     #if (CIRCUITPY_PULSEIO)
@@ -440,12 +440,12 @@ void release_display(displayio_display_obj_t* self) {
     #endif
 }
 
-void reset_display(displayio_display_obj_t* self) {
+void reset_display(displayio_display_obj_t *self) {
     common_hal_displayio_display_set_auto_refresh(self, true);
     self->auto_brightness = true;
     common_hal_displayio_display_show(self, NULL);
 }
 
-void displayio_display_collect_ptrs(displayio_display_obj_t* self) {
+void displayio_display_collect_ptrs(displayio_display_obj_t *self) {
     displayio_display_core_collect_ptrs(&self->core);
 }
diff --git a/shared-module/displayio/Display.h b/shared-module/displayio/Display.h
index cc9cd54c4..a0049f00c 100644
--- a/shared-module/displayio/Display.h
+++ b/shared-module/displayio/Display.h
@@ -64,10 +64,10 @@ typedef struct {
     bool SH1107_addressing;
 } displayio_display_obj_t;
 
-void displayio_display_background(displayio_display_obj_t* self);
-void release_display(displayio_display_obj_t* self);
-void reset_display(displayio_display_obj_t* self);
+void displayio_display_background(displayio_display_obj_t *self);
+void release_display(displayio_display_obj_t *self);
+void reset_display(displayio_display_obj_t *self);
 
-void displayio_display_collect_ptrs(displayio_display_obj_t* self);
+void displayio_display_collect_ptrs(displayio_display_obj_t *self);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_DISPLAY_H
diff --git a/shared-module/displayio/EPaperDisplay.c b/shared-module/displayio/EPaperDisplay.c
index 3fb37ff21..7eff58775 100644
--- a/shared-module/displayio/EPaperDisplay.c
+++ b/shared-module/displayio/EPaperDisplay.c
@@ -42,15 +42,15 @@
 #include <stdint.h>
 #include <string.h>
 
-void common_hal_displayio_epaperdisplay_construct(displayio_epaperdisplay_obj_t* self,
-        mp_obj_t bus, const uint8_t* start_sequence, uint16_t start_sequence_len,
-        const uint8_t* stop_sequence, uint16_t stop_sequence_len,
-        uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height,
-        int16_t colstart, int16_t rowstart, uint16_t rotation,
-        uint16_t set_column_window_command, uint16_t set_row_window_command,
-        uint16_t set_current_column_command, uint16_t set_current_row_command,
-        uint16_t write_black_ram_command, bool black_bits_inverted, uint16_t write_color_ram_command, bool color_bits_inverted, uint32_t highlight_color, uint16_t refresh_display_command, mp_float_t refresh_time,
-        const mcu_pin_obj_t* busy_pin, bool busy_state, mp_float_t seconds_per_frame, bool chip_select, bool grayscale) {
+void common_hal_displayio_epaperdisplay_construct(displayio_epaperdisplay_obj_t *self,
+    mp_obj_t bus, const uint8_t *start_sequence, uint16_t start_sequence_len,
+    const uint8_t *stop_sequence, uint16_t stop_sequence_len,
+    uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height,
+    int16_t colstart, int16_t rowstart, uint16_t rotation,
+    uint16_t set_column_window_command, uint16_t set_row_window_command,
+    uint16_t set_current_column_command, uint16_t set_current_row_command,
+    uint16_t write_black_ram_command, bool black_bits_inverted, uint16_t write_color_ram_command, bool color_bits_inverted, uint32_t highlight_color, uint16_t refresh_display_command, mp_float_t refresh_time,
+    const mcu_pin_obj_t *busy_pin, bool busy_state, mp_float_t seconds_per_frame, bool chip_select, bool grayscale) {
     if (highlight_color != 0x000000) {
         self->core.colorspace.tricolor = true;
         self->core.colorspace.tricolor_hue = displayio_colorconverter_compute_hue(highlight_color);
@@ -97,16 +97,16 @@ void common_hal_displayio_epaperdisplay_construct(displayio_epaperdisplay_obj_t*
     common_hal_displayio_epaperdisplay_show(self, &circuitpython_splash);
 }
 
-bool common_hal_displayio_epaperdisplay_show(displayio_epaperdisplay_obj_t* self, displayio_group_t* root_group) {
+bool common_hal_displayio_epaperdisplay_show(displayio_epaperdisplay_obj_t *self, displayio_group_t *root_group) {
     return displayio_display_core_show(&self->core, root_group);
 }
 
-const displayio_area_t* displayio_epaperdisplay_get_refresh_areas(displayio_epaperdisplay_obj_t *self) {
+const displayio_area_t *displayio_epaperdisplay_get_refresh_areas(displayio_epaperdisplay_obj_t *self) {
     if (self->core.full_refresh) {
         self->core.area.next = NULL;
         return &self->core.area;
     }
-    const displayio_area_t* first_area = NULL;
+    const displayio_area_t *first_area = NULL;
     if (self->core.current_group != NULL) {
         first_area = displayio_group_get_refresh_areas(self->core.current_group, NULL);
     }
@@ -117,15 +117,15 @@ const displayio_area_t* displayio_epaperdisplay_get_refresh_areas(displayio_epap
     return first_area;
 }
 
-uint16_t common_hal_displayio_epaperdisplay_get_width(displayio_epaperdisplay_obj_t* self){
+uint16_t common_hal_displayio_epaperdisplay_get_width(displayio_epaperdisplay_obj_t *self) {
     return displayio_display_core_get_width(&self->core);
 }
 
-uint16_t common_hal_displayio_epaperdisplay_get_height(displayio_epaperdisplay_obj_t* self){
+uint16_t common_hal_displayio_epaperdisplay_get_height(displayio_epaperdisplay_obj_t *self) {
     return displayio_display_core_get_height(&self->core);
 }
 
-STATIC void wait_for_busy(displayio_epaperdisplay_obj_t* self) {
+STATIC void wait_for_busy(displayio_epaperdisplay_obj_t *self) {
     if (self->busy.base.type == &mp_type_NoneType) {
         return;
     }
@@ -134,8 +134,8 @@ STATIC void wait_for_busy(displayio_epaperdisplay_obj_t* self) {
     }
 }
 
-STATIC void send_command_sequence(displayio_epaperdisplay_obj_t* self,
-        bool should_wait_for_busy, const uint8_t* sequence, uint32_t sequence_len) {
+STATIC void send_command_sequence(displayio_epaperdisplay_obj_t *self,
+    bool should_wait_for_busy, const uint8_t *sequence, uint32_t sequence_len) {
     uint32_t i = 0;
     while (i < sequence_len) {
         const uint8_t *cmd = sequence + i;
@@ -163,7 +163,7 @@ STATIC void send_command_sequence(displayio_epaperdisplay_obj_t* self,
     }
 }
 
-void displayio_epaperdisplay_start_refresh(displayio_epaperdisplay_obj_t* self) {
+void displayio_epaperdisplay_start_refresh(displayio_epaperdisplay_obj_t *self) {
     // run start sequence
     self->core.bus_reset(self->core.bus);
 
@@ -171,7 +171,7 @@ void displayio_epaperdisplay_start_refresh(displayio_epaperdisplay_obj_t* self)
     displayio_display_core_start_refresh(&self->core);
 }
 
-uint32_t common_hal_displayio_epaperdisplay_get_time_to_refresh(displayio_epaperdisplay_obj_t* self) {
+uint32_t common_hal_displayio_epaperdisplay_get_time_to_refresh(displayio_epaperdisplay_obj_t *self) {
     if (self->core.last_refresh == 0) {
         return 0;
     }
@@ -183,7 +183,7 @@ uint32_t common_hal_displayio_epaperdisplay_get_time_to_refresh(displayio_epaper
     return self->milliseconds_per_frame - elapsed_time;
 }
 
-void displayio_epaperdisplay_finish_refresh(displayio_epaperdisplay_obj_t* self) {
+void displayio_epaperdisplay_finish_refresh(displayio_epaperdisplay_obj_t *self) {
     // Actually refresh the display now that all pixel RAM has been updated.
     displayio_display_core_begin_transaction(&self->core);
     self->core.send(self->core.bus, DISPLAY_COMMAND, self->chip_select, &self->refresh_display_command, 1);
@@ -194,14 +194,14 @@ void displayio_epaperdisplay_finish_refresh(displayio_epaperdisplay_obj_t* self)
     displayio_display_core_finish_refresh(&self->core);
 }
 
-mp_obj_t common_hal_displayio_epaperdisplay_get_bus(displayio_epaperdisplay_obj_t* self) {
+mp_obj_t common_hal_displayio_epaperdisplay_get_bus(displayio_epaperdisplay_obj_t *self) {
     return self->core.bus;
 }
 
-void common_hal_displayio_epaperdisplay_set_rotation(displayio_epaperdisplay_obj_t* self, int rotation){
+void common_hal_displayio_epaperdisplay_set_rotation(displayio_epaperdisplay_obj_t *self, int rotation) {
     bool transposed = (self->core.rotation == 90 || self->core.rotation == 270);
     bool will_transposed = (rotation == 90 || rotation == 270);
-    if(transposed != will_transposed) {
+    if (transposed != will_transposed) {
         int tmp = self->core.width;
         self->core.width = self->core.height;
         self->core.height = tmp;
@@ -216,12 +216,12 @@ void common_hal_displayio_epaperdisplay_set_rotation(displayio_epaperdisplay_obj
     }
 }
 
-uint16_t common_hal_displayio_epaperdisplay_get_rotation(displayio_epaperdisplay_obj_t* self){
+uint16_t common_hal_displayio_epaperdisplay_get_rotation(displayio_epaperdisplay_obj_t *self) {
     return self->core.rotation;
 }
 
 
-bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, const displayio_area_t* area) {
+bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t *self, const displayio_area_t *area) {
     uint16_t buffer_size = 128; // In uint32_ts
 
     displayio_area_t clipped;
@@ -264,8 +264,8 @@ bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, c
 
         if (self->set_row_window_command != NO_COMMAND) {
             displayio_display_core_set_region_to_update(&self->core, self->set_column_window_command,
-            self->set_row_window_command, self->set_current_column_command, self->set_current_row_command,
-            false, self->chip_select, &clipped, false /* SH1107_addressing */);
+                self->set_row_window_command, self->set_current_column_command, self->set_current_row_command,
+                false, self->chip_select, &clipped, false /* SH1107_addressing */);
         }
 
         uint8_t write_command = self->write_black_ram_command;
@@ -317,7 +317,7 @@ bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, c
                 // Can't acquire display bus; skip the rest of the data. Try next display.
                 return false;
             }
-            self->core.send(self->core.bus, DISPLAY_DATA, self->chip_select, (uint8_t*) buffer, subrectangle_size_bytes);
+            self->core.send(self->core.bus, DISPLAY_DATA, self->chip_select, (uint8_t *)buffer, subrectangle_size_bytes);
             displayio_display_core_end_transaction(&self->core);
 
             // TODO(tannewt): Make refresh displays faster so we don't starve other
@@ -329,7 +329,7 @@ bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, c
     return true;
 }
 
-bool common_hal_displayio_epaperdisplay_refresh(displayio_epaperdisplay_obj_t* self) {
+bool common_hal_displayio_epaperdisplay_refresh(displayio_epaperdisplay_obj_t *self) {
 
     if (self->refreshing && self->busy.base.type == &digitalio_digitalinout_type) {
         if (common_hal_digitalio_digitalinout_get_value(&self->busy) != self->busy_state) {
@@ -352,7 +352,7 @@ bool common_hal_displayio_epaperdisplay_refresh(displayio_epaperdisplay_obj_t* s
         // Can't acquire display bus; skip updating this display. Try next display.
         return false;
     }
-    const displayio_area_t* current_area = displayio_epaperdisplay_get_refresh_areas(self);
+    const displayio_area_t *current_area = displayio_epaperdisplay_get_refresh_areas(self);
     if (current_area == NULL) {
         return true;
     }
@@ -365,7 +365,7 @@ bool common_hal_displayio_epaperdisplay_refresh(displayio_epaperdisplay_obj_t* s
     return true;
 }
 
-void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t* self) {
+void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t *self) {
     if (self->refreshing) {
         bool refresh_done = false;
         if (self->busy.base.type == &digitalio_digitalinout_type) {
@@ -383,12 +383,12 @@ void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t* self) {
     }
 }
 
-bool common_hal_displayio_epaperdisplay_get_busy(displayio_epaperdisplay_obj_t* self) {
+bool common_hal_displayio_epaperdisplay_get_busy(displayio_epaperdisplay_obj_t *self) {
     displayio_epaperdisplay_background(self);
     return self->refreshing;
 }
 
-void release_epaperdisplay(displayio_epaperdisplay_obj_t* self) {
+void release_epaperdisplay(displayio_epaperdisplay_obj_t *self) {
     if (self->refreshing) {
         wait_for_busy(self);
         supervisor_disable_tick();
@@ -403,10 +403,10 @@ void release_epaperdisplay(displayio_epaperdisplay_obj_t* self) {
     }
 }
 
-void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t* self) {
+void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t *self) {
     displayio_display_core_collect_ptrs(&self->core);
-    gc_collect_ptr((void *) self->start_sequence);
-    gc_collect_ptr((void *) self->stop_sequence);
+    gc_collect_ptr((void *)self->start_sequence);
+    gc_collect_ptr((void *)self->stop_sequence);
 }
 
 bool maybe_refresh_epaperdisplay(void) {
@@ -416,7 +416,7 @@ bool maybe_refresh_epaperdisplay(void) {
             // Skip regular displays and those not showing the splash.
             continue;
         }
-        displayio_epaperdisplay_obj_t* display = &displays[i].epaper_display;
+        displayio_epaperdisplay_obj_t *display = &displays[i].epaper_display;
         if (common_hal_displayio_epaperdisplay_get_time_to_refresh(display) != 0) {
             return false;
         }
diff --git a/shared-module/displayio/EPaperDisplay.h b/shared-module/displayio/EPaperDisplay.h
index d0668ff44..988cc57fa 100644
--- a/shared-module/displayio/EPaperDisplay.h
+++ b/shared-module/displayio/EPaperDisplay.h
@@ -38,9 +38,9 @@ typedef struct {
     displayio_display_core_t core;
     digitalio_digitalinout_obj_t busy;
     uint32_t milliseconds_per_frame;
-    const uint8_t* start_sequence;
+    const uint8_t *start_sequence;
     uint32_t start_sequence_len;
-    const uint8_t* stop_sequence;
+    const uint8_t *stop_sequence;
     uint32_t stop_sequence_len;
     uint16_t refresh_time;
     uint16_t set_column_window_command;
@@ -59,10 +59,10 @@ typedef struct {
     display_chip_select_behavior_t chip_select;
 } displayio_epaperdisplay_obj_t;
 
-void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t* self);
-void release_epaperdisplay(displayio_epaperdisplay_obj_t* self);
+void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t *self);
+void release_epaperdisplay(displayio_epaperdisplay_obj_t *self);
 bool maybe_refresh_epaperdisplay(void);
 
-void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t* self);
+void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t *self);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_EPAPERDISPLAY_H
diff --git a/shared-module/displayio/FourWire.c b/shared-module/displayio/FourWire.c
index e993f2480..59e2021bd 100644
--- a/shared-module/displayio/FourWire.c
+++ b/shared-module/displayio/FourWire.c
@@ -36,9 +36,9 @@
 #include "shared-bindings/time/__init__.h"
 #include "shared-module/displayio/display_core.h"
 
-void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self,
-    busio_spi_obj_t* spi, const mcu_pin_obj_t* command,
-    const mcu_pin_obj_t* chip_select, const mcu_pin_obj_t* reset, uint32_t baudrate,
+void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t *self,
+    busio_spi_obj_t *spi, const mcu_pin_obj_t *command,
+    const mcu_pin_obj_t *chip_select, const mcu_pin_obj_t *reset, uint32_t baudrate,
     uint8_t polarity, uint8_t phase) {
 
     self->bus = spi;
@@ -69,7 +69,7 @@ void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self,
     common_hal_never_reset_pin(chip_select);
 }
 
-void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t* self) {
+void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t *self) {
     if (self->bus == &self->inline_bus) {
         common_hal_busio_spi_deinit(self->bus);
     }
@@ -80,7 +80,7 @@ void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t* self) {
 }
 
 bool common_hal_displayio_fourwire_reset(mp_obj_t obj) {
-    displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj);
     if (self->reset.base.type == &mp_type_NoneType) {
         return false;
     }
@@ -92,7 +92,7 @@ bool common_hal_displayio_fourwire_reset(mp_obj_t obj) {
 }
 
 bool common_hal_displayio_fourwire_bus_free(mp_obj_t obj) {
-    displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj);
     if (!common_hal_busio_spi_try_lock(self->bus)) {
         return false;
     }
@@ -101,19 +101,19 @@ bool common_hal_displayio_fourwire_bus_free(mp_obj_t obj) {
 }
 
 bool common_hal_displayio_fourwire_begin_transaction(mp_obj_t obj) {
-    displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj);
     if (!common_hal_busio_spi_try_lock(self->bus)) {
         return false;
     }
     common_hal_busio_spi_configure(self->bus, self->frequency, self->polarity,
-                                   self->phase, 8);
+        self->phase, 8);
     common_hal_digitalio_digitalinout_set_value(&self->chip_select, false);
     return true;
 }
 
 void common_hal_displayio_fourwire_send(mp_obj_t obj, display_byte_type_t data_type,
-        display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) {
-    displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
+    display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) {
+    displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj);
     common_hal_digitalio_digitalinout_set_value(&self->command, data_type == DISPLAY_DATA);
     if (chip_select == CHIP_SELECT_TOGGLE_EVERY_BYTE) {
         // Toggle chip select after each command byte in case the display driver
@@ -130,7 +130,7 @@ void common_hal_displayio_fourwire_send(mp_obj_t obj, display_byte_type_t data_t
 }
 
 void common_hal_displayio_fourwire_end_transaction(mp_obj_t obj) {
-    displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj);
     common_hal_digitalio_digitalinout_set_value(&self->chip_select, true);
     common_hal_busio_spi_unlock(self->bus);
 }
diff --git a/shared-module/displayio/FourWire.h b/shared-module/displayio/FourWire.h
index a4260a3ac..b28c1ef84 100644
--- a/shared-module/displayio/FourWire.h
+++ b/shared-module/displayio/FourWire.h
@@ -33,7 +33,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    busio_spi_obj_t* bus;
+    busio_spi_obj_t *bus;
     busio_spi_obj_t inline_bus;
     digitalio_digitalinout_obj_t command;
     digitalio_digitalinout_obj_t chip_select;
diff --git a/shared-module/displayio/Group.c b/shared-module/displayio/Group.c
index a36acc1c3..c50f034bf 100644
--- a/shared-module/displayio/Group.c
+++ b/shared-module/displayio/Group.c
@@ -35,16 +35,16 @@
 #endif
 
 
-void common_hal_displayio_group_construct(displayio_group_t* self, uint32_t scale, mp_int_t x, mp_int_t y) {
+void common_hal_displayio_group_construct(displayio_group_t *self, uint32_t scale, mp_int_t x, mp_int_t y) {
     mp_obj_list_t *members = mp_obj_new_list(0, NULL);
     displayio_group_construct(self, members, scale, x, y);
 }
 
-bool common_hal_displayio_group_get_hidden(displayio_group_t* self) {
+bool common_hal_displayio_group_get_hidden(displayio_group_t *self) {
     return self->hidden;
 }
 
-void common_hal_displayio_group_set_hidden(displayio_group_t* self, bool hidden) {
+void common_hal_displayio_group_set_hidden(displayio_group_t *self, bool hidden) {
     if (self->hidden == hidden) {
         return;
     }
@@ -95,11 +95,11 @@ void displayio_group_set_hidden_by_parent(displayio_group_t *self, bool hidden)
     }
 }
 
-uint32_t common_hal_displayio_group_get_scale(displayio_group_t* self) {
+uint32_t common_hal_displayio_group_get_scale(displayio_group_t *self) {
     return self->scale;
 }
 
-bool displayio_group_get_previous_area(displayio_group_t *self, displayio_area_t* area) {
+bool displayio_group_get_previous_area(displayio_group_t *self, displayio_area_t *area) {
     bool first = true;
     for (size_t i = 0; i < self->members->len; i++) {
         mp_obj_t layer;
@@ -137,20 +137,20 @@ bool displayio_group_get_previous_area(displayio_group_t *self, displayio_area_t
     return !first;
 }
 
-static void _update_child_transforms(displayio_group_t* self) {
+static void _update_child_transforms(displayio_group_t *self) {
     if (!self->in_group) {
         return;
     }
     for (size_t i = 0; i < self->members->len; i++) {
         mp_obj_t layer;
-#if CIRCUITPY_VECTORIO
+        #if CIRCUITPY_VECTORIO
         layer = mp_instance_cast_to_native_base(
             self->members->items[i], &vectorio_vector_shape_type);
         if (layer != MP_OBJ_NULL) {
             vectorio_vector_shape_update_transform(layer, &self->absolute_transform);
             continue;
         }
-#endif
+        #endif
         layer = mp_instance_cast_to_native_base(
             self->members->items[i], &displayio_tilegrid_type);
         if (layer != MP_OBJ_NULL) {
@@ -167,7 +167,7 @@ static void _update_child_transforms(displayio_group_t* self) {
 }
 
 void displayio_group_update_transform(displayio_group_t *self,
-                                      const displayio_buffer_transform_t* parent_transform) {
+    const displayio_buffer_transform_t *parent_transform) {
     self->in_group = parent_transform != NULL;
     if (self->in_group) {
         int16_t x = self->x;
@@ -189,7 +189,7 @@ void displayio_group_update_transform(displayio_group_t *self,
     _update_child_transforms(self);
 }
 
-void common_hal_displayio_group_set_scale(displayio_group_t* self, uint32_t scale) {
+void common_hal_displayio_group_set_scale(displayio_group_t *self, uint32_t scale) {
     if (self->scale == scale) {
         return;
     }
@@ -201,18 +201,18 @@ void common_hal_displayio_group_set_scale(displayio_group_t* self, uint32_t scal
     _update_child_transforms(self);
 }
 
-mp_int_t common_hal_displayio_group_get_x(displayio_group_t* self) {
+mp_int_t common_hal_displayio_group_get_x(displayio_group_t *self) {
     return self->x;
 }
 
-void common_hal_displayio_group_set_x(displayio_group_t* self, mp_int_t x) {
+void common_hal_displayio_group_set_x(displayio_group_t *self, mp_int_t x) {
     if (self->x == x) {
         return;
     }
     if (self->absolute_transform.transpose_xy) {
         int16_t dy = self->absolute_transform.dy / self->scale;
         self->absolute_transform.y += dy * (x - self->x);
-    } else  {
+    } else {
         int16_t dx = self->absolute_transform.dx / self->scale;
         self->absolute_transform.x += dx * (x - self->x);
     }
@@ -221,18 +221,18 @@ void common_hal_displayio_group_set_x(displayio_group_t* self, mp_int_t x) {
     _update_child_transforms(self);
 }
 
-mp_int_t common_hal_displayio_group_get_y(displayio_group_t* self) {
+mp_int_t common_hal_displayio_group_get_y(displayio_group_t *self) {
     return self->y;
 }
 
-void common_hal_displayio_group_set_y(displayio_group_t* self, mp_int_t y) {
+void common_hal_displayio_group_set_y(displayio_group_t *self, mp_int_t y) {
     if (self->y == y) {
         return;
     }
     if (self->absolute_transform.transpose_xy) {
         int8_t dx = self->absolute_transform.dx / self->scale;
         self->absolute_transform.x += dx * (y - self->y);
-    } else  {
+    } else {
         int8_t dy = self->absolute_transform.dy / self->scale;
         self->absolute_transform.y += dy * (y - self->y);
     }
@@ -240,18 +240,18 @@ void common_hal_displayio_group_set_y(displayio_group_t* self, mp_int_t y) {
     _update_child_transforms(self);
 }
 
-static void _add_layer(displayio_group_t* self, mp_obj_t layer) {
+static void _add_layer(displayio_group_t *self, mp_obj_t layer) {
     mp_obj_t native_layer;
-#if CIRCUITPY_VECTORIO
+    #if CIRCUITPY_VECTORIO
     native_layer = mp_instance_cast_to_native_base(layer, &vectorio_vector_shape_type);
     if (native_layer != MP_OBJ_NULL) {
         vectorio_vector_shape_update_transform(native_layer, &self->absolute_transform);
         return;
     }
-#endif
+    #endif
     native_layer = mp_instance_cast_to_native_base(layer, &displayio_tilegrid_type);
     if (native_layer != MP_OBJ_NULL) {
-        displayio_tilegrid_t* tilegrid = native_layer;
+        displayio_tilegrid_t *tilegrid = native_layer;
         if (tilegrid->in_group) {
             mp_raise_ValueError(translate("Layer already in a group."));
         } else {
@@ -262,7 +262,7 @@ static void _add_layer(displayio_group_t* self, mp_obj_t layer) {
     }
     native_layer = mp_instance_cast_to_native_base(layer, &displayio_group_type);
     if (native_layer != MP_OBJ_NULL) {
-        displayio_group_t* group = native_layer;
+        displayio_group_t *group = native_layer;
         if (group->in_group) {
             mp_raise_ValueError(translate("Layer already in a group."));
         } else {
@@ -274,11 +274,11 @@ static void _add_layer(displayio_group_t* self, mp_obj_t layer) {
     mp_raise_ValueError(translate("Layer must be a Group or TileGrid subclass."));
 }
 
-static void _remove_layer(displayio_group_t* self, size_t index) {
+static void _remove_layer(displayio_group_t *self, size_t index) {
     mp_obj_t layer;
     displayio_area_t layer_area;
     bool rendered_last_frame = false;
-#if CIRCUITPY_VECTORIO
+    #if CIRCUITPY_VECTORIO
     layer = mp_instance_cast_to_native_base(
         self->members->items[index], &vectorio_vector_shape_type);
     if (layer != MP_OBJ_NULL) {
@@ -286,18 +286,18 @@ static void _remove_layer(displayio_group_t* self, size_t index) {
         rendered_last_frame = has_dirty_area;
         vectorio_vector_shape_update_transform(layer, NULL);
     }
-#endif
+    #endif
     layer = mp_instance_cast_to_native_base(
         self->members->items[index], &displayio_tilegrid_type);
     if (layer != MP_OBJ_NULL) {
-        displayio_tilegrid_t* tilegrid = layer;
+        displayio_tilegrid_t *tilegrid = layer;
         rendered_last_frame = displayio_tilegrid_get_previous_area(tilegrid, &layer_area);
         displayio_tilegrid_update_transform(tilegrid, NULL);
     }
     layer = mp_instance_cast_to_native_base(
         self->members->items[index], &displayio_group_type);
     if (layer != MP_OBJ_NULL) {
-        displayio_group_t* group = layer;
+        displayio_group_t *group = layer;
         rendered_last_frame = displayio_group_get_previous_area(group, &layer_area);
         displayio_group_update_transform(group, NULL);
     }
@@ -312,38 +312,38 @@ static void _remove_layer(displayio_group_t* self, size_t index) {
     self->item_removed = true;
 }
 
-void common_hal_displayio_group_insert(displayio_group_t* self, size_t index, mp_obj_t layer) {
+void common_hal_displayio_group_insert(displayio_group_t *self, size_t index, mp_obj_t layer) {
     _add_layer(self, layer);
     mp_obj_list_insert(self->members, index, layer);
 }
 
-mp_obj_t common_hal_displayio_group_pop(displayio_group_t* self, size_t index) {
+mp_obj_t common_hal_displayio_group_pop(displayio_group_t *self, size_t index) {
     _remove_layer(self, index);
     return mp_obj_list_pop(self->members, index);
 }
 
-mp_int_t common_hal_displayio_group_index(displayio_group_t* self, mp_obj_t layer) {
+mp_int_t common_hal_displayio_group_index(displayio_group_t *self, mp_obj_t layer) {
     mp_obj_t args[] = {self->members, layer};
     mp_obj_t *index = mp_seq_index_obj(
         self->members->items, self->members->len, 2, args);
     return MP_OBJ_SMALL_INT_VALUE(index);
 }
 
-size_t common_hal_displayio_group_get_len(displayio_group_t* self) {
+size_t common_hal_displayio_group_get_len(displayio_group_t *self) {
     return self->members->len;
 }
 
-mp_obj_t common_hal_displayio_group_get(displayio_group_t* self, size_t index) {
+mp_obj_t common_hal_displayio_group_get(displayio_group_t *self, size_t index) {
     return self->members->items[index];
 }
 
-void common_hal_displayio_group_set(displayio_group_t* self, size_t index, mp_obj_t layer) {
+void common_hal_displayio_group_set(displayio_group_t *self, size_t index, mp_obj_t layer) {
     _add_layer(self, layer);
     _remove_layer(self, index);
     mp_obj_list_store(self->members, MP_OBJ_NEW_SMALL_INT(index), layer);
 }
 
-void displayio_group_construct(displayio_group_t* self, mp_obj_list_t* members, uint32_t scale, mp_int_t x, mp_int_t y) {
+void displayio_group_construct(displayio_group_t *self, mp_obj_list_t *members, uint32_t scale, mp_int_t x, mp_int_t y) {
     self->x = x;
     self->y = y;
     self->members = members;
@@ -352,12 +352,12 @@ void displayio_group_construct(displayio_group_t* self, mp_obj_list_t* members,
     self->in_group = false;
 }
 
-bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t* buffer) {
+bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer) {
     // Track if any of the layers finishes filling in the given area. We can ignore any remaining
     // layers at that point.
-    for (int32_t i = self->members->len - 1; i >= 0 ; i--) {
+    for (int32_t i = self->members->len - 1; i >= 0; i--) {
         mp_obj_t layer;
-#if CIRCUITPY_VECTORIO
+        #if CIRCUITPY_VECTORIO
         layer = mp_instance_cast_to_native_base(
             self->members->items[i], &vectorio_vector_shape_type);
         if (layer != MP_OBJ_NULL) {
@@ -366,7 +366,7 @@ bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorsp
             }
             continue;
         }
-#endif
+        #endif
         layer = mp_instance_cast_to_native_base(
             self->members->items[i], &displayio_tilegrid_type);
         if (layer != MP_OBJ_NULL) {
@@ -389,16 +389,16 @@ bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorsp
 
 void displayio_group_finish_refresh(displayio_group_t *self) {
     self->item_removed = false;
-    for (int32_t i = self->members->len - 1; i >= 0 ; i--) {
+    for (int32_t i = self->members->len - 1; i >= 0; i--) {
         mp_obj_t layer;
-#if CIRCUITPY_VECTORIO
+        #if CIRCUITPY_VECTORIO
         layer = mp_instance_cast_to_native_base(
             self->members->items[i], &vectorio_vector_shape_type);
         if (layer != MP_OBJ_NULL) {
             vectorio_vector_shape_finish_refresh(layer);
             continue;
         }
-#endif
+        #endif
         layer = mp_instance_cast_to_native_base(
             self->members->items[i], &displayio_tilegrid_type);
         if (layer != MP_OBJ_NULL) {
@@ -414,22 +414,22 @@ void displayio_group_finish_refresh(displayio_group_t *self) {
     }
 }
 
-displayio_area_t* displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t* tail) {
+displayio_area_t *displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t *tail) {
     if (self->item_removed) {
         self->dirty_area.next = tail;
         tail = &self->dirty_area;
     }
 
-    for (int32_t i = self->members->len - 1; i >= 0 ; i--) {
+    for (int32_t i = self->members->len - 1; i >= 0; i--) {
         mp_obj_t layer;
-#if CIRCUITPY_VECTORIO
+        #if CIRCUITPY_VECTORIO
         layer = mp_instance_cast_to_native_base(
             self->members->items[i], &vectorio_vector_shape_type);
         if (layer != MP_OBJ_NULL) {
             tail = vectorio_vector_shape_get_refresh_areas(layer, tail);
             continue;
         }
-#endif
+        #endif
         layer = mp_instance_cast_to_native_base(
             self->members->items[i], &displayio_tilegrid_type);
         if (layer != MP_OBJ_NULL) {
diff --git a/shared-module/displayio/Group.h b/shared-module/displayio/Group.h
index 0964e0a0b..f68422315 100644
--- a/shared-module/displayio/Group.h
+++ b/shared-module/displayio/Group.h
@@ -43,19 +43,19 @@ typedef struct {
     int16_t x;
     int16_t y;
     uint16_t scale;
-    bool item_removed :1;
-    bool in_group :1;
-    bool hidden :1;
-    bool hidden_by_parent :1;
-    uint8_t padding :4;
+    bool item_removed : 1;
+    bool in_group : 1;
+    bool hidden : 1;
+    bool hidden_by_parent : 1;
+    uint8_t padding : 4;
 } displayio_group_t;
 
-void displayio_group_construct(displayio_group_t* self, mp_obj_list_t* members, uint32_t scale, mp_int_t x, mp_int_t y);
+void displayio_group_construct(displayio_group_t *self, mp_obj_list_t *members, uint32_t scale, mp_int_t x, mp_int_t y);
 void displayio_group_set_hidden_by_parent(displayio_group_t *self, bool hidden);
-bool displayio_group_get_previous_area(displayio_group_t *group, displayio_area_t* area);
-bool displayio_group_fill_area(displayio_group_t *group, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer);
-void displayio_group_update_transform(displayio_group_t *group, const displayio_buffer_transform_t* parent_transform);
+bool displayio_group_get_previous_area(displayio_group_t *group, displayio_area_t *area);
+bool displayio_group_fill_area(displayio_group_t *group, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer);
+void displayio_group_update_transform(displayio_group_t *group, const displayio_buffer_transform_t *parent_transform);
 void displayio_group_finish_refresh(displayio_group_t *self);
-displayio_area_t* displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t* tail);
+displayio_area_t *displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t *tail);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_GROUP_H
diff --git a/shared-module/displayio/I2CDisplay.c b/shared-module/displayio/I2CDisplay.c
index cc811e83d..6446e3198 100644
--- a/shared-module/displayio/I2CDisplay.c
+++ b/shared-module/displayio/I2CDisplay.c
@@ -38,8 +38,8 @@
 #include "shared-bindings/time/__init__.h"
 #include "shared-module/displayio/display_core.h"
 
-void common_hal_displayio_i2cdisplay_construct(displayio_i2cdisplay_obj_t* self,
-    busio_i2c_obj_t* i2c, uint16_t device_address, const mcu_pin_obj_t* reset) {
+void common_hal_displayio_i2cdisplay_construct(displayio_i2cdisplay_obj_t *self,
+    busio_i2c_obj_t *i2c, uint16_t device_address, const mcu_pin_obj_t *reset) {
 
     // Reset the display before probing
     self->reset.base.type = &mp_type_NoneType;
@@ -67,7 +67,7 @@ void common_hal_displayio_i2cdisplay_construct(displayio_i2cdisplay_obj_t* self,
     self->address = device_address;
 }
 
-void common_hal_displayio_i2cdisplay_deinit(displayio_i2cdisplay_obj_t* self) {
+void common_hal_displayio_i2cdisplay_deinit(displayio_i2cdisplay_obj_t *self) {
     if (self->bus == &self->inline_bus) {
         common_hal_busio_i2c_deinit(self->bus);
     }
@@ -78,7 +78,7 @@ void common_hal_displayio_i2cdisplay_deinit(displayio_i2cdisplay_obj_t* self) {
 }
 
 bool common_hal_displayio_i2cdisplay_reset(mp_obj_t obj) {
-    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj);
     if (self->reset.base.type == &mp_type_NoneType) {
         return false;
     }
@@ -90,7 +90,7 @@ bool common_hal_displayio_i2cdisplay_reset(mp_obj_t obj) {
 }
 
 bool common_hal_displayio_i2cdisplay_bus_free(mp_obj_t obj) {
-    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj);
     if (!common_hal_busio_i2c_try_lock(self->bus)) {
         return false;
     }
@@ -99,13 +99,13 @@ bool common_hal_displayio_i2cdisplay_bus_free(mp_obj_t obj) {
 }
 
 bool common_hal_displayio_i2cdisplay_begin_transaction(mp_obj_t obj) {
-    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj);
     return common_hal_busio_i2c_try_lock(self->bus);
 }
 
 void common_hal_displayio_i2cdisplay_send(mp_obj_t obj, display_byte_type_t data_type,
-        display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) {
-    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) {
+    displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj);
     if (data_type == DISPLAY_COMMAND) {
         uint8_t command_bytes[2 * data_length];
         for (uint32_t i = 0; i < data_length; i++) {
@@ -122,6 +122,6 @@ void common_hal_displayio_i2cdisplay_send(mp_obj_t obj, display_byte_type_t data
 }
 
 void common_hal_displayio_i2cdisplay_end_transaction(mp_obj_t obj) {
-    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj);
     common_hal_busio_i2c_unlock(self->bus);
 }
diff --git a/shared-module/displayio/I2CDisplay.h b/shared-module/displayio/I2CDisplay.h
index 4636c3f73..cc5bcf1eb 100644
--- a/shared-module/displayio/I2CDisplay.h
+++ b/shared-module/displayio/I2CDisplay.h
@@ -32,7 +32,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    busio_i2c_obj_t* bus;
+    busio_i2c_obj_t *bus;
     busio_i2c_obj_t inline_bus;
     digitalio_digitalinout_obj_t reset;
     uint16_t address;
diff --git a/shared-module/displayio/OnDiskBitmap.c b/shared-module/displayio/OnDiskBitmap.c
index c1a0ddeb7..5c7e00a58 100644
--- a/shared-module/displayio/OnDiskBitmap.c
+++ b/shared-module/displayio/OnDiskBitmap.c
@@ -31,11 +31,11 @@
 #include "py/mperrno.h"
 #include "py/runtime.h"
 
-static uint32_t read_word(uint16_t* bmp_header, uint16_t index) {
+static uint32_t read_word(uint16_t *bmp_header, uint16_t index) {
     return bmp_header[index] | bmp_header[index + 1] << 16;
 }
 
-void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self, pyb_file_obj_t* file) {
+void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self, pyb_file_obj_t *file) {
     // Load the wave
     self->file = file;
     uint16_t bmp_header[69];
@@ -58,12 +58,12 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self,
     uint32_t number_of_colors = read_word(bmp_header, 23);
 
     bool indexed = bits_per_pixel <= 8;
-    self->bitfield_compressed  = (compression == 3);
+    self->bitfield_compressed = (compression == 3);
     self->bits_per_pixel = bits_per_pixel;
     self->width = read_word(bmp_header, 9);
     self->height = read_word(bmp_header, 11);
 
-    if (bits_per_pixel == 16){
+    if (bits_per_pixel == 16) {
         if (((header_size >= 56)) || (self->bitfield_compressed)) {
             self->r_bitmask = read_word(bmp_header, 27);
             self->g_bitmask = read_word(bmp_header, 29);
@@ -101,9 +101,9 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self,
         mp_raise_ValueError_varg(translate("Only monochrome, indexed 4bpp or 8bpp, and 16bpp or greater BMPs supported: %d bpp given"), bits_per_pixel);
     }
 
-    uint8_t bytes_per_pixel = (self->bits_per_pixel / 8)  ? (self->bits_per_pixel /8) : 1;
+    uint8_t bytes_per_pixel = (self->bits_per_pixel / 8)  ? (self->bits_per_pixel / 8) : 1;
     uint8_t pixels_per_byte = 8 / self->bits_per_pixel;
-    if (pixels_per_byte == 0){
+    if (pixels_per_byte == 0) {
         self->stride = (self->width * bytes_per_pixel);
         // Rows are word aligned.
         if (self->stride % 4 != 0) {
@@ -121,15 +121,15 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self,
 
 
 uint32_t common_hal_displayio_ondiskbitmap_get_pixel(displayio_ondiskbitmap_t *self,
-        int16_t x, int16_t y) {
+    int16_t x, int16_t y) {
     if (x < 0 || x >= self->width || y < 0 || y >= self->height) {
         return 0;
     }
 
     uint32_t location;
-    uint8_t bytes_per_pixel = (self->bits_per_pixel / 8)  ? (self->bits_per_pixel /8) : 1;
+    uint8_t bytes_per_pixel = (self->bits_per_pixel / 8)  ? (self->bits_per_pixel / 8) : 1;
     uint8_t pixels_per_byte = 8 / self->bits_per_pixel;
-    if (pixels_per_byte == 0){
+    if (pixels_per_byte == 0) {
         location = self->data_offset + (self->height - y - 1) * self->stride + x * bytes_per_pixel;
     } else {
         location = self->data_offset + (self->height - y - 1) * self->stride + x / pixels_per_byte;
@@ -159,12 +159,12 @@ uint32_t common_hal_displayio_ondiskbitmap_get_pixel(displayio_ondiskbitmap_t *s
             return self->palette_data[index];
         } else if (bytes_per_pixel == 2) {
             if (self->g_bitmask == 0x07e0) { // 565
-                red =((pixel_data & self->r_bitmask) >>11);
-                green = ((pixel_data & self->g_bitmask) >>5);
+                red = ((pixel_data & self->r_bitmask) >> 11);
+                green = ((pixel_data & self->g_bitmask) >> 5);
                 blue = ((pixel_data & self->b_bitmask) >> 0);
             } else { // 555
-                red =((pixel_data & self->r_bitmask) >>10);
-                green = ((pixel_data & self->g_bitmask) >>4);
+                red = ((pixel_data & self->r_bitmask) >> 10);
+                green = ((pixel_data & self->g_bitmask) >> 4);
                 blue = ((pixel_data & self->b_bitmask) >> 0);
             }
             tmp = (red << 19 | green << 10 | blue << 3);
diff --git a/shared-module/displayio/OnDiskBitmap.h b/shared-module/displayio/OnDiskBitmap.h
index 28426f11b..610b11491 100644
--- a/shared-module/displayio/OnDiskBitmap.h
+++ b/shared-module/displayio/OnDiskBitmap.h
@@ -44,9 +44,9 @@ typedef struct {
     uint32_t g_bitmask;
     uint32_t b_bitmask;
     bool bitfield_compressed;
-    pyb_file_obj_t* file;
+    pyb_file_obj_t *file;
     uint8_t bits_per_pixel;
-    uint32_t* palette_data;
+    uint32_t *palette_data;
 } displayio_ondiskbitmap_t;
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_ONDISKBITMAP_H
diff --git a/shared-module/displayio/Palette.c b/shared-module/displayio/Palette.c
index ba5ff665c..6dde3a80f 100644
--- a/shared-module/displayio/Palette.c
+++ b/shared-module/displayio/Palette.c
@@ -28,26 +28,26 @@
 
 #include "shared-module/displayio/ColorConverter.h"
 
-void common_hal_displayio_palette_construct(displayio_palette_t* self, uint16_t color_count) {
+void common_hal_displayio_palette_construct(displayio_palette_t *self, uint16_t color_count) {
     self->color_count = color_count;
-    self->colors = (_displayio_color_t *) m_malloc(color_count * sizeof(_displayio_color_t), false);
+    self->colors = (_displayio_color_t *)m_malloc(color_count * sizeof(_displayio_color_t), false);
 }
 
-void common_hal_displayio_palette_make_opaque(displayio_palette_t* self, uint32_t palette_index) {
+void common_hal_displayio_palette_make_opaque(displayio_palette_t *self, uint32_t palette_index) {
     self->colors[palette_index].transparent = false;
     self->needs_refresh = true;
 }
 
-void common_hal_displayio_palette_make_transparent(displayio_palette_t* self, uint32_t palette_index) {
+void common_hal_displayio_palette_make_transparent(displayio_palette_t *self, uint32_t palette_index) {
     self->colors[palette_index].transparent = true;
     self->needs_refresh = true;
 }
 
-uint32_t common_hal_displayio_palette_get_len(displayio_palette_t* self) {
+uint32_t common_hal_displayio_palette_get_len(displayio_palette_t *self) {
     return self->color_count;
 }
 
-void common_hal_displayio_palette_set_color(displayio_palette_t* self, uint32_t palette_index, uint32_t color) {
+void common_hal_displayio_palette_set_color(displayio_palette_t *self, uint32_t palette_index, uint32_t color) {
     if (self->colors[palette_index].rgb888 == color) {
         return;
     }
@@ -61,11 +61,11 @@ void common_hal_displayio_palette_set_color(displayio_palette_t* self, uint32_t
     self->needs_refresh = true;
 }
 
-uint32_t common_hal_displayio_palette_get_color(displayio_palette_t* self, uint32_t palette_index) {
+uint32_t common_hal_displayio_palette_get_color(displayio_palette_t *self, uint32_t palette_index) {
     return self->colors[palette_index].rgb888;
 }
 
-bool displayio_palette_get_color(displayio_palette_t *self, const _displayio_colorspace_t* colorspace, uint32_t palette_index, uint32_t* color) {
+bool displayio_palette_get_color(displayio_palette_t *self, const _displayio_colorspace_t *colorspace, uint32_t palette_index, uint32_t *color) {
     if (palette_index > self->color_count || self->colors[palette_index].transparent) {
         return false; // returns opaque
     }
@@ -74,7 +74,7 @@ bool displayio_palette_get_color(displayio_palette_t *self, const _displayio_col
         uint8_t luma = self->colors[palette_index].luma;
         *color = luma >> (8 - colorspace->depth);
         // Chroma 0 means the color is a gray and has no hue so never color based on it.
-        if (self->colors[palette_index].chroma  <= 16) {
+        if (self->colors[palette_index].chroma <= 16) {
             if (!colorspace->grayscale) {
                 *color = 0;
             }
diff --git a/shared-module/displayio/Palette.h b/shared-module/displayio/Palette.h
index 993912cc5..82504b7ed 100644
--- a/shared-module/displayio/Palette.h
+++ b/shared-module/displayio/Palette.h
@@ -71,14 +71,14 @@ typedef struct {
 
 typedef struct {
     mp_obj_base_t base;
-    _displayio_color_t* colors;
+    _displayio_color_t *colors;
     uint32_t color_count;
     bool needs_refresh;
 } displayio_palette_t;
 
 // Returns false if color fetch did not succeed (out of range or transparent).
 // Returns true if color is opaque, and sets color.
-bool displayio_palette_get_color(displayio_palette_t *palette, const _displayio_colorspace_t* colorspace, uint32_t palette_index, uint32_t* color);
+bool displayio_palette_get_color(displayio_palette_t *palette, const _displayio_colorspace_t *colorspace, uint32_t palette_index, uint32_t *color);
 bool displayio_palette_needs_refresh(displayio_palette_t *self);
 void displayio_palette_finish_refresh(displayio_palette_t *self);
 
diff --git a/shared-module/displayio/Shape.c b/shared-module/displayio/Shape.c
index b94a392bc..4a32c7a60 100644
--- a/shared-module/displayio/Shape.c
+++ b/shared-module/displayio/Shape.c
@@ -56,10 +56,10 @@ void common_hal_displayio_shape_construct(displayio_shape_t *self, uint32_t widt
         self->data[2 * i + 1] = width;
     }
 
-    self->dirty_area.x1=0;
-    self->dirty_area.x2=width;
-    self->dirty_area.y1=0;
-    self->dirty_area.y2=height;
+    self->dirty_area.x1 = 0;
+    self->dirty_area.x2 = width;
+    self->dirty_area.y1 = 0;
+    self->dirty_area.y2 = height;
 }
 
 void common_hal_displayio_shape_set_boundary(displayio_shape_t *self, uint16_t y, uint16_t start_x, uint16_t end_x) {
@@ -130,7 +130,7 @@ uint32_t common_hal_displayio_shape_get_pixel(void *obj, int16_t x, int16_t y) {
     return 1;
 }
 
-displayio_area_t* displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t* tail) {
+displayio_area_t *displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t *tail) {
     if (self->dirty_area.x1 == self->dirty_area.x2) {
         return tail;
     }
diff --git a/shared-module/displayio/Shape.h b/shared-module/displayio/Shape.h
index e59ad586e..2cac5d73b 100644
--- a/shared-module/displayio/Shape.h
+++ b/shared-module/displayio/Shape.h
@@ -39,13 +39,13 @@ typedef struct {
     uint16_t height;
     uint16_t half_width;
     uint16_t half_height;
-    uint16_t* data;
+    uint16_t *data;
     bool mirror_x;
     bool mirror_y;
     displayio_area_t dirty_area;
 } displayio_shape_t;
 
 void displayio_shape_finish_refresh(displayio_shape_t *self);
-displayio_area_t* displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t* tail);
+displayio_area_t *displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t *tail);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_SHAPE_H
diff --git a/shared-module/displayio/TileGrid.c b/shared-module/displayio/TileGrid.c
index 96473d4a8..347eba577 100644
--- a/shared-module/displayio/TileGrid.c
+++ b/shared-module/displayio/TileGrid.c
@@ -34,21 +34,21 @@
 #include "shared-bindings/displayio/Shape.h"
 
 void common_hal_displayio_tilegrid_construct(displayio_tilegrid_t *self, mp_obj_t bitmap,
-        uint16_t bitmap_width_in_tiles, uint16_t bitmap_height_in_tiles,
-        mp_obj_t pixel_shader, uint16_t width, uint16_t height,
-        uint16_t tile_width, uint16_t tile_height, uint16_t x, uint16_t y, uint8_t default_tile) {
+    uint16_t bitmap_width_in_tiles, uint16_t bitmap_height_in_tiles,
+    mp_obj_t pixel_shader, uint16_t width, uint16_t height,
+    uint16_t tile_width, uint16_t tile_height, uint16_t x, uint16_t y, uint8_t default_tile) {
     uint32_t total_tiles = width * height;
     // Sprites will only have one tile so save a little memory by inlining values in the pointer.
-    uint8_t inline_tiles = sizeof(uint8_t*);
+    uint8_t inline_tiles = sizeof(uint8_t *);
     if (total_tiles <= inline_tiles) {
         self->tiles = 0;
         // Pack values into the pointer since there are only a few.
         for (uint32_t i = 0; i < inline_tiles; i++) {
-            ((uint8_t*) &self->tiles)[i] = default_tile;
+            ((uint8_t *)&self->tiles)[i] = default_tile;
         }
         self->inline_tiles = true;
     } else {
-        self->tiles = (uint8_t*) m_malloc(total_tiles, false);
+        self->tiles = (uint8_t *)m_malloc(total_tiles, false);
         for (uint32_t i = 0; i < total_tiles; i++) {
             self->tiles[i] = default_tile;
         }
@@ -78,25 +78,25 @@ void common_hal_displayio_tilegrid_construct(displayio_tilegrid_t *self, mp_obj_
 }
 
 
-bool common_hal_displayio_tilegrid_get_hidden(displayio_tilegrid_t* self) {
+bool common_hal_displayio_tilegrid_get_hidden(displayio_tilegrid_t *self) {
     return self->hidden;
 }
 
-void common_hal_displayio_tilegrid_set_hidden(displayio_tilegrid_t* self, bool hidden) {
+void common_hal_displayio_tilegrid_set_hidden(displayio_tilegrid_t *self, bool hidden) {
     self->hidden = hidden;
-    if(!hidden){
+    if (!hidden) {
         self->full_change = true;
     }
 }
 
 void displayio_tilegrid_set_hidden_by_parent(displayio_tilegrid_t *self, bool hidden) {
     self->hidden_by_parent = hidden;
-    if(!hidden){
+    if (!hidden) {
         self->full_change = true;
     }
 }
 
-bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t* area) {
+bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t *area) {
     if (self->previous_area.x1 == self->previous_area.x2) {
         return false;
     }
@@ -113,8 +113,8 @@ void _update_current_x(displayio_tilegrid_t *self) {
     }
 
     // If there's no transform, substitute an identity transform so the calculations will work.
-    const displayio_buffer_transform_t* absolute_transform =
-        self->absolute_transform  == NULL
+    const displayio_buffer_transform_t *absolute_transform =
+        self->absolute_transform == NULL
         ? &null_transform
         : self->absolute_transform;
 
@@ -146,8 +146,8 @@ void _update_current_y(displayio_tilegrid_t *self) {
     }
 
     // If there's no transform, substitute an identity transform so the calculations will work.
-    const displayio_buffer_transform_t* absolute_transform =
-        self->absolute_transform  == NULL
+    const displayio_buffer_transform_t *absolute_transform =
+        self->absolute_transform == NULL
         ? &null_transform
         : self->absolute_transform;
 
@@ -171,7 +171,7 @@ void _update_current_y(displayio_tilegrid_t *self) {
 }
 
 void displayio_tilegrid_update_transform(displayio_tilegrid_t *self,
-                                         const displayio_buffer_transform_t* absolute_transform) {
+    const displayio_buffer_transform_t *absolute_transform) {
     self->in_group = absolute_transform != NULL;
     self->absolute_transform = absolute_transform;
     if (absolute_transform != NULL) {
@@ -230,9 +230,9 @@ uint16_t common_hal_displayio_tilegrid_get_height(displayio_tilegrid_t *self) {
 }
 
 uint8_t common_hal_displayio_tilegrid_get_tile(displayio_tilegrid_t *self, uint16_t x, uint16_t y) {
-    uint8_t* tiles = self->tiles;
+    uint8_t *tiles = self->tiles;
     if (self->inline_tiles) {
-        tiles = (uint8_t*) &self->tiles;
+        tiles = (uint8_t *)&self->tiles;
     }
     if (tiles == NULL) {
         return 0;
@@ -244,16 +244,16 @@ void common_hal_displayio_tilegrid_set_tile(displayio_tilegrid_t *self, uint16_t
     if (tile_index >= self->tiles_in_bitmap) {
         mp_raise_ValueError(translate("Tile index out of bounds"));
     }
-    uint8_t* tiles = self->tiles;
+    uint8_t *tiles = self->tiles;
     if (self->inline_tiles) {
-        tiles = (uint8_t*) &self->tiles;
+        tiles = (uint8_t *)&self->tiles;
     }
     if (tiles == NULL) {
         return;
     }
     tiles[y * self->width_in_tiles + x] = tile_index;
     displayio_area_t temp_area;
-    displayio_area_t* tile_area;
+    displayio_area_t *tile_area;
     if (!self->partial_change) {
         tile_area = &self->dirty_area;
     } else {
@@ -331,11 +331,11 @@ void common_hal_displayio_tilegrid_set_top_left(displayio_tilegrid_t *self, uint
     self->full_change = true;
 }
 
-bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer) {
+bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer) {
     // If no tiles are present we have no impact.
-    uint8_t* tiles = self->tiles;
+    uint8_t *tiles = self->tiles;
     if (self->inline_tiles) {
-        tiles = (uint8_t*) &self->tiles;
+        tiles = (uint8_t *)&self->tiles;
     }
     if (tiles == NULL) {
         return false;
@@ -384,9 +384,9 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c
     // can either return full coverage or bulk update the mask.
     displayio_area_t transformed;
     displayio_area_transform_within(flip_x != (self->absolute_transform->dx < 0), flip_y != (self->absolute_transform->dy < 0), self->transpose_xy != self->absolute_transform->transpose_xy,
-                                    &overlap,
-                                    &self->current_area,
-                                    &transformed);
+        &overlap,
+        &self->current_area,
+        &transformed);
 
     int16_t start_x = (transformed.x1 - self->current_area.x1);
     int16_t end_x = (transformed.x2 - self->current_area.x1);
@@ -443,7 +443,7 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c
             input_pixel.tile_x = (input_pixel.tile % self->bitmap_width_in_tiles) * self->tile_width + local_x % self->tile_width;
             input_pixel.tile_y = (input_pixel.tile / self->bitmap_width_in_tiles) * self->tile_height + local_y % self->tile_height;
 
-            //uint32_t value = 0;
+            // uint32_t value = 0;
             output_pixel.pixel = 0;
             input_pixel.pixel = 0;
 
@@ -471,9 +471,9 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c
             } else {
                 mask[offset / 32] |= 1 << (offset % 32);
                 if (colorspace->depth == 16) {
-                    *(((uint16_t*) buffer) + offset) = output_pixel.pixel;
+                    *(((uint16_t *)buffer) + offset) = output_pixel.pixel;
                 } else if (colorspace->depth == 8) {
-                    *(((uint8_t*) buffer) + offset) = output_pixel.pixel;
+                    *(((uint8_t *)buffer) + offset) = output_pixel.pixel;
                 } else if (colorspace->depth < 8) {
                     // Reorder the offsets to pack multiple rows into a byte (meaning they share a column).
                     if (!colorspace->pixels_in_byte_share_row) {
@@ -492,7 +492,7 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c
                         // Reverse the shift by subtracting it from the leftmost shift.
                         shift = (pixels_per_byte - 1) * colorspace->depth - shift;
                     }
-                    ((uint8_t*)buffer)[offset / pixels_per_byte] |= output_pixel.pixel << shift;
+                    ((uint8_t *)buffer)[offset / pixels_per_byte] |= output_pixel.pixel << shift;
                 }
             }
         }
@@ -529,7 +529,7 @@ void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self) {
     // That way they won't change during a refresh and tear.
 }
 
-displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t* tail) {
+displayio_area_t *displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t *tail) {
     bool first_draw = self->previous_area.x1 == self->previous_area.x2;
     bool hidden = self->hidden || self->hidden_by_parent;
     // Check hidden first because it trumps all other changes.
@@ -553,7 +553,7 @@ displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel
 
     // If we have an in-memory bitmap, then check it for modifications.
     if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_bitmap_type)) {
-        displayio_area_t* refresh_area = displayio_bitmap_get_refresh_areas(self->bitmap, tail);
+        displayio_area_t *refresh_area = displayio_bitmap_get_refresh_areas(self->bitmap, tail);
         if (refresh_area != tail) {
             // Special case a TileGrid that shows a full bitmap and use its
             // dirty area. Copy it to ours so we can transform it.
@@ -565,7 +565,7 @@ displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel
             }
         }
     } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_shape_type)) {
-        displayio_area_t* refresh_area = displayio_shape_get_refresh_areas(self->bitmap, tail);
+        displayio_area_t *refresh_area = displayio_shape_get_refresh_areas(self->bitmap, tail);
         if (refresh_area != tail) {
             displayio_area_copy(refresh_area, &self->dirty_area);
             self->partial_change = true;
@@ -574,9 +574,9 @@ displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel
 
     self->full_change = self->full_change ||
         (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_palette_type) &&
-         displayio_palette_needs_refresh(self->pixel_shader)) ||
+            displayio_palette_needs_refresh(self->pixel_shader)) ||
         (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_colorconverter_type) &&
-         displayio_colorconverter_needs_refresh(self->pixel_shader));
+            displayio_colorconverter_needs_refresh(self->pixel_shader));
     if (self->full_change || first_draw) {
         self->current_area.next = tail;
         return &self->current_area;
diff --git a/shared-module/displayio/TileGrid.h b/shared-module/displayio/TileGrid.h
index e97d3dfd4..b5aab5134 100644
--- a/shared-module/displayio/TileGrid.h
+++ b/shared-module/displayio/TileGrid.h
@@ -42,7 +42,8 @@ typedef struct {
     int16_t y;
     uint16_t pixel_width;
     uint16_t pixel_height;
-    uint16_t bitmap_width_in_tiles;;
+    uint16_t bitmap_width_in_tiles;
+    ;
     uint16_t tiles_in_bitmap;
     uint16_t width_in_tiles;
     uint16_t height_in_tiles;
@@ -50,22 +51,22 @@ typedef struct {
     uint16_t tile_height;
     uint16_t top_left_x;
     uint16_t top_left_y;
-    uint8_t* tiles;
-    const displayio_buffer_transform_t* absolute_transform;
+    uint8_t *tiles;
+    const displayio_buffer_transform_t *absolute_transform;
     displayio_area_t dirty_area; // Stored as a relative area until the refresh area is fetched.
     displayio_area_t previous_area; // Stored as an absolute area.
     displayio_area_t current_area; // Stored as an absolute area so it applies across frames.
-    bool partial_change :1;
-    bool full_change :1;
-    bool moved :1;
-    bool inline_tiles :1;
-    bool in_group :1;
-    bool flip_x :1;
-    bool flip_y :1;
-    bool transpose_xy  :1;
-    bool hidden :1;
-    bool hidden_by_parent :1;
-    uint8_t padding :6;
+    bool partial_change : 1;
+    bool full_change : 1;
+    bool moved : 1;
+    bool inline_tiles : 1;
+    bool in_group : 1;
+    bool flip_x : 1;
+    bool flip_y : 1;
+    bool transpose_xy  : 1;
+    bool hidden : 1;
+    bool hidden_by_parent : 1;
+    uint8_t padding : 6;
 } displayio_tilegrid_t;
 
 void displayio_tilegrid_set_hidden_by_parent(displayio_tilegrid_t *self, bool hidden);
@@ -73,16 +74,16 @@ void displayio_tilegrid_set_hidden_by_parent(displayio_tilegrid_t *self, bool hi
 // Updating the screen is a three stage process.
 
 // The first stage is used to determine i
-displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t* tail);
+displayio_area_t *displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t *tail);
 
 // Area is always in absolute screen coordinates. Update transform is used to inform TileGrids how
 // they relate to it.
-bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer);
-void displayio_tilegrid_update_transform(displayio_tilegrid_t *group, const displayio_buffer_transform_t* parent_transform);
+bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer);
+void displayio_tilegrid_update_transform(displayio_tilegrid_t *group, const displayio_buffer_transform_t *parent_transform);
 
 // Fills in area with the maximum bounds of all related pixels in the last rendered frame. Returns
 // false if the tilegrid wasn't rendered in the last frame.
-bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t* area);
+bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t *area);
 void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_TILEGRID_H
diff --git a/shared-module/displayio/__init__.c b/shared-module/displayio/__init__.c
index 740af0570..3c9c2cc3a 100644
--- a/shared-module/displayio/__init__.c
+++ b/shared-module/displayio/__init__.c
@@ -44,7 +44,7 @@ displayio_buffer_transform_t null_transform = {
 STATIC bool any_display_uses_this_framebuffer(mp_obj_base_t *obj) {
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
         if (displays[i].display_base.type == &framebufferio_framebufferdisplay_type) {
-            framebufferio_framebufferdisplay_obj_t* display = &displays[i].framebuffer_display;
+            framebufferio_framebufferdisplay_obj_t *display = &displays[i].framebuffer_display;
             if (display->framebuffer == obj) {
                 return true;
             }
@@ -72,10 +72,10 @@ void displayio_background(void) {
         }
         if (displays[i].display.base.type == &displayio_display_type) {
             displayio_display_background(&displays[i].display);
-#if CIRCUITPY_FRAMEBUFFERIO
+        #if CIRCUITPY_FRAMEBUFFERIO
         } else if (displays[i].framebuffer_display.base.type == &framebufferio_framebufferdisplay_type) {
             framebufferio_framebufferdisplay_background(&displays[i].framebuffer_display);
-#endif
+        #endif
         } else if (displays[i].epaper_display.base.type == &displayio_epaperdisplay_type) {
             displayio_epaperdisplay_background(&displays[i].epaper_display);
         }
@@ -94,10 +94,10 @@ void common_hal_displayio_release_displays(void) {
             release_display(&displays[i].display);
         } else if (display_type == &displayio_epaperdisplay_type) {
             release_epaperdisplay(&displays[i].epaper_display);
-#if CIRCUITPY_FRAMEBUFFERIO
+        #if CIRCUITPY_FRAMEBUFFERIO
         } else if (display_type == &framebufferio_framebufferdisplay_type) {
             release_framebufferdisplay(&displays[i].framebuffer_display);
-#endif
+        #endif
         }
         displays[i].display.base.type = &mp_type_NoneType;
     }
@@ -111,14 +111,14 @@ void common_hal_displayio_release_displays(void) {
             common_hal_displayio_i2cdisplay_deinit(&displays[i].i2cdisplay_bus);
         } else if (bus_type == &displayio_parallelbus_type) {
             common_hal_displayio_parallelbus_deinit(&displays[i].parallel_bus);
-#if CIRCUITPY_RGBMATRIX
+        #if CIRCUITPY_RGBMATRIX
         } else if (bus_type == &rgbmatrix_RGBMatrix_type) {
             common_hal_rgbmatrix_rgbmatrix_deinit(&displays[i].rgbmatrix);
-#endif
-#if CIRCUITPY_SHARPDISPLAY
+        #endif
+        #if CIRCUITPY_SHARPDISPLAY
         } else if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type) {
             common_hal_sharpdisplay_framebuffer_deinit(&displays[i].sharpdisplay);
-#endif
+        #endif
         }
         displays[i].fourwire_bus.base.type = &mp_type_NoneType;
     }
@@ -130,68 +130,68 @@ void reset_displays(void) {
     // The SPI buses used by FourWires may be allocated on the heap so we need to move them inline.
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
         if (displays[i].fourwire_bus.base.type == &displayio_fourwire_type) {
-            displayio_fourwire_obj_t* fourwire = &displays[i].fourwire_bus;
-            if (((uint32_t) fourwire->bus) < ((uint32_t) &displays) ||
-                ((uint32_t) fourwire->bus) > ((uint32_t) &displays + CIRCUITPY_DISPLAY_LIMIT)) {
-                busio_spi_obj_t* original_spi = fourwire->bus;
+            displayio_fourwire_obj_t *fourwire = &displays[i].fourwire_bus;
+            if (((uint32_t)fourwire->bus) < ((uint32_t)&displays) ||
+                ((uint32_t)fourwire->bus) > ((uint32_t)&displays + CIRCUITPY_DISPLAY_LIMIT)) {
+                busio_spi_obj_t *original_spi = fourwire->bus;
                 #if BOARD_SPI
-                    // We don't need to move original_spi if it is the board.SPI object because it is
-                    // statically allocated already. (Doing so would also make it impossible to reference in
-                    // a subsequent VM run.)
-                    if (original_spi == common_hal_board_get_spi()) {
-                        continue;
-                    }
+                // We don't need to move original_spi if it is the board.SPI object because it is
+                // statically allocated already. (Doing so would also make it impossible to reference in
+                // a subsequent VM run.)
+                if (original_spi == common_hal_board_get_spi()) {
+                    continue;
+                }
                 #endif
                 #ifdef BOARD_USE_INTERNAL_SPI
-                    if (original_spi == (mp_obj_t)(&supervisor_flash_spi_bus)) {
-                        continue;
-                    }
+                if (original_spi == (mp_obj_t)(&supervisor_flash_spi_bus)) {
+                    continue;
+                }
                 #endif
                 memcpy(&fourwire->inline_bus, original_spi, sizeof(busio_spi_obj_t));
                 fourwire->bus = &fourwire->inline_bus;
                 // Check for other displays that use the same spi bus and swap them too.
                 for (uint8_t j = i + 1; j < CIRCUITPY_DISPLAY_LIMIT; j++) {
                     if (displays[i].fourwire_bus.base.type == &displayio_fourwire_type &&
-                            displays[i].fourwire_bus.bus == original_spi) {
+                        displays[i].fourwire_bus.bus == original_spi) {
                         displays[i].fourwire_bus.bus = &fourwire->inline_bus;
                     }
                 }
             }
         } else if (displays[i].i2cdisplay_bus.base.type == &displayio_i2cdisplay_type) {
-            displayio_i2cdisplay_obj_t* i2c = &displays[i].i2cdisplay_bus;
-            if (((uint32_t) i2c->bus) < ((uint32_t) &displays) ||
-                ((uint32_t) i2c->bus) > ((uint32_t) &displays + CIRCUITPY_DISPLAY_LIMIT)) {
-                busio_i2c_obj_t* original_i2c = i2c->bus;
+            displayio_i2cdisplay_obj_t *i2c = &displays[i].i2cdisplay_bus;
+            if (((uint32_t)i2c->bus) < ((uint32_t)&displays) ||
+                ((uint32_t)i2c->bus) > ((uint32_t)&displays + CIRCUITPY_DISPLAY_LIMIT)) {
+                busio_i2c_obj_t *original_i2c = i2c->bus;
                 #if BOARD_I2C
-                    // We don't need to move original_i2c if it is the board.I2C object because it is
-                    // statically allocated already. (Doing so would also make it impossible to reference in
-                    // a subsequent VM run.)
-                    if (original_i2c == common_hal_board_get_i2c()) {
-                        continue;
-                    }
+                // We don't need to move original_i2c if it is the board.I2C object because it is
+                // statically allocated already. (Doing so would also make it impossible to reference in
+                // a subsequent VM run.)
+                if (original_i2c == common_hal_board_get_i2c()) {
+                    continue;
+                }
                 #endif
                 memcpy(&i2c->inline_bus, original_i2c, sizeof(busio_i2c_obj_t));
                 i2c->bus = &i2c->inline_bus;
                 // Check for other displays that use the same i2c bus and swap them too.
                 for (uint8_t j = i + 1; j < CIRCUITPY_DISPLAY_LIMIT; j++) {
                     if (displays[i].i2cdisplay_bus.base.type == &displayio_i2cdisplay_type &&
-                            displays[i].i2cdisplay_bus.bus == original_i2c) {
+                        displays[i].i2cdisplay_bus.bus == original_i2c) {
                         displays[i].i2cdisplay_bus.bus = &i2c->inline_bus;
                     }
                 }
             }
-#if CIRCUITPY_RGBMATRIX
+        #if CIRCUITPY_RGBMATRIX
         } else if (displays[i].rgbmatrix.base.type == &rgbmatrix_RGBMatrix_type) {
-            rgbmatrix_rgbmatrix_obj_t * pm = &displays[i].rgbmatrix;
-            if(!any_display_uses_this_framebuffer(&pm->base)) {
+            rgbmatrix_rgbmatrix_obj_t *pm = &displays[i].rgbmatrix;
+            if (!any_display_uses_this_framebuffer(&pm->base)) {
                 common_hal_rgbmatrix_rgbmatrix_deinit(pm);
             }
-#endif
-#if CIRCUITPY_SHARPDISPLAY
+        #endif
+        #if CIRCUITPY_SHARPDISPLAY
         } else if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type) {
-            sharpdisplay_framebuffer_obj_t * sharp = &displays[i].sharpdisplay;
+            sharpdisplay_framebuffer_obj_t *sharp = &displays[i].sharpdisplay;
             common_hal_sharpdisplay_framebuffer_reset(sharp);
-#endif
+        #endif
         } else {
             // Not an active display bus.
             continue;
@@ -204,28 +204,28 @@ void reset_displays(void) {
         if (displays[i].display.base.type == &displayio_display_type) {
             reset_display(&displays[i].display);
         } else if (displays[i].epaper_display.base.type == &displayio_epaperdisplay_type) {
-            displayio_epaperdisplay_obj_t* display = &displays[i].epaper_display;
+            displayio_epaperdisplay_obj_t *display = &displays[i].epaper_display;
             common_hal_displayio_epaperdisplay_show(display, NULL);
-#if CIRCUITPY_FRAMEBUFFERIO
+        #if CIRCUITPY_FRAMEBUFFERIO
         } else if (displays[i].framebuffer_display.base.type == &framebufferio_framebufferdisplay_type) {
             framebufferio_framebufferdisplay_reset(&displays[i].framebuffer_display);
-#endif
+        #endif
         }
     }
 }
 
 void displayio_gc_collect(void) {
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
-#if CIRCUITPY_RGBMATRIX
+        #if CIRCUITPY_RGBMATRIX
         if (displays[i].rgbmatrix.base.type == &rgbmatrix_RGBMatrix_type) {
             rgbmatrix_rgbmatrix_collect_ptrs(&displays[i].rgbmatrix);
         }
-#endif
-#if CIRCUITPY_SHARPDISPLAY
+        #endif
+        #if CIRCUITPY_SHARPDISPLAY
         if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type) {
             common_hal_sharpdisplay_framebuffer_collect_ptrs(&displays[i].sharpdisplay);
         }
-#endif
+        #endif
 
         if (displays[i].display.base.type == NULL) {
             continue;
@@ -235,17 +235,17 @@ void displayio_gc_collect(void) {
         // but this is more precise, and is the only field that needs marking.
         if (displays[i].display.base.type == &displayio_display_type) {
             displayio_display_collect_ptrs(&displays[i].display);
-#if CIRCUITPY_FRAMEBUFFERIO
+        #if CIRCUITPY_FRAMEBUFFERIO
         } else if (displays[i].framebuffer_display.base.type == &framebufferio_framebufferdisplay_type) {
             framebufferio_framebufferdisplay_collect_ptrs(&displays[i].framebuffer_display);
-#endif
+        #endif
         } else if (displays[i].epaper_display.base.type == &displayio_epaperdisplay_type) {
             displayio_epaperdisplay_collect_ptrs(&displays[i].epaper_display);
         }
     }
 }
 
-void displayio_area_expand(displayio_area_t* original, const displayio_area_t* addition) {
+void displayio_area_expand(displayio_area_t *original, const displayio_area_t *addition) {
     if (addition->x1 < original->x1) {
         original->x1 = addition->x1;
     }
@@ -260,30 +260,30 @@ void displayio_area_expand(displayio_area_t* original, const displayio_area_t* a
     }
 }
 
-void displayio_area_copy(const displayio_area_t* src, displayio_area_t* dst) {
+void displayio_area_copy(const displayio_area_t *src, displayio_area_t *dst) {
     dst->x1 = src->x1;
     dst->y1 = src->y1;
     dst->x2 = src->x2;
     dst->y2 = src->y2;
 }
 
-void displayio_area_scale(displayio_area_t* area, uint16_t scale) {
+void displayio_area_scale(displayio_area_t *area, uint16_t scale) {
     area->x1 *= scale;
     area->y1 *= scale;
     area->x2 *= scale;
     area->y2 *= scale;
 }
 
-void displayio_area_shift(displayio_area_t* area, int16_t dx, int16_t dy) {
+void displayio_area_shift(displayio_area_t *area, int16_t dx, int16_t dy) {
     area->x1 += dx;
     area->y1 += dy;
     area->x2 += dx;
     area->y2 += dy;
 }
 
-bool displayio_area_compute_overlap(const displayio_area_t* a,
-                                    const displayio_area_t* b,
-                                    displayio_area_t* overlap) {
+bool displayio_area_compute_overlap(const displayio_area_t *a,
+    const displayio_area_t *b,
+    displayio_area_t *overlap) {
     overlap->x1 = a->x1;
     if (b->x1 > overlap->x1) {
         overlap->x1 = b->x1;
@@ -309,9 +309,9 @@ bool displayio_area_compute_overlap(const displayio_area_t* a,
     return true;
 }
 
-void displayio_area_union(const displayio_area_t* a,
-                          const displayio_area_t* b,
-                          displayio_area_t* u) {
+void displayio_area_union(const displayio_area_t *a,
+    const displayio_area_t *b,
+    displayio_area_t *u) {
     u->x1 = a->x1;
     if (b->x1 < u->x1) {
         u->x1 = b->x1;
@@ -331,19 +331,19 @@ void displayio_area_union(const displayio_area_t* a,
     }
 }
 
-uint16_t displayio_area_width(const displayio_area_t* area) {
+uint16_t displayio_area_width(const displayio_area_t *area) {
     return area->x2 - area->x1;
 }
 
-uint16_t displayio_area_height(const displayio_area_t* area) {
+uint16_t displayio_area_height(const displayio_area_t *area) {
     return area->y2 - area->y1;
 }
 
-uint32_t displayio_area_size(const displayio_area_t* area) {
+uint32_t displayio_area_size(const displayio_area_t *area) {
     return displayio_area_width(area) * displayio_area_height(area);
 }
 
-bool displayio_area_equal(const displayio_area_t* a, const displayio_area_t* b) {
+bool displayio_area_equal(const displayio_area_t *a, const displayio_area_t *b) {
     return a->x1 == b->x1 &&
            a->y1 == b->y1 &&
            a->x2 == b->x2 &&
@@ -352,9 +352,9 @@ bool displayio_area_equal(const displayio_area_t* a, const displayio_area_t* b)
 
 // Original and whole must be in the same coordinate space.
 void displayio_area_transform_within(bool mirror_x, bool mirror_y, bool transpose_xy,
-                                     const displayio_area_t* original,
-                                     const displayio_area_t* whole,
-                                     displayio_area_t* transformed) {
+    const displayio_area_t *original,
+    const displayio_area_t *whole,
+    displayio_area_t *transformed) {
     if (mirror_x) {
         transformed->x1 = whole->x1 + (whole->x2 - original->x2);
         transformed->x2 = whole->x2 - (original->x1 - whole->x1);
diff --git a/shared-module/displayio/__init__.h b/shared-module/displayio/__init__.h
index 44ad5a9a9..4a74b0e0e 100644
--- a/shared-module/displayio/__init__.h
+++ b/shared-module/displayio/__init__.h
@@ -49,20 +49,20 @@ typedef struct {
         displayio_fourwire_obj_t fourwire_bus;
         displayio_i2cdisplay_obj_t i2cdisplay_bus;
         displayio_parallelbus_obj_t parallel_bus;
-#if CIRCUITPY_RGBMATRIX
+        #if CIRCUITPY_RGBMATRIX
         rgbmatrix_rgbmatrix_obj_t rgbmatrix;
-#endif
-#if CIRCUITPY_SHARPDISPLAY
+        #endif
+        #if CIRCUITPY_SHARPDISPLAY
         sharpdisplay_framebuffer_obj_t sharpdisplay;
-#endif
+        #endif
     };
     union {
         mp_obj_base_t display_base;
         displayio_display_obj_t display;
         displayio_epaperdisplay_obj_t epaper_display;
-#if CIRCUITPY_FRAMEBUFFERIO
+        #if CIRCUITPY_FRAMEBUFFERIO
         framebufferio_framebufferdisplay_obj_t framebuffer_display;
-#endif
+        #endif
     };
 } primary_display_t;
 
diff --git a/shared-module/displayio/area.h b/shared-module/displayio/area.h
index 7ad36883c..21bf2f8b2 100644
--- a/shared-module/displayio/area.h
+++ b/shared-module/displayio/area.h
@@ -35,7 +35,7 @@ struct _displayio_area_t {
     int16_t y1;
     int16_t x2; // Second point is exclusive.
     int16_t y2;
-    const displayio_area_t* next; // Next area in the linked list.
+    const displayio_area_t *next; // Next area in the linked list.
 };
 
 typedef struct {
@@ -53,23 +53,23 @@ typedef struct {
 
 extern displayio_buffer_transform_t null_transform;
 
-void displayio_area_union(const displayio_area_t* a,
-                          const displayio_area_t* b,
-                          displayio_area_t* u);
-void displayio_area_expand(displayio_area_t* original, const displayio_area_t* addition);
-void displayio_area_copy(const displayio_area_t* src, displayio_area_t* dst);
-void displayio_area_scale(displayio_area_t* area, uint16_t scale);
-void displayio_area_shift(displayio_area_t* area, int16_t dx, int16_t dy);
-bool displayio_area_compute_overlap(const displayio_area_t* a,
-                                    const displayio_area_t* b,
-                                    displayio_area_t* overlap);
-uint16_t displayio_area_width(const displayio_area_t* area);
-uint16_t displayio_area_height(const displayio_area_t* area);
-uint32_t displayio_area_size(const displayio_area_t* area);
-bool displayio_area_equal(const displayio_area_t* a, const displayio_area_t* b);
+void displayio_area_union(const displayio_area_t *a,
+    const displayio_area_t *b,
+    displayio_area_t *u);
+void displayio_area_expand(displayio_area_t *original, const displayio_area_t *addition);
+void displayio_area_copy(const displayio_area_t *src, displayio_area_t *dst);
+void displayio_area_scale(displayio_area_t *area, uint16_t scale);
+void displayio_area_shift(displayio_area_t *area, int16_t dx, int16_t dy);
+bool displayio_area_compute_overlap(const displayio_area_t *a,
+    const displayio_area_t *b,
+    displayio_area_t *overlap);
+uint16_t displayio_area_width(const displayio_area_t *area);
+uint16_t displayio_area_height(const displayio_area_t *area);
+uint32_t displayio_area_size(const displayio_area_t *area);
+bool displayio_area_equal(const displayio_area_t *a, const displayio_area_t *b);
 void displayio_area_transform_within(bool mirror_x, bool mirror_y, bool transpose_xy,
-                                     const displayio_area_t* original,
-                                     const displayio_area_t* whole,
-                                     displayio_area_t* transformed);
+    const displayio_area_t *original,
+    const displayio_area_t *whole,
+    displayio_area_t *transformed);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_AREA_H
diff --git a/shared-module/displayio/display_core.c b/shared-module/displayio/display_core.c
index 57d33b565..a0b3afa0e 100644
--- a/shared-module/displayio/display_core.c
+++ b/shared-module/displayio/display_core.c
@@ -43,9 +43,9 @@
 #define DISPLAYIO_CORE_DEBUG(...) (void)0
 // #define DISPLAYIO_CORE_DEBUG(...) mp_printf(&mp_plat_print __VA_OPT__(,) __VA_ARGS__)
 
-void displayio_display_core_construct(displayio_display_core_t* self,
-        mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation,
-        uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word) {
+void displayio_display_core_construct(displayio_display_core_t *self,
+    mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation,
+    uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word) {
     self->colorspace.depth = color_depth;
     self->colorspace.grayscale = grayscale;
     self->colorspace.grayscale_bit = 8 - color_depth;
@@ -99,8 +99,8 @@ void displayio_display_core_construct(displayio_display_core_t* self,
     displayio_display_core_set_rotation(self, rotation);
 }
 
-void displayio_display_core_set_rotation( displayio_display_core_t* self,
-        int rotation) {
+void displayio_display_core_set_rotation(displayio_display_core_t *self,
+    int rotation) {
     int height = self->height;
     int width = self->width;
 
@@ -157,7 +157,7 @@ void displayio_display_core_set_rotation( displayio_display_core_t* self,
     }
 }
 
-bool displayio_display_core_show(displayio_display_core_t* self, displayio_group_t* root_group) {
+bool displayio_display_core_show(displayio_display_core_t *self, displayio_group_t *root_group) {
     if (root_group == NULL) {
         if (!circuitpython_splash.in_group) {
             root_group = &circuitpython_splash;
@@ -184,19 +184,19 @@ bool displayio_display_core_show(displayio_display_core_t* self, displayio_group
     return true;
 }
 
-uint16_t displayio_display_core_get_width(displayio_display_core_t* self){
+uint16_t displayio_display_core_get_width(displayio_display_core_t *self) {
     return self->width;
 }
 
-uint16_t displayio_display_core_get_height(displayio_display_core_t* self){
+uint16_t displayio_display_core_get_height(displayio_display_core_t *self) {
     return self->height;
 }
 
-void displayio_display_core_set_dither(displayio_display_core_t* self, bool dither){
+void displayio_display_core_set_dither(displayio_display_core_t *self, bool dither) {
     self->colorspace.dither = dither;
 }
 
-bool displayio_display_core_get_dither(displayio_display_core_t* self){
+bool displayio_display_core_get_dither(displayio_display_core_t *self) {
     return self->colorspace.dither;
 }
 
@@ -204,18 +204,18 @@ bool displayio_display_core_bus_free(displayio_display_core_t *self) {
     return !self->bus || self->bus_free(self->bus);
 }
 
-bool displayio_display_core_begin_transaction(displayio_display_core_t* self) {
+bool displayio_display_core_begin_transaction(displayio_display_core_t *self) {
     return self->begin_transaction(self->bus);
 }
 
-void displayio_display_core_end_transaction(displayio_display_core_t* self) {
+void displayio_display_core_end_transaction(displayio_display_core_t *self) {
     self->end_transaction(self->bus);
 }
 
-void displayio_display_core_set_region_to_update(displayio_display_core_t* self, uint8_t column_command,
-              uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command,
-              bool data_as_commands, bool always_toggle_chip_select,
-              displayio_area_t* area, bool SH1107_addressing) {
+void displayio_display_core_set_region_to_update(displayio_display_core_t *self, uint8_t column_command,
+    uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command,
+    bool data_as_commands, bool always_toggle_chip_select,
+    displayio_area_t *area, bool SH1107_addressing) {
     uint16_t x1 = area->x1;
     uint16_t x2 = area->x2;
     uint16_t y1 = area->y1;
@@ -320,7 +320,7 @@ void displayio_display_core_set_region_to_update(displayio_display_core_t* self,
     }
 }
 
-bool displayio_display_core_start_refresh(displayio_display_core_t* self) {
+bool displayio_display_core_start_refresh(displayio_display_core_t *self) {
     if (!displayio_display_core_bus_free(self)) {
         // Can't acquire display bus; skip updating this display. Try next display.
         return false;
@@ -333,7 +333,7 @@ bool displayio_display_core_start_refresh(displayio_display_core_t* self) {
     return true;
 }
 
-void displayio_display_core_finish_refresh(displayio_display_core_t* self) {
+void displayio_display_core_finish_refresh(displayio_display_core_t *self) {
     if (self->current_group != NULL) {
         DISPLAYIO_CORE_DEBUG("displayiocore group_finish_refresh\n");
         displayio_group_finish_refresh(self->current_group);
@@ -343,21 +343,21 @@ void displayio_display_core_finish_refresh(displayio_display_core_t* self) {
     self->last_refresh = supervisor_ticks_ms64();
 }
 
-void release_display_core(displayio_display_core_t* self) {
+void release_display_core(displayio_display_core_t *self) {
     if (self->current_group != NULL) {
         self->current_group->in_group = false;
     }
 }
 
-void displayio_display_core_collect_ptrs(displayio_display_core_t* self) {
+void displayio_display_core_collect_ptrs(displayio_display_core_t *self) {
     gc_collect_ptr(self->current_group);
 }
 
-bool displayio_display_core_fill_area(displayio_display_core_t *self, displayio_area_t* area, uint32_t* mask, uint32_t *buffer) {
+bool displayio_display_core_fill_area(displayio_display_core_t *self, displayio_area_t *area, uint32_t *mask, uint32_t *buffer) {
     return displayio_group_fill_area(self->current_group, &self->colorspace, area, mask, buffer);
 }
 
-bool displayio_display_core_clip_area(displayio_display_core_t *self, const displayio_area_t* area, displayio_area_t* clipped) {
+bool displayio_display_core_clip_area(displayio_display_core_t *self, const displayio_area_t *area, displayio_area_t *clipped) {
     bool overlaps = displayio_area_compute_overlap(&self->area, area, clipped);
     if (!overlaps) {
         return false;
diff --git a/shared-module/displayio/display_core.h b/shared-module/displayio/display_core.h
index fe6cb6f3f..8c2ba21b5 100644
--- a/shared-module/displayio/display_core.h
+++ b/shared-module/displayio/display_core.h
@@ -57,38 +57,38 @@ typedef struct {
     bool refresh_in_progress;
 } displayio_display_core_t;
 
-void displayio_display_core_construct(displayio_display_core_t* self,
-        mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation,
-        uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word);
+void displayio_display_core_construct(displayio_display_core_t *self,
+    mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation,
+    uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word);
 
-bool displayio_display_core_show(displayio_display_core_t* self, displayio_group_t* root_group);
+bool displayio_display_core_show(displayio_display_core_t *self, displayio_group_t *root_group);
 
-uint16_t displayio_display_core_get_width(displayio_display_core_t* self);
-uint16_t displayio_display_core_get_height(displayio_display_core_t* self);
+uint16_t displayio_display_core_get_width(displayio_display_core_t *self);
+uint16_t displayio_display_core_get_height(displayio_display_core_t *self);
 
-void displayio_display_core_set_dither(displayio_display_core_t* self, bool dither);
-bool displayio_display_core_get_dither(displayio_display_core_t* self);
+void displayio_display_core_set_dither(displayio_display_core_t *self, bool dither);
+bool displayio_display_core_get_dither(displayio_display_core_t *self);
 
-void displayio_display_core_set_rotation(displayio_display_core_t* self, int rotation);
+void displayio_display_core_set_rotation(displayio_display_core_t *self, int rotation);
 
 bool displayio_display_core_bus_free(displayio_display_core_t *self);
-bool displayio_display_core_begin_transaction(displayio_display_core_t* self);
-void displayio_display_core_end_transaction(displayio_display_core_t* self);
+bool displayio_display_core_begin_transaction(displayio_display_core_t *self);
+void displayio_display_core_end_transaction(displayio_display_core_t *self);
 
-void displayio_display_core_set_region_to_update(displayio_display_core_t* self, uint8_t column_command,
-          uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command,
-          bool data_as_commands, bool always_toggle_chip_select,
-          displayio_area_t* area, bool SH1107_addressing);
+void displayio_display_core_set_region_to_update(displayio_display_core_t *self, uint8_t column_command,
+    uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command,
+    bool data_as_commands, bool always_toggle_chip_select,
+    displayio_area_t *area, bool SH1107_addressing);
 
-void release_display_core(displayio_display_core_t* self);
+void release_display_core(displayio_display_core_t *self);
 
-bool displayio_display_core_start_refresh(displayio_display_core_t* self);
-void displayio_display_core_finish_refresh(displayio_display_core_t* self);
+bool displayio_display_core_start_refresh(displayio_display_core_t *self);
+void displayio_display_core_finish_refresh(displayio_display_core_t *self);
 
-void displayio_display_core_collect_ptrs(displayio_display_core_t* self);
+void displayio_display_core_collect_ptrs(displayio_display_core_t *self);
 
-bool displayio_display_core_fill_area(displayio_display_core_t *self, displayio_area_t* area, uint32_t* mask, uint32_t *buffer);
+bool displayio_display_core_fill_area(displayio_display_core_t *self, displayio_area_t *area, uint32_t *mask, uint32_t *buffer);
 
-bool displayio_display_core_clip_area(displayio_display_core_t *self, const displayio_area_t* area, displayio_area_t* clipped);
+bool displayio_display_core_clip_area(displayio_display_core_t *self, const displayio_area_t *area, displayio_area_t *clipped);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_DISPLAY_CORE_H