Merge remote-tracking branch 'adafruit/main' into rp2040-i2c-short-writes

13 files changed, 850 insertions, 148 deletions

diff --git a/shared-module/_pixelbuf/PixelBuf.c b/shared-module/_pixelbuf/PixelBuf.c
index f3e679631..4cbf6dc21 100644
--- a/shared-module/_pixelbuf/PixelBuf.c
+++ b/shared-module/_pixelbuf/PixelBuf.c
@@ -31,6 +31,7 @@
 #include "py/runtime.h"
 #include "shared-bindings/_pixelbuf/PixelBuf.h"
 #include <string.h>
+#include <math.h>
 
 // Helper to ensure we have the native super class instead of a subclass.
 static pixelbuf_pixelbuf_obj_t* native_pixelbuf(mp_obj_t pixelbuf_obj) {
@@ -69,6 +70,7 @@ void common_hal__pixelbuf_pixelbuf_construct(pixelbuf_pixelbuf_obj_t *self, size
     }
     // Call set_brightness so that it can allocate a second buffer if needed.
     self->brightness = 1.0;
+    self->scaled_brightness = 0x100;
     common_hal__pixelbuf_pixelbuf_set_brightness(MP_OBJ_FROM_PTR(self), brightness);
 
     // Turn on auto_write. We don't want to do it with the above brightness call.
@@ -109,26 +111,32 @@ void common_hal__pixelbuf_pixelbuf_set_brightness(mp_obj_t self_in, mp_float_t b
     pixelbuf_pixelbuf_obj_t* self = native_pixelbuf(self_in);
     // Skip out if the brightness is already set. The default of self->brightness is 1.0. So, this
     // also prevents the pre_brightness_buffer allocation when brightness is set to 1.0 again.
-    mp_float_t change = brightness - self->brightness;
-    if (-0.001 < change && change < 0.001) {
+    self->brightness = brightness;
+    // Use 256 steps of brightness so that we can do integer math below.
+    uint16_t new_scaled_brightness = (uint16_t)(brightness * 256);
+    if (new_scaled_brightness == self->scaled_brightness) {
         return;
     }
-    self->brightness = brightness;
+    self->scaled_brightness = new_scaled_brightness;
     size_t pixel_len = self->pixel_count * self->bytes_per_pixel;
-    if (self->pre_brightness_buffer == NULL) {
-        self->pre_brightness_buffer = m_malloc(pixel_len, false);
-        memcpy(self->pre_brightness_buffer, self->post_brightness_buffer, pixel_len);
-    }
-    for (size_t i = 0; i < pixel_len; i++) {
-        // Don't adjust per-pixel luminance bytes in dotstar mode
-        if (self->byteorder.is_dotstar && i % 4 == 0) {
-            continue;
+    if (self->scaled_brightness == 0x100 && !self->pre_brightness_buffer) {
+        return;
+    } else {
+        if (self->pre_brightness_buffer == NULL) {
+            self->pre_brightness_buffer = m_malloc(pixel_len, false);
+            memcpy(self->pre_brightness_buffer, self->post_brightness_buffer, pixel_len);
+        }
+        for (size_t i = 0; i < pixel_len; i++) {
+            // Don't adjust per-pixel luminance bytes in dotstar mode
+            if (self->byteorder.is_dotstar && i % 4 == 0) {
+                continue;
+            }
+            self->post_brightness_buffer[i] = (self->pre_brightness_buffer[i] * self->scaled_brightness) / 256;
         }
-        self->post_brightness_buffer[i] = self->pre_brightness_buffer[i] * self->brightness;
-    }
 
-    if (self->auto_write) {
-        common_hal__pixelbuf_pixelbuf_show(self_in);
+        if (self->auto_write) {
+            common_hal__pixelbuf_pixelbuf_show(self_in);
+        }
     }
 }
 
@@ -197,28 +205,34 @@ void _pixelbuf_set_pixel_color(pixelbuf_pixelbuf_obj_t* self, size_t index, uint
     }
     pixelbuf_rgbw_t *rgbw_order = &self->byteorder.byteorder;
     size_t offset = index * self->bytes_per_pixel;
-    if (self->pre_brightness_buffer != NULL) {
-        uint8_t* pre_brightness_buffer = self->pre_brightness_buffer + offset;
-        if (self->bytes_per_pixel == 4) {
-            pre_brightness_buffer[rgbw_order->w] = w;
-        }
-
-        pre_brightness_buffer[rgbw_order->r] = r;
-        pre_brightness_buffer[rgbw_order->g] = g;
-        pre_brightness_buffer[rgbw_order->b] = b;
+    uint8_t *scaled_buffer, *unscaled_buffer;
+    if (self->pre_brightness_buffer) {
+        scaled_buffer = self->post_brightness_buffer + offset;
+        unscaled_buffer = self->pre_brightness_buffer + offset;
+    } else {
+        scaled_buffer = NULL;
+        unscaled_buffer = self->post_brightness_buffer + offset;
     }
 
-    uint8_t* post_brightness_buffer = self->post_brightness_buffer + offset;
     if (self->bytes_per_pixel == 4) {
-        // Only apply brightness if w is actually white (aka not DotStar.)
-        if (!self->byteorder.is_dotstar) {
-            w *= self->brightness;
+        unscaled_buffer[rgbw_order->w] = w;
+    }
+
+    unscaled_buffer[rgbw_order->r] = r;
+    unscaled_buffer[rgbw_order->g] = g;
+    unscaled_buffer[rgbw_order->b] = b;
+
+    if (scaled_buffer) {
+        if (self->bytes_per_pixel == 4) {
+            if (!self->byteorder.is_dotstar) {
+                w = (w * self->scaled_brightness) / 256;
+            }
+            scaled_buffer[rgbw_order->w] = w;
         }
-        post_brightness_buffer[rgbw_order->w] = w;
+        scaled_buffer[rgbw_order->r] = (r * self->scaled_brightness) / 256;
+        scaled_buffer[rgbw_order->g] = (g * self->scaled_brightness) / 256;
+        scaled_buffer[rgbw_order->b] = (b * self->scaled_brightness) / 256;
     }
-    post_brightness_buffer[rgbw_order->r] = r * self->brightness;
-    post_brightness_buffer[rgbw_order->g] = g * self->brightness;
-    post_brightness_buffer[rgbw_order->b] = b * self->brightness;
 }
 
 void _pixelbuf_set_pixel(pixelbuf_pixelbuf_obj_t* self, size_t index, mp_obj_t value) {
diff --git a/shared-module/_pixelbuf/PixelBuf.h b/shared-module/_pixelbuf/PixelBuf.h
index a9fbed366..f0c80bcad 100644
--- a/shared-module/_pixelbuf/PixelBuf.h
+++ b/shared-module/_pixelbuf/PixelBuf.h
@@ -49,7 +49,8 @@ typedef struct {
 typedef struct {
     mp_obj_base_t base;
     size_t pixel_count;
-    size_t bytes_per_pixel;
+    uint16_t bytes_per_pixel;
+    uint16_t scaled_brightness;
     pixelbuf_byteorder_details_t byteorder;
     mp_float_t brightness;
     mp_obj_t transmit_buffer_obj;
diff --git a/shared-module/bitmaptools/__init__.c b/shared-module/bitmaptools/__init__.c
new file mode 100644
index 000000000..7dc4024ef
--- /dev/null
+++ b/shared-module/bitmaptools/__init__.c
@@ -0,0 +1,174 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Kevin Matocha
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
+#include "shared-bindings/displayio/Bitmap.h"
+
+#include "py/runtime.h"
+
+#include "math.h"
+
+void common_hal_bitmaptools_rotozoom(displayio_bitmap_t *self, int16_t ox, int16_t oy,
+                                            int16_t dest_clip0_x, int16_t dest_clip0_y,
+                                            int16_t dest_clip1_x, int16_t dest_clip1_y,
+                                            displayio_bitmap_t *source, int16_t px, int16_t py,
+                                            int16_t source_clip0_x, int16_t source_clip0_y,
+                                            int16_t source_clip1_x, int16_t source_clip1_y,
+                                            float angle,
+                                            float scale,
+                                            uint32_t skip_index, bool skip_index_none) {
+
+    // Copies region from source to the destination bitmap, including rotation,
+    // scaling and clipping of either the source or destination regions
+    //
+    // *self: destination bitmap
+    // ox: the (ox, oy) destination point where the source (px,py) point is placed
+    // oy:
+    // dest_clip0: (x,y) is the corner of the clip window on the destination bitmap
+    // dest_clip1: (x,y) is the other corner of the clip window of the destination bitmap
+    // *source: the source bitmap
+    // px: the (px, py) point of rotation of the source bitmap
+    // py:
+    // source_clip0: (x,y) is the corner of the clip window on the source bitmap
+    // source_clip1: (x,y) is the other of the clip window on the source bitmap
+    // angle: angle of rotation in radians, positive is clockwise
+    // scale: scale factor
+    // skip_index: color index that should be ignored (and not copied over)
+    // skip_index_none: if skip_index_none is True, then all color indexes should be copied
+    //                                                     (that is, no color indexes should be skipped)
+
+
+    // Copy complete "source" bitmap into "self" bitmap at location x,y in the "self"
+    // Add a boolean to determine if all values are copied, or only if non-zero
+    // If skip_value is encountered in the source bitmap, it will not be copied.
+    // If skip_value is `None`, then all pixels are copied.
+
+
+    // # Credit from https://github.com/wernsey/bitmap
+    // # MIT License from
+    // #  * Copyright (c) 2017 Werner Stoop <wstoop@gmail.com>
+    // #
+    // # *
+    // # * #### `void bm_rotate_blit(Bitmap *dst, int ox, int oy, Bitmap *src, int px, int py, double angle, double scale);`
+    // # *
+    // # * Rotates a source bitmap `src` around a pivot point `px,py` and blits it onto a destination bitmap `dst`.
+    // # *
+    // # * The bitmap is positioned such that the point `px,py` on the source is at the offset `ox,oy` on the destination.
+    // # *
+    // # * The `angle` is clockwise, in radians. The bitmap is also scaled by the factor `scale`.
+    // #
+    // # void bm_rotate_blit(Bitmap *dst, int ox, int oy, Bitmap *src, int px, int py, double angle, double scale);
+
+
+    // #     /*
+    // #    Reference:
+    // #    "Fast Bitmap Rotation and Scaling" By Steven Mortimer, Dr Dobbs' Journal, July 01, 2001
+    // #    http://www.drdobbs.com/architecture-and-design/fast-bitmap-rotation-and-scaling/184416337
+    // #    See also http://www.efg2.com/Lab/ImageProcessing/RotateScanline.htm
+    // #    */
+
+
+    if (self->read_only) {
+        mp_raise_RuntimeError(translate("Read-only object"));
+    }
+
+    int16_t x,y;
+
+    int16_t minx = dest_clip1_x;
+    int16_t miny = dest_clip1_y;
+    int16_t maxx = dest_clip0_x;
+    int16_t maxy = dest_clip0_y;
+
+    float sinAngle = sinf(angle);
+    float cosAngle = cosf(angle);
+
+    float dx, dy;
+
+    /* Compute the position of where each corner on the source bitmap
+    will be on the destination to get a bounding box for scanning */
+    dx = -cosAngle * px * scale + sinAngle * py * scale + ox;
+    dy = -sinAngle * px * scale - cosAngle * py * scale + oy;
+    if(dx < minx) minx = (int16_t)dx;
+    if(dx > maxx) maxx = (int16_t)dx;
+    if(dy < miny) miny = (int16_t)dy;
+    if(dy > maxy) maxy = (int16_t)dy;
+
+    dx = cosAngle * (source->width - px) * scale + sinAngle * py * scale + ox;
+    dy = sinAngle * (source->width - px) * scale - cosAngle * py * scale + oy;
+    if(dx < minx) minx = (int16_t)dx;
+    if(dx > maxx) maxx = (int16_t)dx;
+    if(dy < miny) miny = (int16_t)dy;
+    if(dy > maxy) maxy = (int16_t)dy;
+
+    dx = cosAngle * (source->width - px) * scale - sinAngle * (source->height - py) * scale + ox;
+    dy = sinAngle * (source->width - px) * scale + cosAngle * (source->height - py) * scale + oy;
+    if(dx < minx) minx = (int16_t)dx;
+    if(dx > maxx) maxx = (int16_t)dx;
+    if(dy < miny) miny = (int16_t)dy;
+    if(dy > maxy) maxy = (int16_t)dy;
+
+    dx = -cosAngle * px * scale - sinAngle * (source->height - py) * scale + ox;
+    dy = -sinAngle * px * scale + cosAngle * (source->height - py) * scale + oy;
+    if(dx < minx) minx = (int16_t)dx;
+    if(dx > maxx) maxx = (int16_t)dx;
+    if(dy < miny) miny = (int16_t)dy;
+    if(dy > maxy) maxy = (int16_t)dy;
+
+    /* Clipping */
+    if(minx < dest_clip0_x) minx = dest_clip0_x;
+    if(maxx > dest_clip1_x - 1) maxx = dest_clip1_x - 1;
+    if(miny < dest_clip0_y) miny = dest_clip0_y;
+    if(maxy > dest_clip1_y - 1) maxy = dest_clip1_y - 1;
+
+    float dvCol = cosAngle / scale;
+    float duCol = sinAngle / scale;
+
+    float duRow = dvCol;
+    float dvRow = -duCol;
+
+    float startu = px - (ox * dvCol + oy * duCol);
+    float startv = py - (ox * dvRow + oy * duRow);
+
+    float rowu = startu + miny * duCol;
+    float rowv = startv + miny * dvCol;
+
+    for(y = miny; y <= maxy; y++) {
+        float u = rowu + minx * duRow;
+        float v = rowv + minx * dvRow;
+        for(x = minx; x <= maxx; x++) {
+            if(u >= source_clip0_x  && u < source_clip1_x && v >= source_clip0_y && v < source_clip1_y) {
+                uint32_t c = common_hal_displayio_bitmap_get_pixel(source, u, v);
+                if( (skip_index_none) || (c != skip_index) ) {
+                    common_hal_displayio_bitmap_set_pixel(self, x, y, c);
+                }
+            }
+            u += duRow;
+            v += dvRow;
+        }
+        rowu += duCol;
+        rowv += dvCol;
+    }
+}
diff --git a/shared-module/bitops/__init__.c b/shared-module/bitops/__init__.c
new file mode 100644
index 000000000..cf0ac7bd1
--- /dev/null
+++ b/shared-module/bitops/__init__.c
@@ -0,0 +1,151 @@
+/*
+ * This file is part of the Circuit Python project, https://github.com/adafruit/circuitpython
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Jeff Epler for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-bindings/bitops/__init__.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef __GNUC__
+#define FALLTHROUGH __attribute__((fallthrough))
+#else
+#define FALLTHROUGH ((void)0) /* FALLTHROUGH */
+#endif
+
+// adapted from "Hacker's Delight" - Figure 7-2 Transposing an 8x8-bit matrix
+// basic idea is:
+// > First, treat the 8x8-bit matrix as 16 2x2-bit matrices, and transpose each
+// > of the 16 2x2-bit matrices. Second, treat the matrix as four 2x2 submatrices
+// > whose elements are 2x2-bit matrices and transpose each of the four 2x2
+// > submatrices. Finally, treat the matrix as a 2x2 matrix whose elements are
+// > 4x4-bit matrices, and transpose the 2x2 matrix. These transformations are
+// > illustrated below.
+// We want a different definition of bit/byte order, deal with strides differently, etc.
+// so the code is heavily re-worked compared to the original.
+static void transpose_var(uint32_t *result, const uint8_t *src, int src_stride, int num_strands) {
+    uint32_t x = 0, y = 0, t;
+
+    src += (num_strands-1) * src_stride;
+
+    switch(num_strands) {
+    case 7:
+        x |= *src << 16;
+        src -= src_stride;
+        FALLTHROUGH;
+    case 6:
+        x |= *src << 8;
+        src -= src_stride;
+        FALLTHROUGH;
+    case 5:
+        x |= *src;
+        src -= src_stride;
+        FALLTHROUGH;
+    case 4:
+        y |= *src << 24;
+        src -= src_stride;
+        FALLTHROUGH;
+    case 3:
+        y |= *src << 16;
+        src -= src_stride;
+        FALLTHROUGH;
+    case 2:
+        y |= *src << 8;
+        src -= src_stride;
+        y |= *src;
+    }
+
+    t = (x ^ (x >> 7)) & 0x00AA00AA;  x = x ^ t ^ (t << 7);
+    t = (y ^ (y >> 7)) & 0x00AA00AA;  y = y ^ t ^ (t << 7);
+
+    t = (x ^ (x >>14)) & 0x0000CCCC;  x = x ^ t ^ (t <<14);
+    t = (y ^ (y >>14)) & 0x0000CCCC;  y = y ^ t ^ (t <<14);
+
+    t = (x & 0xF0F0F0F0) | ((y >> 4) & 0x0F0F0F0F);
+    y = ((x << 4) & 0xF0F0F0F0) | (y & 0x0F0F0F0F);
+    x = t;
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    x = __builtin_bswap32(x);
+    y = __builtin_bswap32(y);
+#endif
+    result[0] = x;
+    result[1] = y;
+}
+
+static void transpose_8(uint32_t *result, const uint8_t *src, int src_stride) {
+    uint32_t x, y, t;
+
+    y = *src; src += src_stride;
+    y |= (*src << 8); src += src_stride;
+    y |= (*src << 16); src += src_stride;
+    y |= (*src << 24); src += src_stride;
+    x = *src; src += src_stride;
+    x |= (*src << 8); src += src_stride;
+    x |= (*src << 16); src += src_stride;
+    x |= (*src << 24); src += src_stride;
+
+    t = (x ^ (x >> 7)) & 0x00AA00AA;  x = x ^ t ^ (t << 7);
+    t = (y ^ (y >> 7)) & 0x00AA00AA;  y = y ^ t ^ (t << 7);
+
+    t = (x ^ (x >>14)) & 0x0000CCCC;  x = x ^ t ^ (t <<14);
+    t = (y ^ (y >>14)) & 0x0000CCCC;  y = y ^ t ^ (t <<14);
+
+    t = (x & 0xF0F0F0F0) | ((y >> 4) & 0x0F0F0F0F);
+    y = ((x << 4) & 0xF0F0F0F0) | (y & 0x0F0F0F0F);
+    x = t;
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    x = __builtin_bswap32(x);
+    y = __builtin_bswap32(y);
+#endif
+    result[0] = x;
+    result[1] = y;
+}
+
+static void bit_transpose_8(uint32_t *result, const uint8_t *src, size_t src_stride, size_t n) {
+    for(size_t i=0; i<n; i++) {
+        transpose_8(result, src, src_stride);
+        result += 2;
+        src += 1;
+    }
+}
+
+static void bit_transpose_var(uint32_t *result, const uint8_t *src, size_t src_stride, size_t n, int num_strands) {
+    for(size_t i=0; i<n; i++) {
+        transpose_var(result, src, src_stride, num_strands);
+        result += 2;
+        src += 1;
+    }
+}
+
+void common_hal_bitops_bit_transpose(uint8_t *result, const uint8_t *src, size_t inlen, size_t num_strands) {
+    if(num_strands == 8) {
+        bit_transpose_8((uint32_t*)(void*)result, src, inlen/8, inlen/8);
+    } else  {
+        bit_transpose_var((uint32_t*)(void*)result, src, inlen/num_strands, inlen/num_strands, num_strands);
+    }
+}
diff --git a/shared-module/bitops/__init__.h b/shared-module/bitops/__init__.h
new file mode 100644
index 000000000..945e48b72
--- /dev/null
+++ b/shared-module/bitops/__init__.h
@@ -0,0 +1,27 @@
+/*
+ * This file is part of the Circuit Python project, https://github.com/adafruit/circuitpython
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Jeff Epler
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#pragma once
diff --git a/shared-module/displayio/Bitmap.c b/shared-module/displayio/Bitmap.c
index d1942efc7..c9ea83428 100644
--- a/shared-module/displayio/Bitmap.c
+++ b/shared-module/displayio/Bitmap.c
@@ -116,14 +116,33 @@ void common_hal_displayio_bitmap_blit(displayio_bitmap_t *self, int16_t x, int16
         mp_raise_RuntimeError(translate("Read-only object"));
     }
 
+    bool x_reverse = false;
+    bool y_reverse = false;
+
+    // Add reverse direction option to protect blitting of self bitmap back into self bitmap
+    if (x > x1) {
+        x_reverse = true;
+    }
+    if (y > y1) {
+        y_reverse = true;
+    }
+
     // simplest version - use internal functions for get/set pixels
-    for (int16_t i=0; i < (x2-x1) ; i++) {
-        if ( (x+i >= 0) && (x+i < self->width) ) {
+    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
+
+        if ( (xd_index >= 0) && (xd_index < self->width) ) {
             for (int16_t j=0; j < (y2-y1) ; j++){
-                if ((y+j >= 0) && (y+j < self->height) ) {
-                    uint32_t value = common_hal_displayio_bitmap_get_pixel(source, x1+i, 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
+
+                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
-                            common_hal_displayio_bitmap_set_pixel(self, x+i, y+j, value);
+                            common_hal_displayio_bitmap_set_pixel(self, xd_index, yd_index, value);
                     }
                 }
             }
diff --git a/shared-module/displayio/Group.c b/shared-module/displayio/Group.c
index 15cf5b8e4..42efeb18c 100644
--- a/shared-module/displayio/Group.c
+++ b/shared-module/displayio/Group.c
@@ -27,6 +27,7 @@
 #include "shared-bindings/displayio/Group.h"
 
 #include "py/runtime.h"
+#include "py/objlist.h"
 #include "shared-bindings/displayio/TileGrid.h"
 
 #if CIRCUITPY_VECTORIO
@@ -34,9 +35,9 @@
 #endif
 
 
-void common_hal_displayio_group_construct(displayio_group_t* self, uint32_t max_size, uint32_t scale, mp_int_t x, mp_int_t y) {
-    displayio_group_child_t* children = m_new(displayio_group_child_t, max_size);
-    displayio_group_construct(self, children, max_size, scale, x, 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) {
@@ -51,12 +52,19 @@ void common_hal_displayio_group_set_hidden(displayio_group_t* self, bool hidden)
     if (self->hidden_by_parent) {
         return;
     }
-    for (size_t i = 0; i < self->size; i++) {
-        mp_obj_t layer = self->children[i].native;
-        if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+    for (size_t i = 0; i < self->members->len; i++) {
+        mp_obj_t layer;
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_tilegrid_type);
+        if (layer != MP_OBJ_NULL) {
             displayio_tilegrid_set_hidden_by_parent(layer, hidden);
-        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            continue;
+        }
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_group_type);
+        if (layer != MP_OBJ_NULL) {
             displayio_group_set_hidden_by_parent(layer, hidden);
+            continue;
         }
     }
 }
@@ -70,12 +78,19 @@ void displayio_group_set_hidden_by_parent(displayio_group_t *self, bool hidden)
     if (self->hidden) {
         return;
     }
-    for (size_t i = 0; i < self->size; i++) {
-        mp_obj_t layer = self->children[i].native;
-        if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+    for (size_t i = 0; i < self->members->len; i++) {
+        mp_obj_t layer;
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_tilegrid_type);
+        if (layer != MP_OBJ_NULL) {
             displayio_tilegrid_set_hidden_by_parent(layer, hidden);
-        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            continue;
+        }
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_group_type);
+        if (layer != MP_OBJ_NULL) {
             displayio_group_set_hidden_by_parent(layer, hidden);
+            continue;
         }
     }
 }
@@ -86,16 +101,22 @@ uint32_t common_hal_displayio_group_get_scale(displayio_group_t* self) {
 
 bool displayio_group_get_previous_area(displayio_group_t *self, displayio_area_t* area) {
     bool first = true;
-    for (size_t i = 0; i < self->size; i++) {
-        mp_obj_t layer = self->children[i].native;
+    for (size_t i = 0; i < self->members->len; i++) {
+        mp_obj_t layer;
         displayio_area_t layer_area;
-        if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_tilegrid_type);
+        if (layer != MP_OBJ_NULL) {
             if (!displayio_tilegrid_get_previous_area(layer, &layer_area)) {
                 continue;
             }
-        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
-            if (!displayio_group_get_previous_area(layer, &layer_area)) {
-                continue;
+        } else {
+            layer = mp_instance_cast_to_native_base(
+                self->members->items[i], &displayio_group_type);
+            if (layer != MP_OBJ_NULL) {
+                if (!displayio_group_get_previous_area(layer, &layer_area)) {
+                    continue;
+                }
             }
         }
         if (first) {
@@ -120,18 +141,27 @@ static void _update_child_transforms(displayio_group_t* self) {
     if (!self->in_group) {
         return;
     }
-    for (size_t i = 0; i < self->size; i++) {
-        mp_obj_t layer = self->children[i].native;
+    for (size_t i = 0; i < self->members->len; i++) {
+        mp_obj_t layer;
 #if CIRCUITPY_VECTORIO
-        if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+        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;
         }
-        else
 #endif
-        if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_tilegrid_type);
+        if (layer != MP_OBJ_NULL) {
             displayio_tilegrid_update_transform(layer, &self->absolute_transform);
-        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            continue;
+        }
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_group_type);
+        if (layer != MP_OBJ_NULL) {
             displayio_group_update_transform(layer, &self->absolute_transform);
+            continue;
         }
     }
 }
@@ -210,21 +240,17 @@ void common_hal_displayio_group_set_y(displayio_group_t* self, mp_int_t y) {
     _update_child_transforms(self);
 }
 
-static mp_obj_t _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
     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 native_layer;
+        return;
     }
 #endif
-    native_layer = mp_instance_cast_to_native_base(layer, &displayio_group_type);
-    if (native_layer == MP_OBJ_NULL) {
-        native_layer = mp_instance_cast_to_native_base(layer, &displayio_tilegrid_type);
-        if (native_layer == MP_OBJ_NULL) {
-            mp_raise_ValueError(translate("Layer must be a Group or TileGrid subclass."));
-        }
+    native_layer = mp_instance_cast_to_native_base(layer, &displayio_tilegrid_type);
+    if (native_layer != MP_OBJ_NULL) {
         displayio_tilegrid_t* tilegrid = native_layer;
         if (tilegrid->in_group) {
             mp_raise_ValueError(translate("Layer already in a group."));
@@ -232,7 +258,10 @@ static mp_obj_t _add_layer(displayio_group_t* self, mp_obj_t layer) {
             tilegrid->in_group = true;
         }
         displayio_tilegrid_update_transform(tilegrid, &self->absolute_transform);
-    } else {
+        return;
+    }
+    native_layer = mp_instance_cast_to_native_base(layer, &displayio_group_type);
+    if (native_layer != MP_OBJ_NULL) {
         displayio_group_t* group = native_layer;
         if (group->in_group) {
             mp_raise_ValueError(translate("Layer already in a group."));
@@ -240,27 +269,34 @@ static mp_obj_t _add_layer(displayio_group_t* self, mp_obj_t layer) {
             group->in_group = true;
         }
         displayio_group_update_transform(group, &self->absolute_transform);
+        return;
     }
-    return native_layer;
+    mp_raise_ValueError(translate("Layer must be a Group or TileGrid subclass."));
 }
 
 static void _remove_layer(displayio_group_t* self, size_t index) {
-    mp_obj_t layer = self->children[index].native;
+    mp_obj_t layer;
     displayio_area_t layer_area;
     bool rendered_last_frame = false;
 #if CIRCUITPY_VECTORIO
-    if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+    layer = mp_instance_cast_to_native_base(
+        self->members->items[index], &vectorio_vector_shape_type);
+    if (layer != MP_OBJ_NULL) {
         bool has_dirty_area = vectorio_vector_shape_get_dirty_area(layer, &layer_area);
         rendered_last_frame = has_dirty_area;
         vectorio_vector_shape_update_transform(layer, NULL);
     }
-    else
 #endif
-    if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+    layer = mp_instance_cast_to_native_base(
+        self->members->items[index], &displayio_tilegrid_type);
+    if (layer != MP_OBJ_NULL) {
         displayio_tilegrid_t* tilegrid = layer;
         rendered_last_frame = displayio_tilegrid_get_previous_area(tilegrid, &layer_area);
         displayio_tilegrid_update_transform(tilegrid, NULL);
-    } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+    }
+    layer = mp_instance_cast_to_native_base(
+        self->members->items[index], &displayio_group_type);
+    if (layer != MP_OBJ_NULL) {
         displayio_group_t* group = layer;
         rendered_last_frame = displayio_group_get_previous_area(group, &layer_area);
         displayio_group_update_transform(group, NULL);
@@ -277,62 +313,40 @@ static void _remove_layer(displayio_group_t* self, size_t index) {
 }
 
 void common_hal_displayio_group_insert(displayio_group_t* self, size_t index, mp_obj_t layer) {
-    if (self->size == self->max_size) {
-        mp_raise_RuntimeError(translate("Group full"));
-    }
-    mp_obj_t native_layer = _add_layer(self, layer);
-    // Shift everything right.
-    for (size_t i = self->size; i > index; i--) {
-        self->children[i] = self->children[i - 1];
-    }
-    self->children[index].native = native_layer;
-    self->children[index].original = layer;
-    self->size++;
+    _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) {
-    self->size--;
-    mp_obj_t item = self->children[index].original;
     _remove_layer(self, index);
-
-    // Shift everything left.
-    for (size_t i = index; i < self->size; i++) {
-        self->children[i] = self->children[i + 1];
-    }
-    self->children[self->size].native = NULL;
-    self->children[self->size].original = NULL;
-    return item;
+    return mp_obj_list_pop(self->members, index);
 }
 
 mp_int_t common_hal_displayio_group_index(displayio_group_t* self, mp_obj_t layer) {
-    for (size_t i = 0; i < self->size; i++) {
-        if (self->children[i].original == layer) {
-            return i;
-        }
-    }
-    return -1;
+    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) {
-    return self->size;
+    return self->members->len;
 }
 
 mp_obj_t common_hal_displayio_group_get(displayio_group_t* self, size_t index) {
-    return self->children[index].original;
+    return self->members->items[index];
 }
 
 void common_hal_displayio_group_set(displayio_group_t* self, size_t index, mp_obj_t layer) {
-    mp_obj_t native_layer = _add_layer(self, layer);
+    _add_layer(self, layer);
     _remove_layer(self, index);
-    self->children[index].native = native_layer;
-    self->children[index].original = layer;
+    mp_obj_list_store(self, MP_OBJ_NEW_SMALL_INT(index), layer);
 }
 
-void displayio_group_construct(displayio_group_t* self, displayio_group_child_t* child_array, uint32_t max_size, 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->children = child_array;
-    self->max_size = max_size;
+    self->members = members;
     self->item_removed = false;
     self->scale = scale;
     self->in_group = false;
@@ -341,47 +355,61 @@ void displayio_group_construct(displayio_group_t* self, displayio_group_child_t*
 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.
-    bool full_coverage = false;
-    for (int32_t i = self->size - 1; i >= 0 ; i--) {
-        mp_obj_t layer = self->children[i].native;
+    for (int32_t i = self->members->len - 1; i >= 0 ; i--) {
+        mp_obj_t layer;
 #if CIRCUITPY_VECTORIO
-        if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &vectorio_vector_shape_type);
+        if (layer != MP_OBJ_NULL) {
             if (vectorio_vector_shape_fill_area(layer, colorspace, area, mask, buffer)) {
-                full_coverage = true;
-                break;
+                return true;
             }
+            continue;
         }
-        else
 #endif
-        if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_tilegrid_type);
+        if (layer != MP_OBJ_NULL) {
             if (displayio_tilegrid_fill_area(layer, colorspace, area, mask, buffer)) {
-                full_coverage = true;
-                break;
+                return true;
             }
-        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            continue;
+        }
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_group_type);
+        if (layer != MP_OBJ_NULL) {
             if (displayio_group_fill_area(layer, colorspace, area, mask, buffer)) {
-                full_coverage = true;
-                break;
+                return true;
             }
+            continue;
         }
     }
-    return full_coverage;
+    return false;
 }
 
 void displayio_group_finish_refresh(displayio_group_t *self) {
     self->item_removed = false;
-    for (int32_t i = self->size - 1; i >= 0 ; i--) {
-        mp_obj_t layer = self->children[i].native;
+    for (int32_t i = self->members->len - 1; i >= 0 ; i--) {
+        mp_obj_t layer;
 #if CIRCUITPY_VECTORIO
-        if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+        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;
         }
-        else
 #endif
-        if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_tilegrid_type);
+        if (layer != MP_OBJ_NULL) {
             displayio_tilegrid_finish_refresh(layer);
-        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            continue;
+        }
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_group_type);
+        if (layer != MP_OBJ_NULL) {
             displayio_group_finish_refresh(layer);
+            continue;
         }
     }
 }
@@ -392,18 +420,27 @@ displayio_area_t* displayio_group_get_refresh_areas(displayio_group_t *self, dis
         tail = &self->dirty_area;
     }
 
-    for (int32_t i = self->size - 1; i >= 0 ; i--) {
-        mp_obj_t layer = self->children[i].native;
+    for (int32_t i = self->members->len - 1; i >= 0 ; i--) {
+        mp_obj_t layer;
 #if CIRCUITPY_VECTORIO
-        if (MP_OBJ_IS_TYPE(layer, &vectorio_vector_shape_type)) {
+        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;
         }
-        else
 #endif
-        if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_tilegrid_type);
+        if (layer != MP_OBJ_NULL) {
             tail = displayio_tilegrid_get_refresh_areas(layer, tail);
-        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            continue;
+        }
+        layer = mp_instance_cast_to_native_base(
+            self->members->items[i], &displayio_group_type);
+        if (layer != MP_OBJ_NULL) {
             tail = displayio_group_get_refresh_areas(layer, tail);
+            continue;
         }
     }
 
diff --git a/shared-module/displayio/Group.h b/shared-module/displayio/Group.h
index 5afaac1ba..0964e0a0b 100644
--- a/shared-module/displayio/Group.h
+++ b/shared-module/displayio/Group.h
@@ -31,24 +31,18 @@
 #include <stdint.h>
 
 #include "py/obj.h"
+#include "py/objlist.h"
 #include "shared-module/displayio/area.h"
 #include "shared-module/displayio/Palette.h"
 
 typedef struct {
-    mp_obj_t native;
-    mp_obj_t original;
-} displayio_group_child_t;
-
-typedef struct {
     mp_obj_base_t base;
-    displayio_group_child_t* children;
+    mp_obj_list_t *members;
     displayio_buffer_transform_t absolute_transform;
     displayio_area_t dirty_area; // Catch all for changed area
     int16_t x;
     int16_t y;
     uint16_t scale;
-    uint16_t size;
-    uint16_t max_size;
     bool item_removed :1;
     bool in_group :1;
     bool hidden :1;
@@ -56,7 +50,7 @@ typedef struct {
     uint8_t padding :4;
 } displayio_group_t;
 
-void displayio_group_construct(displayio_group_t* self, displayio_group_child_t* child_array, uint32_t max_size, 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);
diff --git a/shared-module/usb_cdc/Serial.c b/shared-module/usb_cdc/Serial.c
new file mode 100644
index 000000000..b4d8667ca
--- /dev/null
+++ b/shared-module/usb_cdc/Serial.c
@@ -0,0 +1,149 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "lib/utils/interrupt_char.h"
+#include "shared-module/usb_cdc/Serial.h"
+#include "supervisor/shared/tick.h"
+
+#include "tusb.h"
+
+size_t common_hal_usb_cdc_serial_read(usb_cdc_serial_obj_t *self, uint8_t *data, size_t len, int *errcode) {
+
+    const bool wait_forever = self->timeout < 0.0f;
+    const bool wait_for_timeout = self->timeout > 0.0f;
+
+    // Read up to len bytes immediately.
+    // The number of bytes read will not be larger than what is already in the TinyUSB FIFO.
+    uint32_t total_num_read = tud_cdc_n_read(self->idx, data, len);
+
+    if (wait_forever || wait_for_timeout) {
+        // Read more if we have time.
+        // Use special routine to avoid pulling in uint64-float-compatible math routines.
+        uint64_t timeout_ms = float_to_uint64(self->timeout * 1000);  // Junk value if timeout < 0.
+        uint64_t start_ticks = supervisor_ticks_ms64();
+
+        uint32_t num_read = 0;
+        while (total_num_read < len &&
+               (wait_forever || supervisor_ticks_ms64() - start_ticks <= timeout_ms)) {
+
+            // Wait for a bit, and check for ctrl-C.
+            RUN_BACKGROUND_TASKS;
+            if (mp_hal_is_interrupted()) {
+                return 0;
+            }
+
+            // Advance buffer pointer and reduce number of bytes that need to be read.
+            len -= num_read;
+            data += num_read;
+
+            // Try to read another batch of bytes.
+            num_read = tud_cdc_n_read(self->idx, data, len);
+            total_num_read += num_read;
+        }
+    }
+
+    return total_num_read;
+}
+
+size_t common_hal_usb_cdc_serial_write(usb_cdc_serial_obj_t *self, const uint8_t *data, size_t len, int *errcode) {
+    const bool wait_forever = self->write_timeout < 0.0f;
+    const bool wait_for_timeout = self->write_timeout > 0.0f;
+
+    // Write as many bytes as possible immediately.
+    // The number of bytes written at once will not be larger than what can fit in the TinyUSB FIFO.
+    uint32_t total_num_written = tud_cdc_n_write(self->idx, data, len);
+    tud_cdc_n_write_flush(self->idx);
+
+    if (wait_forever || wait_for_timeout) {
+        // Write more if we have time.
+        // Use special routine to avoid pulling in uint64-float-compatible math routines.
+        uint64_t timeout_ms = float_to_uint64(self->write_timeout * 1000);  // Junk value if write_timeout < 0.
+        uint64_t start_ticks = supervisor_ticks_ms64();
+
+        uint32_t num_written = 0;
+        while (total_num_written < len &&
+               (wait_forever || supervisor_ticks_ms64() - start_ticks <= timeout_ms)) {
+
+            // Wait for a bit, and check for ctrl-C.
+            RUN_BACKGROUND_TASKS;
+            if (mp_hal_is_interrupted()) {
+                return 0;
+            }
+
+            // Advance buffer pointer and reduce number of bytes that need to be written.
+            len -= num_written;
+            data += num_written;
+
+            // Try to write another batch of bytes.
+            num_written = tud_cdc_n_write(self->idx, data, len);
+            tud_cdc_n_write_flush(self->idx);
+            total_num_written += num_written;
+        }
+    }
+
+    return total_num_written;
+}
+
+uint32_t common_hal_usb_cdc_serial_get_in_waiting(usb_cdc_serial_obj_t *self) {
+    return tud_cdc_n_available(self->idx);
+}
+
+uint32_t common_hal_usb_cdc_serial_get_out_waiting(usb_cdc_serial_obj_t *self) {
+    // Return number of FIFO bytes currently occupied.
+    return CFG_TUD_CDC_TX_BUFSIZE - tud_cdc_n_write_available(self->idx);
+}
+
+void common_hal_usb_cdc_serial_reset_input_buffer(usb_cdc_serial_obj_t *self) {
+    tud_cdc_n_read_flush(self->idx);
+}
+
+uint32_t common_hal_usb_cdc_serial_reset_output_buffer(usb_cdc_serial_obj_t *self) {
+    return tud_cdc_n_write_clear(self->idx);
+}
+
+uint32_t common_hal_usb_cdc_serial_flush(usb_cdc_serial_obj_t *self) {
+    return tud_cdc_n_write_flush(self->idx);
+}
+
+bool common_hal_usb_cdc_serial_get_connected(usb_cdc_serial_obj_t *self) {
+    return tud_cdc_n_connected(self->idx);
+}
+
+mp_float_t common_hal_usb_cdc_serial_get_timeout(usb_cdc_serial_obj_t *self) {
+    return self->timeout;
+}
+
+void common_hal_usb_cdc_serial_set_timeout(usb_cdc_serial_obj_t *self, mp_float_t timeout) {
+    self->timeout = timeout;
+}
+
+mp_float_t common_hal_usb_cdc_serial_get_write_timeout(usb_cdc_serial_obj_t *self) {
+    return self->write_timeout;
+}
+
+void common_hal_usb_cdc_serial_set_write_timeout(usb_cdc_serial_obj_t *self, mp_float_t write_timeout) {
+    self->write_timeout = write_timeout;
+}
diff --git a/shared-module/usb_cdc/Serial.h b/shared-module/usb_cdc/Serial.h
new file mode 100644
index 000000000..ddf78eefa
--- /dev/null
+++ b/shared-module/usb_cdc/Serial.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef SHARED_MODULE_USB_CDC_SERIAL_H
+#define SHARED_MODULE_USB_CDC_SERIAL_H
+
+#include "py/obj.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    mp_float_t timeout;       // if negative, wait forever.
+    mp_float_t write_timeout; // if negative, wait forever.
+    uint8_t idx;              // which CDC device?
+} usb_cdc_serial_obj_t;
+
+#endif // SHARED_MODULE_USB_CDC_SERIAL_H
diff --git a/shared-module/usb_cdc/__init__.c b/shared-module/usb_cdc/__init__.c
new file mode 100644
index 000000000..fe05cb107
--- /dev/null
+++ b/shared-module/usb_cdc/__init__.c
@@ -0,0 +1,61 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "genhdr/autogen_usb_descriptor.h"
+#include "py/gc.h"
+#include "py/obj.h"
+#include "py/mphal.h"
+#include "py/runtime.h"
+#include "py/objtuple.h"
+#include "shared-bindings/usb_cdc/__init__.h"
+#include "shared-bindings/usb_cdc/Serial.h"
+#include "tusb.h"
+
+#if CFG_TUD_CDC != 2
+#error CFG_TUD_CDC must be exactly 2
+#endif
+
+static usb_cdc_serial_obj_t serial_objs[CFG_TUD_CDC] = {
+    {   .base.type = &usb_cdc_serial_type,
+        .timeout = -1.0f,
+        .write_timeout = -1.0f,
+        .idx = 0,
+    }, {
+        .base.type = &usb_cdc_serial_type,
+        .timeout = -1.0f,
+        .write_timeout = -1.0f,
+        .idx = 1,
+    }
+};
+
+const mp_rom_obj_tuple_t usb_cdc_serials_tuple = {
+    .base.type = &mp_type_tuple,
+    .len = CFG_TUD_CDC,
+    .items = {
+        &serial_objs[0],
+        &serial_objs[1],
+    },
+};
diff --git a/shared-module/usb_cdc/__init__.h b/shared-module/usb_cdc/__init__.h
new file mode 100644
index 000000000..9de3eb2fa
--- /dev/null
+++ b/shared-module/usb_cdc/__init__.h
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef SHARED_MODULE_USB_CDC___INIT___H
+#define SHARED_MODULE_USB_CDC___INIT___H
+
+#include "py/objtuple.h"
+
+extern const mp_rom_obj_tuple_t usb_cdc_serials_tuple;
+
+#endif /* SHARED_MODULE_USB_CDC___INIT___H */
diff --git a/shared-module/usb_hid/Device.c b/shared-module/usb_hid/Device.c
index 943c9bfed..2b560c328 100644
--- a/shared-module/usb_hid/Device.c
+++ b/shared-module/usb_hid/Device.c
@@ -73,7 +73,8 @@ static usb_hid_device_obj_t* get_hid_device(uint8_t report_id) {
 }
 
 // Callbacks invoked when receive Get_Report request through control endpoint
-uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen) {
+uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen) {
+    (void) itf;
     // only support Input Report
     if ( report_type != HID_REPORT_TYPE_INPUT ) return 0;
 
@@ -83,7 +84,8 @@ uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type,
 }
 
 // Callbacks invoked when receive Set_Report request through control endpoint
-void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize) {
+void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize) {
+    (void) itf;
     if (report_type == HID_REPORT_TYPE_INVALID) {
         report_id = buffer[0];
         buffer++;