Use recursive mutex for USB

Looks like adafruit/Adafruit_TinyUSB_Arduino#293

cores/rp2040/CoreMutex.cpp

@@ -24,13 +24,47 @@
 #include "Arduino.h"
 #include "CoreMutex.h"
 
+CoreMutex::CoreMutex(recursive_mutex_t *mutex, uint8_t option) {
+ _mutex = mutex;
+ _acquired = false;
+ _option = option;
+ _pxHigherPriorityTaskWoken = 0; // pdFALSE
+ _recursive = true;
+ if (__isFreeRTOS) {
+ auto m = __get_freertos_mutex_for_ptr(reinterpret_cast<mutex_t*>(mutex), true);
+
+ if (__freertos_check_if_in_isr()) {
+ if (!__freertos_mutex_take_from_isr(m, &_pxHigherPriorityTaskWoken)) {
+ return;
+ }
+ // At this point we have the mutex in ISR
+ } else {
+ // Grab the mutex normally, possibly waking other tasks to get it
+ __freertos_mutex_take(m);
+ }
+ } else {
+ uint32_t owner;
+ if (!recursive_mutex_try_enter(reinterpret_cast<recursive_mutex_t*>(_mutex), &owner)) {
+ if (owner == get_core_num()) { // Deadlock!
+ if (_option & DebugEnable) {
+ DEBUGCORE("CoreMutex - Deadlock detected!\n");
+ }
+ return;
+ }
+ recursive_mutex_enter_blocking(reinterpret_cast<recursive_mutex_t*>(_mutex));
+ }
+ }
+ _acquired = true;
+}
+
 CoreMutex::CoreMutex(mutex_t *mutex, uint8_t option) {
  _mutex = mutex;
  _acquired = false;
  _option = option;
  _pxHigherPriorityTaskWoken = 0; // pdFALSE
+ _recursive = false;
  if (__isFreeRTOS) {
- auto m = __get_freertos_mutex_for_ptr(mutex);
+ auto m = __get_freertos_mutex_for_ptr(reinterpret_cast<mutex_t*>(mutex));
 
  if (__freertos_check_if_in_isr()) {
  if (!__freertos_mutex_take_from_isr(m, &_pxHigherPriorityTaskWoken)) {
@@ -43,14 +77,14 @@ CoreMutex::CoreMutex(mutex_t *mutex, uint8_t option) {
  }
  } else {
  uint32_t owner;
- if (!mutex_try_enter(_mutex, &owner)) {
+ if (!mutex_try_enter(reinterpret_cast<mutex_t*>(_mutex), &owner)) {
  if (owner == get_core_num()) { // Deadlock!
  if (_option & DebugEnable) {
  DEBUGCORE("CoreMutex - Deadlock detected!\n");
  }
  return;
  }
- mutex_enter_blocking(_mutex);
+ mutex_enter_blocking(reinterpret_cast<mutex_t*>(_mutex));
  }
  }
  _acquired = true;
@@ -59,14 +93,18 @@ CoreMutex::CoreMutex(mutex_t *mutex, uint8_t option) {
 CoreMutex::~CoreMutex() {
  if (_acquired) {
  if (__isFreeRTOS) {
- auto m = __get_freertos_mutex_for_ptr(_mutex);
+ auto m = __get_freertos_mutex_for_ptr(reinterpret_cast<mutex_t*>(_mutex), _recursive);
  if (__freertos_check_if_in_isr()) {
  __freertos_mutex_give_from_isr(m, &_pxHigherPriorityTaskWoken);
  } else {
  __freertos_mutex_give(m);
  }
  } else {
- mutex_exit(_mutex);
+ if (_recursive) {
+ recursive_mutex_exit(reinterpret_cast<recursive_mutex_t*>(_mutex));
+ } else {
+ mutex_exit(reinterpret_cast<mutex_t*>(_mutex));
+ }
  }
  }
 }

cores/rp2040/CoreMutex.h

@@ -32,6 +32,7 @@ enum {
 
 class CoreMutex {
 public:
+ CoreMutex(recursive_mutex_t *mutex, uint8_t option = DebugEnable);
  CoreMutex(mutex_t *mutex, uint8_t option = DebugEnable);
  ~CoreMutex();
 
@@ -40,7 +41,8 @@ class CoreMutex {
  }
 
 private:
- mutex_t *_mutex;
+ bool _recursive;
+ void *_mutex;
  bool _acquired;
  uint8_t _option;
  BaseType_t _pxHigherPriorityTaskWoken;

cores/rp2040/RP2040USB.cpp

@@ -40,7 +40,7 @@
 
 // Big, global USB mutex, shared with all USB devices to make sure we don't
 // have multiple cores updating the TUSB state in parallel
-mutex_t __usb_mutex;
+recursive_mutex_t __usb_mutex;
 
 // USB processing will be a periodic timer task
 #define USB_TASK_INTERVAL 1000
@@ -360,9 +360,9 @@ static void usb_irq() {
  // if the mutex is already owned, then we are in user code
  // in this file which will do a tud_task itself, so we'll just do nothing
  // until the next tick; we won't starve
- if (mutex_try_enter(&__usb_mutex, nullptr)) {
+ if (recursive_mutex_try_enter(&__usb_mutex, nullptr)) {
  tud_task();
- mutex_exit(&__usb_mutex);
+ recursive_mutex_exit(&__usb_mutex);
  }
 }
 
@@ -382,7 +382,7 @@ void __USBStart() {
  __SetupDescHIDReport();
  __SetupUSBDescriptor();
 
- mutex_init(&__usb_mutex);
+ recursive_mutex_init(&__usb_mutex);
 
  tusb_init();
 

cores/rp2040/RP2040USB.h

@@ -36,7 +36,7 @@ extern void __USBInstallMassStorage() __attribute__((weak));
 
 // Big, global USB mutex, shared with all USB devices to make sure we don't
 // have multiple cores updating the TUSB state in parallel
-extern mutex_t __usb_mutex;
+extern recursive_mutex_t __usb_mutex;
 
 // HID report ID inquiry (report ID will vary depending on the number/type of other HID)
 int __USBGetKeyboardReportID();