Fix inherited nRF52 USB READY hang in build-local TinyUSB driver
This commit is contained in:
1 parent
14796e6573
commit
602dbfe3d9
7 files changed
+645
No files matched your search
@@ -88,6 +88,7 @@ jobs:
|
||||
python3 -B test/test_cascade_release_package.py
|
||||
python3 -B test/test_t096_full_memory.py
|
||||
python3 -B test/test_nrf52_ble_startup.py
|
||||
python3 -B test/test_nrf52_usb_power.py
|
||||
python3 -B test/test_shared_mota_queue.py
|
||||
|
||||
- name: Verify Companion Bluetooth settings and WebConfig
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
# nRF52 USB READY hang
|
||||
|
||||
The RAK3401 on Mercer was found stuck in the framework's TinyUSB power handler:
|
||||
USBD was enabled and attached, but its write-one-to-clear READY event was
|
||||
already consumed. The duplicate-event guard also required HFCLK to be running.
|
||||
If that guard missed the completed initialization, the following unbounded
|
||||
READY wait could stop application startup. A bootloader update alone cannot
|
||||
replace this USB driver in an already installed MeshCore application.
|
||||
|
||||
The wait and guard were inherited through the pinned Adafruit nRF52 Arduino
|
||||
framework, not introduced by the recent OTAFIX upstream merge. TinyUSB's wait
|
||||
dates back at least to 2019; the guard was added in
|
||||
[upstream commit 7d9efd0697](https://github.com/hathach/tinyusb/commit/7d9efd06979f6cdde2a4093f0c26e8100312c92c).
|
||||
OTAFIX's August 24 HFCLK backport addressed a later clock wait, leaving this
|
||||
earlier READY wait uncovered. The exact live interrupt ordering is not known;
|
||||
the stalled program counter and consumed event were read directly over SWD.
|
||||
|
||||
All nRF52 environments inherit `pre:scripts/nrf52_usb_power_fix.py`. It compiles
|
||||
a build-local replacement for the matching framework driver, without changing
|
||||
PlatformIO's shared SDK or affecting ESP32 builds. A changed/unrecognized
|
||||
framework implementation stops the build for review. The backport:
|
||||
|
||||
- requests HFCLK before checking the consumed READY event;
|
||||
- rechecks attachment while waiting, including completion by another callback;
|
||||
- bounds both waits with one 100,000-poll budget, independent of OS ticks;
|
||||
- ignores stale READY on a disabled peripheral and exits if it is removed.
|
||||
|
||||
The poll budget is an iteration limit, not a promised elapsed-time timeout.
|
||||
If the clock/peripheral never becomes ready, the caller returns instead of
|
||||
freezing the application. A later power event can retry; permanent electrical
|
||||
failure can still require reconnecting USB. This does not establish or fix the
|
||||
separate Pi hub/controller fault.
|
||||
|
||||
Run `python3 -B test/test_nrf52_usb_power.py -v`. The tests compile the actual
|
||||
patched handler from the pinned-framework fixture, model W1C event semantics,
|
||||
and cover duplicate/nested callbacks, delayed/missing clocks and READY, removal,
|
||||
retry, and detached USB. Restoring the inherited READY prefix must reproduce
|
||||
the infinite wait under a subprocess deadline. Additional tests check SDK
|
||||
isolation, idempotence, fail-closed patching, and all nRF52 environment hooks.
|
||||
The harness is shared with OTAFIX's TinyUSB fork at
|
||||
`test/otafix/nrf5x_power_test.py`; keep the two copies in sync when extending it.
|
||||
@@ -137,6 +137,7 @@ platform_packages =
|
||||
framework-arduinoadafruitnrf52 @ https://github.com/meshcore-dev/Adafruit_nRF52_Arduino#d541301
|
||||
platformio/toolchain-gccarmnoneeabi@^1.140201.0
|
||||
extra_scripts = create-uf2.py
|
||||
pre:scripts/nrf52_usb_power_fix.py
|
||||
pre:scripts/nrf52_internal_bootloader_link.py
|
||||
post:scripts/check_firmware_ram.py
|
||||
build_flags = ${arduino_base.build_flags}
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
"""Compile a build-local fix for the framework's inherited nRF52 USB READY hang.
|
||||
|
||||
Never modify PlatformIO's shared framework package. Fail closed if a framework
|
||||
update changes the code this narrow backport expects. The same handler policy
|
||||
is carried by OTAFIX's mikecarper/tinyusb fork.
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
OLD_READY = """ case USB_EVT_READY:
|
||||
// Skip if pull-up is enabled and HCLK is already running.
|
||||
// Application probably call this more than necessary.
|
||||
if (NRF_USBD->USBPULLUP && hfclk_running()) break;
|
||||
|
||||
// Waiting for USBD peripheral enabled
|
||||
while (!(USBD_EVENTCAUSE_READY_Msk & NRF_USBD->EVENTCAUSE)) {}
|
||||
|
||||
"""
|
||||
READY = """ case USB_EVT_READY:
|
||||
{
|
||||
// READY is a consumed event, not a persistent status bit. In particular,
|
||||
// a post-SoftDevice callback may find USB already attached but HFCLK no
|
||||
// longer requested by this context. Restore the clock before testing
|
||||
// completion; do not wait for a second peripheral READY event.
|
||||
uint32_t remaining = 100000;
|
||||
if ( !NRF_USBD->ENABLE ) break;
|
||||
hfclk_enable();
|
||||
while ( !hfclk_running() )
|
||||
{
|
||||
if ( !NRF_USBD->ENABLE || !--remaining ) return;
|
||||
}
|
||||
|
||||
// Recheck attachment inside the wait: another READY handler can preempt
|
||||
// this one and consume EVENTCAUSE before it attaches. Both waits share
|
||||
// a finite poll budget, independent of ticks/interrupts being available.
|
||||
while ( !(USBD_EVENTCAUSE_READY_Msk & NRF_USBD->EVENTCAUSE) )
|
||||
{
|
||||
if ( NRF_USBD->USBPULLUP || !NRF_USBD->ENABLE || !--remaining ) return;
|
||||
}
|
||||
if ( NRF_USBD->USBPULLUP || !NRF_USBD->ENABLE ) break;
|
||||
|
||||
"""
|
||||
OLD_ATTACH = """ // Wait for HFCLK
|
||||
while (!hfclk_running()) {}
|
||||
|
||||
// Enable pull up
|
||||
NRF_USBD->USBPULLUP = 1;
|
||||
__ISB();
|
||||
__DSB(); // for sync
|
||||
break;
|
||||
|
||||
case USB_EVT_REMOVED:"""
|
||||
ATTACH = """ // Enable pull up
|
||||
if ( NRF_USBD->ENABLE ) NRF_USBD->USBPULLUP = 1;
|
||||
__ISB();
|
||||
__DSB(); // for sync
|
||||
}
|
||||
break;
|
||||
|
||||
case USB_EVT_REMOVED:"""
|
||||
|
||||
|
||||
def patched_source(source):
|
||||
source = source.replace("\r\n", "\n")
|
||||
if READY in source and ATTACH in source and OLD_READY not in source and OLD_ATTACH not in source:
|
||||
return source
|
||||
if source.count(OLD_READY) != 1 or source.count(OLD_ATTACH) != 1:
|
||||
raise RuntimeError(
|
||||
"nRF52 USB power fix: unrecognized TinyUSB driver; review the "
|
||||
"framework update before building (shared SDK was not modified)"
|
||||
)
|
||||
return source.replace(OLD_READY, READY).replace(OLD_ATTACH, ATTACH)
|
||||
|
||||
|
||||
def replace_driver(build_env, node):
|
||||
# SCons passes a not-yet-created VariantDir node, not the SDK source path.
|
||||
source = Path(node.srcnode().get_abspath())
|
||||
patched = patched_source(source.read_text(encoding="utf-8"))
|
||||
destination = Path(build_env.subst("$BUILD_DIR")) / "patched-nrf52-usb" / source.name
|
||||
destination.parent.mkdir(parents=True, exist_ok=True)
|
||||
if not destination.exists() or destination.read_text(encoding="utf-8") != patched:
|
||||
destination.write_text(patched, encoding="utf-8")
|
||||
print("nRF52 USB: build-local bounded READY/HFCLK fix enabled")
|
||||
return build_env.File(str(destination))
|
||||
|
||||
|
||||
def install(build_env):
|
||||
build_env.AddBuildMiddleware(
|
||||
replace_driver,
|
||||
"*Adafruit_TinyUSB_Arduino*src*portable*nordic*nrf5x*dcd_nrf5x.c",
|
||||
)
|
||||
|
||||
|
||||
if "Import" in globals():
|
||||
Import("env")
|
||||
install(env)
|
||||
+188
@@ -0,0 +1,188 @@
|
||||
/*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2019 Ha Thach (tinyusb.org)
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* This file is part of the TinyUSB stack.
|
||||
*/
|
||||
|
||||
// Pinned framework d541301: real power handler before the build-local fix.
|
||||
void tusb_hal_nrf_power_event(uint32_t event);
|
||||
void tusb_hal_nrf_power_event(uint32_t event) {
|
||||
// Value is chosen to be as same as NRFX_POWER_USB_EVT_* in nrfx_power.h
|
||||
enum {
|
||||
USB_EVT_DETECTED = 0,
|
||||
USB_EVT_REMOVED = 1,
|
||||
USB_EVT_READY = 2
|
||||
};
|
||||
|
||||
#if CFG_TUSB_DEBUG >= 3
|
||||
const char* const power_evt_str[] = {"Detected", "Removed", "Ready"};
|
||||
TU_LOG(3, "Power USB event: %s\r\n", power_evt_str[event]);
|
||||
#endif
|
||||
|
||||
switch (event) {
|
||||
case USB_EVT_DETECTED:
|
||||
if (!NRF_USBD->ENABLE) {
|
||||
// Prepare for receiving READY event: disable interrupt since we will blocking wait
|
||||
NRF_USBD->INTENCLR = USBD_INTEN_USBEVENT_Msk;
|
||||
NRF_USBD->EVENTCAUSE = USBD_EVENTCAUSE_READY_Msk;
|
||||
__ISB();
|
||||
__DSB(); // for sync
|
||||
|
||||
#ifdef NRF52_SERIES // NRF53 does not need this errata
|
||||
// ERRATA 171, 187, 166
|
||||
if (nrf52_errata_187()) {
|
||||
// CRITICAL_REGION_ENTER();
|
||||
if (*((volatile uint32_t*) (0x4006EC00)) == 0x00000000) {
|
||||
*((volatile uint32_t*) (0x4006EC00)) = 0x00009375;
|
||||
*((volatile uint32_t*) (0x4006ED14)) = 0x00000003;
|
||||
*((volatile uint32_t*) (0x4006EC00)) = 0x00009375;
|
||||
} else {
|
||||
*((volatile uint32_t*) (0x4006ED14)) = 0x00000003;
|
||||
}
|
||||
// CRITICAL_REGION_EXIT();
|
||||
}
|
||||
|
||||
if (nrf52_errata_171()) {
|
||||
// CRITICAL_REGION_ENTER();
|
||||
if (*((volatile uint32_t*) (0x4006EC00)) == 0x00000000) {
|
||||
*((volatile uint32_t*) (0x4006EC00)) = 0x00009375;
|
||||
*((volatile uint32_t*) (0x4006EC14)) = 0x000000C0;
|
||||
*((volatile uint32_t*) (0x4006EC00)) = 0x00009375;
|
||||
} else {
|
||||
*((volatile uint32_t*) (0x4006EC14)) = 0x000000C0;
|
||||
}
|
||||
// CRITICAL_REGION_EXIT();
|
||||
}
|
||||
#endif
|
||||
|
||||
// Enable the peripheral (will cause Ready event)
|
||||
NRF_USBD->ENABLE = 1;
|
||||
__ISB();
|
||||
__DSB(); // for sync
|
||||
|
||||
// Enable HFCLK
|
||||
hfclk_enable();
|
||||
}
|
||||
break;
|
||||
|
||||
case USB_EVT_READY:
|
||||
// Skip if pull-up is enabled and HCLK is already running.
|
||||
// Application probably call this more than necessary.
|
||||
if (NRF_USBD->USBPULLUP && hfclk_running()) break;
|
||||
|
||||
// Waiting for USBD peripheral enabled
|
||||
while (!(USBD_EVENTCAUSE_READY_Msk & NRF_USBD->EVENTCAUSE)) {}
|
||||
|
||||
NRF_USBD->EVENTCAUSE = USBD_EVENTCAUSE_READY_Msk;
|
||||
__ISB();
|
||||
__DSB(); // for sync
|
||||
|
||||
#ifdef NRF52_SERIES
|
||||
if (nrf52_errata_171()) {
|
||||
// CRITICAL_REGION_ENTER();
|
||||
if (*((volatile uint32_t*) (0x4006EC00)) == 0x00000000) {
|
||||
*((volatile uint32_t*) (0x4006EC00)) = 0x00009375;
|
||||
*((volatile uint32_t*) (0x4006EC14)) = 0x00000000;
|
||||
*((volatile uint32_t*) (0x4006EC00)) = 0x00009375;
|
||||
} else {
|
||||
*((volatile uint32_t*) (0x4006EC14)) = 0x00000000;
|
||||
}
|
||||
|
||||
// CRITICAL_REGION_EXIT();
|
||||
}
|
||||
|
||||
if (nrf52_errata_187()) {
|
||||
// CRITICAL_REGION_ENTER();
|
||||
if (*((volatile uint32_t*) (0x4006EC00)) == 0x00000000) {
|
||||
*((volatile uint32_t*) (0x4006EC00)) = 0x00009375;
|
||||
*((volatile uint32_t*) (0x4006ED14)) = 0x00000000;
|
||||
*((volatile uint32_t*) (0x4006EC00)) = 0x00009375;
|
||||
} else {
|
||||
*((volatile uint32_t*) (0x4006ED14)) = 0x00000000;
|
||||
}
|
||||
// CRITICAL_REGION_EXIT();
|
||||
}
|
||||
|
||||
if (nrf52_errata_166()) {
|
||||
*((volatile uint32_t*) (NRF_USBD_BASE + 0x800)) = 0x7E3;
|
||||
*((volatile uint32_t*) (NRF_USBD_BASE + 0x804)) = 0x40;
|
||||
|
||||
__ISB();
|
||||
__DSB();
|
||||
}
|
||||
#endif
|
||||
|
||||
// ISO buffer Lower half for IN, upper half for OUT
|
||||
NRF_USBD->ISOSPLIT = USBD_ISOSPLIT_SPLIT_HalfIN;
|
||||
|
||||
// Enable bus-reset interrupt
|
||||
NRF_USBD->INTENSET = USBD_INTEN_USBRESET_Msk;
|
||||
|
||||
// Enable interrupt, priorities should be set by application
|
||||
NVIC_ClearPendingIRQ(USBD_IRQn);
|
||||
|
||||
// Don't enable USBD interrupt yet, if dcd_init() did not finish yet
|
||||
// Interrupt will be enabled by tud_init(), when USB stack is ready
|
||||
// to handle interrupts.
|
||||
if (tud_inited()) {
|
||||
NVIC_EnableIRQ(USBD_IRQn);
|
||||
}
|
||||
|
||||
// Wait for HFCLK
|
||||
while (!hfclk_running()) {}
|
||||
|
||||
// Enable pull up
|
||||
NRF_USBD->USBPULLUP = 1;
|
||||
__ISB();
|
||||
__DSB(); // for sync
|
||||
break;
|
||||
|
||||
case USB_EVT_REMOVED:
|
||||
if (NRF_USBD->ENABLE) {
|
||||
// Abort all transfers
|
||||
|
||||
// Disable pull up
|
||||
NRF_USBD->USBPULLUP = 0;
|
||||
__ISB();
|
||||
__DSB(); // for sync
|
||||
|
||||
// Disable Interrupt
|
||||
NVIC_DisableIRQ(USBD_IRQn);
|
||||
|
||||
// disable all interrupt
|
||||
NRF_USBD->INTENCLR = NRF_USBD->INTEN;
|
||||
|
||||
NRF_USBD->ENABLE = 0;
|
||||
__ISB();
|
||||
__DSB(); // for sync
|
||||
|
||||
hfclk_disable();
|
||||
|
||||
dcd_event_bus_signal(0, DCD_EVENT_UNPLUGGED, is_in_isr());
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,217 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Execute the real nRF5x power handler against write-one-to-clear registers.
|
||||
|
||||
No board/SDK is required. The negative control restores the inherited READY
|
||||
prefix and must reproduce the hang, not merely fail a source-text assertion.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import shlex
|
||||
import subprocess
|
||||
import tempfile
|
||||
|
||||
|
||||
HARNESS = r'''
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <functional>
|
||||
|
||||
static std::function<void(int)> on_read;
|
||||
static std::function<void()> on_barrier;
|
||||
static bool auto_ready = true, clock_requested, clock_ok = true, irq_enabled;
|
||||
static unsigned clock_reads, clock_delay, clock_requests, ready_reads, unplugged;
|
||||
static std::function<void()> on_clock;
|
||||
enum { ENABLE, PULLUP, CAUSE, PLAIN };
|
||||
static constexpr uint32_t USBD_EVENTCAUSE_READY_Msk = 1u << 11;
|
||||
struct Register {
|
||||
int kind;
|
||||
uint32_t value = 0;
|
||||
explicit Register(int k = PLAIN): kind(k) {}
|
||||
operator uint32_t() const {
|
||||
if (kind == CAUSE) ++ready_reads;
|
||||
if (on_read) on_read(kind);
|
||||
return value;
|
||||
}
|
||||
void operator=(uint32_t v);
|
||||
};
|
||||
static struct {
|
||||
Register ENABLE{::ENABLE}, USBPULLUP{PULLUP}, EVENTCAUSE{CAUSE};
|
||||
Register INTENCLR, INTENSET, INTEN, ISOSPLIT;
|
||||
} usbd;
|
||||
void Register::operator=(uint32_t v) {
|
||||
if (kind == CAUSE) value &= ~v; // hardware event register is W1C
|
||||
else value = v;
|
||||
if (kind == ENABLE && v && auto_ready)
|
||||
usbd.EVENTCAUSE.value |= USBD_EVENTCAUSE_READY_Msk;
|
||||
}
|
||||
#define NRF_USBD (&usbd)
|
||||
#define CFG_TUSB_DEBUG 0
|
||||
static constexpr unsigned USBD_INTEN_USBEVENT_Msk = 1, USBD_INTEN_USBRESET_Msk = 2;
|
||||
static constexpr unsigned USBD_ISOSPLIT_SPLIT_HalfIN = 0, USBD_IRQn = 39;
|
||||
static constexpr unsigned DCD_EVENT_UNPLUGGED = 0;
|
||||
static void hfclk_enable() { clock_requested = true; ++clock_requests; }
|
||||
static void hfclk_disable() { clock_requested = false; }
|
||||
static bool hfclk_running() {
|
||||
++clock_reads;
|
||||
if (on_clock) on_clock();
|
||||
return clock_requested && clock_ok && clock_reads > clock_delay;
|
||||
}
|
||||
static void __ISB() { if (on_barrier) on_barrier(); }
|
||||
static void __DSB() { if (on_barrier) on_barrier(); }
|
||||
static void NVIC_ClearPendingIRQ(unsigned) {}
|
||||
static void NVIC_EnableIRQ(unsigned) { irq_enabled = true; }
|
||||
static void NVIC_DisableIRQ(unsigned) { irq_enabled = false; }
|
||||
static bool tud_inited() { return true; }
|
||||
static bool is_in_isr() { return false; }
|
||||
static void dcd_event_bus_signal(unsigned, unsigned, bool) { ++unplugged; }
|
||||
|
||||
/* DRIVER_FUNCTION */
|
||||
|
||||
static void reset() {
|
||||
usbd.ENABLE.value = usbd.USBPULLUP.value = usbd.EVENTCAUSE.value = 0;
|
||||
on_read = {}; on_barrier = {}; on_clock = {};
|
||||
auto_ready = clock_ok = true;
|
||||
clock_requested = irq_enabled = false;
|
||||
clock_reads = clock_delay = clock_requests = ready_reads = unplugged = 0;
|
||||
}
|
||||
static void detected() { tusb_hal_nrf_power_event(0); }
|
||||
static void ready() { tusb_hal_nrf_power_event(2); }
|
||||
static void removed() { tusb_hal_nrf_power_event(1); }
|
||||
static void bounded() { assert(clock_reads + ready_reads <= 100010); }
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
// Exact live failure state: attached, consumed READY, clock no longer running.
|
||||
if (argc > 1 && !std::strcmp(argv[1], "consumed-ready")) {
|
||||
reset(); usbd.ENABLE = 1; usbd.USBPULLUP = 1;
|
||||
usbd.EVENTCAUSE.value = 0;
|
||||
ready();
|
||||
assert(clock_requested && usbd.USBPULLUP.value == 1); bounded();
|
||||
return 0;
|
||||
}
|
||||
reset(); detected(); ready();
|
||||
assert(usbd.USBPULLUP.value == 1 && irq_enabled);
|
||||
assert(usbd.EVENTCAUSE.value == 0 && clock_requested);
|
||||
ready(); bounded();
|
||||
removed();
|
||||
assert(!usbd.ENABLE.value && !usbd.USBPULLUP.value && !irq_enabled);
|
||||
assert(!clock_requested && unplugged == 1);
|
||||
|
||||
// READY delivered after removal must not request clocks or reattach.
|
||||
reset(); ready();
|
||||
assert(!clock_requests && !usbd.USBPULLUP.value); bounded();
|
||||
|
||||
// Missing peripheral READY and missing HFXO must return, never attach.
|
||||
reset(); auto_ready = false; detected(); ready();
|
||||
assert(!usbd.USBPULLUP.value); bounded();
|
||||
usbd.EVENTCAUSE.value = USBD_EVENTCAUSE_READY_Msk; ready();
|
||||
assert(usbd.USBPULLUP.value == 1); // subsequent event can retry
|
||||
reset(); clock_ok = false; detected(); ready();
|
||||
assert(!usbd.USBPULLUP.value); bounded();
|
||||
clock_ok = true; ready(); assert(usbd.USBPULLUP.value == 1);
|
||||
|
||||
// Both clock and regulator may take a little time to settle.
|
||||
reset(); auto_ready = false; clock_delay = 10; detected();
|
||||
on_read = [](int kind) {
|
||||
if (kind == CAUSE && ready_reads == 10)
|
||||
usbd.EVENTCAUSE.value = USBD_EVENTCAUSE_READY_Msk;
|
||||
};
|
||||
ready(); assert(usbd.USBPULLUP.value == 1); bounded();
|
||||
|
||||
// An interrupt completes another READY before the outer READY read.
|
||||
reset(); detected();
|
||||
bool injected = false;
|
||||
on_read = [&](int kind) {
|
||||
if (kind == CAUSE && !injected) { injected = true; ready(); }
|
||||
};
|
||||
ready(); assert(injected && usbd.USBPULLUP.value == 1); bounded();
|
||||
|
||||
// A nested callback after W1C but before pull-up cannot block its caller.
|
||||
reset(); detected(); injected = false;
|
||||
on_barrier = [&]() {
|
||||
if (!injected && !usbd.EVENTCAUSE.value) { injected = true; ready(); }
|
||||
};
|
||||
ready(); assert(injected && usbd.USBPULLUP.value == 1); bounded();
|
||||
|
||||
// Removal during either wait and immediately before attachment.
|
||||
reset(); clock_ok = false; detected(); injected = false;
|
||||
on_clock = [&]() { if (!injected) { injected = true; removed(); } };
|
||||
ready(); assert(!usbd.ENABLE.value && !usbd.USBPULLUP.value); bounded();
|
||||
reset(); auto_ready = false; detected(); injected = false;
|
||||
on_read = [&](int kind) {
|
||||
if (kind == CAUSE && !injected) { injected = true; removed(); }
|
||||
};
|
||||
ready(); assert(!usbd.ENABLE.value && !usbd.USBPULLUP.value); bounded();
|
||||
reset(); detected(); injected = false;
|
||||
on_barrier = [&]() {
|
||||
if (!injected && !usbd.EVENTCAUSE.value) { injected = true; removed(); }
|
||||
};
|
||||
ready(); assert(!usbd.ENABLE.value && !usbd.USBPULLUP.value); bounded();
|
||||
|
||||
// A deliberately detached, enabled peripheral has no fresh READY event.
|
||||
reset(); detected(); ready(); usbd.USBPULLUP = 0; ready();
|
||||
assert(!usbd.USBPULLUP.value); bounded();
|
||||
puts("PASS: actual USB power handler, 13 event/clock/removal scenarios");
|
||||
}
|
||||
'''
|
||||
|
||||
|
||||
def extract_handler(source):
|
||||
start = source.index("void tusb_hal_nrf_power_event")
|
||||
opening = source.index("{", start)
|
||||
depth = 1
|
||||
cursor = opening + 1
|
||||
while depth:
|
||||
if source[cursor] == "{":
|
||||
depth += 1
|
||||
elif source[cursor] == "}":
|
||||
depth -= 1
|
||||
cursor += 1
|
||||
return source[start:cursor]
|
||||
|
||||
|
||||
def exercise(source):
|
||||
handler = extract_handler(source)
|
||||
start = handler.index(" case USB_EVT_READY:")
|
||||
stop = handler.index(" NRF_USBD->EVENTCAUSE =", start)
|
||||
inherited = """ case USB_EVT_READY:
|
||||
{
|
||||
if (NRF_USBD->USBPULLUP && hfclk_running()) break;
|
||||
while (!(USBD_EVENTCAUSE_READY_Msk & NRF_USBD->EVENTCAUSE)) {}
|
||||
|
||||
"""
|
||||
# The fixed case has a scope; the remainder stays identical to the driver.
|
||||
assert re.search(r"case USB_EVT_READY:\s*\{", handler)
|
||||
broken = handler[:start] + inherited + handler[stop:]
|
||||
with tempfile.TemporaryDirectory(prefix="nrf5x-power-test-") as directory:
|
||||
root = Path(directory)
|
||||
for label, function in (("fixed", handler), ("inherited", broken)):
|
||||
cpp = root / (label + ".cpp")
|
||||
binary = root / label
|
||||
cpp.write_text(HARNESS.replace("/* DRIVER_FUNCTION */", function))
|
||||
subprocess.run([
|
||||
*shlex.split(os.environ.get("CXX", "c++")), "-std=c++11", "-O2",
|
||||
"-Wall", "-Wextra", "-Werror", *shlex.split(os.environ.get("USB_TEST_CXXFLAGS", "")),
|
||||
str(cpp), "-o", str(binary),
|
||||
], check=True)
|
||||
if label == "fixed":
|
||||
subprocess.run([str(binary)], check=True, timeout=5)
|
||||
subprocess.run([str(binary), "consumed-ready"], check=True, timeout=5)
|
||||
else:
|
||||
try:
|
||||
subprocess.run([str(binary), "consumed-ready"], check=True, timeout=0.5)
|
||||
except subprocess.TimeoutExpired:
|
||||
print("PASS: inherited READY loop reproduces hang (negative control)")
|
||||
else:
|
||||
raise AssertionError("negative control did not reproduce the hang")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("driver", nargs="?", type=Path, default=(
|
||||
Path(__file__).resolve().parents[2] / "src/portable/nordic/nrf5x/dcd_nrf5x.c"))
|
||||
exercise(parser.parse_args().driver.read_text())
|
||||
@@ -0,0 +1,100 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Exercise the actual patched framework handler and isolated build integration."""
|
||||
|
||||
import configparser
|
||||
import importlib.util
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from nrf5x_power_harness import exercise
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
SPEC = importlib.util.spec_from_file_location("usb_fix", ROOT / "scripts/nrf52_usb_power_fix.py")
|
||||
FIX = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(FIX)
|
||||
ORIGINAL = (ROOT / "test/fixtures/nrf52_usb_power_original.c").read_text()
|
||||
|
||||
|
||||
class UsbPowerTests(unittest.TestCase):
|
||||
def test_actual_handler_and_inherited_hang(self):
|
||||
exercise(FIX.patched_source(ORIGINAL))
|
||||
|
||||
def test_crlf_and_idempotence(self):
|
||||
fixed = FIX.patched_source(ORIGINAL)
|
||||
self.assertEqual(fixed, FIX.patched_source(ORIGINAL.replace("\n", "\r\n")))
|
||||
self.assertEqual(fixed, FIX.patched_source(fixed))
|
||||
|
||||
def test_unrecognized_or_partly_fixed_driver_fails_closed(self):
|
||||
for source in ("", ORIGINAL.replace("hfclk_running()", "clock_running()"),
|
||||
ORIGINAL + ORIGINAL, ORIGINAL.replace(FIX.OLD_READY, FIX.READY)):
|
||||
with self.subTest(source=source[:40]), self.assertRaises(RuntimeError):
|
||||
FIX.patched_source(source)
|
||||
|
||||
def test_build_local_copy_does_not_modify_shared_package(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
original = root / "shared-sdk/dcd_nrf5x.c"
|
||||
original.parent.mkdir()
|
||||
original.write_text(ORIGINAL)
|
||||
|
||||
class Node:
|
||||
def get_abspath(self):
|
||||
return str(original)
|
||||
|
||||
class VariantNode:
|
||||
def srcnode(self):
|
||||
return Node()
|
||||
|
||||
def get_abspath(self):
|
||||
raise AssertionError("VariantDir file does not exist yet; use srcnode()")
|
||||
|
||||
class Env:
|
||||
def subst(self, value):
|
||||
assert value == "$BUILD_DIR"
|
||||
return str(root / "build")
|
||||
|
||||
def File(self, value):
|
||||
return Path(value)
|
||||
|
||||
output = FIX.replace_driver(Env(), VariantNode())
|
||||
self.assertEqual(original.read_text(), ORIGINAL)
|
||||
self.assertEqual(output, root / "build/patched-nrf52-usb/dcd_nrf5x.c")
|
||||
self.assertEqual(output.read_text(), FIX.patched_source(ORIGINAL))
|
||||
modified = output.stat().st_mtime_ns
|
||||
FIX.replace_driver(Env(), VariantNode())
|
||||
self.assertEqual(output.stat().st_mtime_ns, modified)
|
||||
|
||||
def test_all_nrf52_environments_inherit_pre_hook(self):
|
||||
config = configparser.ConfigParser(interpolation=None, strict=False)
|
||||
config.read([str(ROOT / "platformio.ini"), *map(str, (ROOT / "variants").glob("*/platformio.ini"))])
|
||||
|
||||
def option(section, key, seen=()):
|
||||
if section in seen:
|
||||
raise AssertionError("configuration inheritance cycle")
|
||||
if config.has_option(section, key):
|
||||
value = config.get(section, key)
|
||||
import re
|
||||
return re.sub(r"\$\{([^}.]+)\.([^}]+)\}",
|
||||
lambda m: option(m[1], m[2], seen + (section,)), value)
|
||||
for parent in config.get(section, "extends", fallback="").split(","):
|
||||
parent = parent.strip()
|
||||
if parent and config.has_section(parent):
|
||||
value = option(parent, key, seen + (section,))
|
||||
if value:
|
||||
return value
|
||||
return ""
|
||||
|
||||
checked = 0
|
||||
for section in config.sections():
|
||||
if section.startswith("env:") and option(section, "platform") == "nordicnrf52":
|
||||
with self.subTest(environment=section):
|
||||
self.assertIn("pre:scripts/nrf52_usb_power_fix.py", option(section, "extra_scripts"))
|
||||
checked += 1
|
||||
self.assertGreater(checked, 30)
|
||||
print("nRF52 USB hook inherited by %d environments" % checked)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user