merge from upstream; working; includes debug_out code for debugging via Saleae for posterity

10 files changed, 527 insertions, 54 deletions

diff --git a/shared-module/_pixelbuf/PixelBuf.c b/shared-module/_pixelbuf/PixelBuf.c
index 9d671e454..f3e679631 100644
--- a/shared-module/_pixelbuf/PixelBuf.c
+++ b/shared-module/_pixelbuf/PixelBuf.c
@@ -132,6 +132,18 @@ void common_hal__pixelbuf_pixelbuf_set_brightness(mp_obj_t self_in, mp_float_t b
     }
 }
 
+uint8_t _pixelbuf_get_as_uint8(mp_obj_t obj) {
+    if (MP_OBJ_IS_SMALL_INT(obj)) {
+        return MP_OBJ_SMALL_INT_VALUE(obj);
+    } else if (MP_OBJ_IS_INT(obj)) {
+        return mp_obj_get_int_truncated(obj);
+    } else if (mp_obj_is_float(obj)) {
+        return (uint8_t)mp_obj_get_float(obj);
+    }
+    mp_raise_TypeError_varg(
+            translate("can't convert %q to %q"), mp_obj_get_type_qstr(obj), MP_QSTR_int);
+}
+
 void _pixelbuf_parse_color(pixelbuf_pixelbuf_obj_t* self, mp_obj_t color, uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* w) {
     pixelbuf_byteorder_details_t *byteorder = &self->byteorder;
     // w is shared between white in NeoPixels and brightness in dotstars (so that DotStars can have
@@ -142,8 +154,8 @@ void _pixelbuf_parse_color(pixelbuf_pixelbuf_obj_t* self, mp_obj_t color, uint8_
         *w = 0;
     }
 
-    if (MP_OBJ_IS_INT(color)) {
-        mp_int_t value = mp_obj_get_int_truncated(color);
+    if (MP_OBJ_IS_INT(color) || mp_obj_is_float(color)) {
+        mp_int_t value = MP_OBJ_IS_INT(color) ? mp_obj_get_int_truncated(color) : mp_obj_get_float(color);
         *r = value >> 16 & 0xff;
         *g = (value >> 8) & 0xff;
         *b = value & 0xff;
@@ -155,9 +167,9 @@ void _pixelbuf_parse_color(pixelbuf_pixelbuf_obj_t* self, mp_obj_t color, uint8_
             mp_raise_ValueError_varg(translate("Expected tuple of length %d, got %d"), byteorder->bpp, len);
         }
 
-        *r = mp_obj_get_int_truncated(items[PIXEL_R]);
-        *g = mp_obj_get_int_truncated(items[PIXEL_G]);
-        *b = mp_obj_get_int_truncated(items[PIXEL_B]);
+        *r = _pixelbuf_get_as_uint8(items[PIXEL_R]);
+        *g = _pixelbuf_get_as_uint8(items[PIXEL_G]);
+        *b = _pixelbuf_get_as_uint8(items[PIXEL_B]);
         if (len > 3) {
             if (mp_obj_is_float(items[PIXEL_W])) {
                 *w = 255 * mp_obj_get_float(items[PIXEL_W]);
@@ -218,17 +230,35 @@ void _pixelbuf_set_pixel(pixelbuf_pixelbuf_obj_t* self, size_t index, mp_obj_t v
     _pixelbuf_set_pixel_color(self, index, r, g, b, w);
 }
 
-void common_hal__pixelbuf_pixelbuf_set_pixels(mp_obj_t self_in, size_t start, mp_int_t step, size_t slice_len, mp_obj_t* values) {
+void common_hal__pixelbuf_pixelbuf_set_pixels(mp_obj_t self_in, size_t start, mp_int_t step, size_t slice_len, mp_obj_t* values,
+    mp_obj_tuple_t *flatten_to)
+{
     pixelbuf_pixelbuf_obj_t* self = native_pixelbuf(self_in);
-    for (size_t i = 0; i < slice_len; i++) {
-        _pixelbuf_set_pixel(self, start, values[i]);
-        start+=step;
+    mp_obj_iter_buf_t iter_buf;
+    mp_obj_t iterable = mp_getiter(values, &iter_buf);
+    mp_obj_t item;
+    size_t i = 0;
+    bool flattened = flatten_to != mp_const_none;
+    if (flattened) flatten_to->len = self->bytes_per_pixel;
+    while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
+        if (flattened) {
+            flatten_to->items[i % self->bytes_per_pixel] = item;
+            if (++i % self->bytes_per_pixel == 0) {
+                _pixelbuf_set_pixel(self, start, flatten_to);
+                start+=step;
+            }
+        } else {
+            _pixelbuf_set_pixel(self, start, item);
+            start+=step;
+        }
     }
     if (self->auto_write) {
         common_hal__pixelbuf_pixelbuf_show(self_in);
     }
 }
 
+
+
 void common_hal__pixelbuf_pixelbuf_set_pixel(mp_obj_t self_in, size_t index, mp_obj_t value) {
     pixelbuf_pixelbuf_obj_t* self = native_pixelbuf(self_in);
     _pixelbuf_set_pixel(self, index, value);
diff --git a/shared-module/board/__init__.c b/shared-module/board/__init__.c
index 2c9139d8a..265c6517f 100644
--- a/shared-module/board/__init__.c
+++ b/shared-module/board/__init__.c
@@ -39,6 +39,11 @@
 #include "shared-module/displayio/__init__.h"
 #endif
 
+#if CIRCUITPY_SHARPDISPLAY
+#include "shared-bindings/sharpdisplay/SharpMemoryFramebuffer.h"
+#include "shared-module/sharpdisplay/SharpMemoryFramebuffer.h"
+#endif
+
 #if BOARD_I2C
 // Statically allocate the I2C object so it can live past the end of the heap and into the next VM.
 // That way it can be used by built-in I2CDisplay displays and be accessible through board.I2C().
@@ -148,10 +153,17 @@ void reset_board_busses(void) {
     bool display_using_spi = false;
     #if CIRCUITPY_DISPLAYIO
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
-        if (displays[i].fourwire_bus.bus == spi_singleton) {
+        mp_const_obj_t bus_type = displays[i].bus_base.type;
+        if (bus_type == &displayio_fourwire_type && displays[i].fourwire_bus.bus == spi_singleton) {
+            display_using_spi = true;
+            break;
+        }
+        #if CIRCUITPY_SHARPDISPLAY
+        if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type && displays[i].sharpdisplay.bus == spi_singleton) {
             display_using_spi = true;
             break;
         }
+        #endif
     }
     #endif
     if (!display_using_spi) {
diff --git a/shared-module/displayio/__init__.c b/shared-module/displayio/__init__.c
index efc28470f..4a6428ea0 100644
--- a/shared-module/displayio/__init__.c
+++ b/shared-module/displayio/__init__.c
@@ -19,14 +19,19 @@
 #include "supervisor/spi_flash_api.h"
 #include "py/mpconfig.h"
 
+#if CIRCUITPY_SHARPDISPLAY
+#include "shared-bindings/sharpdisplay/SharpMemoryFramebuffer.h"
+#include "shared-module/sharpdisplay/SharpMemoryFramebuffer.h"
+#endif
+
 primary_display_t displays[CIRCUITPY_DISPLAY_LIMIT];
 
 #if CIRCUITPY_RGBMATRIX
-STATIC bool any_display_uses_this_rgbmatrix(rgbmatrix_rgbmatrix_obj_t* pm) {
+STATIC bool any_display_uses_this_framebuffer(mp_obj_base_t *obj) {
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
-        if (displays[i].framebuffer_display.base.type == &framebufferio_framebufferdisplay_type) {
+        if (displays[i].display_base.type == &framebufferio_framebufferdisplay_type) {
             framebufferio_framebufferdisplay_obj_t* display = &displays[i].framebuffer_display;
-            if (display->framebuffer == pm) {
+            if (display->framebuffer == obj) {
                 return true;
             }
         }
@@ -102,10 +107,14 @@ void common_hal_displayio_release_displays(void) {
             common_hal_displayio_i2cdisplay_deinit(&displays[i].i2cdisplay_bus);
         } else if (bus_type == &displayio_parallelbus_type) {
             common_hal_displayio_parallelbus_deinit(&displays[i].parallel_bus);
-#if CIRCUITPY_FRAMEBUFFERIO
+#if CIRCUITPY_RGBMATRIX
         } else if (bus_type == &rgbmatrix_RGBMatrix_type) {
             common_hal_rgbmatrix_rgbmatrix_deinit(&displays[i].rgbmatrix);
 #endif
+#if CIRCUITPY_SHARPDISPLAY
+        } else if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type) {
+            common_hal_sharpdisplay_framebuffer_deinit(&displays[i].sharpdisplay);
+#endif
         }
         displays[i].fourwire_bus.base.type = &mp_type_NoneType;
     }
@@ -170,10 +179,15 @@ void reset_displays(void) {
 #if CIRCUITPY_RGBMATRIX
         } else if (displays[i].rgbmatrix.base.type == &rgbmatrix_RGBMatrix_type) {
             rgbmatrix_rgbmatrix_obj_t * pm = &displays[i].rgbmatrix;
-            if(!any_display_uses_this_rgbmatrix(pm)) {
+            if(!any_display_uses_this_framebuffer(&pm->base)) {
                 common_hal_rgbmatrix_rgbmatrix_deinit(pm);
             }
 #endif
+#if CIRCUITPY_SHARPDISPLAY
+        } else if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type) {
+            sharpdisplay_framebuffer_obj_t * sharp = &displays[i].sharpdisplay;
+            common_hal_sharpdisplay_framebuffer_reset(sharp);
+#endif
         } else {
             // Not an active display bus.
             continue;
@@ -203,6 +217,11 @@ void displayio_gc_collect(void) {
             rgbmatrix_rgbmatrix_collect_ptrs(&displays[i].rgbmatrix);
         }
 #endif
+#if CIRCUITPY_SHARPDISPLAY
+        if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type) {
+            common_hal_sharpdisplay_framebuffer_collect_ptrs(&displays[i].sharpdisplay);
+        }
+#endif
 
         if (displays[i].display.base.type == NULL) {
             continue;
diff --git a/shared-module/displayio/__init__.h b/shared-module/displayio/__init__.h
index 9eb10c28b..44ad5a9a9 100644
--- a/shared-module/displayio/__init__.h
+++ b/shared-module/displayio/__init__.h
@@ -36,18 +36,28 @@
 #include "shared-bindings/displayio/Group.h"
 #include "shared-bindings/displayio/I2CDisplay.h"
 #include "shared-bindings/displayio/ParallelBus.h"
+#if CIRCUITPY_RGBMATRIX
 #include "shared-bindings/rgbmatrix/RGBMatrix.h"
+#endif
+#if CIRCUITPY_SHARPDISPLAY
+#include "shared-module/sharpdisplay/SharpMemoryFramebuffer.h"
+#endif
 
 typedef struct {
     union {
+        mp_obj_base_t bus_base;
         displayio_fourwire_obj_t fourwire_bus;
         displayio_i2cdisplay_obj_t i2cdisplay_bus;
         displayio_parallelbus_obj_t parallel_bus;
 #if CIRCUITPY_RGBMATRIX
         rgbmatrix_rgbmatrix_obj_t rgbmatrix;
 #endif
+#if CIRCUITPY_SHARPDISPLAY
+        sharpdisplay_framebuffer_obj_t sharpdisplay;
+#endif
     };
     union {
+        mp_obj_base_t display_base;
         displayio_display_obj_t display;
         displayio_epaperdisplay_obj_t epaper_display;
 #if CIRCUITPY_FRAMEBUFFERIO
diff --git a/shared-module/framebufferio/FramebufferDisplay.c b/shared-module/framebufferio/FramebufferDisplay.c
index 2a90fa0d4..6b5346877 100644
--- a/shared-module/framebufferio/FramebufferDisplay.c
+++ b/shared-module/framebufferio/FramebufferDisplay.c
@@ -40,6 +40,11 @@
 #include <stdint.h>
 #include <string.h>
 
+#define fb_getter_default(method, default_value) \
+    (self->framebuffer_protocol->method \
+        ? self->framebuffer_protocol->method(self->framebuffer) \
+        : (default_value))
+
 void common_hal_framebufferio_framebufferdisplay_construct(framebufferio_framebufferdisplay_obj_t* self,
         mp_obj_t framebuffer,
         uint16_t rotation,
@@ -51,7 +56,7 @@ void common_hal_framebufferio_framebufferdisplay_construct(framebufferio_framebu
 
     uint16_t ram_width = 0x100;
     uint16_t ram_height = 0x100;
-
+    uint16_t depth = fb_getter_default(get_color_depth, 16);
     displayio_display_core_construct(
         &self->core,
         NULL,
@@ -62,16 +67,29 @@ void common_hal_framebufferio_framebufferdisplay_construct(framebufferio_framebu
         0,
         0,
         rotation,
-        self->framebuffer_protocol->get_color_depth(self->framebuffer),
-        false,
-        false,
-        self->framebuffer_protocol->get_bytes_per_cell(self->framebuffer),
-        false,
-        false);
+        depth,
+        fb_getter_default(get_grayscale, (depth < 8)),
+        fb_getter_default(get_pixels_in_byte_share_row, false),
+        fb_getter_default(get_bytes_per_cell, 2),
+        fb_getter_default(get_reverse_pixels_in_byte, false),
+        fb_getter_default(get_reverse_pixels_in_word, false)
+    );
+
+    self->first_pixel_offset = fb_getter_default(get_first_pixel_offset, 0);
+    self->row_stride = fb_getter_default(get_row_stride, 0);
+    if (self->row_stride == 0) {
+        self->row_stride = self->core.width * self->core.colorspace.depth/8;
+    }
+
+    self->framebuffer_protocol->get_bufinfo(self->framebuffer, &self->bufinfo);
+    size_t framebuffer_size = self->first_pixel_offset + self->row_stride * self->core.height;
+    if (self->bufinfo.len < framebuffer_size) {
+        mp_raise_IndexError_varg(translate("Framebuffer requires %d bytes"), framebuffer_size);
+    }
 
     self->first_manual_refresh = !auto_refresh;
 
-    self->native_frames_per_second = self->framebuffer_protocol->get_native_frames_per_second(self->framebuffer);
+    self->native_frames_per_second = fb_getter_default(get_native_frames_per_second, 60);
     self->native_ms_per_frame = 1000 / self->native_frames_per_second;
 
     supervisor_start_terminal(self->core.width, self->core.height);
@@ -109,7 +127,7 @@ bool common_hal_framebufferio_framebufferdisplay_set_auto_brightness(framebuffer
 }
 
 mp_float_t common_hal_framebufferio_framebufferdisplay_get_brightness(framebufferio_framebufferdisplay_obj_t* self) {
-    if (self->framebuffer_protocol->set_brightness) {
+    if (self->framebuffer_protocol->get_brightness) {
         return self->framebuffer_protocol->get_brightness(self->framebuffer);
     }
     return -1;
@@ -138,7 +156,8 @@ STATIC const displayio_area_t* _get_refresh_areas(framebufferio_framebufferdispl
     return NULL;
 }
 
-STATIC bool _refresh_area(framebufferio_framebufferdisplay_obj_t* self, const displayio_area_t* area) {
+#define MARK_ROW_DIRTY(r) (dirty_row_bitmask[r/8] |= (1 << (r & 7)))
+STATIC bool _refresh_area(framebufferio_framebufferdisplay_obj_t* self, const displayio_area_t* area, uint8_t *dirty_row_bitmask) {
     uint16_t buffer_size = 128; // In uint32_ts
 
     displayio_area_t clipped;
@@ -147,6 +166,14 @@ STATIC bool _refresh_area(framebufferio_framebufferdisplay_obj_t* self, const di
         return true;
     }
     uint16_t subrectangles = 1;
+
+    // If pixels are packed by row then rows are on byte boundaries
+    if (self->core.colorspace.depth < 8 && self->core.colorspace.pixels_in_byte_share_row) {
+        int div = 8 / self->core.colorspace.depth;
+        clipped.x1 = (clipped.x1 / div) * div;
+        clipped.x2 = ((clipped.x2 + div - 1) / div) * div;
+    }
+
     uint16_t rows_per_buffer = displayio_area_height(&clipped);
     uint8_t pixels_per_word = (sizeof(uint32_t) * 8) / self->core.colorspace.depth;
     uint16_t pixels_per_buffer = displayio_area_size(&clipped);
@@ -187,6 +214,7 @@ STATIC bool _refresh_area(framebufferio_framebufferdisplay_obj_t* self, const di
             .x2 = clipped.x2,
             .y2 = clipped.y1 + rows_per_buffer * (j + 1)
         };
+
         if (remaining_rows < rows_per_buffer) {
             subrectangle.y2 = subrectangle.y1 + remaining_rows;
         }
@@ -197,12 +225,18 @@ STATIC bool _refresh_area(framebufferio_framebufferdisplay_obj_t* self, const di
 
         displayio_display_core_fill_area(&self->core, &subrectangle, mask, buffer);
 
-        // COULDDO: this arithmetic only supports multiple-of-8 bpp
-        uint8_t *dest = self->bufinfo.buf + (subrectangle.y1 * self->core.width + subrectangle.x1) * (self->core.colorspace.depth / 8);
+        uint8_t *buf = (uint8_t *)self->bufinfo.buf, *endbuf = buf + self->bufinfo.len;
+        (void)endbuf; // Hint to compiler that endbuf is "used" even if NDEBUG
+        buf += self->first_pixel_offset;
+
+        size_t rowstride = self->row_stride;
+        uint8_t *dest = buf + subrectangle.y1 * rowstride + subrectangle.x1 * self->core.colorspace.depth / 8;
         uint8_t *src = (uint8_t*)buffer;
-        size_t rowsize = (subrectangle.x2 - subrectangle.x1) * (self->core.colorspace.depth / 8);
-        size_t rowstride = self->core.width * (self->core.colorspace.depth/8);
+        size_t rowsize = (subrectangle.x2 - subrectangle.x1) * self->core.colorspace.depth / 8;
+
         for (uint16_t i = subrectangle.y1; i < subrectangle.y2; i++) {
+            assert(dest >= buf && dest < endbuf && dest+rowsize <= endbuf);
+            MARK_ROW_DIRTY(i);
             memcpy(dest, src, rowsize);
             dest += rowstride;
             src += rowsize;
@@ -216,15 +250,23 @@ STATIC bool _refresh_area(framebufferio_framebufferdisplay_obj_t* self, const di
 }
 
 STATIC void _refresh_display(framebufferio_framebufferdisplay_obj_t* self) {
-    displayio_display_core_start_refresh(&self->core);
     self->framebuffer_protocol->get_bufinfo(self->framebuffer, &self->bufinfo);
+    if(!self->bufinfo.buf) {
+        return;
+    }
+    displayio_display_core_start_refresh(&self->core);
     const displayio_area_t* current_area = _get_refresh_areas(self);
-    while (current_area != NULL) {
-        _refresh_area(self, current_area);
-        current_area = current_area->next;
+    if (current_area) {
+        uint8_t dirty_row_bitmask[(self->core.height + 7) / 8];
+        memset(dirty_row_bitmask, 0, sizeof(dirty_row_bitmask));
+        self->framebuffer_protocol->get_bufinfo(self->framebuffer, &self->bufinfo);
+        while (current_area != NULL) {
+            _refresh_area(self, current_area, dirty_row_bitmask);
+            current_area = current_area->next;
+        }
+        self->framebuffer_protocol->swapbuffers(self->framebuffer, dirty_row_bitmask);
     }
     displayio_display_core_finish_refresh(&self->core);
-    self->framebuffer_protocol->swapbuffers(self->framebuffer);
 }
 
 void common_hal_framebufferio_framebufferdisplay_set_rotation(framebufferio_framebufferdisplay_obj_t* self, int rotation){
@@ -307,11 +349,7 @@ void release_framebufferdisplay(framebufferio_framebufferdisplay_obj_t* self) {
     common_hal_framebufferio_framebufferdisplay_set_auto_refresh(self, false);
     release_display_core(&self->core);
     self->framebuffer_protocol->deinit(self->framebuffer);
-}
-
-void reset_framebufferdisplay(framebufferio_framebufferdisplay_obj_t* self) {
-    common_hal_framebufferio_framebufferdisplay_set_auto_refresh(self, true);
-    common_hal_framebufferio_framebufferdisplay_show(self, NULL);
+    self->base.type = &mp_type_NoneType;
 }
 
 void framebufferio_framebufferdisplay_collect_ptrs(framebufferio_framebufferdisplay_obj_t* self) {
@@ -320,6 +358,12 @@ void framebufferio_framebufferdisplay_collect_ptrs(framebufferio_framebufferdisp
 }
 
 void framebufferio_framebufferdisplay_reset(framebufferio_framebufferdisplay_obj_t* self) {
-    common_hal_framebufferio_framebufferdisplay_set_auto_refresh(self, true);
-    common_hal_framebufferio_framebufferdisplay_show(self, NULL);
+    mp_obj_type_t *fb_type = mp_obj_get_type(self->framebuffer);
+    if(fb_type != NULL && fb_type != &mp_type_NoneType) {
+        common_hal_framebufferio_framebufferdisplay_set_auto_refresh(self, true);
+        common_hal_framebufferio_framebufferdisplay_show(self, NULL);
+        self->core.full_refresh = true;
+    } else {
+        release_framebufferdisplay(self);
+    }
 }
diff --git a/shared-module/framebufferio/FramebufferDisplay.h b/shared-module/framebufferio/FramebufferDisplay.h
index ca1ab984a..89df0d27c 100644
--- a/shared-module/framebufferio/FramebufferDisplay.h
+++ b/shared-module/framebufferio/FramebufferDisplay.h
@@ -48,44 +48,65 @@ typedef struct {
     uint64_t last_refresh_call;
     uint16_t native_frames_per_second;
     uint16_t native_ms_per_frame;
+    uint16_t first_pixel_offset;
+    uint16_t row_stride;
     bool auto_refresh;
     bool first_manual_refresh;
 } framebufferio_framebufferdisplay_obj_t;
 
 void framebufferio_framebufferdisplay_background(framebufferio_framebufferdisplay_obj_t* self);
 void release_framebufferdisplay(framebufferio_framebufferdisplay_obj_t* self);
-void reset_framebufferdisplay(framebufferio_framebufferdisplay_obj_t* self);
 void framebufferio_framebufferdisplay_reset(framebufferio_framebufferdisplay_obj_t* self);
 
 void framebufferio_framebufferdisplay_collect_ptrs(framebufferio_framebufferdisplay_obj_t* self);
 
 mp_obj_t common_hal_framebufferio_framebufferdisplay_get_framebuffer(framebufferio_framebufferdisplay_obj_t* self);
 
-typedef void (*framebuffer_get_bufinfo_fun)(mp_obj_t, mp_buffer_info_t *bufinfo);
-typedef void (*framebuffer_swapbuffers_fun)(mp_obj_t);
-typedef void (*framebuffer_deinit_fun)(mp_obj_t);
-typedef bool (*framebuffer_set_brightness_fun)(mp_obj_t, mp_float_t);
-typedef mp_float_t (*framebuffer_get_brightness_fun)(mp_obj_t);
-typedef bool (*framebuffer_set_auto_brightness_fun)(mp_obj_t, bool);
 typedef bool (*framebuffer_get_auto_brightness_fun)(mp_obj_t);
-typedef int (*framebuffer_get_width_fun)(mp_obj_t);
-typedef int (*framebuffer_get_height_fun)(mp_obj_t);
-typedef int (*framebuffer_get_color_depth_fun)(mp_obj_t);
+typedef bool (*framebuffer_get_reverse_pixels_in_byte_fun)(mp_obj_t);
+typedef bool (*framebuffer_get_reverse_pixels_in_word_fun)(mp_obj_t);
+typedef bool (*framebuffer_set_auto_brightness_fun)(mp_obj_t, bool);
+typedef bool (*framebuffer_set_brightness_fun)(mp_obj_t, mp_float_t);
 typedef int (*framebuffer_get_bytes_per_cell_fun)(mp_obj_t);
+typedef int (*framebuffer_get_color_depth_fun)(mp_obj_t);
+typedef int (*framebuffer_get_first_pixel_offset_fun)(mp_obj_t);
+typedef int (*framebuffer_get_grayscale_fun)(mp_obj_t);
+typedef int (*framebuffer_get_height_fun)(mp_obj_t);
 typedef int (*framebuffer_get_native_frames_per_second_fun)(mp_obj_t);
+typedef bool (*framebuffer_get_pixels_in_byte_share_row_fun)(mp_obj_t);
+typedef int (*framebuffer_get_row_stride_fun)(mp_obj_t);
+typedef int (*framebuffer_get_width_fun)(mp_obj_t);
+typedef mp_float_t (*framebuffer_get_brightness_fun)(mp_obj_t);
+typedef void (*framebuffer_deinit_fun)(mp_obj_t);
+typedef void (*framebuffer_get_bufinfo_fun)(mp_obj_t, mp_buffer_info_t *bufinfo);
+typedef void (*framebuffer_swapbuffers_fun)(mp_obj_t, uint8_t *dirty_row_bitmask);
 
 typedef struct _framebuffer_p_t {
     MP_PROTOCOL_HEAD // MP_QSTR_protocol_framebuffer
+
+    // Mandatory
     framebuffer_get_bufinfo_fun get_bufinfo;
     framebuffer_swapbuffers_fun swapbuffers;
     framebuffer_deinit_fun deinit;
     framebuffer_get_width_fun get_width;
     framebuffer_get_height_fun get_height;
-    framebuffer_get_color_depth_fun get_color_depth;
-    framebuffer_get_bytes_per_cell_fun get_bytes_per_cell;
-    framebuffer_get_native_frames_per_second_fun get_native_frames_per_second;
+
+    // Optional getters
+    framebuffer_get_bytes_per_cell_fun get_bytes_per_cell; // default: 2
+    framebuffer_get_color_depth_fun get_color_depth; // default: 16
+    framebuffer_get_first_pixel_offset_fun get_first_pixel_offset; // default: 0
+    framebuffer_get_grayscale_fun get_grayscale; // default: grayscale if depth < 8
+    framebuffer_get_native_frames_per_second_fun get_native_frames_per_second; // default: 60
+    framebuffer_get_pixels_in_byte_share_row_fun get_pixels_in_byte_share_row; // default: false
+    framebuffer_get_reverse_pixels_in_byte_fun get_reverse_pixels_in_byte; // default: false
+    framebuffer_get_reverse_pixels_in_word_fun get_reverse_pixels_in_word; // default: false
+    framebuffer_get_row_stride_fun get_row_stride; // default: 0 (no extra row padding)
+
+    // Optional -- default is no brightness control
     framebuffer_get_brightness_fun get_brightness;
     framebuffer_set_brightness_fun set_brightness;
+
+    // Optional -- default is no automatic brightness control
     framebuffer_get_auto_brightness_fun get_auto_brightness;
     framebuffer_set_auto_brightness_fun set_auto_brightness;
 } framebuffer_p_t;
diff --git a/shared-module/sharpdisplay/SharpMemoryFramebuffer.c b/shared-module/sharpdisplay/SharpMemoryFramebuffer.c
new file mode 100644
index 000000000..71e00d7f0
--- /dev/null
+++ b/shared-module/sharpdisplay/SharpMemoryFramebuffer.c
@@ -0,0 +1,277 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 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 <string.h>
+
+#include "py/gc.h"
+
+#include "shared-bindings/board/__init__.h"
+#include "shared-bindings/microcontroller/Pin.h"
+#include "shared-bindings/sharpdisplay/SharpMemoryFramebuffer.h"
+#include "shared-module/sharpdisplay/SharpMemoryFramebuffer.h"
+
+#include "supervisor/memory.h"
+
+#define SHARPMEM_BIT_WRITECMD_LSB (0x80)
+#define SHARPMEM_BIT_VCOM_LSB (0x40)
+
+static inline void *hybrid_alloc(size_t sz) {
+    if (gc_alloc_possible()) {
+        return m_malloc(sz + sizeof(void*), true);
+    } else {
+        supervisor_allocation *allocation = allocate_memory(align32_size(sz), false);
+        if (!allocation) {
+            return NULL;
+        }
+        memset(allocation->ptr, 0, sz);
+        return allocation->ptr;
+    }
+}
+
+static inline void hybrid_free(void *ptr_in) {
+    supervisor_allocation *allocation = allocation_from_ptr(ptr_in);
+
+    if (allocation) {
+        free_memory(allocation);
+    }
+}
+
+STATIC uint8_t bitrev(uint8_t n) {
+    uint8_t r = 0;
+    for(int i=0;i<8;i++) r |= ((n>>i) & 1)<<(7-i);
+    return r;
+}
+
+int common_hal_sharpdisplay_framebuffer_get_width(sharpdisplay_framebuffer_obj_t *self) {
+    return self->width;
+}
+
+int common_hal_sharpdisplay_framebuffer_get_height(sharpdisplay_framebuffer_obj_t *self) {
+    return self->height;
+}
+
+int common_hal_sharpdisplay_framebuffer_get_row_stride(sharpdisplay_framebuffer_obj_t *self) {
+    return (self->width + 7) / 8 + 2;
+}
+
+int common_hal_sharpdisplay_framebuffer_get_first_pixel_offset(sharpdisplay_framebuffer_obj_t *self) {
+    return 2;
+}
+
+bool common_hal_sharpdisplay_framebuffer_get_reverse_pixels_in_byte(sharpdisplay_framebuffer_obj_t *self) {
+    return true;
+}
+
+bool common_hal_sharpdisplay_framebuffer_get_pixels_in_byte_share_row(sharpdisplay_framebuffer_obj_t *self) {
+    return true;
+}
+
+void common_hal_sharpdisplay_framebuffer_reset(sharpdisplay_framebuffer_obj_t *self) {
+    if (!allocation_from_ptr(self->bufinfo.buf)) {
+        self->bufinfo.buf = NULL;
+    }
+
+    if (self->bus != &self->inline_bus
+#if BOARD_SPI
+        && self->bus != common_hal_board_get_spi()
+#endif
+    ) {
+        memcpy(&self->inline_bus, self->bus, sizeof(busio_spi_obj_t));
+        self->bus = &self->inline_bus;
+    }
+}
+
+void common_hal_sharpdisplay_framebuffer_reconstruct(sharpdisplay_framebuffer_obj_t *self) {
+
+}
+
+void common_hal_sharpdisplay_framebuffer_get_bufinfo(sharpdisplay_framebuffer_obj_t *self, mp_buffer_info_t *bufinfo) {
+    if (!self->bufinfo.buf) {
+        int row_stride = common_hal_sharpdisplay_framebuffer_get_row_stride(self);
+        int height = common_hal_sharpdisplay_framebuffer_get_height(self);
+        self->bufinfo.len = row_stride * height + 2;
+        self->bufinfo.buf = hybrid_alloc(self->bufinfo.len);
+
+        uint8_t *data = self->bufinfo.buf;
+        *data++ = SHARPMEM_BIT_WRITECMD_LSB;
+
+        for(int y=0; y<height; y++) {
+            *data = bitrev(y+1);
+            data += row_stride;
+        }
+        self->full_refresh = true;
+    }
+    *bufinfo = self->bufinfo;
+}
+
+void common_hal_sharpdisplay_framebuffer_deinit(sharpdisplay_framebuffer_obj_t *self) {
+    if (self->base.type != &sharpdisplay_framebuffer_type) {
+        return;
+    }
+
+    if (self->bus == &self->inline_bus) {
+        common_hal_busio_spi_deinit(self->bus);
+    }
+
+    common_hal_reset_pin(self->chip_select.pin);
+
+    hybrid_free(self->bufinfo.buf);
+
+    memset(self, 0, sizeof(*self));
+}
+
+void common_hal_sharpdisplay_framebuffer_construct(sharpdisplay_framebuffer_obj_t *self, busio_spi_obj_t *spi, mcu_pin_obj_t *chip_select, int baudrate, int width, int height) {
+    common_hal_digitalio_digitalinout_construct(&self->chip_select, chip_select);
+    common_hal_digitalio_digitalinout_switch_to_output(&self->chip_select, true, DRIVE_MODE_PUSH_PULL);
+    common_hal_never_reset_pin(chip_select);
+
+    self->bus = spi;
+    common_hal_busio_spi_never_reset(self->bus);
+
+    self->width = width;
+    self->height = height;
+    self->baudrate = baudrate;
+
+    int row_stride = common_hal_sharpdisplay_framebuffer_get_row_stride(self);
+    self->bufinfo.len = row_stride * height + 2;
+    self->bufinfo.buf = gc_alloc(self->bufinfo.len, false, true);
+
+    uint8_t *data = self->bufinfo.buf;
+    *data++ = SHARPMEM_BIT_WRITECMD_LSB;
+
+    for(int y=0; y<self->height; y++) {
+        *data = bitrev(y+1);
+        data += row_stride;
+    }
+    self->full_refresh = true;
+}
+
+void common_hal_sharpdisplay_framebuffer_swapbuffers(sharpdisplay_framebuffer_obj_t *self, uint8_t *dirty_row_bitmask) {
+    // claim SPI bus
+    if (!common_hal_busio_spi_try_lock(self->bus)) {
+        return;
+    }
+    common_hal_busio_spi_configure(self->bus, self->baudrate, 0, 0, 8);
+
+    // set chip select high
+    common_hal_digitalio_digitalinout_set_value(&self->chip_select, true);
+
+    // output the toggling signal
+    uint8_t *data = self->bufinfo.buf;
+    data[0] ^= SHARPMEM_BIT_VCOM_LSB;
+
+    common_hal_busio_spi_write(self->bus, data++, 1);
+
+    // output each changed row
+    size_t row_stride = common_hal_sharpdisplay_framebuffer_get_row_stride(self);
+    for(int y=0; y<self->height; y++) {
+        if(self->full_refresh || (dirty_row_bitmask[y/8] & (1 << (y & 7)))) {
+            common_hal_busio_spi_write(self->bus, data, row_stride);
+        }
+        data += row_stride;
+    }
+
+    // output a trailing zero
+    common_hal_busio_spi_write(self->bus, data, 1);
+
+    // set chip select low
+    common_hal_digitalio_digitalinout_set_value(&self->chip_select, false);
+
+    // release SPI bus
+    common_hal_busio_spi_unlock(self->bus);
+
+    self->full_refresh = false;
+}
+
+STATIC void sharpdisplay_framebuffer_deinit(mp_obj_t self_in) {
+    sharpdisplay_framebuffer_obj_t *self = self_in;
+    common_hal_sharpdisplay_framebuffer_deinit(self);
+}
+
+STATIC void sharpdisplay_framebuffer_get_bufinfo(mp_obj_t self_in, mp_buffer_info_t *bufinfo) {
+    sharpdisplay_framebuffer_obj_t *self = self_in;
+    common_hal_sharpdisplay_framebuffer_get_bufinfo(self, bufinfo);
+}
+
+STATIC int sharpdisplay_framebuffer_get_color_depth(mp_obj_t self_in) {
+    return 1;
+}
+
+STATIC int sharpdisplay_framebuffer_get_height(mp_obj_t self_in) {
+    sharpdisplay_framebuffer_obj_t *self = self_in;
+    return common_hal_sharpdisplay_framebuffer_get_height(self);
+}
+
+STATIC int sharpdisplay_framebuffer_get_width(mp_obj_t self_in) {
+    sharpdisplay_framebuffer_obj_t *self = self_in;
+    return common_hal_sharpdisplay_framebuffer_get_width(self);
+}
+
+STATIC int sharpdisplay_framebuffer_get_first_pixel_offset(mp_obj_t self_in) {
+    sharpdisplay_framebuffer_obj_t *self = self_in;
+    return common_hal_sharpdisplay_framebuffer_get_first_pixel_offset(self);
+}
+
+STATIC bool sharpdisplay_framebuffer_get_pixels_in_byte_share_row(mp_obj_t self_in) {
+    sharpdisplay_framebuffer_obj_t *self = self_in;
+    return common_hal_sharpdisplay_framebuffer_get_pixels_in_byte_share_row(self);
+}
+
+STATIC bool sharpdisplay_framebuffer_get_reverse_pixels_in_byte(mp_obj_t self_in) {
+    sharpdisplay_framebuffer_obj_t *self = self_in;
+    return common_hal_sharpdisplay_framebuffer_get_reverse_pixels_in_byte(self);
+}
+
+STATIC int sharpdisplay_framebuffer_get_row_stride(mp_obj_t self_in) {
+    sharpdisplay_framebuffer_obj_t *self = self_in;
+    return common_hal_sharpdisplay_framebuffer_get_row_stride(self);
+}
+
+STATIC void sharpdisplay_framebuffer_swapbuffers(mp_obj_t self_in, uint8_t *dirty_row_bitmask) {
+    sharpdisplay_framebuffer_obj_t *self = self_in;
+    common_hal_sharpdisplay_framebuffer_swapbuffers(self, dirty_row_bitmask);
+}
+
+const framebuffer_p_t sharpdisplay_framebuffer_proto = {
+    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_framebuffer)
+    .deinit = sharpdisplay_framebuffer_deinit,
+    .get_bufinfo = sharpdisplay_framebuffer_get_bufinfo,
+    .get_color_depth = sharpdisplay_framebuffer_get_color_depth,
+    .get_height = sharpdisplay_framebuffer_get_height,
+    .get_width = sharpdisplay_framebuffer_get_width,
+    .swapbuffers = sharpdisplay_framebuffer_swapbuffers,
+
+    .get_first_pixel_offset = sharpdisplay_framebuffer_get_first_pixel_offset,
+    .get_pixels_in_byte_share_row = sharpdisplay_framebuffer_get_pixels_in_byte_share_row,
+    .get_reverse_pixels_in_byte = sharpdisplay_framebuffer_get_reverse_pixels_in_byte,
+    .get_row_stride = sharpdisplay_framebuffer_get_row_stride,
+};
+
+void common_hal_sharpdisplay_framebuffer_collect_ptrs(sharpdisplay_framebuffer_obj_t *self) {
+    gc_collect_ptr(self->framebuffer);
+    gc_collect_ptr(self->bus);
+    gc_collect_ptr(self->bufinfo.buf);
+}
diff --git a/shared-module/sharpdisplay/SharpMemoryFramebuffer.h b/shared-module/sharpdisplay/SharpMemoryFramebuffer.h
new file mode 100644
index 000000000..8acacc94e
--- /dev/null
+++ b/shared-module/sharpdisplay/SharpMemoryFramebuffer.h
@@ -0,0 +1,60 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 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.
+ */
+
+#pragma once
+
+#include "py/obj.h"
+#include "shared-bindings/busio/SPI.h"
+#include "shared-bindings/digitalio/DigitalInOut.h"
+#include "shared-module/framebufferio/FramebufferDisplay.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    mp_obj_t framebuffer;
+    busio_spi_obj_t* bus;
+    busio_spi_obj_t inline_bus;
+    digitalio_digitalinout_obj_t chip_select;
+    mp_buffer_info_t bufinfo;
+
+    uint16_t width, height;
+    uint32_t baudrate;
+
+    bool full_refresh:1;
+} sharpdisplay_framebuffer_obj_t;
+
+void common_hal_sharpdisplay_framebuffer_construct(sharpdisplay_framebuffer_obj_t *self, busio_spi_obj_t *spi, mcu_pin_obj_t *chip_select, int baudrate, int width, int height);
+void common_hal_sharpdisplay_framebuffer_swap_buffers(sharpdisplay_framebuffer_obj_t *self, uint8_t *dirty_row_bitmask);
+void common_hal_sharpdisplay_framebuffer_deinit(sharpdisplay_framebuffer_obj_t *self);
+void common_hal_sharpdisplay_framebuffer_get_bufinfo(sharpdisplay_framebuffer_obj_t *self, mp_buffer_info_t *bufinfo);
+int common_hal_sharpdisplay_framebuffer_get_height(sharpdisplay_framebuffer_obj_t *self);
+int common_hal_sharpdisplay_framebuffer_get_width(sharpdisplay_framebuffer_obj_t *self);
+void common_hal_sharpdisplay_framebuffer_swap_buffers(sharpdisplay_framebuffer_obj_t *self, uint8_t *dirty_row_bitmask);
+void common_hal_sharpdisplay_framebuffer_reset(sharpdisplay_framebuffer_obj_t *self);
+void common_hal_sharpdisplay_framebuffer_reconstruct(sharpdisplay_framebuffer_obj_t *self);
+
+extern const framebuffer_p_t sharpdisplay_framebuffer_proto;
+
+void common_hal_sharpdisplay_framebuffer_collect_ptrs(sharpdisplay_framebuffer_obj_t*);
diff --git a/shared-module/sharpdisplay/__init__.c b/shared-module/sharpdisplay/__init__.c
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/shared-module/sharpdisplay/__init__.c
diff --git a/shared-module/sharpdisplay/__init__.h b/shared-module/sharpdisplay/__init__.h
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/shared-module/sharpdisplay/__init__.h