Merge pull request #2 from adafruit/master

Pull master

12 files changed, 97 insertions, 114 deletions

diff --git a/shared-module/audiocore/RawSample.c b/shared-module/audiocore/RawSample.c
index d6bf3a567..a69ddeb65 100644
--- a/shared-module/audiocore/RawSample.c
+++ b/shared-module/audiocore/RawSample.c
@@ -60,6 +60,12 @@ void common_hal_audioio_rawsample_set_sample_rate(audioio_rawsample_obj_t* self,
                                                   uint32_t sample_rate) {
     self->sample_rate = sample_rate;
 }
+uint8_t common_hal_audioio_rawsample_get_bits_per_sample(audioio_rawsample_obj_t* self) {
+    return self->bits_per_sample;
+}
+uint8_t common_hal_audioio_rawsample_get_channel_count(audioio_rawsample_obj_t* self) {
+    return self->channel_count;
+}
 
 void audioio_rawsample_reset_buffer(audioio_rawsample_obj_t* self,
                                     bool single_channel,
diff --git a/shared-module/audiocore/__init__.c b/shared-module/audiocore/__init__.c
index f9762676f..1553dbe96 100644
--- a/shared-module/audiocore/__init__.c
+++ b/shared-module/audiocore/__init__.c
@@ -36,103 +36,37 @@
 #include "shared-module/audiomixer/Mixer.h"
 
 uint32_t audiosample_sample_rate(mp_obj_t sample_obj) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        return sample->sample_rate;
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return file->sample_rate;
-    #if CIRCUITPY_AUDIOMIXER
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
-        audiomixer_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
-        return mixer->sample_rate;
-    #endif
-    }
-    return 16000;
+    const audiosample_p_t *proto = mp_proto_get_or_throw(MP_QSTR_protocol_audiosample, sample_obj);
+    return proto->sample_rate(MP_OBJ_TO_PTR(sample_obj));
 }
 
 uint8_t audiosample_bits_per_sample(mp_obj_t sample_obj) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        return sample->bits_per_sample;
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return file->bits_per_sample;
-    #if CIRCUITPY_AUDIOMIXER
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
-        audiomixer_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
-        return mixer->bits_per_sample;
-    #endif
-    }
-    return 8;
+    const audiosample_p_t *proto = mp_proto_get_or_throw(MP_QSTR_protocol_audiosample, sample_obj);
+    return proto->bits_per_sample(MP_OBJ_TO_PTR(sample_obj));
 }
 
 uint8_t audiosample_channel_count(mp_obj_t sample_obj) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        return sample->channel_count;
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return file->channel_count;
-    #if CIRCUITPY_AUDIOMIXER
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
-        audiomixer_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
-        return mixer->channel_count;
-    #endif
-    }
-    return 1;
+    const audiosample_p_t *proto = mp_proto_get_or_throw(MP_QSTR_protocol_audiosample, sample_obj);
+    return proto->channel_count(MP_OBJ_TO_PTR(sample_obj));
 }
 
 void audiosample_reset_buffer(mp_obj_t sample_obj, bool single_channel, uint8_t audio_channel) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        audioio_rawsample_reset_buffer(sample, single_channel, audio_channel);
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        audioio_wavefile_reset_buffer(file, single_channel, audio_channel);
-    #if CIRCUITPY_AUDIOMIXER
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
-        audiomixer_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        audiomixer_mixer_reset_buffer(file, single_channel, audio_channel);
-    #endif
-    }
+    const audiosample_p_t *proto = mp_proto_get_or_throw(MP_QSTR_protocol_audiosample, sample_obj);
+    proto->reset_buffer(MP_OBJ_TO_PTR(sample_obj));
 }
 
 audioio_get_buffer_result_t audiosample_get_buffer(mp_obj_t sample_obj,
                                                    bool single_channel,
                                                    uint8_t channel,
                                                    uint8_t** buffer, uint32_t* buffer_length) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        return audioio_rawsample_get_buffer(sample, single_channel, channel, buffer, buffer_length);
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return audioio_wavefile_get_buffer(file, single_channel, channel, buffer, buffer_length);
-    #if CIRCUITPY_AUDIOMIXER
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
-        audiomixer_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return audiomixer_mixer_get_buffer(file, single_channel, channel, buffer, buffer_length);
-    #endif
-    }
-    return GET_BUFFER_DONE;
+    const audiosample_p_t *proto = mp_proto_get_or_throw(MP_QSTR_protocol_audiosample, sample_obj);
+    return proto->get_buffer(MP_OBJ_TO_PTR(sample_obj), single_channel, channel, buffer, buffer_length);
 }
 
 void audiosample_get_buffer_structure(mp_obj_t sample_obj, bool single_channel,
                                       bool* single_buffer, bool* samples_signed,
                                       uint32_t* max_buffer_length, uint8_t* spacing) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        audioio_rawsample_get_buffer_structure(sample, single_channel, single_buffer,
-                                               samples_signed, max_buffer_length, spacing);
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        audioio_wavefile_get_buffer_structure(file, single_channel, single_buffer, samples_signed,
-                                              max_buffer_length, spacing);
-    #if CIRCUITPY_AUDIOMIXER
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
-        audiomixer_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        audiomixer_mixer_get_buffer_structure(file, single_channel, single_buffer, samples_signed,
-                                              max_buffer_length, spacing);
-    #endif
-    }
+    const audiosample_p_t *proto = mp_proto_get_or_throw(MP_QSTR_protocol_audiosample, sample_obj);
+    proto->get_buffer_structure(MP_OBJ_TO_PTR(sample_obj), single_channel, single_buffer,
+        samples_signed, max_buffer_length, spacing);
 }
diff --git a/shared-module/audiocore/__init__.h b/shared-module/audiocore/__init__.h
index 7aa0c1824..38c1f5aeb 100644
--- a/shared-module/audiocore/__init__.h
+++ b/shared-module/audiocore/__init__.h
@@ -31,6 +31,7 @@
 #include <stdint.h>
 
 #include "py/obj.h"
+#include "py/proto.h"
 
 typedef enum {
     GET_BUFFER_DONE,            // No more data to read
@@ -38,6 +39,28 @@ typedef enum {
     GET_BUFFER_ERROR,           // Error while reading data.
 } audioio_get_buffer_result_t;
 
+typedef uint32_t (*audiosample_sample_rate_fun)(mp_obj_t);
+typedef uint8_t (*audiosample_bits_per_sample_fun)(mp_obj_t);
+typedef uint8_t (*audiosample_channel_count_fun)(mp_obj_t);
+typedef void (*audiosample_reset_buffer_fun)(mp_obj_t);
+typedef audioio_get_buffer_result_t (*audiosample_get_buffer_fun)(mp_obj_t,
+        bool single_channel, uint8_t channel, uint8_t** buffer,
+        uint32_t* buffer_length);
+typedef void (*audiosample_get_buffer_structure_fun)(mp_obj_t,
+        bool single_channel, bool* single_buffer,
+        bool* samples_signed, uint32_t *max_buffer_length,
+        uint8_t* spacing);
+
+typedef struct _audiosample_p_t {
+    MP_PROTOCOL_HEAD // MP_QSTR_protocol_audiosample
+    audiosample_sample_rate_fun sample_rate;
+    audiosample_bits_per_sample_fun bits_per_sample;
+    audiosample_channel_count_fun channel_count;
+    audiosample_reset_buffer_fun reset_buffer;
+    audiosample_get_buffer_fun get_buffer;
+    audiosample_get_buffer_structure_fun get_buffer_structure;
+} audiosample_p_t;
+
 uint32_t audiosample_sample_rate(mp_obj_t sample_obj);
 uint8_t audiosample_bits_per_sample(mp_obj_t sample_obj);
 uint8_t audiosample_channel_count(mp_obj_t sample_obj);
diff --git a/shared-module/audiomixer/Mixer.c b/shared-module/audiomixer/Mixer.c
index a52489f85..afa3a0632 100644
--- a/shared-module/audiomixer/Mixer.c
+++ b/shared-module/audiomixer/Mixer.c
@@ -76,6 +76,14 @@ uint32_t common_hal_audiomixer_mixer_get_sample_rate(audiomixer_mixer_obj_t* sel
     return self->sample_rate;
 }
 
+uint8_t common_hal_audiomixer_mixer_get_channel_count(audiomixer_mixer_obj_t* self) {
+    return self->channel_count;
+}
+
+uint8_t common_hal_audiomixer_mixer_get_bits_per_sample(audiomixer_mixer_obj_t* self) {
+    return self->bits_per_sample;
+}
+
 bool common_hal_audiomixer_mixer_get_playing(audiomixer_mixer_obj_t* self) {
     for (uint8_t v = 0; v < self->voice_count; v++) {
         if (common_hal_audiomixer_mixervoice_get_playing(MP_OBJ_TO_PTR(self->voice[v]))) {
diff --git a/shared-module/board/__init__.c b/shared-module/board/__init__.c
index dd07d7190..914bc4313 100644
--- a/shared-module/board/__init__.c
+++ b/shared-module/board/__init__.c
@@ -101,7 +101,7 @@ mp_obj_t common_hal_board_create_uart(void) {
     const mcu_pin_obj_t* rx = MP_OBJ_TO_PTR(DEFAULT_UART_BUS_RX);
     const mcu_pin_obj_t* tx = MP_OBJ_TO_PTR(DEFAULT_UART_BUS_TX);
 
-    common_hal_busio_uart_construct(self, tx, rx, 9600, 8, PARITY_NONE, 1, 1000, 64);
+    common_hal_busio_uart_construct(self, tx, rx, 9600, 8, PARITY_NONE, 1, 1.0f, 64);
     MP_STATE_VM(shared_uart_bus) = MP_OBJ_FROM_PTR(self);
     return MP_STATE_VM(shared_uart_bus);
 }
diff --git a/shared-module/displayio/Display.c b/shared-module/displayio/Display.c
index 06b81f2f8..11db0f8ff 100644
--- a/shared-module/displayio/Display.c
+++ b/shared-module/displayio/Display.c
@@ -35,6 +35,7 @@
 #include "shared-module/displayio/__init__.h"
 #include "shared-module/displayio/display_core.h"
 #include "supervisor/shared/display.h"
+#include "supervisor/shared/tick.h"
 #include "supervisor/usb.h"
 
 #include <stdint.h>
@@ -113,7 +114,7 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
         if (result != PWMOUT_OK) {
             self->backlight_inout.base.type = &digitalio_digitalinout_type;
             common_hal_digitalio_digitalinout_construct(&self->backlight_inout, backlight_pin);
-            never_reset_pin_number(backlight_pin->number);
+            common_hal_never_reset_pin(backlight_pin);
         } else {
             self->backlight_pwm.base.type = &pulseio_pwmout_type;
             common_hal_pulseio_pwmout_never_reset(&self->backlight_pwm);
@@ -313,7 +314,7 @@ uint16_t common_hal_displayio_display_get_rotation(displayio_display_obj_t* self
 
 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) {
-        uint64_t current_time = ticks_ms;
+        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.
         if (current_ms_since_real_refresh > maximum_ms_per_real_frame) {
@@ -327,7 +328,7 @@ bool common_hal_displayio_display_refresh(displayio_display_obj_t* self, uint32_
         }
         uint32_t remaining_time = target_ms_per_frame - (current_ms_since_real_refresh % target_ms_per_frame);
         // We're ahead of the game so wait until we align with the frame rate.
-        while (ticks_ms - self->last_refresh_call < remaining_time) {
+        while (supervisor_ticks_ms64() - self->last_refresh_call < remaining_time) {
             RUN_BACKGROUND_TASKS;
         }
     }
@@ -350,20 +351,20 @@ STATIC void _update_backlight(displayio_display_obj_t* self) {
     if (!self->auto_brightness || self->updating_backlight) {
         return;
     }
-    if (ticks_ms - self->last_backlight_refresh < 100) {
+    if (supervisor_ticks_ms64() - self->last_backlight_refresh < 100) {
         return;
     }
     // TODO(tannewt): Fade the backlight based on it's existing value and a target value. The target
     // should account for ambient light when possible.
     common_hal_displayio_display_set_brightness(self, 1.0);
 
-    self->last_backlight_refresh = ticks_ms;
+    self->last_backlight_refresh = supervisor_ticks_ms64();
 }
 
 void displayio_display_background(displayio_display_obj_t* self) {
     _update_backlight(self);
 
-    if (self->auto_refresh && (ticks_ms - self->core.last_refresh) > self->native_ms_per_frame) {
+    if (self->auto_refresh && (supervisor_ticks_ms64() - self->core.last_refresh) > self->native_ms_per_frame) {
         _refresh_display(self);
     }
 }
diff --git a/shared-module/displayio/EPaperDisplay.c b/shared-module/displayio/EPaperDisplay.c
index efbd9f3dd..91d4bb7f9 100644
--- a/shared-module/displayio/EPaperDisplay.c
+++ b/shared-module/displayio/EPaperDisplay.c
@@ -26,6 +26,7 @@
 
 #include "shared-bindings/displayio/EPaperDisplay.h"
 
+#include "py/gc.h"
 #include "py/runtime.h"
 #include "shared-bindings/displayio/ColorConverter.h"
 #include "shared-bindings/displayio/FourWire.h"
@@ -35,6 +36,7 @@
 #include "shared-bindings/time/__init__.h"
 #include "shared-module/displayio/__init__.h"
 #include "supervisor/shared/display.h"
+#include "supervisor/shared/tick.h"
 #include "supervisor/usb.h"
 
 #include <stdint.h>
@@ -82,7 +84,7 @@ void common_hal_displayio_epaperdisplay_construct(displayio_epaperdisplay_obj_t*
     if (busy_pin != NULL) {
         self->busy.base.type = &digitalio_digitalinout_type;
         common_hal_digitalio_digitalinout_construct(&self->busy, busy_pin);
-        never_reset_pin_number(busy_pin->number);
+        common_hal_never_reset_pin(busy_pin);
     }
 
     // Clear the color memory if it isn't in use.
@@ -175,7 +177,7 @@ uint32_t common_hal_displayio_epaperdisplay_get_time_to_refresh(displayio_epaper
         return 0;
     }
     // Refresh at seconds per frame rate.
-    uint32_t elapsed_time = ticks_ms - self->core.last_refresh;
+    uint32_t elapsed_time = supervisor_ticks_ms64() - self->core.last_refresh;
     if (elapsed_time > self->milliseconds_per_frame) {
         return 0;
     }
@@ -298,7 +300,7 @@ bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, c
 }
 
 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) {
             self->refreshing = false;
@@ -339,7 +341,7 @@ void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t* self) {
             bool busy = common_hal_digitalio_digitalinout_get_value(&self->busy);
             refresh_done = busy != self->busy_state;
         } else {
-            refresh_done = ticks_ms - self->core.last_refresh > self->refresh_time;
+            refresh_done = supervisor_ticks_ms64() - self->core.last_refresh > self->refresh_time;
         }
         if (refresh_done) {
             self->refreshing = false;
@@ -365,6 +367,8 @@ void release_epaperdisplay(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(self->start_sequence);
+    gc_collect_ptr(self->stop_sequence);
 }
 
 bool maybe_refresh_epaperdisplay(void) {
diff --git a/shared-module/displayio/FourWire.c b/shared-module/displayio/FourWire.c
index fcc4c1a20..256c29642 100644
--- a/shared-module/displayio/FourWire.c
+++ b/shared-module/displayio/FourWire.c
@@ -31,6 +31,7 @@
 #include "py/gc.h"
 #include "shared-bindings/busio/SPI.h"
 #include "shared-bindings/digitalio/DigitalInOut.h"
+#include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/time/__init__.h"
 #include "shared-module/displayio/display_core.h"
@@ -48,8 +49,8 @@ void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self,
     gc_never_free(self->bus);
 
     self->frequency = baudrate;
-    self->polarity = common_hal_busio_spi_get_polarity(spi);
-    self->phase = common_hal_busio_spi_get_phase(spi);
+    self->polarity = 0;
+    self->phase = 0;
 
     common_hal_digitalio_digitalinout_construct(&self->command, command);
     common_hal_digitalio_digitalinout_switch_to_output(&self->command, true, DRIVE_MODE_PUSH_PULL);
@@ -61,12 +62,12 @@ void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self,
         self->reset.base.type = &digitalio_digitalinout_type;
         common_hal_digitalio_digitalinout_construct(&self->reset, reset);
         common_hal_digitalio_digitalinout_switch_to_output(&self->reset, true, DRIVE_MODE_PUSH_PULL);
-        never_reset_pin_number(reset->number);
+        common_hal_never_reset_pin(reset);
         common_hal_displayio_fourwire_reset(self);
     }
 
-    never_reset_pin_number(command->number);
-    never_reset_pin_number(chip_select->number);
+    common_hal_never_reset_pin(command);
+    common_hal_never_reset_pin(chip_select);
 }
 
 void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t* self) {
@@ -74,9 +75,9 @@ void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t* self) {
         common_hal_busio_spi_deinit(self->bus);
     }
 
-    reset_pin_number(self->command.pin->number);
-    reset_pin_number(self->chip_select.pin->number);
-    reset_pin_number(self->reset.pin->number);
+    common_hal_reset_pin(self->command.pin);
+    common_hal_reset_pin(self->chip_select.pin);
+    common_hal_reset_pin(self->reset.pin);
 }
 
 bool common_hal_displayio_fourwire_reset(mp_obj_t obj) {
diff --git a/shared-module/displayio/I2CDisplay.c b/shared-module/displayio/I2CDisplay.c
index d9452dc50..280476f19 100644
--- a/shared-module/displayio/I2CDisplay.c
+++ b/shared-module/displayio/I2CDisplay.c
@@ -33,6 +33,7 @@
 #include "py/runtime.h"
 #include "shared-bindings/busio/I2C.h"
 #include "shared-bindings/digitalio/DigitalInOut.h"
+#include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/time/__init__.h"
 #include "shared-module/displayio/display_core.h"
@@ -42,12 +43,22 @@
 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;
+    if (reset != NULL) {
+        self->reset.base.type = &digitalio_digitalinout_type;
+        common_hal_digitalio_digitalinout_construct(&self->reset, reset);
+        common_hal_digitalio_digitalinout_switch_to_output(&self->reset, true, DRIVE_MODE_PUSH_PULL);
+        common_hal_never_reset_pin(reset);
+        common_hal_displayio_i2cdisplay_reset(self);
+    }
+
     // Probe the bus to see if a device acknowledges the given address.
     if (!common_hal_busio_i2c_probe(i2c, device_address)) {
         mp_raise_ValueError_varg(translate("Unable to find I2C Display at %x"), device_address);
     }
 
-        // Write to the device and return 0 on success or an appropriate error code from mperrno.h
+    // Write to the device and return 0 on success or an appropriate error code from mperrno.h
     self->bus = i2c;
     common_hal_busio_i2c_never_reset(self->bus);
     // Our object is statically allocated off the heap so make sure the bus object lives to the end
@@ -55,15 +66,6 @@ void common_hal_displayio_i2cdisplay_construct(displayio_i2cdisplay_obj_t* self,
     gc_never_free(self->bus);
 
     self->address = device_address;
-
-    self->reset.base.type = &mp_type_NoneType;
-    if (reset != NULL) {
-        self->reset.base.type = &digitalio_digitalinout_type;
-        common_hal_digitalio_digitalinout_construct(&self->reset, reset);
-        common_hal_digitalio_digitalinout_switch_to_output(&self->reset, true, DRIVE_MODE_PUSH_PULL);
-        never_reset_pin_number(reset->number);
-        common_hal_displayio_i2cdisplay_reset(self);
-    }
 }
 
 void common_hal_displayio_i2cdisplay_deinit(displayio_i2cdisplay_obj_t* self) {
@@ -71,7 +73,7 @@ void common_hal_displayio_i2cdisplay_deinit(displayio_i2cdisplay_obj_t* self) {
         common_hal_busio_i2c_deinit(self->bus);
     }
 
-    reset_pin_number(self->reset.pin->number);
+    common_hal_reset_pin(self->reset.pin);
 }
 
 bool common_hal_displayio_i2cdisplay_reset(mp_obj_t obj) {
diff --git a/shared-module/displayio/display_core.c b/shared-module/displayio/display_core.c
index a73ea81d1..658daa8d6 100644
--- a/shared-module/displayio/display_core.c
+++ b/shared-module/displayio/display_core.c
@@ -35,6 +35,7 @@
 #include "shared-bindings/time/__init__.h"
 #include "shared-module/displayio/__init__.h"
 #include "supervisor/shared/display.h"
+#include "supervisor/shared/tick.h"
 
 #include <stdint.h>
 #include <string.h>
@@ -281,7 +282,7 @@ void displayio_display_core_set_region_to_update(displayio_display_core_t* self,
 }
 
 void displayio_display_core_start_refresh(displayio_display_core_t* self) {
-    self->last_refresh = ticks_ms;
+    self->last_refresh = supervisor_ticks_ms64();
 }
 
 void displayio_display_core_finish_refresh(displayio_display_core_t* self) {
@@ -289,7 +290,7 @@ void displayio_display_core_finish_refresh(displayio_display_core_t* self) {
         displayio_group_finish_refresh(self->current_group);
     }
     self->full_refresh = false;
-    self->last_refresh = ticks_ms;
+    self->last_refresh = supervisor_ticks_ms64();
 }
 
 void release_display_core(displayio_display_core_t* self) {
diff --git a/shared-module/network/__init__.c b/shared-module/network/__init__.c
index 96648b260..925e9a2a3 100644
--- a/shared-module/network/__init__.c
+++ b/shared-module/network/__init__.c
@@ -31,6 +31,8 @@
 #include "py/mphal.h"
 #include "py/mperrno.h"
 
+#include "supervisor/shared/tick.h"
+
 #include "shared-bindings/random/__init__.h"
 
 #include "shared-module/network/__init__.h"
@@ -53,7 +55,7 @@ void network_module_deinit(void) {
 
 void network_module_background(void) {
     static uint32_t next_tick = 0;
-    uint32_t this_tick = ticks_ms;
+    uint32_t this_tick = supervisor_ticks_ms32();
     if (this_tick < next_tick) return;
     next_tick = this_tick + 1000;
 
diff --git a/shared-module/usb_hid/Device.c b/shared-module/usb_hid/Device.c
index bed7d163f..8744f2ed3 100644
--- a/shared-module/usb_hid/Device.c
+++ b/shared-module/usb_hid/Device.c
@@ -30,6 +30,7 @@
 #include "shared-bindings/usb_hid/Device.h"
 #include "shared-module/usb_hid/Device.h"
 #include "supervisor/shared/translate.h"
+#include "supervisor/shared/tick.h"
 #include "tusb.h"
 
 uint8_t common_hal_usb_hid_device_get_usage_page(usb_hid_device_obj_t *self) {
@@ -46,8 +47,8 @@ void common_hal_usb_hid_device_send_report(usb_hid_device_obj_t *self, uint8_t*
     }
 
     // Wait until interface is ready, timeout = 2 seconds
-    uint64_t end_ticks = ticks_ms + 2000;
-    while ( (ticks_ms < end_ticks) && !tud_hid_ready() ) {
+    uint64_t end_ticks = supervisor_ticks_ms64() + 2000;
+    while ( (supervisor_ticks_ms64() < end_ticks) && !tud_hid_ready() ) {
         RUN_BACKGROUND_TASKS;
     }