pxt-common-packages 10.1.5 → 10.1.6

package/libs/core/hf2.cpp

@@ -101,21 +101,54 @@ int HF2::stdRequest(UsbEndpointIn &ctrl, USBSetup &setup) {
     return DEVICE_NOT_SUPPORTED;
 }
 
-// same as in microbit
-#define CTRL_GET_REPORT 0x01
-#define CTRL_SET_REPORT 0x09
-#define CTRL_OUT_REPORT_H 0x2
-#define CTRL_IN_REPORT_H 0x1
+#define HF2_FLAG_EVENT 0x01
 
+REAL_TIME_FUNC
 void HF2::sendBuffer(uint8_t flag, const void *data, unsigned size, uint32_t prepend) {
     if (!CodalUSB::usbInstance->isInitialised())
         return;
 
-    uint32_t buf[64 / 4]; // aligned
+#ifdef USB_EP_FLAG_ASYNC
+    // drop non-responses if too much stuff queued up
+    if (flag != HF2_FLAG_CMDPKT_LAST && pendingWriteSize > 1000)
+        return;
+#endif
+
+    if (flag == HF2_FLAG_EVENT)
+        flag = HF2_FLAG_CMDPKT_LAST;
 
     if (prepend + 1)
         size += 4;
 
+#ifdef USB_EP_FLAG_ASYNC
+    HF2_PendingWrite *e = (HF2_PendingWrite *)malloc(sizeof(HF2_PendingWrite) + size);
+    e->size = size;
+    e->flag = flag;
+    e->next = NULL;
+    uint8_t *dst = e->data;
+    if (prepend + 1) {
+        memcpy(dst, &prepend, 4);
+        dst += 4;
+        size -= 4;
+    }
+    memcpy(dst, data, size);
+
+    target_disable_irq();
+    auto p = this->pendingWrite;
+    if (!p)
+        this->pendingWrite = e;
+    else {
+        while (p->next)
+            p = p->next;
+        p->next = e;
+    }
+    this->pendingWriteSize += 16 + e->size;
+    target_enable_irq();
+
+    pokeSend();
+#else
+    uint32_t buf[64 / 4]; // aligned
+
     target_disable_irq();
     while (size > 0) {
         memset(buf + 1, 0, 60);
@@ -143,6 +176,7 @@ void HF2::sendBuffer(uint8_t flag, const void *data, unsigned size, uint32_t pre
         in->write(buf, sizeof(buf));
     }
     target_enable_irq();
+#endif
 }
 
 const InterfaceInfo *HF2::getInterfaceInfo() {
@@ -154,7 +188,7 @@ const InterfaceInfo *HF2::getInterfaceInfo() {
 }
 
 int HF2::sendEvent(uint32_t evId, const void *data, int size) {
-    sendBuffer(HF2_FLAG_CMDPKT_LAST, data, size, evId);
+    sendBuffer(HF2_FLAG_EVENT, data, size, evId);
     return 0;
 }
 
@@ -231,7 +265,7 @@ static void copy_words(void *dst0, const void *src0, uint32_t n_words) {
 #define DBL_TAP_PTR ((volatile uint32_t *)(HSRAM_ADDR + HSRAM_SIZE - 4))
 #endif
 #if defined(NRF52840) || defined(NRF52833)
-#define DBL_TAP_PTR ((volatile uint32_t*)0x20007F7C)
+#define DBL_TAP_PTR ((volatile uint32_t *)0x20007F7C)
 #endif
 #define DBL_TAP_MAGIC_QUICK_BOOT 0xf02669ef
 #define QUICK_BOOT(v) *DBL_TAP_PTR = v ? DBL_TAP_MAGIC_QUICK_BOOT : 0
@@ -242,7 +276,50 @@ static void jdLog(const uint8_t *frame) {
     jdLogger->sendEvent(HF2_EV_JDS_PACKET, frame, frame[2] + 12);
 }
 
+void HF2::pokeSend() {
+#ifdef USB_EP_FLAG_ASYNC
+    target_disable_irq();
+    if (pendingWrite && in->canWrite()) {
+        in->flags |= USB_EP_FLAG_ASYNC;
+
+        int size = pendingWrite->size - pendingWritePtr;
+        usb_assert(size > 0);
+        uint32_t buf[64 / 4] = {0};
+
+        int s = 63;
+        if (size <= 63) {
+            s = size;
+            buf[0] = pendingWrite->flag;
+        } else {
+            buf[0] = pendingWrite->flag == HF2_FLAG_CMDPKT_LAST ? HF2_FLAG_CMDPKT_BODY : pendingWrite->flag;
+        }
+        buf[0] |= s;
+        uint8_t *dst = (uint8_t *)buf;
+        dst++;
+        memcpy(dst, pendingWrite->data + pendingWritePtr, s);
+
+        int r = in->write(buf, sizeof(buf));
+        if (r == 0) {
+            if (s == size) {
+                pendingWritePtr = 0;
+                pendingWriteSize -= 16 + pendingWrite->size;
+                HF2_PendingWrite *n = pendingWrite->next;
+                free(pendingWrite);
+                pendingWrite = n;
+            } else {
+                pendingWritePtr += s;
+            }
+        }
+    }
+    target_enable_irq();
+#endif
+}
+
 int HF2::endpointRequest() {
+#ifdef USB_EP_FLAG_ASYNC
+    pokeSend();
+#endif
+
     int sz = recv();
 
     if (!sz)
@@ -369,6 +446,11 @@ int HF2::endpointRequest() {
 
 HF2::HF2(HF2_Buffer &p) : gotSomePacket(false), ctrlWaiting(false), pkt(p), useHID(false) {
     lastExchange = 0;
+#ifdef USB_EP_FLAG_ASYNC
+    pendingWrite = NULL;
+    pendingWriteSize = 0;
+    pendingWritePtr = 0;
+#endif
 }
 
 static const InterfaceInfo dummyIfaceInfo = {

package/libs/core/hf2.h

@@ -21,11 +21,25 @@ typedef struct {
     };
 } HF2_Buffer;
 
+struct HF2_PendingWrite {
+    HF2_PendingWrite *next;
+    uint16_t size;
+    uint8_t flag;
+    uint8_t _reserved;
+    uint8_t data[0];
+};
+
 class HF2 : public CodalUSBInterface {
     bool gotSomePacket;
     bool ctrlWaiting;
     uint32_t lastExchange;
 
+#ifdef USB_EP_FLAG_ASYNC
+    HF2_PendingWrite *pendingWrite;
+    int pendingWriteSize;
+    int pendingWritePtr;
+#endif
+
   public:
     HF2_Buffer &pkt;
 
@@ -36,6 +50,7 @@ class HF2 : public CodalUSBInterface {
     int sendResponseWithData(const void *data, int size);
     int sendEvent(uint32_t evId, const void *data, int size);
     void sendBuffer(uint8_t flag, const void *data, unsigned size, uint32_t prepend = -1);
+    void pokeSend();
 
     HF2(HF2_Buffer &pkt);
     virtual int endpointRequest();

package/libs/core/pxt.h

@@ -44,6 +44,11 @@ using namespace codal;
 
 #define PXT_COMM_BASE 0x20002000 // 8k in
 
+// old codal compat
+#ifndef REAL_TIME_FUNC
+#define REAL_TIME_FUNC /* */
+#endif
+
 namespace pxt {
 
 #if CONFIG_ENABLED(DEVICE_USB)

package/libs/core---rp2040/platform.cpp

@@ -4,26 +4,54 @@
 
 #include "hardware/pll.h"
 #include "hardware/clocks.h"
+#include "hardware/structs/rosc.h"
 
 namespace pxt {
 
 LowLevelTimer *allocateTimer() {
-  // TODO: add config to low level timer
-  return new RP2040LowLevelTimer();
+    // TODO: add config to low level timer
+    return new RP2040LowLevelTimer();
 }
 
-static void initRandomSeed() {
-  uint32_t f_rosc = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_ROSC_CLKSRC);
-  seedRandom(f_rosc);
+static uint32_t hw_random(void) {
+    uint8_t buf[16];
+    for (unsigned i = 0; i < sizeof(buf); ++i) {
+        buf[i] = 0;
+        for (int j = 0; j < 8; ++j) {
+            buf[i] <<= 1;
+            if (rosc_hw->randombit)
+                buf[i] |= 1;
+        }
+    }
+    return hash_fnv1(buf, sizeof(buf));
 }
 
-void deepSleep() {
-
+static void initRandomSeed() {
+    seedRandom(hw_random());
 }
 
+void deepSleep() {}
+
 void platform_init() {
-  initRandomSeed();
+    initRandomSeed();
+}
 
+int *getBootloaderConfigData() {
+    static bool inited;
+    static int *cached;
+
+    if (!inited) {
+        inited = 1;
+        for (int i = 1; i <= 64; i *= 2) {
+            uint32_t *p = (uint32_t *)(XIP_BASE + i * 1024 * 1024 - 4096);
+            if (p[0] == CFG_MAGIC0 && p[1] == CFG_MAGIC1) {
+                cached = (int *)p;
+                break;
+            }
+        }
+    }
+
+    return cached;
 }
 
 } // namespace pxt

package/libs/mixer---rp2040/SoundOutput.h

@@ -10,7 +10,7 @@ class SoundOutput {
   public:
     RP2040PWM dac;
 
-    SoundOutput(DataSource &data) : dac(*LOOKUP_PIN(JACK_SND), data) {
+    SoundOutput(DataSource &data) : dac(*LOOKUP_PIN(JACK_SND), data, 44000) {
         jacdac::setJackRouterOutput(-1);
     }
 

package/libs/settings/settings.cpp

@@ -37,7 +37,7 @@ class WStorage {
              SETTINGS_SIZE),
 #elif defined(PICO_BOARD)
           // XIP bias 0x10000000
-          fs(flash, 0x10000000 + flash.totalSize() - SETTINGS_SIZE, SETTINGS_SIZE),
+          fs(flash, 0x10000000 + flash.totalSize() - SETTINGS_SIZE - 4096, SETTINGS_SIZE),
 #else
           fs(flash),
 #endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pxt-common-packages",
-  "version": "10.1.5",
+  "version": "10.1.6",
   "description": "Microsoft MakeCode (PXT) common packages",
   "keywords": [
     "MakeCode",