Merge pull request #6 from adafruit/master

updating from adafruit

9 files changed, 82 insertions, 14 deletions

diff --git a/supervisor/shared/bluetooth.h b/supervisor/shared/bluetooth.h
index 7ebcb953f..1fb6a879a 100644
--- a/supervisor/shared/bluetooth.h
+++ b/supervisor/shared/bluetooth.h
@@ -31,4 +31,4 @@ 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
+#endif
diff --git a/supervisor/shared/external_flash/devices.h b/supervisor/shared/external_flash/devices.h
index f99fad4e7..466ab49eb 100644
--- a/supervisor/shared/external_flash/devices.h
+++ b/supervisor/shared/external_flash/devices.h
@@ -187,6 +187,24 @@ typedef struct {
     .single_status_byte = false, \
 }
 
+// Settings for the Gigadevice GD25S512MD 64MiB SPI flash.
+// Datasheet: http://www.gigadevice.com/datasheet/gd25s512md/
+#define GD25S512MD {\
+    .total_size = (1 << 26), /* 64 MiB */ \
+    .start_up_time_us = 5000, \
+    .manufacturer_id = 0xc8, \
+    .memory_type = 0x40, \
+    .capacity = 0x19, \
+    .max_clock_speed_mhz = 104, /* if we need 120 then we can turn on high performance mode */ \
+    .quad_enable_bit_mask = 0x02, \
+    .has_sector_protection = false, \
+    .supports_fast_read = true, \
+    .supports_qspi = true, \
+    .supports_qspi_writes = true, \
+    .write_status_register_split = true, \
+    .single_status_byte = false, \
+}
+
 // Settings for the Cypress (was Spansion) S25FL064L 8MiB SPI flash.
 // Datasheet: http://www.cypress.com/file/316661/download
 #define S25FL064L {\
diff --git a/supervisor/shared/safe_mode.c b/supervisor/shared/safe_mode.c
index c957aee53..a167ab392 100644
--- a/supervisor/shared/safe_mode.c
+++ b/supervisor/shared/safe_mode.c
@@ -160,6 +160,9 @@ void print_safe_mode_message(safe_mode_t reason) {
             case MEM_MANAGE:
                 serial_write_compressed(translate("Invalid memory access."));
                 break;
+            case WATCHDOG_RESET:
+                serial_write_compressed(translate("Watchdog timer expired."));
+                break;
             default:
                 serial_write_compressed(translate("Unknown reason."));
                 break;
diff --git a/supervisor/shared/safe_mode.h b/supervisor/shared/safe_mode.h
index 5b09c4b54..c160739ae 100644
--- a/supervisor/shared/safe_mode.h
+++ b/supervisor/shared/safe_mode.h
@@ -41,6 +41,7 @@ typedef enum {
   NORDIC_SOFT_DEVICE_ASSERT,
   FLASH_WRITE_FAIL,
   MEM_MANAGE,
+  WATCHDOG_RESET,
 } safe_mode_t;
 
 safe_mode_t wait_for_safe_mode_reset(void);
diff --git a/supervisor/shared/tick.c b/supervisor/shared/tick.c
index dc38e76f6..47395bd60 100644
--- a/supervisor/shared/tick.c
+++ b/supervisor/shared/tick.c
@@ -44,6 +44,13 @@ static volatile uint64_t PLACE_IN_DTCM_BSS(background_ticks);
 
 #include "shared-bindings/microcontroller/__init__.h"
 
+#if CIRCUITPY_WATCHDOG
+#include "shared-bindings/watchdog/__init__.h"
+#define WATCHDOG_EXCEPTION_CHECK() (MP_STATE_VM(mp_pending_exception) == &mp_watchdog_timeout_exception)
+#else
+#define WATCHDOG_EXCEPTION_CHECK() 0
+#endif
+
 void supervisor_tick(void) {
 #if CIRCUITPY_FILESYSTEM_FLUSH_INTERVAL_MS > 0
     filesystem_tick();
@@ -96,7 +103,8 @@ void mp_hal_delay_ms(mp_uint_t delay) {
         RUN_BACKGROUND_TASKS;
         // Check to see if we've been CTRL-Ced by autoreload or the user.
         if(MP_STATE_VM(mp_pending_exception) == MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception)) ||
-           MP_STATE_VM(mp_pending_exception) == MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_reload_exception))) {
+           MP_STATE_VM(mp_pending_exception) == MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_reload_exception)) ||
+           WATCHDOG_EXCEPTION_CHECK()) {
             break;
         }
         remaining = end_tick - port_get_raw_ticks(NULL);
@@ -132,4 +140,3 @@ extern void supervisor_disable_tick(void) {
     }
     common_hal_mcu_enable_interrupts();
 }
-
diff --git a/supervisor/shared/translate.c b/supervisor/shared/translate.c
index 187d5ff8a..606f8fa91 100644
--- a/supervisor/shared/translate.c
+++ b/supervisor/shared/translate.c
@@ -37,7 +37,7 @@
 #include "supervisor/serial.h"
 
 void serial_write_compressed(const compressed_string_t* compressed) {
-    char decompressed[compressed->length];
+    char decompressed[decompress_length(compressed)];
     decompress(compressed, decompressed);
     serial_write(decompressed);
 }
@@ -58,12 +58,22 @@ STATIC int put_utf8(char *buf, int u) {
     }
 }
 
+uint16_t decompress_length(const compressed_string_t* compressed) {
+    if (compress_max_length_bits <= 8) {
+        return 1 + (compressed->data >> (8 - compress_max_length_bits));
+    } else {
+        return 1 + ((compressed->data * 256 + compressed->tail[0]) >> (16 - compress_max_length_bits));
+    }
+}
+
 char* decompress(const compressed_string_t* compressed, char* decompressed) {
-    uint8_t this_byte = 0;
-    uint8_t this_bit = 7;
-    uint8_t b = compressed->data[this_byte];
+    uint8_t this_byte = compress_max_length_bits / 8;
+    uint8_t this_bit = 7 - compress_max_length_bits % 8;
+    uint8_t b = (&compressed->data)[this_byte];
+    uint16_t length = decompress_length(compressed);
+
     // Stop one early because the last byte is always NULL.
-    for (uint16_t i = 0; i < compressed->length - 1;) {
+    for (uint16_t i = 0; i < length - 1;) {
         uint32_t bits = 0;
         uint8_t bit_length = 0;
         uint32_t max_code = lengths[0];
@@ -78,7 +88,7 @@ char* decompress(const compressed_string_t* compressed, char* decompressed) {
             if (this_bit == 0) {
                 this_bit = 7;
                 this_byte += 1;
-                b = compressed->data[this_byte]; // This may read past the end but its never used.
+                b = (&compressed->data)[this_byte]; // This may read past the end but its never used.
             } else {
                 this_bit -= 1;
             }
@@ -91,14 +101,14 @@ char* decompress(const compressed_string_t* compressed, char* decompressed) {
         i += put_utf8(decompressed + i, values[searched_length + bits - max_code]);
     }
 
-    decompressed[compressed->length-1] = '\0';
+    decompressed[length-1] = '\0';
     return decompressed;
 }
 
 inline __attribute__((always_inline)) const compressed_string_t* translate(const char* original) {
     #ifndef NO_QSTR
     #define QDEF(id, str)
-    #define TRANSLATION(id, len, compressed...) if (strcmp(original, id) == 0) { static const compressed_string_t v = {.length = len, .data = compressed}; return &v; } else
+    #define TRANSLATION(id, firstbyte, ...) if (strcmp(original, id) == 0) { static const compressed_string_t v = { .data = firstbyte, .tail = { __VA_ARGS__ } }; return &v; } else
     #include "genhdr/qstrdefs.generated.h"
     #undef TRANSLATION
     #undef QDEF
diff --git a/supervisor/shared/translate.h b/supervisor/shared/translate.h
index 5e8acbb6a..731b26d12 100644
--- a/supervisor/shared/translate.h
+++ b/supervisor/shared/translate.h
@@ -29,13 +29,41 @@
 
 #include <stdint.h>
 
+// The format of the compressed data is:
+// - the size of the uncompressed string in UTF-8 bytes, encoded as a
+//   (compress_max_length_bits)-bit number.  compress_max_length_bits is
+//   computed during dictionary generation time, and happens to be 8
+//   for all current platforms.  However, it'll probably end up being
+//   9 in some translations sometime in the future.  This length excludes
+//   the trailing NUL, though notably decompress_length includes it.
+//
+// - followed by the huffman encoding of the individual UTF-16 code
+//   points that make up the string.  The trailing "\0" is not
+//   represented by a huffman code, but is implied by the length.
+//   (building the huffman encoding on UTF-16 code points gave better
+//   compression than building it on UTF-8 bytes)
+//
+// The "data" / "tail" construct is so that the struct's last member is a
+// "flexible array".  However, the _only_ member is not permitted to be
+// a flexible member, so we have to declare the first byte as a separte
+// member of the structure.
+//
+// For translations where length needs 8 bits, this saves about 1.5
+// bytes per string on average compared to a structure of {uint16_t,
+// flexible array}, but is also future-proofed against strings with
+// UTF-8 length above 256, with a savings of about 1.375 bytes per
+// string.
 typedef struct {
-    uint16_t length;
-    const uint8_t data[];
+    uint8_t data;
+    const uint8_t tail[];
 } compressed_string_t;
 
+// Return the compressed, translated version of a source string
+// Usually, due to LTO, this is optimized into a load of a constant
+// pointer.
 const compressed_string_t* translate(const char* c);
 void serial_write_compressed(const compressed_string_t* compressed);
 char* decompress(const compressed_string_t* compressed, char* decompressed);
+uint16_t decompress_length(const compressed_string_t* compressed);
 
 #endif  // MICROPY_INCLUDED_SUPERVISOR_TRANSLATE_H
diff --git a/supervisor/shared/usb/tusb_config.h b/supervisor/shared/usb/tusb_config.h
index 627de743e..5b7230983 100644
--- a/supervisor/shared/usb/tusb_config.h
+++ b/supervisor/shared/usb/tusb_config.h
@@ -49,7 +49,9 @@
 //--------------------------------------------------------------------+
 #define CFG_TUSB_RHPORT0_MODE       OPT_MODE_DEVICE
 
+#ifndef CFG_TUSB_DEBUG
 #define CFG_TUSB_DEBUG              0
+#endif
 
 /*------------- RTOS -------------*/
 #ifndef CFG_TUSB_OS
diff --git a/supervisor/stub/internal_flash.c b/supervisor/stub/internal_flash.c
index 5db6b5bc0..5a82f81f7 100644
--- a/supervisor/stub/internal_flash.c
+++ b/supervisor/stub/internal_flash.c
@@ -63,4 +63,3 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t block_num,
 
 void supervisor_flash_release_cache(void) {
 }
-