From 51b9a1aeca51c34e0894a08f88888eb4173af32a Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Mon, 13 Jul 2020 10:32:52 -0500
Subject: tick.c: adjust whitespace

---
 supervisor/shared/tick.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'supervisor')

diff --git a/supervisor/shared/tick.c b/supervisor/shared/tick.c
index dd7dba8f3..01a554e15 100644
--- a/supervisor/shared/tick.c
+++ b/supervisor/shared/tick.c
@@ -104,13 +104,13 @@ void mp_hal_delay_ms(mp_uint_t delay) {
         // 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)))
            {
-           // clear exception and generate stacktrace
+            // clear exception and generate stacktrace
             MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
             nlr_raise(&MP_STATE_VM(mp_kbd_exception));
           }
         if( MP_STATE_VM(mp_pending_exception) == MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_reload_exception)) ||
            WATCHDOG_EXCEPTION_CHECK()) {
-           // stop sleeping immediately
+            // stop sleeping immediately
             break;
         }
         remaining = end_tick - port_get_raw_ticks(NULL);
-- 
cgit v1.2.3


From 1474fccd2fb1cf6ccd14979a3b5405d2a355054b Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Mon, 11 May 2020 08:37:20 -0500
Subject: supervisor: Add a linked list of background callbacks

In time, we should transition interrupt driven background tasks out of the
overall run_background_tasks into distinct background callbacks,
so that the number of checks that occur with each tick is reduced.
---
 main.c                                  |   3 +
 supervisor/background_callback.h        |  82 +++++++++++++++++++++++++
 supervisor/shared/background_callback.c | 104 ++++++++++++++++++++++++++++++++
 supervisor/shared/tick.c                |   6 +-
 supervisor/supervisor.mk                |   1 +
 5 files changed, 192 insertions(+), 4 deletions(-)
 create mode 100644 supervisor/background_callback.h
 create mode 100644 supervisor/shared/background_callback.c

(limited to 'supervisor')

diff --git a/main.c b/main.c
index c3787122d..201022f1a 100755
--- a/main.c
+++ b/main.c
@@ -45,6 +45,7 @@
 
 #include "background.h"
 #include "mpconfigboard.h"
+#include "supervisor/background_callback.h"
 #include "supervisor/cpu.h"
 #include "supervisor/memory.h"
 #include "supervisor/port.h"
@@ -161,6 +162,8 @@ void stop_mp(void) {
     MP_STATE_VM(vfs_cur) = vfs;
     #endif
 
+    background_callback_reset();
+
     gc_deinit();
 }
 
diff --git a/supervisor/background_callback.h b/supervisor/background_callback.h
new file mode 100644
index 000000000..82025f6b7
--- /dev/null
+++ b/supervisor/background_callback.h
@@ -0,0 +1,82 @@
+/*
+ * 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.
+ */
+
+#ifndef CIRCUITPY_INCLUDED_SUPERVISOR_BACKGROUND_CALLBACK_H
+#define CIRCUITPY_INCLUDED_SUPERVISOR_BACKGROUND_CALLBACK_H
+
+/** Background callbacks are a linked list of tasks to call in the background.
+ *
+ * Include a member of type `background_callback_t` inside an object
+ * which needs to queue up background work, and zero-initialize it.
+ *
+ * To schedule the work, use background_callback_add, with fun as the
+ * function to call and data pointing to the object itself.
+ *
+ * Next time run_background_tasks_if_tick is called, the callback will
+ * be run and removed from the linked list.
+ *
+ * Queueing a task that is already queued does nothing.  Unconditionally
+ * re-queueing it from its own background task will cause it to run during the
+ * very next background-tasks invocation, leading to a CircuitPython freeze, so
+ * don't do that.
+ *
+ * background_callback_add can be called from interrupt context.
+ */
+typedef void (*background_callback_fun)(void *data);
+typedef struct background_callback {
+    background_callback_fun fun;
+    void *data;
+    struct background_callback *next;
+    struct background_callback *prev;
+} background_callback_t;
+
+/* Add a background callback for which 'fun' and 'data' were previously set */
+void background_callback_add_core(background_callback_t *cb);
+
+/* Add a background callback to the given function with the given data.  When
+ * the callback involves an object on the GC heap, the 'data' must be a pointer
+ * to that object itself, not an internal pointer.  Otherwise, it can be the
+ * case that no other references to the object itself survive, and the object
+ * becomes garbage collected while an outstanding background callback still
+ * exists.
+ */
+void background_callback_add(background_callback_t *cb, background_callback_fun fun, void *data);
+
+/* Run all background callbacks.  Normally, this is done by the supervisor
+ * whenever the list is non-empty */
+void background_callback_run_all(void);
+
+/* During soft reset, remove all pending callbacks and clear the critical section flag */
+void background_callback_reset(void);
+
+/* Sometimes background callbacks must be blocked.  Use these functions to
+ * bracket the section of code where this is the case.  These calls nest, and
+ * begins must be balanced with ends.
+ */
+void background_callback_begin_critical_section(void);
+void background_callback_end_critical_section(void);
+
+#endif
diff --git a/supervisor/shared/background_callback.c b/supervisor/shared/background_callback.c
new file mode 100644
index 000000000..99607b7a8
--- /dev/null
+++ b/supervisor/shared/background_callback.c
@@ -0,0 +1,104 @@
+/*
+ * 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 "py/mpconfig.h"
+#include "supervisor/background_callback.h"
+#include "supervisor/shared/tick.h"
+#include "shared-bindings/microcontroller/__init__.h"
+
+STATIC volatile background_callback_t *callback_head, *callback_tail;
+
+#define CALLBACK_CRITICAL_BEGIN (common_hal_mcu_disable_interrupts())
+#define CALLBACK_CRITICAL_END (common_hal_mcu_enable_interrupts())
+
+void background_callback_add_core(background_callback_t *cb) {
+    CALLBACK_CRITICAL_BEGIN;
+    if (cb->prev || callback_head == cb) {
+        CALLBACK_CRITICAL_END;
+        return;
+    }
+    cb->next = 0;
+    cb->prev = (background_callback_t*)callback_tail;
+    if (callback_tail) {
+        callback_tail->next = cb;
+        cb->prev = (background_callback_t*)callback_tail;
+    }
+    if (!callback_head) {
+        callback_head = cb;
+    }
+    callback_tail = cb;
+    CALLBACK_CRITICAL_END;
+}
+
+void background_callback_add(background_callback_t *cb, background_callback_fun fun, void *data) {
+    cb->fun = fun;
+    cb->data = data;
+    background_callback_add_core(cb);
+}
+
+static bool in_background_callback;
+void background_callback_run_all() {
+    CALLBACK_CRITICAL_BEGIN;
+    if(in_background_callback) {
+        CALLBACK_CRITICAL_END;
+        return;
+    }
+    in_background_callback = true;
+    background_callback_t *cb = (background_callback_t*)callback_head;
+    callback_head = NULL;
+    callback_tail = NULL;
+    while (cb) {
+        background_callback_t *next = cb->next;
+        cb->next = cb->prev = NULL;
+        background_callback_fun fun = cb->fun;
+        void *data = cb->data;
+        CALLBACK_CRITICAL_END;
+        // Leave the critical section in order to run the callback function
+        if (fun) {
+            fun(data);
+        }
+        CALLBACK_CRITICAL_BEGIN;
+        cb = next;
+    }
+    in_background_callback = false;
+    CALLBACK_CRITICAL_END;
+}
+
+void background_callback_begin_critical_section() {
+    CALLBACK_CRITICAL_BEGIN;
+}
+
+void background_callback_end_critical_section() {
+    CALLBACK_CRITICAL_END;
+}
+
+void background_callback_reset() {
+    CALLBACK_CRITICAL_BEGIN;
+    callback_head = NULL;
+    callback_tail = NULL;
+    in_background_callback = false;
+    CALLBACK_CRITICAL_END;
+}
diff --git a/supervisor/shared/tick.c b/supervisor/shared/tick.c
index 01a554e15..7a2f313eb 100644
--- a/supervisor/shared/tick.c
+++ b/supervisor/shared/tick.c
@@ -29,6 +29,7 @@
 #include "py/mpstate.h"
 #include "supervisor/linker.h"
 #include "supervisor/filesystem.h"
+#include "supervisor/background_callback.h"
 #include "supervisor/port.h"
 #include "supervisor/shared/autoreload.h"
 
@@ -86,10 +87,7 @@ uint32_t supervisor_ticks_ms32() {
 extern void run_background_tasks(void);
 
 void PLACE_IN_ITCM(supervisor_run_background_tasks_if_tick)() {
-    // TODO: Add a global that can be set by anyone to indicate we should run background tasks. That
-    // way we can short circuit the background tasks early. We used to do it based on time but it
-    // breaks cases where we wake up for a short period and then sleep. If we skipped the last
-    // background task or more before sleeping we may end up starving a task like USB.
+    background_callback_run_all();
     run_background_tasks();
 }
 
diff --git a/supervisor/supervisor.mk b/supervisor/supervisor.mk
index 21803ae0a..188536686 100644
--- a/supervisor/supervisor.mk
+++ b/supervisor/supervisor.mk
@@ -2,6 +2,7 @@ SRC_SUPERVISOR = \
 	main.c \
 	supervisor/port.c \
 	supervisor/shared/autoreload.c \
+	supervisor/shared/background_callback.c \
 	supervisor/shared/board.c \
 	supervisor/shared/filesystem.c \
 	supervisor/shared/flash.c \
-- 
cgit v1.2.3


From 8c4a9f644407ee6fccf3720fd3b727085a2ff109 Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Thu, 9 Jul 2020 09:47:10 -0500
Subject: supervisor: tick: only run background tasks once per tick

---
 supervisor/shared/tick.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

(limited to 'supervisor')

diff --git a/supervisor/shared/tick.c b/supervisor/shared/tick.c
index 7a2f313eb..46172d0f3 100644
--- a/supervisor/shared/tick.c
+++ b/supervisor/shared/tick.c
@@ -52,6 +52,14 @@ static volatile uint64_t PLACE_IN_DTCM_BSS(background_ticks);
 #define WATCHDOG_EXCEPTION_CHECK() 0
 #endif
 
+static background_callback_t callback;
+
+extern void run_background_tasks(void);
+
+void background_task_tick(void *unused) {
+    run_background_tasks();
+}
+
 void supervisor_tick(void) {
 #if CIRCUITPY_FILESYSTEM_FLUSH_INTERVAL_MS > 0
     filesystem_tick();
@@ -69,6 +77,7 @@ void supervisor_tick(void) {
         #endif
     }
 #endif
+    background_callback_add(&callback, background_task_tick, NULL);
 }
 
 uint64_t supervisor_ticks_ms64() {
@@ -84,11 +93,9 @@ uint32_t supervisor_ticks_ms32() {
     return supervisor_ticks_ms64();
 }
 
-extern void run_background_tasks(void);
 
 void PLACE_IN_ITCM(supervisor_run_background_tasks_if_tick)() {
     background_callback_run_all();
-    run_background_tasks();
 }
 
 void mp_hal_delay_ms(mp_uint_t delay) {
-- 
cgit v1.2.3


From 36b46465167f15eaf8535608b16859e6de10fac8 Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Fri, 10 Jul 2020 14:42:21 -0500
Subject: background_callback: Avoid CALLBACK_CRITICAL_BEGIN with nothing to do

CALLBACK_CRITICAL_BEGIN is heavyweight, but we can be confident we do
not have work to do as long as callback_head is NULL.

This gives back performance on nRF.
---
 supervisor/shared/background_callback.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'supervisor')

diff --git a/supervisor/shared/background_callback.c b/supervisor/shared/background_callback.c
index 99607b7a8..e45c9b5c3 100644
--- a/supervisor/shared/background_callback.c
+++ b/supervisor/shared/background_callback.c
@@ -61,8 +61,11 @@ void background_callback_add(background_callback_t *cb, background_callback_fun
 
 static bool in_background_callback;
 void background_callback_run_all() {
+    if (!callback_head) {
+        return;
+    }
     CALLBACK_CRITICAL_BEGIN;
-    if(in_background_callback) {
+    if (in_background_callback) {
         CALLBACK_CRITICAL_END;
         return;
     }
-- 
cgit v1.2.3


From 6160d11c5a04f60e54ce977fd73fafa5ba858aa0 Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Tue, 7 Jul 2020 11:14:43 -0500
Subject: supervisor: factor out, Handle USB via background callback

---
 ports/atmel-samd/background.c     |  1 -
 ports/atmel-samd/supervisor/usb.c | 12 +++++++-----
 ports/litex/mphalport.c           |  3 ++-
 ports/mimxrt10xx/supervisor/usb.c |  3 ++-
 ports/nrf/background.c            |  1 -
 ports/nrf/supervisor/usb.c        |  7 +++++--
 ports/stm/supervisor/usb.c        |  2 +-
 supervisor/shared/usb/usb.c       | 11 +++++++++++
 supervisor/usb.h                  |  3 +++
 9 files changed, 31 insertions(+), 12 deletions(-)

(limited to 'supervisor')

diff --git a/ports/atmel-samd/background.c b/ports/atmel-samd/background.c
index b903456ee..5c499ab3a 100644
--- a/ports/atmel-samd/background.c
+++ b/ports/atmel-samd/background.c
@@ -85,7 +85,6 @@ void run_background_tasks(void) {
     network_module_background();
     #endif
     filesystem_background();
-    usb_background();
     running_background_tasks = false;
     assert_heap_ok();
 
diff --git a/ports/atmel-samd/supervisor/usb.c b/ports/atmel-samd/supervisor/usb.c
index 650ed6a39..ea940f898 100644
--- a/ports/atmel-samd/supervisor/usb.c
+++ b/ports/atmel-samd/supervisor/usb.c
@@ -29,6 +29,8 @@
 #include "hpl/gclk/hpl_gclk_base.h"
 #include "hal_gpio.h"
 #include "lib/tinyusb/src/device/usbd.h"
+#include "supervisor/background_callback.h"
+#include "supervisor/usb.h"
 
 void init_usb_hardware(void) {
     #ifdef SAMD21
@@ -61,24 +63,24 @@ void init_usb_hardware(void) {
 
 #ifdef SAMD21
 void USB_Handler(void) {
-    tud_int_handler(0);
+    usb_irq_handler();
 }
 #endif
 
 #ifdef SAM_D5X_E5X
 void USB_0_Handler (void) {
-  tud_int_handler(0);
+    usb_irq_handler();
 }
 
 void USB_1_Handler (void) {
-  tud_int_handler(0);
+    usb_irq_handler();
 }
 
 void USB_2_Handler (void) {
-  tud_int_handler(0);
+    usb_irq_handler();
 }
 
 void USB_3_Handler (void) {
-  tud_int_handler(0);
+    usb_irq_handler();
 }
 #endif
diff --git a/ports/litex/mphalport.c b/ports/litex/mphalport.c
index 84a546795..862f16393 100644
--- a/ports/litex/mphalport.c
+++ b/ports/litex/mphalport.c
@@ -31,6 +31,7 @@
 #include "py/mphal.h"
 #include "py/mpstate.h"
 #include "py/gc.h"
+#include "supervisor/usb.h"
 
 #include "csr.h"
 #include "generated/soc.h"
@@ -49,7 +50,7 @@ void isr(void) {
 
 #ifdef CFG_TUSB_MCU
     if (irqs & (1 << USB_INTERRUPT))
-        tud_int_handler(0);
+        usb_irq_handler();
 #endif
     if (irqs & (1 << TIMER0_INTERRUPT))
         SysTick_Handler();
diff --git a/ports/mimxrt10xx/supervisor/usb.c b/ports/mimxrt10xx/supervisor/usb.c
index 1bc7ea9b5..af259405a 100644
--- a/ports/mimxrt10xx/supervisor/usb.c
+++ b/ports/mimxrt10xx/supervisor/usb.c
@@ -27,6 +27,7 @@
 
 #include "fsl_clock.h"
 #include "tusb.h"
+#include "supervisor/usb.h"
 
 void init_usb_hardware(void) {
     CLOCK_EnableUsbhs0PhyPllClock(kCLOCK_Usbphy480M, 480000000U);
@@ -56,5 +57,5 @@ void init_usb_hardware(void) {
 }
 
 void USB_OTG1_IRQHandler(void) {
-    tud_int_handler(0);
+    usb_irq_handler();
 }
diff --git a/ports/nrf/background.c b/ports/nrf/background.c
index 966c56e0b..bc7c0d7d3 100644
--- a/ports/nrf/background.c
+++ b/ports/nrf/background.c
@@ -59,7 +59,6 @@ void run_background_tasks(void) {
     }
     running_background_tasks = true;
     filesystem_background();
-    usb_background();
 #if CIRCUITPY_AUDIOPWMIO
     audiopwmout_background();
 #endif
diff --git a/ports/nrf/supervisor/usb.c b/ports/nrf/supervisor/usb.c
index 3d2527faa..771e86ce0 100644
--- a/ports/nrf/supervisor/usb.c
+++ b/ports/nrf/supervisor/usb.c
@@ -30,6 +30,7 @@
 #include "lib/utils/interrupt_char.h"
 #include "lib/mp-readline/readline.h"
 #include "lib/tinyusb/src/device/usbd.h"
+#include "supervisor/background_callback.h"
 
 #ifdef SOFTDEVICE_PRESENT
 #include "nrf_sdm.h"
@@ -42,7 +43,9 @@ extern void tusb_hal_nrf_power_event(uint32_t event);
 
 void init_usb_hardware(void) {
 
-    // 2 is max priority (0, 1 are reserved for SD)
+    // 2 is max priority (0, 1, and 4 are reserved for SD)
+    // 5 is max priority that still allows calling SD functions such as
+    // sd_softdevice_is_enabled
     NVIC_SetPriority(USBD_IRQn, 2);
 
     // USB power may already be ready at this time -> no event generated
@@ -89,5 +92,5 @@ void init_usb_hardware(void) {
 }
 
 void USBD_IRQHandler(void) {
-  tud_int_handler(0);
+    usb_irq_handler();
 }
diff --git a/ports/stm/supervisor/usb.c b/ports/stm/supervisor/usb.c
index 3dd0acafd..3d53fa374 100644
--- a/ports/stm/supervisor/usb.c
+++ b/ports/stm/supervisor/usb.c
@@ -130,5 +130,5 @@ void init_usb_hardware(void) {
 }
 
 void OTG_FS_IRQHandler(void) {
-  tud_int_handler(0);
+  usb_irq_handler();
 }
diff --git a/supervisor/shared/usb/usb.c b/supervisor/shared/usb/usb.c
index edf810118..472be96d5 100644
--- a/supervisor/shared/usb/usb.c
+++ b/supervisor/shared/usb/usb.c
@@ -27,6 +27,7 @@
 #include "py/objstr.h"
 #include "shared-bindings/microcontroller/Processor.h"
 #include "shared-module/usb_midi/__init__.h"
+#include "supervisor/background_callback.h"
 #include "supervisor/port.h"
 #include "supervisor/usb.h"
 #include "lib/utils/interrupt_char.h"
@@ -82,6 +83,16 @@ void usb_background(void) {
     }
 }
 
+static background_callback_t callback;
+static void usb_background_do(void* unused) {
+    usb_background();
+}
+
+void usb_irq_handler(void) {
+    tud_int_handler(0);
+    background_callback_add(&callback, usb_background_do, NULL);
+}
+
 //--------------------------------------------------------------------+
 // tinyusb callbacks
 //--------------------------------------------------------------------+
diff --git a/supervisor/usb.h b/supervisor/usb.h
index 29280c725..1bed9bbb4 100644
--- a/supervisor/usb.h
+++ b/supervisor/usb.h
@@ -33,6 +33,9 @@
 // alive and responsive.
 void usb_background(void);
 
+// Ports must call this from their particular USB IRQ handler
+void usb_irq_handler(void);
+
 // Only inits the USB peripheral clocks and pins. The peripheral will be initialized by
 // TinyUSB.
 void init_usb_hardware(void);
-- 
cgit v1.2.3


From 1df48176ce2e4111c4629269cb86d2a6e365a3d2 Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Mon, 13 Jul 2020 10:33:58 -0500
Subject: supervisor: factor supervisor_background_tasks from sundry ports

---
 main.c                                             |  2 -
 ports/atmel-samd/background.c                      | 48 ++------------------
 ports/atmel-samd/background.h                      |  5 --
 .../common-hal/frequencyio/FrequencyIn.c           |  3 +-
 ports/atmel-samd/common-hal/pulseio/PulseIn.c      |  3 +-
 ports/cxd56/background.c                           | 24 ++--------
 ports/cxd56/background.h                           |  3 --
 ports/esp32s2/background.c                         | 23 ++--------
 ports/esp32s2/background.h                         |  3 --
 ports/litex/background.c                           | 32 ++-----------
 ports/litex/background.h                           |  5 --
 ports/mimxrt10xx/background.c                      | 53 ++--------------------
 ports/mimxrt10xx/background.h                      |  7 ---
 ports/mimxrt10xx/common-hal/pulseio/PulseIn.c      |  2 +-
 ports/nrf/background.c                             | 27 ++---------
 ports/nrf/background.h                             |  5 --
 ports/stm/background.c                             | 28 ++----------
 ports/stm/background.h                             |  5 --
 supervisor/port.h                                  |  8 ++++
 supervisor/shared/tick.c                           | 52 +++++++++++++++++++--
 supervisor/shared/tick.h                           | 16 ++++---
 21 files changed, 94 insertions(+), 260 deletions(-)

(limited to 'supervisor')

diff --git a/main.c b/main.c
index 201022f1a..ce95de95f 100755
--- a/main.c
+++ b/main.c
@@ -101,8 +101,6 @@ void start_mp(supervisor_allocation* heap) {
     reset_status_led();
     autoreload_stop();
 
-    background_tasks_reset();
-
     // Stack limit should be less than real stack size, so we have a chance
     // to recover from limit hit.  (Limit is measured in bytes.)
     mp_stack_ctrl_init();
diff --git a/ports/atmel-samd/background.c b/ports/atmel-samd/background.c
index 5c499ab3a..62c233a3f 100644
--- a/ports/atmel-samd/background.c
+++ b/ports/atmel-samd/background.c
@@ -39,59 +39,21 @@
 #include "shared-module/displayio/__init__.h"
 #endif
 
-volatile uint64_t last_finished_tick = 0;
-
-bool stack_ok_so_far = true;
-
-static bool running_background_tasks = false;
-
 #ifdef MONITOR_BACKGROUND_TASKS
 // PB03 is physical pin "SCL" on the Metro M4 express
 // so you can't use this code AND an i2c peripheral
 // at the same time unless you change this
-STATIC void start_background_task(void) {
+void port_start_background_task(void) {
     REG_PORT_DIRSET1 = (1<<3);
     REG_PORT_OUTSET1 = (1<<3);
 }
 
-STATIC void finish_background_task(void) {
+void port_finish_background_task(void) {
     REG_PORT_OUTCLR1 = (1<<3);
 }
 #else
-STATIC void start_background_task(void) {}
-STATIC void finish_background_task(void) {}
+void port_start_background_task(void) {}
+void port_finish_background_task(void) {}
 #endif
 
-void background_tasks_reset(void) {
-    running_background_tasks = false;
-}
-
-void run_background_tasks(void) {
-    // Don't call ourselves recursively.
-    if (running_background_tasks) {
-        return;
-    }
-
-    start_background_task();
-
-    assert_heap_ok();
-    running_background_tasks = true;
-
-    #if CIRCUITPY_DISPLAYIO
-    displayio_background();
-    #endif
-
-    #if CIRCUITPY_NETWORK
-    network_module_background();
-    #endif
-    filesystem_background();
-    running_background_tasks = false;
-    assert_heap_ok();
-
-    last_finished_tick = port_get_raw_ticks(NULL);
-    finish_background_task();
-}
-
-bool background_tasks_ok(void) {
-    return port_get_raw_ticks(NULL) - last_finished_tick < 1024;
-}
+void port_background_task(void) {}
diff --git a/ports/atmel-samd/background.h b/ports/atmel-samd/background.h
index d9866a6ab..2a89c3b1b 100644
--- a/ports/atmel-samd/background.h
+++ b/ports/atmel-samd/background.h
@@ -29,9 +29,4 @@
 
 #include <stdbool.h>
 
-void background_tasks_reset(void);
-void run_background_tasks(void);
-void run_background_vm_tasks(void);
-bool background_tasks_ok(void);
-
 #endif  // MICROPY_INCLUDED_ATMEL_SAMD_BACKGROUND_H
diff --git a/ports/atmel-samd/common-hal/frequencyio/FrequencyIn.c b/ports/atmel-samd/common-hal/frequencyio/FrequencyIn.c
index 1952df563..02d0482dc 100644
--- a/ports/atmel-samd/common-hal/frequencyio/FrequencyIn.c
+++ b/ports/atmel-samd/common-hal/frequencyio/FrequencyIn.c
@@ -46,6 +46,7 @@
 #include "hpl_gclk_config.h"
 
 #include "shared-bindings/time/__init__.h"
+#include "supervisor/shared/tick.h"
 #include "supervisor/shared/translate.h"
 
 #ifdef SAMD21
@@ -132,7 +133,7 @@ void frequencyin_interrupt_handler(uint8_t index) {
             }
 
             // Check if we've reached the upper limit of detection
-            if (!background_tasks_ok() || self->errored_too_fast) {
+            if (!supervisor_background_tasks_ok() || self->errored_too_fast) {
                 self->errored_too_fast = true;
                 frequencyin_emergency_cancel_capture(i);
             }
diff --git a/ports/atmel-samd/common-hal/pulseio/PulseIn.c b/ports/atmel-samd/common-hal/pulseio/PulseIn.c
index b825579db..ae58b089d 100644
--- a/ports/atmel-samd/common-hal/pulseio/PulseIn.c
+++ b/ports/atmel-samd/common-hal/pulseio/PulseIn.c
@@ -42,6 +42,7 @@
 #include "samd/timers.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/pulseio/PulseIn.h"
+#include "supervisor/shared/tick.h"
 #include "supervisor/shared/translate.h"
 
 // This timer is shared amongst all PulseIn objects as a higher resolution clock.
@@ -87,7 +88,7 @@ void pulsein_interrupt_handler(uint8_t channel) {
     uint32_t current_count = tc->COUNT16.COUNT.reg;
 
     pulseio_pulsein_obj_t* self = get_eic_channel_data(channel);
-    if (!background_tasks_ok() || self->errored_too_fast) {
+    if (!supervisor_background_tasks_ok() || self->errored_too_fast) {
         self->errored_too_fast = true;
         common_hal_pulseio_pulsein_pause(self);
         return;
diff --git a/ports/cxd56/background.c b/ports/cxd56/background.c
index ade257dd2..6de6d7275 100644
--- a/ports/cxd56/background.c
+++ b/ports/cxd56/background.c
@@ -30,24 +30,6 @@
 #include "supervisor/filesystem.h"
 #include "supervisor/shared/stack.h"
 
-static bool running_background_tasks = false;
-
-void background_tasks_reset(void) {
-    running_background_tasks = false;
-}
-
-void run_background_tasks(void) {
-    // Don't call ourselves recursively.
-    if (running_background_tasks) {
-        return;
-    }
-
-    assert_heap_ok();
-    running_background_tasks = true;
-
-    usb_background();
-    filesystem_background();
-
-    running_background_tasks = false;
-    assert_heap_ok();
-}
+void port_background_task(void) {}
+void port_start_background_task(void) {}
+void port_finish_background_task(void) {}
diff --git a/ports/cxd56/background.h b/ports/cxd56/background.h
index a38e3faed..5f76e6442 100644
--- a/ports/cxd56/background.h
+++ b/ports/cxd56/background.h
@@ -27,7 +27,4 @@
 #ifndef MICROPY_INCLUDED_CXD56_BACKGROUND_H
 #define MICROPY_INCLUDED_CXD56_BACKGROUND_H
 
-void background_tasks_reset(void);
-void run_background_tasks(void);
-
 #endif  // MICROPY_INCLUDED_CXD56_BACKGROUND_H
diff --git a/ports/esp32s2/background.c b/ports/esp32s2/background.c
index a90fa7d0a..40ce9ecfd 100644
--- a/ports/esp32s2/background.c
+++ b/ports/esp32s2/background.c
@@ -35,27 +35,12 @@
 #include "shared-module/displayio/__init__.h"
 #endif
 
-static bool running_background_tasks = false;
-
-void background_tasks_reset(void) {
-    running_background_tasks = false;
-}
-
-void run_background_tasks(void) {
-    // Don't call ourselves recursively.
-    if (running_background_tasks) {
-        return;
-    }
 
+void port_background_task(void) {
     // Zero delay in case FreeRTOS wants to switch to something else.
     vTaskDelay(0);
-    running_background_tasks = true;
-    filesystem_background();
+}
 
-    #if CIRCUITPY_DISPLAYIO
-    displayio_background();
-    #endif
-    running_background_tasks = false;
+void port_start_background_task(void) {}
 
-    assert_heap_ok();
-}
+void port_finish_background_task(void) {}
diff --git a/ports/esp32s2/background.h b/ports/esp32s2/background.h
index 0e1fb7a56..cb850d4e5 100644
--- a/ports/esp32s2/background.h
+++ b/ports/esp32s2/background.h
@@ -29,7 +29,4 @@
 
 #include <stdbool.h>
 
-void background_tasks_reset(void);
-void run_background_tasks(void);
-
 #endif  // MICROPY_INCLUDED_ESP32S2_BACKGROUND_H
diff --git a/ports/litex/background.c b/ports/litex/background.c
index 8c1897043..174d9588a 100644
--- a/ports/litex/background.c
+++ b/ports/litex/background.c
@@ -29,32 +29,6 @@
 #include "supervisor/usb.h"
 #include "supervisor/shared/stack.h"
 
-#if CIRCUITPY_DISPLAYIO
-#include "shared-module/displayio/__init__.h"
-#endif
-
-static bool running_background_tasks = false;
-
-void background_tasks_reset(void) {
-    running_background_tasks = false;
-}
-
-void run_background_tasks(void) {
-    // Don't call ourselves recursively.
-    if (running_background_tasks) {
-        return;
-    }
-    running_background_tasks = true;
-    filesystem_background();
-
-    #if USB_AVAILABLE
-    usb_background();
-    #endif
-
-    #if CIRCUITPY_DISPLAYIO
-    displayio_background();
-    #endif
-    running_background_tasks = false;
-
-    assert_heap_ok();
-}
+void port_background_task(void) {}
+void port_start_background_task(void) {}
+void port_finish_background_task(void) {}
diff --git a/ports/litex/background.h b/ports/litex/background.h
index 09551c7fb..c80fbbe5c 100644
--- a/ports/litex/background.h
+++ b/ports/litex/background.h
@@ -27,9 +27,4 @@
 #ifndef MICROPY_INCLUDED_LITEX_BACKGROUND_H
 #define MICROPY_INCLUDED_LITEX_BACKGROUND_H
 
-#include <stdbool.h>
-
-void background_tasks_reset(void);
-void run_background_tasks(void);
-
 #endif  // MICROPY_INCLUDED_LITEX_BACKGROUND_H
diff --git a/ports/mimxrt10xx/background.c b/ports/mimxrt10xx/background.c
index ff53ea44f..a8a613d41 100644
--- a/ports/mimxrt10xx/background.c
+++ b/ports/mimxrt10xx/background.c
@@ -24,58 +24,13 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-#include "background.h"
 
-//#include "audio_dma.h"
-#include "supervisor/filesystem.h"
-#include "supervisor/shared/tick.h"
-#include "supervisor/usb.h"
-
-#include "py/runtime.h"
-#include "shared-module/network/__init__.h"
-#include "supervisor/linker.h"
-#include "supervisor/shared/stack.h"
-
-#ifdef CIRCUITPY_DISPLAYIO
-#include "shared-module/displayio/__init__.h"
-#endif
-
-volatile uint64_t last_finished_tick = 0;
-
-bool stack_ok_so_far = true;
-
-static bool running_background_tasks = false;
-
-void background_tasks_reset(void) {
-    running_background_tasks = false;
-}
-
-void PLACE_IN_ITCM(run_background_tasks)(void) {
-    // Don't call ourselves recursively.
-    if (running_background_tasks) {
-        return;
-    }
-    assert_heap_ok();
-    running_background_tasks = true;
+#include "supervisor/port.h"
 
+void port_background_task(void) {
     #if CIRCUITPY_AUDIOIO || CIRCUITPY_AUDIOBUSIO
     audio_dma_background();
     #endif
-    #if CIRCUITPY_DISPLAYIO
-    displayio_background();
-    #endif
-
-    #if CIRCUITPY_NETWORK
-    network_module_background();
-    #endif
-    filesystem_background();
-    usb_background();
-    running_background_tasks = false;
-    assert_heap_ok();
-
-    last_finished_tick = supervisor_ticks_ms64();
-}
-
-bool background_tasks_ok(void) {
-    return supervisor_ticks_ms64() - last_finished_tick < 1000;
 }
+void port_start_background_task(void) {}
+void port_finish_background_task(void) {}
diff --git a/ports/mimxrt10xx/background.h b/ports/mimxrt10xx/background.h
index 52789d038..a3fe102ac 100644
--- a/ports/mimxrt10xx/background.h
+++ b/ports/mimxrt10xx/background.h
@@ -28,11 +28,4 @@
 #ifndef MICROPY_INCLUDED_MIMXRT10XX_BACKGROUND_H
 #define MICROPY_INCLUDED_MIMXRT10XX_BACKGROUND_H
 
-#include <stdbool.h>
-
-void background_tasks_reset(void);
-void run_background_tasks(void);
-void run_background_vm_tasks(void);
-bool background_tasks_ok(void);
-
 #endif  // MICROPY_INCLUDED_MIMXRT10XX_BACKGROUND_H
diff --git a/ports/mimxrt10xx/common-hal/pulseio/PulseIn.c b/ports/mimxrt10xx/common-hal/pulseio/PulseIn.c
index d8bf2017e..ec0290861 100644
--- a/ports/mimxrt10xx/common-hal/pulseio/PulseIn.c
+++ b/ports/mimxrt10xx/common-hal/pulseio/PulseIn.c
@@ -64,7 +64,7 @@
 //    // last ms.
 //    current_us = 1000 - current_us;
 //    pulseio_pulsein_obj_t* self = get_eic_channel_data(channel);
-//    if (!background_tasks_ok() || self->errored_too_fast) {
+//    if (!supervisor_background_tasks_ok() || self->errored_too_fast) {
 //        self->errored_too_fast = true;
 //        common_hal_pulseio_pulsein_pause(self);
 //        return;
diff --git a/ports/nrf/background.c b/ports/nrf/background.c
index bc7c0d7d3..10543ddb2 100644
--- a/ports/nrf/background.c
+++ b/ports/nrf/background.c
@@ -46,35 +46,14 @@
 #include "common-hal/_bleio/bonding.h"
 #endif
 
-static bool running_background_tasks = false;
+void port_start_background_task(void) {}
+void port_finish_background_task(void) {}
 
-void background_tasks_reset(void) {
-    running_background_tasks = false;
-}
-
-void run_background_tasks(void) {
-    // Don't call ourselves recursively.
-    if (running_background_tasks) {
-        return;
-    }
-    running_background_tasks = true;
-    filesystem_background();
+void port_background_task(void) {
 #if CIRCUITPY_AUDIOPWMIO
     audiopwmout_background();
 #endif
 #if CIRCUITPY_AUDIOBUSIO
     i2s_background();
 #endif
-
-#if CIRCUITPY_BLEIO
-    supervisor_bluetooth_background();
-    bonding_background();
-#endif
-
-    #if CIRCUITPY_DISPLAYIO
-    displayio_background();
-    #endif
-    running_background_tasks = false;
-
-    assert_heap_ok();
 }
diff --git a/ports/nrf/background.h b/ports/nrf/background.h
index d53681c0f..64a768cf9 100644
--- a/ports/nrf/background.h
+++ b/ports/nrf/background.h
@@ -27,9 +27,4 @@
 #ifndef MICROPY_INCLUDED_NRF_BACKGROUND_H
 #define MICROPY_INCLUDED_NRF_BACKGROUND_H
 
-#include <stdbool.h>
-
-void background_tasks_reset(void);
-void run_background_tasks(void);
-
 #endif  // MICROPY_INCLUDED_NRF_BACKGROUND_H
diff --git a/ports/stm/background.c b/ports/stm/background.c
index 8c1897043..d83a0ccec 100644
--- a/ports/stm/background.c
+++ b/ports/stm/background.c
@@ -33,28 +33,6 @@
 #include "shared-module/displayio/__init__.h"
 #endif
 
-static bool running_background_tasks = false;
-
-void background_tasks_reset(void) {
-    running_background_tasks = false;
-}
-
-void run_background_tasks(void) {
-    // Don't call ourselves recursively.
-    if (running_background_tasks) {
-        return;
-    }
-    running_background_tasks = true;
-    filesystem_background();
-
-    #if USB_AVAILABLE
-    usb_background();
-    #endif
-
-    #if CIRCUITPY_DISPLAYIO
-    displayio_background();
-    #endif
-    running_background_tasks = false;
-
-    assert_heap_ok();
-}
+void port_background_task(void) {}
+void port_start_background_task(void) {}
+void port_finish_background_task(void) {}
diff --git a/ports/stm/background.h b/ports/stm/background.h
index 6225429f8..e57aa40dd 100644
--- a/ports/stm/background.h
+++ b/ports/stm/background.h
@@ -27,9 +27,4 @@
 #ifndef MICROPY_INCLUDED_STM32_BACKGROUND_H
 #define MICROPY_INCLUDED_STM32_BACKGROUND_H
 
-#include <stdbool.h>
-
-void background_tasks_reset(void);
-void run_background_tasks(void);
-
 #endif  // MICROPY_INCLUDED_STM32_BACKGROUND_H
diff --git a/supervisor/port.h b/supervisor/port.h
index 8a12d34c8..ad5b3cf32 100644
--- a/supervisor/port.h
+++ b/supervisor/port.h
@@ -91,4 +91,12 @@ void port_interrupt_after_ticks(uint32_t ticks);
 // Sleep the CPU until an interrupt is received.
 void port_sleep_until_interrupt(void);
 
+// Execute port specific actions during background tasks.
+void port_background_task(void);
+
+// Take port specific actions at the beginning and end of background tasks.
+// This is used e.g., to set a monitoring pin for debug purposes.  "Actual
+// work" should be done in port_background_task() instead.
+void port_start_background_task(void);
+void port_finish_background_task(void);
 #endif  // MICROPY_INCLUDED_SUPERVISOR_PORT_H
diff --git a/supervisor/shared/tick.c b/supervisor/shared/tick.c
index 46172d0f3..bc270030f 100644
--- a/supervisor/shared/tick.c
+++ b/supervisor/shared/tick.c
@@ -32,8 +32,16 @@
 #include "supervisor/background_callback.h"
 #include "supervisor/port.h"
 #include "supervisor/shared/autoreload.h"
+#include "supervisor/shared/stack.h"
 
-static volatile uint64_t PLACE_IN_DTCM_BSS(background_ticks);
+#if CIRCUITPY_BLEIO
+#include "supervisor/shared/bluetooth.h"
+#include "common-hal/_bleio/bonding.h"
+#endif
+
+#if CIRCUITPY_DISPLAYIO
+#include "shared-module/displayio/__init__.h"
+#endif
 
 #if CIRCUITPY_GAMEPAD
 #include "shared-module/gamepad/__init__.h"
@@ -43,6 +51,10 @@ static volatile uint64_t PLACE_IN_DTCM_BSS(background_ticks);
 #include "shared-module/gamepadshift/__init__.h"
 #endif
 
+#if CIRCUITPY_NETWORK
+#include "shared-module/network/__init__.h"
+#endif
+
 #include "shared-bindings/microcontroller/__init__.h"
 
 #if CIRCUITPY_WATCHDOG
@@ -52,12 +64,42 @@ static volatile uint64_t PLACE_IN_DTCM_BSS(background_ticks);
 #define WATCHDOG_EXCEPTION_CHECK() 0
 #endif
 
+static volatile uint64_t PLACE_IN_DTCM_BSS(background_ticks);
+
 static background_callback_t callback;
 
-extern void run_background_tasks(void);
+volatile uint64_t last_finished_tick = 0;
+
+void supervisor_background_tasks(void *unused) {
+    port_start_background_task();
+
+    assert_heap_ok();
+
+    #if CIRCUITPY_DISPLAYIO
+    displayio_background();
+    #endif
+
+    #if CIRCUITPY_NETWORK
+    network_module_background();
+    #endif
+    filesystem_background();
+
+    #if CIRCUITPY_BLEIO
+    supervisor_bluetooth_background();
+    bonding_background();
+    #endif
+
+    port_background_task();
+
+    assert_heap_ok();
+
+    last_finished_tick = port_get_raw_ticks(NULL);
+
+    port_finish_background_task();
+}
 
-void background_task_tick(void *unused) {
-    run_background_tasks();
+bool supervisor_background_tasks_ok(void) {
+    return port_get_raw_ticks(NULL) - last_finished_tick < 1024;
 }
 
 void supervisor_tick(void) {
@@ -77,7 +119,7 @@ void supervisor_tick(void) {
         #endif
     }
 #endif
-    background_callback_add(&callback, background_task_tick, NULL);
+    background_callback_add(&callback, supervisor_background_tasks, NULL);
 }
 
 uint64_t supervisor_ticks_ms64() {
diff --git a/supervisor/shared/tick.h b/supervisor/shared/tick.h
index e7e808058..3a01bd622 100644
--- a/supervisor/shared/tick.h
+++ b/supervisor/shared/tick.h
@@ -28,6 +28,7 @@
 #define __INCLUDED_SUPERVISOR_TICK_H
 
 #include <stdint.h>
+#include <stdbool.h>
 
 /** @brief To be called once every ms
  *
@@ -36,13 +37,6 @@
  * interrupt context.
  */
 extern void supervisor_tick(void);
-/** @brief Cause background tasks to be called soon
- *
- * Normally, background tasks are only run once per tick.  For other cases where
- * an event noticed from an interrupt context needs to be completed by a background
- * task activity, the interrupt can call supervisor_fake_tick.
- */
-extern void supervisor_fake_tick(void);
 /** @brief Get the lower 32 bits of the time in milliseconds
  *
  * This can be more efficient than supervisor_ticks_ms64, for sites where a wraparound
@@ -67,4 +61,12 @@ extern void supervisor_run_background_if_tick(void);
 extern void supervisor_enable_tick(void);
 extern void supervisor_disable_tick(void);
 
+/**
+ * @brief Return true if tick-based background tasks ran within the last 1s
+ *
+ * Note that when ticks are not enabled, this function can return false; this is
+ * intended.
+ */
+extern bool supervisor_background_tasks_ok(void);
+
 #endif
-- 
cgit v1.2.3


From 81105cb9ef68c4d88eab206f111af448440c8f30 Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Tue, 14 Jul 2020 10:08:07 -0500
Subject: supervisor: usb: note that it's unusual to need to call
 usb_background

---
 supervisor/usb.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'supervisor')

diff --git a/supervisor/usb.h b/supervisor/usb.h
index 1bed9bbb4..2a447c368 100644
--- a/supervisor/usb.h
+++ b/supervisor/usb.h
@@ -29,8 +29,10 @@
 
 #include <stdbool.h>
 
-// Ports must call this as frequently as they can in order to keep the USB connection
-// alive and responsive.
+// Ports must call this as frequently as they can in order to keep the USB
+// connection alive and responsive.  Normally this is called from background
+// tasks after the USB IRQ handler is executed, but in specific circumstances
+// it may be necessary to call it directly.
 void usb_background(void);
 
 // Ports must call this from their particular USB IRQ handler
-- 
cgit v1.2.3


From a18a39210919a886d4efb4c52b85a309b3403abf Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Fri, 17 Jul 2020 08:36:26 -0500
Subject: background_callback: Add gc collect callback

A background callback must never outlive its related object.  By
collecting the head of the linked list of background tasks, this will
not happen.

One hypothetical case where this could happen is if an MP3Decoder is
deleted while its callback to fill its buffer is scheduled.
---
 main.c                                  | 2 ++
 supervisor/background_callback.h        | 5 +++++
 supervisor/shared/background_callback.c | 6 ++++++
 3 files changed, 13 insertions(+)

(limited to 'supervisor')

diff --git a/main.c b/main.c
index ce95de95f..f928d0d62 100755
--- a/main.c
+++ b/main.c
@@ -493,6 +493,8 @@ void gc_collect(void) {
     // have lost their references in the VM even though they are mounted.
     gc_collect_root((void**)&MP_STATE_VM(vfs_mount_table), sizeof(mp_vfs_mount_t) / sizeof(mp_uint_t));
 
+    background_callback_gc_collect();
+
     #if CIRCUITPY_DISPLAYIO
     displayio_gc_collect();
     #endif
diff --git a/supervisor/background_callback.h b/supervisor/background_callback.h
index 82025f6b7..535dd656b 100644
--- a/supervisor/background_callback.h
+++ b/supervisor/background_callback.h
@@ -79,4 +79,9 @@ void background_callback_reset(void);
 void background_callback_begin_critical_section(void);
 void background_callback_end_critical_section(void);
 
+/*
+ * Background callbacks may stop objects from being collected
+ */
+void background_callback_gc_collect(void);
+
 #endif
diff --git a/supervisor/shared/background_callback.c b/supervisor/shared/background_callback.c
index e45c9b5c3..1be3cae2b 100644
--- a/supervisor/shared/background_callback.c
+++ b/supervisor/shared/background_callback.c
@@ -24,6 +24,7 @@
  * THE SOFTWARE.
  */
 
+#include "py/gc.h"
 #include "py/mpconfig.h"
 #include "supervisor/background_callback.h"
 #include "supervisor/shared/tick.h"
@@ -105,3 +106,8 @@ void background_callback_reset() {
     in_background_callback = false;
     CALLBACK_CRITICAL_END;
 }
+
+void background_callback_gc_collect(void) {
+    background_callback_t *cb = (background_callback_t*)callback_head;
+    gc_collect_ptr(cb);
+}
-- 
cgit v1.2.3


From 98eef79faaa36adbdd0b074c712aad5df7ef37a0 Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Fri, 17 Jul 2020 14:55:46 -0500
Subject: background_callback_gc_collect: We must traverse the whole list

---
 supervisor/shared/background_callback.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

(limited to 'supervisor')

diff --git a/supervisor/shared/background_callback.c b/supervisor/shared/background_callback.c
index 1be3cae2b..d10579c4f 100644
--- a/supervisor/shared/background_callback.c
+++ b/supervisor/shared/background_callback.c
@@ -108,6 +108,23 @@ void background_callback_reset() {
 }
 
 void background_callback_gc_collect(void) {
+    // We don't enter the callback critical section here.  We rely on
+    // gc_collect_ptr _NOT_ entering background callbacks, so it is not
+    // possible for the list to be cleared.
+    //
+    // However, it is possible for the list to be extended.  We make the
+    // minor assumption that no newly added callback is for a
+    // collectable object.  That is, we only plug the hole where an
+    // object becomes collectable AFTER it is added but before the
+    // callback is run, not the hole where an object was ALREADY
+    // collectable but adds a background task for itself.
+    //
+    // It's necessary to traverse the whole list here, as the callbacks
+    // themselves can be in non-gc memory, and some of the cb->data
+    // objects themselves might be in non-gc memory.
     background_callback_t *cb = (background_callback_t*)callback_head;
-    gc_collect_ptr(cb);
+    while(cb) {
+        gc_collect_ptr(cb->data);
+        cb = cb->next;
+    }
 }
-- 
cgit v1.2.3


From db43c56f794508689b07d931c16cadd3e98aad87 Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Mon, 20 Jul 2020 08:44:39 -0500
Subject: background callbacks: Clear any callbacks that were queued

Before this, a background callback that was on the list when
background_callback_reset was called could have ended up in a state
that made it "un-queueable": its "prev" pointer could have been non-NULL.
---
 supervisor/shared/background_callback.c | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'supervisor')

diff --git a/supervisor/shared/background_callback.c b/supervisor/shared/background_callback.c
index d10579c4f..8e12dd362 100644
--- a/supervisor/shared/background_callback.c
+++ b/supervisor/shared/background_callback.c
@@ -24,6 +24,8 @@
  * THE SOFTWARE.
  */
 
+#include <string.h>
+
 #include "py/gc.h"
 #include "py/mpconfig.h"
 #include "supervisor/background_callback.h"
@@ -101,6 +103,12 @@ void background_callback_end_critical_section() {
 
 void background_callback_reset() {
     CALLBACK_CRITICAL_BEGIN;
+    background_callback_t *cb = (background_callback_t*)callback_head;
+    while(cb) {
+        background_callback_t *next = cb->next;
+        memset(cb, 0, sizeof(*cb));
+        cb = next;
+    }
     callback_head = NULL;
     callback_tail = NULL;
     in_background_callback = false;
-- 
cgit v1.2.3


From 9fd10322fedc4a7736118fdb6cb1480ad8da94f1 Mon Sep 17 00:00:00 2001
From: Jeff Epler <jepler@gmail.com>
Date: Mon, 20 Jul 2020 08:45:31 -0500
Subject: supervisor: rename some locals for clarity

It's perfectly OK for these variables with static linkage to have the
same name, but it's inconvenient for humans like me.
---
 supervisor/shared/tick.c    | 4 ++--
 supervisor/shared/usb/usb.c | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'supervisor')

diff --git a/supervisor/shared/tick.c b/supervisor/shared/tick.c
index bc270030f..4af59f78e 100644
--- a/supervisor/shared/tick.c
+++ b/supervisor/shared/tick.c
@@ -66,7 +66,7 @@
 
 static volatile uint64_t PLACE_IN_DTCM_BSS(background_ticks);
 
-static background_callback_t callback;
+static background_callback_t tick_callback;
 
 volatile uint64_t last_finished_tick = 0;
 
@@ -119,7 +119,7 @@ void supervisor_tick(void) {
         #endif
     }
 #endif
-    background_callback_add(&callback, supervisor_background_tasks, NULL);
+    background_callback_add(&tick_callback, supervisor_background_tasks, NULL);
 }
 
 uint64_t supervisor_ticks_ms64() {
diff --git a/supervisor/shared/usb/usb.c b/supervisor/shared/usb/usb.c
index 472be96d5..36b5ec05d 100644
--- a/supervisor/shared/usb/usb.c
+++ b/supervisor/shared/usb/usb.c
@@ -64,8 +64,8 @@ void usb_init(void) {
     tusb_init();
 
 #if MICROPY_KBD_EXCEPTION
-    // Set Ctrl+C as wanted char, tud_cdc_rx_wanted_cb() callback will be invoked when Ctrl+C is received
-    // This callback always got invoked regardless of mp_interrupt_char value since we only set it once here
+    // Set Ctrl+C as wanted char, tud_cdc_rx_wanted_cb() usb_callback will be invoked when Ctrl+C is received
+    // This usb_callback always got invoked regardless of mp_interrupt_char value since we only set it once here
     tud_cdc_set_wanted_char(CHAR_CTRL_C);
 #endif
 
@@ -83,14 +83,14 @@ void usb_background(void) {
     }
 }
 
-static background_callback_t callback;
+static background_callback_t usb_callback;
 static void usb_background_do(void* unused) {
     usb_background();
 }
 
 void usb_irq_handler(void) {
     tud_int_handler(0);
-    background_callback_add(&callback, usb_background_do, NULL);
+    background_callback_add(&usb_callback, usb_background_do, NULL);
 }
 
 //--------------------------------------------------------------------+
-- 
cgit v1.2.3