diff --git a/ports/espressif/background.c b/ports/espressif/background.c
index 61615c01615b2..b1b81ac2c83a4 100644
--- a/ports/espressif/background.c
+++ b/ports/espressif/background.c
@@ -13,8 +13,8 @@
 #include "freertos/task.h"
 
 void port_background_tick(void) {
-    // Zero delay in case FreeRTOS wants to switch to something else.
-    vTaskDelay(0);
+    // Yield with zero delay in case FreeRTOS wants to switch to something else.
+    port_task_yield();
 }
 
 void port_background_task(void) {
diff --git a/ports/espressif/common-hal/busio/SPI.c b/ports/espressif/common-hal/busio/SPI.c
index 4c07917b20b86..21dc8c383794e 100644
--- a/ports/espressif/common-hal/busio/SPI.c
+++ b/ports/espressif/common-hal/busio/SPI.c
@@ -72,11 +72,6 @@ void common_hal_busio_spi_construct(busio_spi_obj_t *self,
         mp_raise_ValueError(MP_ERROR_TEXT("All SPI peripherals are in use"));
     }
 
-    self->mutex = xSemaphoreCreateMutex();
-    if (self->mutex == NULL) {
-        mp_raise_RuntimeError(MP_ERROR_TEXT("Unable to create lock"));
-    }
-
     esp_err_t result = spi_bus_initialize(self->host_id, &bus_config, SPI_DMA_CH_AUTO);
     if (result == ESP_ERR_NO_MEM) {
         mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("ESP-IDF memory allocation failed"));
@@ -162,11 +157,17 @@ bool common_hal_busio_spi_configure(busio_spi_obj_t *self,
     return true;
 }
 
-bool common_hal_busio_spi_try_lock(busio_spi_obj_t *self) {
+// Wait as long as needed for the lock. This is used by SD card access from USB.
+// Overrides the default busy-wait implementation in shared-bindings/busio/SPI.c
+bool common_hal_busio_spi_wait_for_lock(busio_spi_obj_t *self, uint32_t timeout_ms) {
     if (common_hal_busio_spi_deinited(self)) {
         return false;
     }
-    return xSemaphoreTake(self->mutex, 1) == pdTRUE;
+    return xSemaphoreTake(self->mutex, pdMS_TO_TICKS(timeout_ms)) == pdTRUE;
+}
+
+bool common_hal_busio_spi_try_lock(busio_spi_obj_t *self) {
+    return common_hal_busio_spi_wait_for_lock(self, 0);
 }
 
 bool common_hal_busio_spi_has_lock(busio_spi_obj_t *self) {
diff --git a/ports/espressif/supervisor/port.c b/ports/espressif/supervisor/port.c
index 192a91717169a..b3045026e12d9 100644
--- a/ports/espressif/supervisor/port.c
+++ b/ports/espressif/supervisor/port.c
@@ -251,12 +251,12 @@ safe_mode_t port_init(void) {
     #define pin_GPIOn(n) pin_GPIO##n
     #define pin_GPIOn_EXPAND(x) pin_GPIOn(x)
 
-    #ifdef CONFIG_CONSOLE_UART_TX_GPIO
-    common_hal_never_reset_pin(&pin_GPIOn_EXPAND(CONFIG_CONSOLE_UART_TX_GPIO));
+    #ifdef CONFIG_ESP_CONSOLE_UART_TX_GPIO
+    common_hal_never_reset_pin(&pin_GPIOn_EXPAND(CONFIG_ESP_CONSOLE_UART_TX_GPIO));
     #endif
 
-    #ifdef CONFIG_CONSOLE_UART_RX_GPIO
-    common_hal_never_reset_pin(&pin_GPIOn_EXPAND(CONFIG_CONSOLE_UART_RX_GPIO));
+    #ifdef CONFIG_ESP_CONSOLE_UART_RX_GPIO
+    common_hal_never_reset_pin(&pin_GPIOn_EXPAND(CONFIG_ESP_CONSOLE_UART_RX_GPIO));
     #endif
 
     #ifndef ENABLE_JTAG
@@ -404,8 +404,8 @@ void reset_port(void) {
     watchdog_reset();
     #endif
 
-    // Yield so the idle task can run and do any IDF cleanup needed.
-    port_yield();
+    // Yield so the idle task, at priority 0, can run and do any IDF cleanup needed.
+    port_task_sleep_ms(4);
 }
 
 void reset_to_bootloader(void) {
@@ -483,8 +483,13 @@ void port_wake_main_task_from_isr(void) {
     }
 }
 
-void port_yield(void) {
-    vTaskDelay(4);
+// Yield to other tasks at the same priority.
+void port_task_yield(void) {
+    vTaskDelay(0);
+}
+
+void port_task_sleep_ms(uint32_t msecs) {
+    vTaskDelay(pdMS_TO_TICKS(msecs));
 }
 
 void sleep_timer_cb(void *arg) {
diff --git a/ports/espressif/supervisor/usb.c b/ports/espressif/supervisor/usb.c
index 62feea6981e05..e4d34ee7694f3 100644
--- a/ports/espressif/supervisor/usb.c
+++ b/ports/espressif/supervisor/usb.c
@@ -56,7 +56,8 @@ static void usb_device_task(void *param) {
             tud_task();
             tud_cdc_write_flush();
         }
-        vTaskDelay(1);
+        // Yield with zero delay to switch to any other tasks at same priority.
+        port_task_yield();
     }
 }
 #endif // CIRCUITPY_USB_DEVICE
@@ -112,7 +113,7 @@ void init_usb_hardware(void) {
         "usbd",
         USBD_STACK_SIZE,
         NULL,
-        5,
+        1,
         usb_device_stack,
         &usb_device_taskdef,
         xPortGetCoreID());
diff --git a/ports/raspberrypi/supervisor/port.c b/ports/raspberrypi/supervisor/port.c
index 5cfbdfa66a32b..bb6482240a697 100644
--- a/ports/raspberrypi/supervisor/port.c
+++ b/ports/raspberrypi/supervisor/port.c
@@ -600,7 +600,7 @@ __attribute__((used)) void __not_in_flash_func(isr_hardfault)(void) {
     }
 }
 
-void port_yield(void) {
+void port_task_yield(void) {
     #if CIRCUITPY_CYW43
     cyw43_arch_poll();
     #endif
diff --git a/ports/renode/supervisor/port.c b/ports/renode/supervisor/port.c
index d12ebd2efddb9..a40e222d34df3 100644
--- a/ports/renode/supervisor/port.c
+++ b/ports/renode/supervisor/port.c
@@ -210,7 +210,7 @@ __attribute__((used)) void HardFault_Handler(void) {
     }
 }
 
-void port_yield(void) {
+void port_task_yield(void) {
 }
 
 void port_boot_info(void) {
diff --git a/ports/zephyr-cp/supervisor/port.c b/ports/zephyr-cp/supervisor/port.c
index 401b283ba8496..c40475177e000 100644
--- a/ports/zephyr-cp/supervisor/port.c
+++ b/ports/zephyr-cp/supervisor/port.c
@@ -170,10 +170,14 @@ void port_wake_main_task_from_isr(void) {
     k_event_set(&main_needed, 1);
 }
 
-void port_yield(void) {
+void port_task_yield(void) {
     k_yield();
 }
 
+void port_task_sleep_ms(uint32_t msecs) {
+    k_msleep(msecs);
+}
+
 void port_boot_info(void) {
 }
 
diff --git a/py/circuitpy_defns.mk b/py/circuitpy_defns.mk
index ae7ec7da7b763..886ba96f3e5fa 100644
--- a/py/circuitpy_defns.mk
+++ b/py/circuitpy_defns.mk
@@ -201,6 +201,9 @@ endif
 ifeq ($(CIRCUITPY_DISPLAYIO),1)
 SRC_PATTERNS += displayio/%
 endif
+ifeq ($(CIRCUITPY_DOTCLOCKFRAMEBUFFER),1)
+SRC_PATTERNS += dotclockframebuffer/%
+endif
 ifeq ($(CIRCUITPY_DUALBANK),1)
 SRC_PATTERNS += dualbank/%
 endif
@@ -228,9 +231,6 @@ endif
 ifeq ($(CIRCUITPY_FOURWIRE),1)
 SRC_PATTERNS += fourwire/%
 endif
-ifeq ($(CIRCUITPY_QSPIBUS),1)
-SRC_PATTERNS += qspibus/%
-endif
 ifeq ($(CIRCUITPY_FRAMEBUFFERIO),1)
 SRC_PATTERNS += framebufferio/%
 endif
@@ -357,8 +357,8 @@ endif
 ifeq ($(CIRCUITPY_RGBMATRIX),1)
 SRC_PATTERNS += rgbmatrix/%
 endif
-ifeq ($(CIRCUITPY_DOTCLOCKFRAMEBUFFER),1)
-SRC_PATTERNS += dotclockframebuffer/%
+ifeq ($(CIRCUITPY_QSPIBUS),1)
+SRC_PATTERNS += qspibus/%
 endif
 ifeq ($(CIRCUITPY_RP2PIO),1)
 SRC_PATTERNS += rp2pio/%
diff --git a/py/mpconfig.h b/py/mpconfig.h
index a48958200616b..5ff568e64b00a 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -2205,6 +2205,12 @@ typedef double mp_float_t;
 #define MP_INLINE inline MP_NO_INSTRUMENT
 #endif
 
+// CIRCUITPY-CHANGE
+// Modifier for functions whose return value should not be ignored
+#ifndef MP_WARN_UNUSED_RESULT
+#define MP_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+#endif
+
 // Modifier for functions which should be never inlined
 #ifndef MP_NOINLINE
 #define MP_NOINLINE __attribute__((noinline))
diff --git a/shared-bindings/busdisplay/BusDisplay.c b/shared-bindings/busdisplay/BusDisplay.c
index 297a869057700..0bf171a5d089c 100644
--- a/shared-bindings/busdisplay/BusDisplay.c
+++ b/shared-bindings/busdisplay/BusDisplay.c
@@ -122,7 +122,6 @@
 //|         :param int native_frames_per_second: Number of display refreshes per second that occur with the given init_sequence.
 //|         :param bool backlight_on_high: If True, pulling the backlight pin high turns the backlight on.
 //|         :param bool SH1107_addressing: Special quirk for SH1107, use upper/lower column set and page set
-//|         :param int set_vertical_scroll: This parameter is accepted but ignored for backwards compatibility. It will be removed in a future release.
 //|         :param int backlight_pwm_frequency: The frequency to use to drive the PWM for backlight brightness control. Default is 50000.
 //|         """
 //|         ...
@@ -133,7 +132,7 @@ static mp_obj_t busdisplay_busdisplay_make_new(const mp_obj_type_t *type, size_t
            ARG_rotation, ARG_color_depth, ARG_grayscale, ARG_pixels_in_byte_share_row,
            ARG_bytes_per_cell, ARG_reverse_pixels_in_byte, ARG_reverse_bytes_in_word,
            ARG_set_column_command, ARG_set_row_command, ARG_write_ram_command,
-           ARG_set_vertical_scroll, ARG_backlight_pin, ARG_brightness_command,
+           ARG_backlight_pin, ARG_brightness_command,
            ARG_brightness, ARG_single_byte_bounds, ARG_data_as_commands,
            ARG_auto_refresh, ARG_native_frames_per_second, ARG_backlight_on_high,
            ARG_SH1107_addressing, ARG_backlight_pwm_frequency };
@@ -154,7 +153,6 @@ static mp_obj_t busdisplay_busdisplay_make_new(const mp_obj_type_t *type, size_t
         { MP_QSTR_set_column_command, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0x2a} },
         { MP_QSTR_set_row_command, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0x2b} },
         { MP_QSTR_write_ram_command, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0x2c} },
-        { MP_QSTR_set_vertical_scroll, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 0x0} },
         { MP_QSTR_backlight_pin, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_obj = mp_const_none} },
         { MP_QSTR_brightness_command, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = NO_BRIGHTNESS_COMMAND} },
         { MP_QSTR_brightness, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_obj = MP_OBJ_NEW_SMALL_INT(1)} },
diff --git a/shared-bindings/busio/SPI.c b/shared-bindings/busio/SPI.c
index 132da473af94e..962080648ce4d 100644
--- a/shared-bindings/busio/SPI.c
+++ b/shared-bindings/busio/SPI.c
@@ -9,17 +9,17 @@
 
 #include <string.h>
 
+#include "py/binary.h"
+#include "py/mperrno.h"
+#include "py/objproperty.h"
+#include "py/runtime.h"
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/busio/SPI.h"
 #include "shared-bindings/util.h"
-
 #include "shared/runtime/buffer_helper.h"
 #include "shared/runtime/context_manager_helpers.h"
-#include "py/binary.h"
-#include "py/mperrno.h"
-#include "py/objproperty.h"
-#include "py/runtime.h"
-
+#include "shared/runtime/interrupt_char.h"
+#include "supervisor/shared/tick.h"
 
 //| class SPI:
 //|     """A 3-4 wire serial protocol
@@ -494,3 +494,17 @@ MP_DEFINE_CONST_OBJ_TYPE(
 busio_spi_obj_t *validate_obj_is_spi_bus(mp_obj_t obj, qstr arg_name) {
     return mp_arg_validate_type(obj, &busio_spi_type, arg_name);
 }
+
+// Wait as long as needed for the lock. This is used by SD card access from USB.
+// The default implementation is to busy-wait while running the background tasks. espressif is different.
+bool common_hal_busio_spi_wait_for_lock(busio_spi_obj_t *self, uint32_t timeout_ms) {
+    uint64_t deadline = supervisor_ticks_ms64() + timeout_ms;
+    while (supervisor_ticks_ms64() < deadline &&
+           !mp_hal_is_interrupted()) {
+        if (common_hal_busio_spi_try_lock(self)) {
+            return true;
+        }
+        RUN_BACKGROUND_TASKS;
+    }
+    return false;
+}
diff --git a/shared-bindings/busio/SPI.h b/shared-bindings/busio/SPI.h
index 34f34c927f613..76ed697d66531 100644
--- a/shared-bindings/busio/SPI.h
+++ b/shared-bindings/busio/SPI.h
@@ -54,3 +54,7 @@ uint8_t common_hal_busio_spi_get_polarity(busio_spi_obj_t *self);
 extern void common_hal_busio_spi_never_reset(busio_spi_obj_t *self);
 
 extern busio_spi_obj_t *validate_obj_is_spi_bus(mp_obj_t obj_in, qstr arg_name);
+
+// Wait as long as needed for the lock. This is used by SD card access from USB.
+// For most ports, busy-wait while running the background tasks.
+MP_WEAK bool common_hal_busio_spi_wait_for_lock(busio_spi_obj_t *self, uint32_t timeout_ms);
diff --git a/shared-module/busdisplay/BusDisplay.c b/shared-module/busdisplay/BusDisplay.c
index 5d8d396cbb46f..01e0f7a7896f0 100644
--- a/shared-module/busdisplay/BusDisplay.c
+++ b/shared-module/busdisplay/BusDisplay.c
@@ -6,6 +6,7 @@
 
 #include "shared-bindings/busdisplay/BusDisplay.h"
 
+#include "py/mphal.h"
 #include "py/runtime.h"
 #if CIRCUITPY_FOURWIRE
 #include "shared-bindings/fourwire/FourWire.h"
@@ -16,6 +17,7 @@
 #if CIRCUITPY_PARALLELDISPLAYBUS
 #include "shared-bindings/paralleldisplaybus/ParallelBus.h"
 #endif
+#include "shared/runtime/interrupt_char.h"
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/time/__init__.h"
 #include "shared-module/displayio/__init__.h"
@@ -73,6 +75,9 @@ void common_hal_busdisplay_busdisplay_construct(busdisplay_busdisplay_obj_t *sel
         uint8_t *data = cmd + 2;
         while (!displayio_display_bus_begin_transaction(&self->bus)) {
             RUN_BACKGROUND_TASKS;
+            if (mp_hal_is_interrupted()) {
+                mp_raise_RuntimeError_varg(MP_ERROR_TEXT("%q init failed"), MP_QSTR_display);
+            }
         }
         if (self->bus.data_as_commands) {
             uint8_t full_command[data_size + 1];
@@ -288,6 +293,7 @@ static bool _refresh_area(busdisplay_busdisplay_obj_t *self, const displayio_are
 
         displayio_display_bus_set_region_to_update(&self->bus, &self->core, &subrectangle);
 
+        // Can't acquire display bus; skip the rest of the data.
         if (!displayio_display_bus_begin_transaction(&self->bus)) {
             return false;
         }
diff --git a/shared-module/displayio/__init__.c b/shared-module/displayio/__init__.c
index ce90bf8f1c327..ae9bc40a2ae83 100644
--- a/shared-module/displayio/__init__.c
+++ b/shared-module/displayio/__init__.c
@@ -146,6 +146,9 @@ static void common_hal_displayio_release_displays_impl(bool keep_primary) {
         displays[i].display_base.type = &mp_type_NoneType;
     }
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
+        if (i == primary_display_number) {
+            continue;
+        }
         mp_const_obj_t bus_type = display_buses[i].bus_base.type;
         if (bus_type == NULL || bus_type == &mp_type_NoneType) {
             continue;
@@ -197,7 +200,9 @@ static void common_hal_displayio_release_displays_impl(bool keep_primary) {
         display_buses[i].bus_base.type = &mp_type_NoneType;
     }
 
-    supervisor_stop_terminal();
+    if (!keep_primary) {
+        supervisor_stop_terminal();
+    }
 }
 
 void common_hal_displayio_release_displays(void) {
@@ -205,8 +210,9 @@ void common_hal_displayio_release_displays(void) {
 }
 
 void reset_displays(void) {
-    // In CircuitPython 10, release secondary displays before doing anything else:
-    // common_hal_displayio_release_displays_impl(true);
+    // TODO: In CircuitPython 11, uncomment the call.
+    // Release secondary displays.
+    // common_hal_displayio_release_displays_impl(/*keep_primary*/ true);
 
     // 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++) {
diff --git a/shared-module/displayio/bus_core.c b/shared-module/displayio/bus_core.c
index bfa6192351110..9b3fb426217e1 100644
--- a/shared-module/displayio/bus_core.c
+++ b/shared-module/displayio/bus_core.c
@@ -101,11 +101,16 @@ void displayio_display_bus_construct(displayio_display_bus_t *self,
     self->bus = bus;
 }
 
+// This is just a hint, and is not a reliable result, since the bus could be grabbed in between this called
+// and the attempt to use the bus. Use displayio_display_bus_begin_transaction(), which is atomic.
 bool displayio_display_bus_is_free(displayio_display_bus_t *self) {
     return !self->bus || self->bus_free(self->bus);
 }
 
-bool displayio_display_bus_begin_transaction(displayio_display_bus_t *self) {
+MP_WARN_UNUSED_RESULT bool displayio_display_bus_begin_transaction(displayio_display_bus_t *self) {
+    if (!self->bus) {
+        return false;
+    }
     mp_obj_base_t *bus_base = MP_OBJ_TO_PTR(self->bus);
     if (bus_base->type == &mp_type_NoneType) {
         return false;
@@ -144,7 +149,9 @@ void displayio_display_bus_set_region_to_update(displayio_display_bus_t *self, d
     }
 
     // Set column.
-    displayio_display_bus_begin_transaction(self);
+    if (!displayio_display_bus_begin_transaction(self)) {
+        return;
+    }
     uint8_t data[5];
     data[0] = self->column_command;
     uint8_t data_length = 1;
@@ -183,7 +190,9 @@ void displayio_display_bus_set_region_to_update(displayio_display_bus_t *self, d
 
     if (self->set_current_column_command != NO_COMMAND) {
         uint8_t command = self->set_current_column_command;
-        displayio_display_bus_begin_transaction(self);
+        if (!displayio_display_bus_begin_transaction(self)) {
+            return;
+        }
         self->send(self->bus, DISPLAY_COMMAND, chip_select, &command, 1);
         // Only send the first half of data because it is the first coordinate.
         self->send(self->bus, DISPLAY_DATA, chip_select, data, data_length / 2);
@@ -192,7 +201,9 @@ void displayio_display_bus_set_region_to_update(displayio_display_bus_t *self, d
 
 
     // Set row.
-    displayio_display_bus_begin_transaction(self);
+    if (!displayio_display_bus_begin_transaction(self)) {
+        return;
+    }
     data[0] = self->row_command;
     data_length = 1;
     if (!self->data_as_commands) {
@@ -227,7 +238,9 @@ void displayio_display_bus_set_region_to_update(displayio_display_bus_t *self, d
 
     if (self->set_current_row_command != NO_COMMAND) {
         uint8_t command = self->set_current_row_command;
-        displayio_display_bus_begin_transaction(self);
+        if (!displayio_display_bus_begin_transaction(self)) {
+            return;
+        }
         self->send(self->bus, DISPLAY_COMMAND, chip_select, &command, 1);
         // Only send the first half of data because it is the first coordinate.
         self->send(self->bus, DISPLAY_DATA, chip_select, data, data_length / 2);
diff --git a/shared-module/epaperdisplay/EPaperDisplay.c b/shared-module/epaperdisplay/EPaperDisplay.c
index 655ae10307155..d34be9d5c7c0a 100644
--- a/shared-module/epaperdisplay/EPaperDisplay.c
+++ b/shared-module/epaperdisplay/EPaperDisplay.c
@@ -153,7 +153,10 @@ static void send_command_sequence(epaperdisplay_epaperdisplay_obj_t *self,
             data_size = ((data_size & ~DELAY) << 8) + *(cmd + 2);
             data = cmd + 3;
         }
-        displayio_display_bus_begin_transaction(&self->bus);
+        while (!displayio_display_bus_begin_transaction(&self->bus) &&
+               !mp_hal_is_interrupted()) {
+            RUN_BACKGROUND_TASKS;
+        }
         self->bus.send(self->bus.bus, DISPLAY_COMMAND, self->chip_select, cmd, 1);
         self->bus.send(self->bus.bus, DISPLAY_DATA, self->chip_select, data, data_size);
         displayio_display_bus_end_transaction(&self->bus);
@@ -311,7 +314,10 @@ static bool epaperdisplay_epaperdisplay_refresh_area(epaperdisplay_epaperdisplay
         if (pass == 1) {
             write_command = self->write_color_ram_command;
         }
-        displayio_display_bus_begin_transaction(&self->bus);
+        if (!displayio_display_bus_begin_transaction(&self->bus)) {
+            // Display bus not available now.
+            return false;
+        }
         self->bus.send(self->bus.bus, DISPLAY_COMMAND, self->chip_select, &write_command, 1);
         displayio_display_bus_end_transaction(&self->bus);
 
@@ -388,7 +394,9 @@ static bool _clean_area(epaperdisplay_epaperdisplay_obj_t *self) {
     memset(buffer, 0x77, width / 2);
 
     uint8_t write_command = self->write_black_ram_command;
-    displayio_display_bus_begin_transaction(&self->bus);
+    if (displayio_display_bus_begin_transaction(&self->bus)) {
+        return false;
+    }
     self->bus.send(self->bus.bus, DISPLAY_COMMAND, self->chip_select, &write_command, 1);
     displayio_display_bus_end_transaction(&self->bus);
 
diff --git a/shared-module/sdcardio/SDCard.c b/shared-module/sdcardio/SDCard.c
index 878fed7a13c9b..5d3c021f27ed4 100644
--- a/shared-module/sdcardio/SDCard.c
+++ b/shared-module/sdcardio/SDCard.c
@@ -7,15 +7,16 @@
 // This implementation largely follows the structure of adafruit_sdcard.py
 
 #include "extmod/vfs.h"
-
 #include "shared-bindings/busio/SPI.h"
 #include "shared-bindings/digitalio/DigitalInOut.h"
 #include "shared-bindings/sdcardio/SDCard.h"
 #include "shared-bindings/time/__init__.h"
 #include "shared-bindings/util.h"
 #include "shared-module/sdcardio/SDCard.h"
+#include "supervisor/shared/tick.h"
 
 #include "py/mperrno.h"
+#include "py/mphal.h"
 
 #if 0
 #define DEBUG_PRINT(...) ((void)mp_printf(&mp_plat_print,##__VA_ARGS__))
@@ -23,7 +24,15 @@
 #define DEBUG_PRINT(...) ((void)0)
 #endif
 
-#define CMD_TIMEOUT (200)
+// https://nodeloop.org/guides/sd-card-spi-init-guide/ is an excellent source of info for SPI card use.
+
+// https://www.taterli.com/wp-content/uploads/2017/05/Physical-Layer-Simplified-SpecificationV6.0.pdf
+// specifies timeouts for read (100 ms), write (250 ms), erase (depends on size), and other operations.
+#define CMD_TIMEOUT_MS (250)
+#define SPI_TIMEOUT_MS (250)
+// Init ready timeout.
+#define READY_TIMEOUT_MS (300)
+
 
 #define R1_IDLE_STATE (1 << 0)
 #define R1_ILLEGAL_COMMAND (1 << 2)
@@ -54,9 +63,8 @@ static bool lock_and_configure_bus(sdcardio_sdcard_obj_t *self) {
     if (common_hal_sdcardio_sdcard_deinited(self)) {
         return false;
     }
-    common_hal_sdcardio_check_for_deinit(self);
 
-    if (!common_hal_busio_spi_try_lock(self->bus)) {
+    if (!common_hal_busio_spi_wait_for_lock(self->bus, SPI_TIMEOUT_MS)) {
         return false;
     }
 
@@ -79,11 +87,10 @@ static void lock_bus_or_throw(sdcardio_sdcard_obj_t *self) {
 }
 
 static void clock_card(sdcardio_sdcard_obj_t *self, int bytes) {
-    uint8_t buf[] = {0xff};
+    uint8_t buf[bytes];
+    memset(buf, 0xff, bytes);
     common_hal_digitalio_digitalinout_set_value(&self->cs, true);
-    for (int i = 0; i < bytes; i++) {
-        common_hal_busio_spi_write(self->bus, buf, 1);
-    }
+    common_hal_busio_spi_write(self->bus, buf, bytes);
 }
 
 static void extraclock_and_unlock_bus(sdcardio_sdcard_obj_t *self) {
@@ -106,21 +113,35 @@ static uint8_t CRC7(const uint8_t *data, uint8_t n) {
     return (crc << 1) | 1;
 }
 
-#define READY_TIMEOUT_NS (300 * 1000 * 1000) // 300ms
-static int wait_for_ready(sdcardio_sdcard_obj_t *self) {
-    uint64_t deadline = common_hal_time_monotonic_ns() + READY_TIMEOUT_NS;
-    while (common_hal_time_monotonic_ns() < deadline) {
+// Assumes that the spi lock has been acquired.
+//
+// Mask the incoming value with mask. Use 0xff to not mask.
+// if not_match is true, wait for something NOT matching the value.
+// Return the response as an int32_t (which is always >= 0), or -1 if timed out.
+static int32_t wait_for_masked_response(sdcardio_sdcard_obj_t *self, uint8_t mask, uint8_t response, bool not_match, uint32_t timeout_ms) {
+    uint64_t deadline = supervisor_ticks_ms64() + timeout_ms;
+    while (supervisor_ticks_ms64() < deadline) {
         uint8_t b;
         common_hal_busio_spi_read(self->bus, &b, 1, 0xff);
-        if (b == 0xff) {
-            return 0;
+        if (((b & mask) == response) ^ not_match) {
+            return b;
         }
     }
-    return -ETIMEDOUT;
+    return -1;
+}
+
+// Wait for the given response byte.
+static bool wait_for_response(sdcardio_sdcard_obj_t *self, uint8_t response) {
+    return wait_for_masked_response(self, 0xff, response, false, CMD_TIMEOUT_MS) != -1;
+}
+
+// Wait for 0xff, with a specific timeout.
+static bool wait_for_ready(sdcardio_sdcard_obj_t *self) {
+    return wait_for_masked_response(self, 0xff, 0xff, false, READY_TIMEOUT_MS) != -1;
 }
 
 // Note: this is never called while "in cmd25" (in fact, it's only used by `exit_cmd25`)
-static int cmd_nodata(sdcardio_sdcard_obj_t *self, int cmd, int response) {
+static mp_negative_errno_t cmd_nodata(sdcardio_sdcard_obj_t *self, int cmd, int response) {
     uint8_t cmdbuf[2] = {cmd, 0xff};
 
     assert(!self->in_cmd25);
@@ -128,17 +149,14 @@ static int cmd_nodata(sdcardio_sdcard_obj_t *self, int cmd, int response) {
     common_hal_busio_spi_write(self->bus, cmdbuf, sizeof(cmdbuf));
 
     // Wait for the response (response[7] == response)
-    for (int i = 0; i < CMD_TIMEOUT; i++) {
-        common_hal_busio_spi_read(self->bus, cmdbuf, 1, 0xff);
-        if (cmdbuf[0] == response) {
-            return 0;
-        }
+    if (wait_for_response(self, response)) {
+        return 0;
     }
     return -MP_EIO;
 }
 
 
-static int exit_cmd25(sdcardio_sdcard_obj_t *self) {
+static mp_negative_errno_t exit_cmd25(sdcardio_sdcard_obj_t *self) {
     if (self->in_cmd25) {
         DEBUG_PRINT("exit cmd25\n");
         self->in_cmd25 = false;
@@ -149,7 +167,7 @@ static int exit_cmd25(sdcardio_sdcard_obj_t *self) {
 
 // In Python API, defaults are response=None, data_block=True, wait=True
 static int cmd(sdcardio_sdcard_obj_t *self, int cmd, int arg, void *response_buf, size_t response_len, bool data_block, bool wait) {
-    int r = exit_cmd25(self);
+    mp_negative_errno_t r = exit_cmd25(self);
     if (r < 0) {
         return r;
     }
@@ -164,25 +182,17 @@ static int cmd(sdcardio_sdcard_obj_t *self, int cmd, int arg, void *response_buf
     cmdbuf[5] = CRC7(cmdbuf, 5);
 
     if (wait) {
-        r = wait_for_ready(self);
-        if (r < 0) {
-            return r;
+        if (!wait_for_ready(self)) {
+            return -MP_ETIMEDOUT;
         }
     }
 
     common_hal_busio_spi_write(self->bus, cmdbuf, sizeof(cmdbuf));
 
     // Wait for the response (response[7] == 0)
-    bool response_received = false;
-    for (int i = 0; i < CMD_TIMEOUT; i++) {
-        common_hal_busio_spi_read(self->bus, cmdbuf, 1, 0xff);
-        if ((cmdbuf[0] & 0x80) == 0) {
-            response_received = true;
-            break;
-        }
-    }
-
-    if (!response_received) {
+    // Now wait for cmd response, which is the high bit being 0.
+    int32_t response = wait_for_masked_response(self, 0x80, 0, false, CMD_TIMEOUT_MS);
+    if (response == -1) {
         return -MP_EIO;
     }
 
@@ -190,22 +200,25 @@ static int cmd(sdcardio_sdcard_obj_t *self, int cmd, int arg, void *response_buf
 
         if (data_block) {
             cmdbuf[1] = 0xff;
-            do {
-                // Wait for the start block byte
-                common_hal_busio_spi_read(self->bus, cmdbuf + 1, 1, 0xff);
-            } while (cmdbuf[1] != 0xfe);
+            if (!wait_for_response(self, 0xfe)) {
+                return -MP_EIO;
+            }
         }
 
-        common_hal_busio_spi_read(self->bus, response_buf, response_len, 0xff);
+        if (!common_hal_busio_spi_read(self->bus, response_buf, response_len, 0xff)) {
+            return -MP_EIO;
+        }
 
         if (data_block) {
             // Read and discard the CRC-CCITT checksum
-            common_hal_busio_spi_read(self->bus, cmdbuf + 1, 2, 0xff);
+            if (!common_hal_busio_spi_read(self->bus, cmdbuf + 1, 2, 0xff)) {
+                return -MP_EIO;
+            }
         }
 
     }
 
-    return cmdbuf[0];
+    return response;
 }
 
 static int block_cmd(sdcardio_sdcard_obj_t *self, int cmd_, int block, void *response_buf, size_t response_len, bool data_block, bool wait) {
@@ -213,7 +226,8 @@ static int block_cmd(sdcardio_sdcard_obj_t *self, int cmd_, int block, void *res
 }
 
 static mp_rom_error_text_t init_card_v1(sdcardio_sdcard_obj_t *self) {
-    for (int i = 0; i < CMD_TIMEOUT; i++) {
+    uint64_t deadline = supervisor_ticks_ms64() + CMD_TIMEOUT_MS;
+    while (supervisor_ticks_ms64() < deadline) {
         if (cmd(self, 41, 0, NULL, 0, true, true) == 0) {
             return NULL;
         }
@@ -222,7 +236,8 @@ static mp_rom_error_text_t init_card_v1(sdcardio_sdcard_obj_t *self) {
 }
 
 static mp_rom_error_text_t init_card_v2(sdcardio_sdcard_obj_t *self) {
-    for (int i = 0; i < CMD_TIMEOUT; i++) {
+    uint64_t deadline = supervisor_ticks_ms64() + CMD_TIMEOUT_MS;
+    while (supervisor_ticks_ms64() < deadline) {
         uint8_t ocr[4];
         common_hal_time_delay_ms(50);
         cmd(self, 58, 0, ocr, sizeof(ocr), false, true);
@@ -239,6 +254,8 @@ static mp_rom_error_text_t init_card_v2(sdcardio_sdcard_obj_t *self) {
 }
 
 static mp_rom_error_text_t init_card(sdcardio_sdcard_obj_t *self) {
+    // https://nodeloop.org/guides/sd-card-spi-init-guide/ recommends at least 74 bit clocks
+    // and says 80 bit clocks(10*8) is common. Value below is bytes, not bits.
     clock_card(self, 10);
 
     common_hal_digitalio_digitalinout_set_value(&self->cs, false);
@@ -366,23 +383,25 @@ int common_hal_sdcardio_sdcard_get_blockcount(sdcardio_sdcard_obj_t *self) {
 }
 
 static int readinto(sdcardio_sdcard_obj_t *self, void *buf, size_t size) {
-    uint8_t aux[2] = {0, 0};
-    while (aux[0] != 0xfe) {
-        common_hal_busio_spi_read(self->bus, aux, 1, 0xff);
+
+    if (!wait_for_response(self, 0xfe)) {
+        return -MP_EIO;
     }
 
     common_hal_busio_spi_read(self->bus, buf, size, 0xff);
 
     // Read checksum and throw it away
-    common_hal_busio_spi_read(self->bus, aux, sizeof(aux), 0xff);
+    uint8_t checksum[2];
+    common_hal_busio_spi_read(self->bus, checksum, sizeof(checksum), 0xff);
     return 0;
 }
 
+// The mp_uint_t is misleading; negative errors can be returned.
 mp_uint_t sdcardio_sdcard_readblocks(mp_obj_t self_in, uint8_t *buf, uint32_t start_block, uint32_t nblocks) {
     // deinit check is in lock_and_configure_bus()
     sdcardio_sdcard_obj_t *self = MP_OBJ_TO_PTR(self_in);
     if (!lock_and_configure_bus(self)) {
-        return MP_EAGAIN;
+        return -MP_ETIMEDOUT;
     }
     int r = 0;
     size_t buflen = 512 * nblocks;
@@ -415,6 +434,7 @@ mp_uint_t sdcardio_sdcard_readblocks(mp_obj_t self_in, uint8_t *buf, uint32_t st
         }
     }
     extraclock_and_unlock_bus(self);
+    // No caller actually uses this value.
     return r;
 }
 
@@ -427,7 +447,9 @@ int common_hal_sdcardio_sdcard_readblocks(sdcardio_sdcard_obj_t *self, uint32_t
 }
 
 static int _write(sdcardio_sdcard_obj_t *self, uint8_t token, void *buf, size_t size) {
-    wait_for_ready(self);
+    if (!wait_for_ready(self)) {
+        return -MP_ETIMEDOUT;
+    }
 
     uint8_t cmd[2];
     cmd[0] = token;
@@ -450,9 +472,9 @@ static int _write(sdcardio_sdcard_obj_t *self, uint8_t token, void *buf, size_t
     // with STATUS 010 indicating "data accepted", and other status bit
     // combinations indicating failure.
     // In practice, I was seeing cmd[0] as 0xe5, indicating success
-    for (int i = 0; i < CMD_TIMEOUT; i++) {
+    uint64_t deadline = supervisor_ticks_ms64() + CMD_TIMEOUT_MS;
+    while (supervisor_ticks_ms64() < deadline) {
         common_hal_busio_spi_read(self->bus, cmd, 1, 0xff);
-        DEBUG_PRINT("i=%02d cmd[0] = 0x%02x\n", i, cmd[0]);
         if ((cmd[0] & 0b00010001) == 0b00000001) {
             if ((cmd[0] & 0x1f) != 0x5) {
                 return -MP_EIO;
@@ -463,9 +485,11 @@ static int _write(sdcardio_sdcard_obj_t *self, uint8_t token, void *buf, size_t
     }
 
     // Wait for the write to finish
-    do {
-        common_hal_busio_spi_read(self->bus, cmd, 1, 0xff);
-    } while (cmd[0] == 0);
+
+    // Wait for a non-zero value.
+    if (wait_for_masked_response(self, 0xff /*mask*/, 0, true /*not_match*/, CMD_TIMEOUT_MS) == -1) {
+        return -MP_EIO;
+    }
 
     // Success
     return 0;
@@ -475,7 +499,7 @@ mp_uint_t sdcardio_sdcard_writeblocks(mp_obj_t self_in, uint8_t *buf, uint32_t s
     // deinit check is in lock_and_configure_bus()
     sdcardio_sdcard_obj_t *self = MP_OBJ_TO_PTR(self_in);
     if (!lock_and_configure_bus(self)) {
-        return MP_EAGAIN;
+        return -MP_ETIMEDOUT;
     }
 
     if (!self->in_cmd25 || start_block != self->next_block) {
@@ -507,15 +531,17 @@ mp_uint_t sdcardio_sdcard_writeblocks(mp_obj_t self_in, uint8_t *buf, uint32_t s
     return 0;
 }
 
-int common_hal_sdcardio_sdcard_sync(sdcardio_sdcard_obj_t *self) {
+mp_negative_errno_t common_hal_sdcardio_sdcard_sync(sdcardio_sdcard_obj_t *self) {
     // deinit check is in lock_and_configure_bus()
-    lock_and_configure_bus(self);
+    if (!lock_and_configure_bus(self)) {
+        return -MP_ETIMEDOUT;
+    }
     int r = exit_cmd25(self);
     extraclock_and_unlock_bus(self);
     return r;
 }
 
-int common_hal_sdcardio_sdcard_writeblocks(sdcardio_sdcard_obj_t *self, uint32_t start_block, mp_buffer_info_t *buf) {
+mp_negative_errno_t common_hal_sdcardio_sdcard_writeblocks(sdcardio_sdcard_obj_t *self, uint32_t start_block, mp_buffer_info_t *buf) {
     if (buf->len % 512 != 0) {
         mp_raise_ValueError_varg(MP_ERROR_TEXT("Buffer must be a multiple of %d bytes"), 512);
     }
diff --git a/supervisor/port.h b/supervisor/port.h
index 192307a5f5714..7e2463032f74f 100644
--- a/supervisor/port.h
+++ b/supervisor/port.h
@@ -92,9 +92,17 @@ void port_wake_main_task(void);
 void port_wake_main_task_from_isr(void);
 
 // Some ports may use real RTOS tasks besides the background task framework of
-// CircuitPython. Calling this will yield to other tasks and then return to the
-// CircuitPython task when others are done.
-void port_yield(void);
+// CircuitPython. Calling this will yield to other tasks at the same priority level
+// (or higher priority level if pre-emption is not immediate in the RTOS)
+// and then return to the CircuitPython task when others are done.
+// Note that this does NOT yield to lower priority tasks. Use port_task_sleep_ms() instead.
+void port_task_yield(void);
+
+// On ports using real RTOS tasks, yield to other tasks for at least msecs.
+// This will allow lower priority tasks to run.
+// On non-RTOS implementations, this just sleeps for msecs and will run CircuitPython
+// background tasks.
+void port_task_sleep_ms(uint32_t msecs);
 
 // Some ports want to add information to boot_out.txt.
 // A default weak implementation is provided that does nothing.
diff --git a/supervisor/shared/port.c b/supervisor/shared/port.c
index f908e3f0bd877..3c95f2b740931 100644
--- a/supervisor/shared/port.c
+++ b/supervisor/shared/port.c
@@ -8,6 +8,7 @@
 
 #include <string.h>
 
+#include "py/mphal.h"
 #include "py/runtime.h"
 #include "py/gc.h"
 
@@ -26,7 +27,11 @@ MP_WEAK void port_wake_main_task(void) {
 MP_WEAK void port_wake_main_task_from_isr(void) {
 }
 
-MP_WEAK void port_yield(void) {
+MP_WEAK void port_task_yield(void) {
+}
+
+MP_WEAK void port_task_sleep_ms(uint32_t msecs) {
+    mp_hal_delay_ms(msecs);
 }
 
 MP_WEAK void port_boot_info(void) {
diff --git a/supervisor/shared/usb/usb.c b/supervisor/shared/usb/usb.c
index fbe8be9788207..5061fee00633e 100644
--- a/supervisor/shared/usb/usb.c
+++ b/supervisor/shared/usb/usb.c
@@ -7,6 +7,7 @@
 #include "py/objstr.h"
 #include "supervisor/background_callback.h"
 #include "supervisor/linker.h"
+#include "supervisor/port.h"
 #include "supervisor/shared/tick.h"
 #include "supervisor/usb.h"
 #include "shared/readline/readline.h"
@@ -160,9 +161,8 @@ void usb_background(void) {
         tuh_task();
         #endif
         #elif CFG_TUSB_OS == OPT_OS_FREERTOS
-        // Yield to FreeRTOS in case TinyUSB runs in a separate task. Don't use
-        // port_yield() because it has a longer delay.
-        vTaskDelay(0);
+        // TinyUSB may run in a separate task, at the same priority as CircuitPython.
+        port_task_yield();
         #endif
         // No need to flush if there's no REPL.
         #if CIRCUITPY_USB_DEVICE && CIRCUITPY_USB_CDC
diff --git a/supervisor/shared/web_workflow/web_workflow.c b/supervisor/shared/web_workflow/web_workflow.c
index 55b7de8df6340..a14f79a5bb47f 100644
--- a/supervisor/shared/web_workflow/web_workflow.c
+++ b/supervisor/shared/web_workflow/web_workflow.c
@@ -434,7 +434,7 @@ void web_workflow_send_raw(socketpool_socket_obj_t *socket, bool flush, const ui
             total_sent += sent;
             if (total_sent < len) {
                 // Yield so that network code can run.
-                port_yield();
+                port_task_sleep_ms(4);
             }
         }
     }