Ensure USB host buffers are allocated in internal RAM

Author: tannewt

locale/circuitpython.pot

@@ -844,6 +844,10 @@ msgstr ""
 msgid "Coordinate arrays types have different sizes"
 msgstr ""
 
+#: shared-module/usb/core/Device.c
+msgid "Could not allocate DMA capable buffer"
+msgstr ""
+
 #: ports/espressif/common-hal/rclcpy/Publisher.c
 msgid "Could not publish to ROS topic"
 msgstr ""

ports/raspberrypi/mpconfigport.mk

@@ -59,6 +59,9 @@ CIRCUITPY_CYW43_INIT_DELAY ?= 1000
 endif
 
 ifeq ($(CHIP_VARIANT),RP2350)
+# RP2350 has PSRAM that is not DMA-capable
+CIRCUITPY_ALL_MEMORY_DMA_CAPABLE = 0
+
 # This needs to be implemented.
 CIRCUITPY_ALARM = 0
 # Default PICODVI on because it doesn't require much code in RAM to talk to HSTX.

ports/raspberrypi/supervisor/port.c

@@ -302,6 +302,14 @@ void *port_realloc(void *ptr, size_t size, bool dma_capable) {
     return new_ptr;
 }
 
+#if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+bool port_buffer_is_dma_capable(const void *ptr) {
+    // For RP2350, DMA can only access SRAM, not PSRAM
+    // PSRAM addresses are below SRAM_BASE
+    return ptr != NULL && ((size_t)ptr) >= SRAM_BASE;
+}
+#endif
+
 static bool max_size_walker(void *ptr, size_t size, int used, void *user) {
     size_t *max_size = (size_t *)user;
     if (!used && *max_size < size) {

py/circuitpy_mpconfig.mk

@@ -98,6 +98,11 @@ CFLAGS += -DCIRCUITPY_ALARM=$(CIRCUITPY_ALARM)
 CIRCUITPY_ALARM_TOUCH ?= $(CIRCUITPY_ALARM)
 CFLAGS += -DCIRCUITPY_ALARM_TOUCH=$(CIRCUITPY_ALARM_TOUCH)
 
+# Enable DMA buffer management for platforms where not all memory is DMA-capable
+# Platforms with PSRAM or other non-DMA memory should set this to 0
+CIRCUITPY_ALL_MEMORY_DMA_CAPABLE ?= 1
+CFLAGS += -DCIRCUITPY_ALL_MEMORY_DMA_CAPABLE=$(CIRCUITPY_ALL_MEMORY_DMA_CAPABLE)
+
 CIRCUITPY_ANALOGBUFIO ?= 0
 CFLAGS += -DCIRCUITPY_ANALOGBUFIO=$(CIRCUITPY_ANALOGBUFIO)
 

shared-module/usb/core/Device.c

@@ -8,6 +8,8 @@
 #include "shared-bindings/usb/core/Device.h"
 
 #include "tusb_config.h"
+#include "supervisor/port.h"
+#include "supervisor/port_heap.h"
 
 #include "lib/tinyusb/src/host/hcd.h"
 #include "lib/tinyusb/src/host/usbh.h"
@@ -33,6 +35,39 @@ void tuh_umount_cb(uint8_t dev_addr) {
 
 static xfer_result_t _xfer_result;
 static size_t _actual_len;
+
+#if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+// Helper to ensure buffer is DMA-capable for transfer operations
+static uint8_t *_ensure_dma_buffer(usb_core_device_obj_t *self, const uint8_t *buffer, size_t len, bool for_write) {
+    if (port_buffer_is_dma_capable(buffer)) {
+        return (uint8_t *)buffer;  // Already DMA-capable, use directly
+    }
+
+    // Need to allocate/reallocate temporary buffer in DMA-capable memory
+    if (self->temp_buffer_size < len) {
+        self->temp_buffer = port_realloc(self->temp_buffer, len, true);  // true = DMA capable
+        if (self->temp_buffer == NULL) {
+            self->temp_buffer_size = 0;
+            return NULL;  // Allocation failed
+        }
+        self->temp_buffer_size = len;
+    }
+
+    // Copy data to DMA buffer if writing
+    if (for_write && buffer != NULL) {
+        memcpy(self->temp_buffer, buffer, len);
+    }
+
+    return self->temp_buffer;
+}
+
+// Copy data back from DMA buffer to original buffer after read
+static void _copy_from_dma_buffer(usb_core_device_obj_t *self, uint8_t *original_buffer, size_t len) {
+    if (!port_buffer_is_dma_capable(original_buffer) && self->temp_buffer != NULL) {
+        memcpy(original_buffer, self->temp_buffer, len);
+    }
+}
+#endif
 bool common_hal_usb_core_device_construct(usb_core_device_obj_t *self, uint8_t device_address) {
     if (!tuh_inited()) {
         mp_raise_RuntimeError(MP_ERROR_TEXT("No usb host port initialized"));
@@ -46,6 +81,10 @@ bool common_hal_usb_core_device_construct(usb_core_device_obj_t *self, uint8_t d
     }
     self->device_address = device_address;
     self->first_langid = 0;
+    #if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+    self->temp_buffer = NULL;
+    self->temp_buffer_size = 0;
+    #endif
     _xfer_result = XFER_RESULT_INVALID;
     return true;
 }
@@ -65,6 +104,14 @@ void common_hal_usb_core_device_deinit(usb_core_device_obj_t *self) {
             self->open_endpoints[i] = 0;
         }
     }
+    #if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+    // Clean up temporary buffer
+    if (self->temp_buffer != NULL) {
+        port_free(self->temp_buffer);
+        self->temp_buffer = NULL;
+        self->temp_buffer_size = 0;
+    }
+    #endif
     self->device_address = 0;
 }
 
@@ -399,10 +446,22 @@ mp_int_t common_hal_usb_core_device_write(usb_core_device_obj_t *self, mp_int_t
         mp_raise_usb_core_USBError(NULL);
         return 0;
     }
+
+    #if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+    // Ensure buffer is in DMA-capable memory
+    uint8_t *dma_buffer = _ensure_dma_buffer(self, buffer, len, true);  // true = for write
+    if (dma_buffer == NULL) {
+        mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("Could not allocate DMA capable buffer"));
+        return 0;
+    }
+    #else
+    uint8_t *dma_buffer = (uint8_t *)buffer;  // All memory is DMA-capable
+    #endif
+
     tuh_xfer_t xfer;
     xfer.daddr = self->device_address;
     xfer.ep_addr = endpoint;
-    xfer.buffer = (uint8_t *)buffer;
+    xfer.buffer = dma_buffer;
     xfer.buflen = len;
     return _xfer(&xfer, timeout);
 }
@@ -412,12 +471,33 @@ mp_int_t common_hal_usb_core_device_read(usb_core_device_obj_t *self, mp_int_t e
         mp_raise_usb_core_USBError(NULL);
         return 0;
     }
+
+    #if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+    // Ensure buffer is in DMA-capable memory
+    uint8_t *dma_buffer = _ensure_dma_buffer(self, buffer, len, false);  // false = for read
+    if (dma_buffer == NULL) {
+        mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("Could not allocate DMA capable buffer"));
+        return 0;
+    }
+    #else
+    uint8_t *dma_buffer = buffer;  // All memory is DMA-capable
+    #endif
+
     tuh_xfer_t xfer;
     xfer.daddr = self->device_address;
     xfer.ep_addr = endpoint;
-    xfer.buffer = buffer;
+    xfer.buffer = dma_buffer;
     xfer.buflen = len;
-    return _xfer(&xfer, timeout);
+    mp_int_t result = _xfer(&xfer, timeout);
+
+    #if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+    // Copy data back to original buffer if needed
+    if (result > 0) {
+        _copy_from_dma_buffer(self, buffer, result);
+    }
+    #endif
+
+    return result;
 }
 
 mp_int_t common_hal_usb_core_device_ctrl_transfer(usb_core_device_obj_t *self,
@@ -426,6 +506,23 @@ mp_int_t common_hal_usb_core_device_ctrl_transfer(usb_core_device_obj_t *self,
     uint8_t *buffer, mp_int_t len, mp_int_t timeout) {
     // Timeout is in ms.
 
+    #if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+    // Determine if this is a write (host-to-device) or read (device-to-host) transfer
+    bool is_write = (bmRequestType & 0x80) == 0;  // Bit 7: 0=host-to-device, 1=device-to-host
+
+    // Ensure buffer is in DMA-capable memory
+    uint8_t *dma_buffer = NULL;
+    if (len > 0 && buffer != NULL) {
+        dma_buffer = _ensure_dma_buffer(self, buffer, len, is_write);
+        if (dma_buffer == NULL) {
+            mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("Could not allocate DMA capable buffer"));
+            return 0;
+        }
+    }
+    #else
+    uint8_t *dma_buffer = buffer;  // All memory is DMA-capable
+    #endif
+
     tusb_control_request_t request = {
         .bmRequestType = bmRequestType,
         .bRequest = bRequest,
@@ -437,7 +534,7 @@ mp_int_t common_hal_usb_core_device_ctrl_transfer(usb_core_device_obj_t *self,
         .daddr = self->device_address,
         .ep_addr = 0,
         .setup = &request,
-        .buffer = buffer,
+        .buffer = dma_buffer,
         .complete_cb = _transfer_done_cb,
     };
 
@@ -446,7 +543,16 @@ mp_int_t common_hal_usb_core_device_ctrl_transfer(usb_core_device_obj_t *self,
         mp_raise_usb_core_USBError(NULL);
         return 0;
     }
-    return (mp_int_t)_handle_timed_transfer_callback(&xfer, timeout);
+    mp_int_t result = (mp_int_t)_handle_timed_transfer_callback(&xfer, timeout);
+
+    #if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+    // Copy data back to original buffer if this was a read transfer and we got data
+    if ((bmRequestType & 0x80) != 0 && result > 0 && buffer != NULL) {  // Read transfer (device-to-host)
+        _copy_from_dma_buffer(self, buffer, result);
+    }
+    #endif
+
+    return result;
 }
 
 bool common_hal_usb_core_device_is_kernel_driver_active(usb_core_device_obj_t *self, mp_int_t interface) {

shared-module/usb/core/Device.h

@@ -15,4 +15,8 @@ typedef struct {
     uint8_t *configuration_descriptor; // Contains the length of the all descriptors.
     uint8_t open_endpoints[8];
     uint16_t first_langid;
+    #if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+    uint8_t *temp_buffer;  // Temporary buffer for PSRAM data
+    size_t temp_buffer_size;  // Size of temporary buffer
+    #endif
 } usb_core_device_obj_t;

supervisor/port_heap.h

@@ -27,4 +27,10 @@ void port_free(void *ptr);
 
 void *port_realloc(void *ptr, size_t size, bool dma_capable);
 
+#if !CIRCUITPY_ALL_MEMORY_DMA_CAPABLE
+// Check if a buffer pointer is in DMA-capable memory. DMA-capable memory is also accessible during
+// flash operations.
+bool port_buffer_is_dma_capable(const void *ptr);
+#endif
+
 size_t port_heap_get_largest_free_size(void);