Merge pull request #1 from adafruit/master

Update base

12 files changed, 575 insertions, 40 deletions

diff --git a/supervisor/port.h b/supervisor/port.h
index 1430c6a50..c8a011978 100644
--- a/supervisor/port.h
+++ b/supervisor/port.h
@@ -54,6 +54,12 @@ void reset_board(void);
 // Reset to the bootloader
 void reset_to_bootloader(void);
 
+// Get stack limit address
+uint32_t *port_stack_get_limit(void);
+
+// Get stack top address
+uint32_t *port_stack_get_top(void);
+
 // Save and retrieve a word from memory that is preserved over reset. Used for safe mode.
 void port_set_saved_word(uint32_t);
 uint32_t port_get_saved_word(void);
diff --git a/supervisor/shared/autoreload.c b/supervisor/shared/autoreload.c
index 14b21902c..a6212c1a9 100644
--- a/supervisor/shared/autoreload.c
+++ b/supervisor/shared/autoreload.c
@@ -76,3 +76,11 @@ void autoreload_stop() {
     autoreload_delay_ms = 0;
     reload_requested = false;
 }
+
+void autoreload_now() {
+    if (!autoreload_enabled || autoreload_suspended || reload_requested) {
+        return;
+    }
+    mp_raise_reload_exception();
+    reload_requested = true;
+}
diff --git a/supervisor/shared/autoreload.h b/supervisor/shared/autoreload.h
index bcb100151..fbd482c19 100644
--- a/supervisor/shared/autoreload.h
+++ b/supervisor/shared/autoreload.h
@@ -43,4 +43,6 @@ bool autoreload_is_enabled(void);
 void autoreload_suspend(void);
 void autoreload_resume(void);
 
+void autoreload_now(void);
+
 #endif  // MICROPY_INCLUDED_SUPERVISOR_AUTORELOAD_H
diff --git a/supervisor/shared/bluetooth.c b/supervisor/shared/bluetooth.c
new file mode 100644
index 000000000..02258de74
--- /dev/null
+++ b/supervisor/shared/bluetooth.c
@@ -0,0 +1,340 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Scott Shawcroft 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 "extmod/vfs.h"
+#include "extmod/vfs_fat.h"
+
+#include "shared-bindings/_bleio/__init__.h"
+#include "shared-bindings/_bleio/Adapter.h"
+#include "shared-bindings/_bleio/Characteristic.h"
+#include "shared-bindings/_bleio/Service.h"
+#include "shared-bindings/_bleio/UUID.h"
+
+#include "common-hal/_bleio/__init__.h"
+
+#include "supervisor/shared/autoreload.h"
+
+#include "py/mpstate.h"
+
+bleio_service_obj_t supervisor_ble_service;
+bleio_uuid_obj_t supervisor_ble_service_uuid;
+bleio_characteristic_obj_t supervisor_ble_version_characteristic;
+bleio_uuid_obj_t supervisor_ble_version_uuid;
+bleio_characteristic_obj_t supervisor_ble_filename_characteristic;
+bleio_uuid_obj_t supervisor_ble_filename_uuid;
+bleio_characteristic_obj_t supervisor_ble_length_characteristic;
+bleio_uuid_obj_t supervisor_ble_length_uuid;
+bleio_characteristic_obj_t supervisor_ble_contents_characteristic;
+bleio_uuid_obj_t supervisor_ble_contents_uuid;
+const uint8_t circuitpython_base_uuid[16] = {0x6e, 0x68, 0x74, 0x79, 0x50, 0x74, 0x69, 0x75, 0x63, 0x72, 0x69, 0x43, 0x00, 0x00, 0xaf, 0xad };
+uint8_t circuitpython_advertising_data[] = { 0x02, 0x01, 0x06, 0x02, 0x0a, 0x00, 0x11, 0x07, 0x6e, 0x68, 0x74, 0x79, 0x50, 0x74, 0x69, 0x75, 0x63, 0x72, 0x69, 0x43, 0x00, 0x01, 0xaf, 0xad, 0x06, 0x08, 0x43, 0x49, 0x52, 0x43, 0x55 }; 
+uint8_t circuitpython_scan_response_data[15] = {0x0e, 0x09, 0x43, 0x49, 0x52, 0x43, 0x55, 0x49, 0x54, 0x50, 0x59, 0x00, 0x00, 0x00, 0x00};
+mp_obj_list_t service_list;
+mp_obj_t service_list_items[1];
+mp_obj_list_t characteristic_list;
+mp_obj_t characteristic_list_items[4];
+
+void supervisor_bluetooth_start_advertising(void) {
+    bool is_connected = common_hal_bleio_adapter_get_connected(&common_hal_bleio_adapter_obj);
+    if (is_connected) {
+        return;
+    }
+    // TODO: switch to Adafruit short UUID for the advertisement and add manufacturing data to distinguish ourselves from arduino.
+    _common_hal_bleio_adapter_start_advertising(&common_hal_bleio_adapter_obj,
+                                                   true,
+                                                   1.0,
+                                                   circuitpython_advertising_data,
+                                                   sizeof(circuitpython_advertising_data),
+                                                   circuitpython_scan_response_data,
+                                                   sizeof(circuitpython_scan_response_data));
+}
+
+void supervisor_start_bluetooth(void) {
+    common_hal_bleio_adapter_set_enabled(&common_hal_bleio_adapter_obj, true);
+
+    supervisor_ble_service_uuid.base.type = &bleio_uuid_type;
+    common_hal_bleio_uuid_construct(&supervisor_ble_service_uuid, 0x0100, circuitpython_base_uuid);
+
+    // We know we'll only be 1 characteristic so we can statically allocate it.
+    characteristic_list.base.type = &mp_type_list;
+    characteristic_list.alloc = sizeof(characteristic_list_items) / sizeof(characteristic_list_items[0]);
+    characteristic_list.len = 0;
+    characteristic_list.items = characteristic_list_items;
+    mp_seq_clear(characteristic_list.items, 0, characteristic_list.alloc, sizeof(*characteristic_list.items));
+    
+    _common_hal_bleio_service_construct(&supervisor_ble_service, &supervisor_ble_service_uuid, false /* is secondary */, &characteristic_list);
+
+    // File length
+    supervisor_ble_version_uuid.base.type = &bleio_uuid_type;
+    common_hal_bleio_uuid_construct(&supervisor_ble_version_uuid, 0x0203, circuitpython_base_uuid);
+    common_hal_bleio_characteristic_construct(&supervisor_ble_version_characteristic,
+                                              &supervisor_ble_service,
+                                              0, // handle (for remote only)
+                                              &supervisor_ble_version_uuid,
+                                              CHAR_PROP_READ,
+                                              SECURITY_MODE_OPEN,
+                                              SECURITY_MODE_NO_ACCESS,
+                                              4, // max length
+                                              true, // fixed length
+                                              NULL); // no initial value
+
+    uint32_t version = 1;
+    mp_buffer_info_t bufinfo;
+    bufinfo.buf = &version;
+    bufinfo.len = sizeof(version);
+    common_hal_bleio_characteristic_set_value(&supervisor_ble_version_characteristic, &bufinfo);
+
+    // Active filename.
+    supervisor_ble_filename_uuid.base.type = &bleio_uuid_type;
+    common_hal_bleio_uuid_construct(&supervisor_ble_filename_uuid, 0x0200, circuitpython_base_uuid);
+    common_hal_bleio_characteristic_construct(&supervisor_ble_filename_characteristic,
+                                              &supervisor_ble_service,
+                                              0, // handle (for remote only)
+                                              &supervisor_ble_filename_uuid,
+                                              CHAR_PROP_READ | CHAR_PROP_WRITE,
+                                              SECURITY_MODE_OPEN,
+                                              SECURITY_MODE_OPEN,
+                                              500, // max length
+                                              false, // fixed length
+                                              NULL); // no initial value
+
+    char code_py[] = "/code.py";
+    bufinfo.buf = code_py;
+    bufinfo.len = sizeof(code_py);
+    common_hal_bleio_characteristic_set_value(&supervisor_ble_filename_characteristic, &bufinfo);
+
+    // File length
+    supervisor_ble_length_uuid.base.type = &bleio_uuid_type;
+    common_hal_bleio_uuid_construct(&supervisor_ble_length_uuid, 0x0202, circuitpython_base_uuid);
+    common_hal_bleio_characteristic_construct(&supervisor_ble_length_characteristic,
+                                              &supervisor_ble_service,
+                                              0, // handle (for remote only)
+                                              &supervisor_ble_length_uuid,
+                                              CHAR_PROP_NOTIFY | CHAR_PROP_READ,
+                                              SECURITY_MODE_OPEN,
+                                              SECURITY_MODE_NO_ACCESS,
+                                              4, // max length
+                                              true, // fixed length
+                                              NULL); // no initial value
+
+    // File actions
+    supervisor_ble_contents_uuid.base.type = &bleio_uuid_type;
+    common_hal_bleio_uuid_construct(&supervisor_ble_contents_uuid, 0x0201, circuitpython_base_uuid);
+    common_hal_bleio_characteristic_construct(&supervisor_ble_contents_characteristic,
+                                              &supervisor_ble_service,
+                                              0, // handle (for remote only)
+                                              &supervisor_ble_contents_uuid,
+                                              CHAR_PROP_NOTIFY | CHAR_PROP_WRITE_NO_RESPONSE | CHAR_PROP_WRITE,
+                                              SECURITY_MODE_OPEN,
+                                              SECURITY_MODE_OPEN,
+                                              500, // max length
+                                              false, // fixed length
+                                              NULL); // no initial value
+
+    supervisor_bluetooth_start_advertising();
+    vm_used_ble = false;
+}
+
+FIL active_file;
+volatile bool new_filename;
+volatile bool run_ble_background;
+bool was_connected;
+
+void update_file_length(void) {
+    int32_t file_length = -1;
+    mp_buffer_info_t bufinfo;
+    bufinfo.buf = &file_length;
+    bufinfo.len = sizeof(file_length);
+    if (active_file.obj.fs != 0) {
+        file_length = (int32_t) f_size(&active_file);
+    }
+    common_hal_bleio_characteristic_set_value(&supervisor_ble_length_characteristic, &bufinfo);
+}
+
+void open_current_file(void) {
+    if (active_file.obj.fs != 0) {
+        return;
+    }
+    uint16_t max_len = supervisor_ble_filename_characteristic.max_length;
+    uint8_t path[max_len];
+    size_t length = common_hal_bleio_characteristic_get_value(&supervisor_ble_filename_characteristic, path, max_len - 1);
+    path[length] = '\0';
+
+    FATFS *fs = &((fs_user_mount_t *) MP_STATE_VM(vfs_mount_table)->obj)->fatfs;
+    f_open(fs, &active_file, (char*) path, FA_READ | FA_WRITE);
+
+    update_file_length();
+}
+
+void close_current_file(void) {
+    f_close(&active_file);
+}
+
+uint32_t current_command[1024 / sizeof(uint32_t)];
+volatile size_t current_offset;
+
+void supervisor_bluetooth_background(void) {
+    if (!run_ble_background) {
+        return;
+    }
+    bool is_connected = common_hal_bleio_adapter_get_connected(&common_hal_bleio_adapter_obj);
+    if (!was_connected && is_connected) {
+        open_current_file();
+    } else if (was_connected && !is_connected) {
+        close_current_file();
+        new_filename = false;
+    }
+    was_connected = is_connected;
+    run_ble_background = false;
+    if (!is_connected) {
+        supervisor_bluetooth_start_advertising();
+        return;
+    }
+    if (new_filename) {
+        close_current_file();
+        open_current_file();
+
+        new_filename = false;
+        // get length and set the characteristic for it
+    }
+    uint16_t current_length = ((uint16_t*) current_command)[0];
+    if (current_length > 0 && current_length == current_offset) {
+        uint16_t command = ((uint16_t *) current_command)[1];
+        
+        if (command == 1) {
+            uint16_t max_len = 20; //supervisor_ble_contents_characteristic.max_length;
+            uint8_t buf[max_len];
+            mp_buffer_info_t bufinfo;
+            bufinfo.buf = buf;
+            f_lseek(&active_file, 0);
+            while (f_read(&active_file, buf, max_len, &bufinfo.len) == FR_OK) {
+                if (bufinfo.len == 0) {
+                    break;
+                }
+                common_hal_bleio_characteristic_set_value(&supervisor_ble_contents_characteristic, &bufinfo);
+            }
+        } else if (command == 2) { // patch
+            uint32_t offset = current_command[1];
+            uint32_t remove_length = current_command[2];
+            uint32_t insert_length = current_command[3];
+            uint32_t file_length =  (int32_t) f_size(&active_file);
+            //uint32_t data_shift_length = fileLength - offset - remove_length;
+            int32_t data_shift = insert_length - remove_length;
+            uint32_t new_length = file_length + data_shift;
+
+            // TODO: Make these loops smarter to read and write on sector boundaries.
+            if (data_shift < 0) {
+                for (uint32_t shift_offset = offset + insert_length; shift_offset < new_length; shift_offset++) {
+                    uint8_t data;
+                    UINT actual;
+                    f_lseek(&active_file, shift_offset - data_shift);
+                    f_read(&active_file, &data, 1, &actual);
+                    f_lseek(&active_file, shift_offset);
+                    f_write(&active_file, &data, 1, &actual);
+                }
+                f_truncate(&active_file);
+            } else if (data_shift > 0) {
+                f_lseek(&active_file, file_length);
+                // Fill end with 0xff so we don't need to erase.
+                uint8_t data = 0xff;
+                for (size_t i = 0; i < (size_t) data_shift; i++) {
+                    UINT actual;
+                    f_write(&active_file, &data, 1, &actual);
+                }
+                for (uint32_t shift_offset = new_length - 1; shift_offset >= offset + insert_length ; shift_offset--) {
+                    UINT actual;
+                    f_lseek(&active_file, shift_offset - data_shift);
+                    f_read(&active_file, &data, 1, &actual);
+                    f_lseek(&active_file, shift_offset);
+                    f_write(&active_file, &data, 1, &actual);
+                }
+            }
+            
+            f_lseek(&active_file, offset);
+            uint8_t* data = (uint8_t *) (current_command + 4);
+            UINT written;
+            f_write(&active_file, data, insert_length, &written);
+            f_sync(&active_file);
+            // Notify the new file length.
+            update_file_length();
+
+            // Trigger an autoreload
+            autoreload_now();
+        }
+        current_offset = 0;
+    }
+}
+
+// This happens in an interrupt so we need to be quick.
+bool supervisor_bluetooth_hook(ble_evt_t *ble_evt) {
+    // Catch writes to filename or contents. Length is read-only.
+
+    bool done = false;
+    switch (ble_evt->header.evt_id) {
+        case BLE_GAP_EVT_CONNECTED:
+            // We run our background task even if it wasn't us connected to because we may want to
+            // advertise if the user code stopped advertising.
+            run_ble_background = true;
+            break;
+        case BLE_GAP_EVT_DISCONNECTED:
+            run_ble_background = true;
+            break;
+        case BLE_GATTS_EVT_WRITE: {
+            // A client wrote to a characteristic.
+
+            ble_gatts_evt_write_t *evt_write = &ble_evt->evt.gatts_evt.params.write;
+            // Event handle must match the handle for my characteristic.
+            if (evt_write->handle == supervisor_ble_contents_characteristic.handle) {
+                // Handle events
+                //write_to_ringbuf(self, evt_write->data, evt_write->len);
+                // First packet includes a uint16_t le for length at the start.
+                uint16_t current_length = ((uint16_t*) current_command)[0];
+                memcpy(((uint8_t*) current_command) + current_offset, evt_write->data, evt_write->len);
+                current_offset += evt_write->len;
+                current_length = ((uint16_t*) current_command)[0];
+                if (current_offset == current_length) {
+                    run_ble_background = true;
+                    done = true;
+                }
+            } else if (evt_write->handle == supervisor_ble_filename_characteristic.handle) {
+                new_filename = true;
+                run_ble_background = true;
+                done = true;
+            } else {
+                return done;
+            }
+            break;
+        }
+
+        default:
+            // For debugging.
+            // mp_printf(&mp_plat_print, "Unhandled peripheral event: 0x%04x\n", ble_evt->header.evt_id);
+            break;
+    }
+    return done;
+}
diff --git a/supervisor/shared/bluetooth.h b/supervisor/shared/bluetooth.h
new file mode 100644
index 000000000..7ebcb953f
--- /dev/null
+++ b/supervisor/shared/bluetooth.h
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Scott Shawcroft 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 MICROPY_INCLUDED_SUPERVISOR_SHARED_BLUETOOTH_H
+#define MICROPY_INCLUDED_SUPERVISOR_SHARED_BLUETOOTH_H
+
+void supervisor_start_bluetooth(void);
+bool supervisor_bluetooth_hook(ble_evt_t *ble_evt);
+void supervisor_bluetooth_background(void);
+
+#endif
\ No newline at end of file
diff --git a/supervisor/shared/external_flash/devices.h b/supervisor/shared/external_flash/devices.h
index e787ba739..08d0a78fd 100644
--- a/supervisor/shared/external_flash/devices.h
+++ b/supervisor/shared/external_flash/devices.h
@@ -85,6 +85,26 @@ typedef struct {
     .single_status_byte = false, \
 }
 
+// Settings for the Adesto Tech AT25SF161-SSHD-T 2MiB SPI flash
+// for the StringCar M0 (SAMD21) Express board.
+// Source: https://www.digikey.com/product-detail/en/adesto-technologies/AT25SF161-SDHD-T/1265-1230-1-ND/
+// Datasheet: https://www.adestotech.com/wpo-content/uploads/jDS-AT25SF161_046.pdf
+#define AT25SF161 {\
+    .total_size = (1 << 21), /* 2 MiB */ \
+    .start_up_time_us = 10000, \
+    .manufacturer_id = 0x1f, \
+    .memory_type = 0x86, \
+    .capacity = 0x01, \
+    .max_clock_speed_mhz = 85, \
+    .quad_enable_bit_mask = 0x00, \
+    .has_sector_protection = true, \
+    .supports_fast_read = true, \
+    .supports_qspi = false, \
+    .supports_qspi_writes = false, \
+    .write_status_register_split = false, \
+    .single_status_byte = false, \
+}
+
 // Settings for the Gigadevice GD25Q16C 2MiB SPI flash.
 // Datasheet: http://www.gigadevice.com/datasheet/gd25q16c/
 #define GD25Q16C {\
@@ -280,6 +300,23 @@ typedef struct {
     .write_status_register_split = false, \
 }
 
+// Settings for the Winbond W25Q32JV-IQ 4MiB SPI flash.
+// Datasheet: https://www.mouser.com/datasheet/2/949/w25q32jv_revg_03272018_plus-1489806.pdf
+#define W25Q32JV_IQ {\
+    .total_size = (1 << 22), /* 4 MiB */ \
+    .start_up_time_us = 5000, \
+    .manufacturer_id = 0xef, \
+    .memory_type = 0x40, \
+    .capacity = 0x16, \
+    .max_clock_speed_mhz = 133, \
+    .quad_enable_bit_mask = 0x02, \
+    .has_sector_protection = false, \
+    .supports_fast_read = true, \
+    .supports_qspi = true, \
+    .supports_qspi_writes = true, \
+    .write_status_register_split = false, \
+}
+
 // Settings for the Winbond W25Q64JV-IM 8MiB SPI flash. Note that JV-IQ has a different .memory_type (0x40)
 // Datasheet: http://www.winbond.com/resource-files/w25q64jv%20revj%2003272018%20plus.pdf
 #define W25Q64JV_IM {\
@@ -442,4 +479,22 @@ typedef struct {
     .write_status_register_split = false, \
     .single_status_byte = false, \
 }
+
+// Settings for the ISSI IS25LP128F 16MiB SPI flash.
+// Datasheet: http://www.issi.com/WW/pdf/25LP-WP128F.pdf
+#define IS25LP128F {\
+    .total_size = (1 << 24), /* 16 MiB */ \
+    .start_up_time_us = 10000, \
+    .manufacturer_id = 0x9d, \
+    .memory_type = 0x60, \
+    .capacity = 0x18, \
+    .max_clock_speed_mhz = 133, \
+    .quad_enable_bit_mask = 0x02, \
+    .has_sector_protection = true, \
+    .supports_fast_read = true, \
+    .supports_qspi = true, \
+    .supports_qspi_writes = true, \
+    .write_status_register_split = false, \
+    .single_status_byte = true, \
+}
 #endif  // MICROPY_INCLUDED_ATMEL_SAMD_EXTERNAL_FLASH_DEVICES_H
diff --git a/supervisor/shared/memory.c b/supervisor/shared/memory.c
index 11133415d..38040d11d 100755
--- a/supervisor/shared/memory.c
+++ b/supervisor/shared/memory.c
@@ -25,6 +25,7 @@
  */
 
 #include "supervisor/memory.h"
+#include "supervisor/port.h"
 
 #include <stddef.h>
 
@@ -36,12 +37,10 @@ static supervisor_allocation allocations[CIRCUITPY_SUPERVISOR_ALLOC_COUNT];
 // We use uint32_t* to ensure word (4 byte) alignment.
 uint32_t* low_address;
 uint32_t* high_address;
-extern uint32_t _ebss;
-extern uint32_t _estack;
 
 void memory_init(void) {
-    low_address = &_ebss;
-    high_address = &_estack;
+    low_address = port_stack_get_limit();
+    high_address = port_stack_get_top();
 }
 
 void free_memory(supervisor_allocation* allocation) {
diff --git a/supervisor/shared/rgb_led_colors.h b/supervisor/shared/rgb_led_colors.h
index 48994ad62..c723fbab3 100644
--- a/supervisor/shared/rgb_led_colors.h
+++ b/supervisor/shared/rgb_led_colors.h
@@ -1,12 +1,18 @@
-#define BLACK   0x000000
-#define GREEN   0x003000
-#define BLUE    0x000030
-#define CYAN    0x003030
-#define RED     0x300000
-#define ORANGE  0x302000
-#define YELLOW  0x303000
-#define PURPLE  0x300030
-#define WHITE   0x303030
+
+#define COLOR(r, g, b) (((r) << 16) | ((g) << 8) | (b))
+// For brightness == 255 (full). This will be adjusted downward for various different RGB indicators,
+// which vary in brightness.
+#define INTENSITY (0x30)
+
+#define BLACK   COLOR(0, 0, 0)
+#define GREEN   COLOR(0, INTENSITY, 0)
+#define BLUE    COLOR(0, 0, INTENSITY)
+#define CYAN    COLOR(0, INTENSITY, INTENSITY)
+#define RED     COLOR(INTENSITY, 0, 0)
+#define ORANGE  COLOR(INTENSITY, INTENSITY*2/3, 0)
+#define YELLOW  COLOR(INTENSITY, INTENSITY, 0)
+#define PURPLE  COLOR(INTENSITY, 0, INTENSITY)
+#define WHITE   COLOR(INTENSITY, INTENSITY, INTENSITY)
 
 #define BOOT_RUNNING BLUE
 #define MAIN_RUNNING GREEN
diff --git a/supervisor/shared/rgb_led_status.c b/supervisor/shared/rgb_led_status.c
index 4d9371516..05df4c628 100644
--- a/supervisor/shared/rgb_led_status.c
+++ b/supervisor/shared/rgb_led_status.c
@@ -38,7 +38,7 @@ static digitalio_digitalinout_obj_t status_neopixel;
 
 
 #if defined(MICROPY_HW_APA102_MOSI) && defined(MICROPY_HW_APA102_SCK)
-uint8_t rgb_status_brightness = 255;
+uint8_t rgb_status_brightness = 50;
 
 #define APA102_BUFFER_LENGTH 12
 static uint8_t status_apa102_color[APA102_BUFFER_LENGTH] = {0, 0, 0, 0, 0xff, 0, 0, 0, 0xff, 0xff, 0xff, 0xff};
@@ -46,10 +46,18 @@ static uint8_t status_apa102_color[APA102_BUFFER_LENGTH] = {0, 0, 0, 0, 0xff, 0,
 #if CIRCUITPY_BITBANG_APA102
 #include "shared-bindings/bitbangio/SPI.h"
 #include "shared-module/bitbangio/types.h"
-static bitbangio_spi_obj_t status_apa102;
+static bitbangio_spi_obj_t status_apa102 = {
+    .base = {
+        .type = &bitbangio_spi_type,
+    },
+};
 #else
 #include "shared-bindings/busio/SPI.h"
-busio_spi_obj_t status_apa102;
+busio_spi_obj_t status_apa102 = {
+    .base = {
+        .type = &busio_spi_type,
+    },
+};
 #endif
 #endif
 
@@ -59,9 +67,21 @@ busio_spi_obj_t status_apa102;
 #include "shared-bindings/pulseio/PWMOut.h"
 #include "shared-bindings/microcontroller/Pin.h"
 
-pulseio_pwmout_obj_t rgb_status_r;
-pulseio_pwmout_obj_t rgb_status_g;
-pulseio_pwmout_obj_t rgb_status_b;
+pulseio_pwmout_obj_t rgb_status_r = {
+    .base = {
+        .type = &pulseio_pwmout_type,
+    },
+};
+pulseio_pwmout_obj_t rgb_status_g = {
+    .base = {
+        .type = &pulseio_pwmout_type,
+    },
+};
+pulseio_pwmout_obj_t rgb_status_b = {
+    .base = {
+        .type = &pulseio_pwmout_type,
+    },
+};
 
 uint8_t rgb_status_brightness = 0xFF;
 
@@ -74,8 +94,14 @@ uint16_t status_rgb_color[3] = {
 static uint32_t current_status_color = 0;
 #endif
 
-
+static bool rgb_led_status_init_in_progress = false;
 void rgb_led_status_init() {
+    if (rgb_led_status_init_in_progress) {
+        // Avoid recursion.
+        return;
+    }
+    rgb_led_status_init_in_progress = true;
+
     #ifdef MICROPY_HW_NEOPIXEL
         common_hal_digitalio_digitalinout_construct(&status_neopixel, MICROPY_HW_NEOPIXEL);
         // Pretend we aren't using the pins. digitalio.DigitalInOut
@@ -91,15 +117,15 @@ void rgb_led_status_init() {
                                               mp_const_none);
         #else
         if (!common_hal_busio_spi_deinited(&status_apa102)) {
-            // Don't use spi_deinit because that leads to infinite
-            // recursion because reset_pin_number may call
-            // rgb_led_status_init.
-            spi_m_sync_disable(&status_apa102.spi_desc);
+            // This may call us recursively if reset_pin_number() is called,
+            // The rgb_led_status_init_in_progress guard will prevent further recursion.
+            common_hal_busio_spi_deinit(&status_apa102);
         }
         common_hal_busio_spi_construct(&status_apa102,
                                       MICROPY_HW_APA102_SCK,
                                       MICROPY_HW_APA102_MOSI,
                                       mp_const_none);
+        common_hal_busio_spi_never_reset(&status_apa102);
         #endif
         // Pretend we aren't using the pins. bitbangio.SPI will
         // mark them as used.
@@ -149,6 +175,8 @@ void rgb_led_status_init() {
     current_status_color = 0x1000000; // Not a valid color
     new_status_color(rgb);
     #endif
+
+    rgb_led_status_init_in_progress = false;
 }
 
 void reset_status_led() {
diff --git a/supervisor/shared/safe_mode.h b/supervisor/shared/safe_mode.h
index ee0723cff..8c5dcd9c5 100644
--- a/supervisor/shared/safe_mode.h
+++ b/supervisor/shared/safe_mode.h
@@ -37,7 +37,8 @@ typedef enum {
   MICROPY_NLR_JUMP_FAIL,
   MICROPY_FATAL_ERROR,
   GC_ALLOC_OUTSIDE_VM,
-  PROGRAMMATIC_SAFE_MODE
+  PROGRAMMATIC_SAFE_MODE,
+  NORDIC_SOFT_DEVICE_ASSERT
 } safe_mode_t;
 
 safe_mode_t wait_for_safe_mode_reset(void);
diff --git a/supervisor/shared/stack.c b/supervisor/shared/stack.c
index 311fa31b2..dcecf2067 100755
--- a/supervisor/shared/stack.c
+++ b/supervisor/shared/stack.c
@@ -29,6 +29,7 @@
 #include "py/mpconfig.h"
 #include "py/runtime.h"
 #include "supervisor/cpu.h"
+#include "supervisor/port.h"
 #include "supervisor/shared/safe_mode.h"
 
 extern uint32_t _estack;
@@ -43,7 +44,7 @@ void allocate_stack(void) {
     mp_uint_t regs[10];
     mp_uint_t sp = cpu_get_regs_and_sp(regs);
 
-    mp_uint_t c_size = (uint32_t) &_estack - sp;
+    mp_uint_t c_size = (uint32_t) port_stack_get_top() - sp;
 
     stack_alloc = allocate_memory(c_size + next_stack_size + EXCEPTION_STACK_SIZE, true);
     if (stack_alloc == NULL) {
diff --git a/supervisor/supervisor.mk b/supervisor/supervisor.mk
index ee47be4b0..ad0f716fb 100644
--- a/supervisor/supervisor.mk
+++ b/supervisor/supervisor.mk
@@ -28,6 +28,11 @@ ifneq ($(SPI_FLASH_FILESYSTEM),)
 	CFLAGS += -DSPI_FLASH_FILESYSTEM=$(SPI_FLASH_FILESYSTEM) -DEXPRESS_BOARD
 endif
 
+
+ifeq ($(CIRCUITPY_BLEIO),1)
+	SRC_SUPERVISOR += supervisor/shared/bluetooth.c
+endif
+
 # Choose which flash filesystem impl to use.
 # (Right now INTERNAL_FLASH_FILESYSTEM and SPI_FLASH_FILESYSTEM are mutually exclusive.
 # But that might not be true in the future.)
@@ -94,9 +99,69 @@ ifndef USB_HID_DEVICES
 USB_HID_DEVICES = "KEYBOARD,MOUSE,CONSUMER,GAMEPAD"
 endif
 
-# SAMD21 needs separate endpoint pairs for MSC BULK IN and BULK OUT, otherwise it's erratic.
-ifndef USB_MSC_NUM_ENDPOINT_PAIRS
-USB_MSC_NUM_ENDPOINT_PAIRS = 1
+ifndef USB_MSC_MAX_PACKET_SIZE
+USB_MSC_MAX_PACKET_SIZE = 64
+endif
+
+ifndef USB_CDC_EP_NUM_NOTIFICATION
+USB_CDC_EP_NUM_NOTIFICATION = 0
+endif
+
+ifndef USB_CDC_EP_NUM_DATA_OUT
+USB_CDC_EP_NUM_DATA_OUT = 0
+endif
+
+ifndef USB_CDC_EP_NUM_DATA_IN
+USB_CDC_EP_NUM_DATA_IN = 0
+endif
+
+ifndef USB_MSC_EP_NUM_OUT
+USB_MSC_EP_NUM_OUT = 0
+endif
+
+ifndef USB_MSC_EP_NUM_IN
+USB_MSC_EP_NUM_IN = 0
+endif
+
+ifndef USB_HID_EP_NUM_OUT
+USB_HID_EP_NUM_OUT = 0
+endif
+
+ifndef USB_HID_EP_NUM_IN
+USB_HID_EP_NUM_IN = 0
+endif
+
+ifndef USB_MIDI_EP_NUM_OUT
+USB_MIDI_EP_NUM_OUT = 0
+endif
+
+ifndef USB_MIDI_EP_NUM_IN
+USB_MIDI_EP_NUM_IN = 0
+endif
+
+USB_DESCRIPTOR_ARGS = \
+	--manufacturer $(USB_MANUFACTURER)\
+	--product $(USB_PRODUCT)\
+	--vid $(USB_VID)\
+	--pid $(USB_PID)\
+	--serial_number_length $(USB_SERIAL_NUMBER_LENGTH)\
+	--devices $(USB_DEVICES)\
+	--hid_devices $(USB_HID_DEVICES)\
+  --msc_max_packet_size $(USB_MSC_MAX_PACKET_SIZE)\
+	--cdc_ep_num_notification $(USB_CDC_EP_NUM_NOTIFICATION)\
+	--cdc_ep_num_data_out $(USB_CDC_EP_NUM_DATA_OUT)\
+	--cdc_ep_num_data_in $(USB_CDC_EP_NUM_DATA_IN)\
+	--msc_ep_num_out $(USB_MSC_EP_NUM_OUT)\
+	--msc_ep_num_in $(USB_MSC_EP_NUM_IN)\
+	--hid_ep_num_out $(USB_HID_EP_NUM_OUT)\
+	--hid_ep_num_in $(USB_HID_EP_NUM_IN)\
+	--midi_ep_num_out $(USB_MIDI_EP_NUM_OUT)\
+	--midi_ep_num_in $(USB_MIDI_EP_NUM_IN)\
+	--output_c_file $(BUILD)/autogen_usb_descriptor.c\
+	--output_h_file $(BUILD)/genhdr/autogen_usb_descriptor.h
+
+ifeq ($(USB_RENUMBER_ENDPOINTS), 0)
+USB_DESCRIPTOR_ARGS += --no-renumber_endpoints
 endif
 
 SUPERVISOR_O = $(addprefix $(BUILD)/, $(SRC_SUPERVISOR:.c=.o)) $(BUILD)/autogen_display_resources.o
@@ -110,17 +175,7 @@ $(BUILD)/autogen_usb_descriptor.c $(BUILD)/genhdr/autogen_usb_descriptor.h: auto
 autogen_usb_descriptor.intermediate: ../../tools/gen_usb_descriptor.py Makefile | $(HEADER_BUILD)
 	$(STEPECHO) "GEN $@"
 	$(Q)install -d $(BUILD)/genhdr
-	$(Q)$(PYTHON3) ../../tools/gen_usb_descriptor.py \
-		--manufacturer $(USB_MANUFACTURER)\
-		--product $(USB_PRODUCT)\
-		--vid $(USB_VID)\
-		--pid $(USB_PID)\
-		--serial_number_length $(USB_SERIAL_NUMBER_LENGTH)\
-	        --devices $(USB_DEVICES)\
-		--hid_devices $(USB_HID_DEVICES)\
-		--msc_num_endpoint_pairs $(USB_MSC_NUM_ENDPOINT_PAIRS)\
-		--output_c_file $(BUILD)/autogen_usb_descriptor.c\
-		--output_h_file $(BUILD)/genhdr/autogen_usb_descriptor.h
+	$(Q)$(PYTHON3) ../../tools/gen_usb_descriptor.py $(USB_DESCRIPTOR_ARGS)
 
 CIRCUITPY_DISPLAY_FONT ?= "../../tools/fonts/ter-u12n.bdf"