Update version

Fixes #1835

README.md

@@ -4,7 +4,7 @@
 
 Raspberry Pi Pico Arduino core, for all RP2040 boards
 
-This is a port of the RP2040 (Raspberry Pi Pico processor) to the Arduino ecosystem. It uses the bare Raspberry Pi Pico SDK and a custom GCC 10.3/Newlib 4.0 toolchain.
+This is a port of the RP2040 (Raspberry Pi Pico processor) to the Arduino ecosystem. It uses the bare Raspberry Pi Pico SDK and a custom GCC 12.3/Newlib 4.0 toolchain.
 
 # Documentation
 See https://arduino-pico.readthedocs.io/en/latest/ along with the examples for more detailed usage information.
@@ -31,6 +31,7 @@ Read the [Contributing Guide](https://github.com/earlephilhower/arduino-pico/blo
 * Cytron Maker Pi RP2040
 * Cytron Maker Nano RP2040
 * DatanoiseTV PicoADK+
+* Degz Suibo RP2040
 * DeRuiLab FlyBoard2040 Core
 * DFRobot Beetle RP2040
 * ElectronicCats Hunter Cat NFC
@@ -52,6 +53,10 @@ Read the [Contributing Guide](https://github.com/earlephilhower/arduino-pico/blo
 * Pimoroni PGA2040
 * Pimoroni Plasma2040
 * Pimoroni Tiny2040
+* RAKwireless RAK11300
+* Redscorp RP2040-Eins
+* Redscorp RP2040-ProMini
+* Sea-Picro
 * Seeed Indicator RP2040
 * Seeed XIAO RP2040
 * Silicognition RP2040-Shim
@@ -69,7 +74,6 @@ Read the [Contributing Guide](https://github.com/earlephilhower/arduino-pico/blo
 * WIZnet W5100S-EVB-Pico
 * WIZnet W5500-EVB-Pico
 * WIZnet WizFi360-EVB-Pico
-* Redscorp RP2040-ProMini
 * Generic (configurable flash, I/O pins)
 
 # Installing via Arduino Boards Manager
@@ -202,6 +206,7 @@ The installed tools include a version of OpenOCD (in the pqt-openocd directory)
 * Bluetooth on the PicoW (Classic and BLE) with Keyboard, Mouse, Joystick, and Virtual Serial
 * Generic Arduino USB Serial, Keyboard, Joystick, and Mouse emulation
 * WiFi (Pico W)
+* Ethernet (Wired W5500, W5100, ENC28J60)
 * HTTP client and server (WebServer)
 * SSL/TLS/HTTPS
 * Over-the-Air (OTA) upgrades
@@ -213,7 +218,7 @@ The installed tools include a version of OpenOCD (in the pqt-openocd directory)
 * Analog stereo audio in using DMA and the built-in ADC
 * Analog stereo audio out using PWM hardware
 * USB drive mode for data loggers (SingleFileDrive)
-* Peripherals:  SPI master, Wire(I2C) master/slave, dual UART, emulated EEPROM, I2S audio input, I2S audio output, Servo
+* Peripherals:  SPI master/slave, Wire(I2C) master/slave, dual UART, emulated EEPROM, I2S audio input/output, Servo
 * printf (i.e. debug) output over USB serial
 
 The RP2040 PIO state machines (SMs) are used to generate jitter-free:

cores/rp2040/BluetoothDebug.cpp

@@ -0,0 +1,87 @@
+/*
+    Enable BTStack debugging to a Print-able object
+
+    Copyright (c) 2023 Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#if defined(ENABLE_CLASSIC) || defined(ENABLE_BLE)
+#include <Arduino.h>
+#include <btstack.h>
+#include <hci_dump.h>
+
+static Print *_print;
+
+static void _log_packet(uint8_t packet_type, uint8_t in, uint8_t *packet, uint16_t len) {
+    if (!_print) {
+        return;
+    }
+    _print->printf("[BT @%lu] ", millis());
+
+    switch (packet_type) {
+    case HCI_COMMAND_DATA_PACKET:
+        _print->printf("CMD => ");
+        break;
+    case HCI_EVENT_PACKET:
+        _print->printf("EVT <= ");
+        break;
+    case HCI_ACL_DATA_PACKET:
+        _print->printf("ACL %s ", in ? "<=" : "=>");
+        break;
+    case HCI_SCO_DATA_PACKET:
+        _print->printf("SCO %s ", in ? "<=" : "=>");
+        break;
+    case HCI_ISO_DATA_PACKET:
+        _print->printf("ISO %s ", in ? "<=" : "=>");
+        break;
+    case LOG_MESSAGE_PACKET:
+        _print->printf("LOG -- %s\n", (char*) packet);
+        return;
+    default:
+        _print->printf("UNK(%x) %s ", packet_type, in ? "<=" : "=>");
+        break;
+    }
+
+    for (uint16_t i = 0; i < len; i++) {
+        _print->printf("%02X ", packet[i]);
+    }
+    _print->printf("\n");
+}
+
+static void _log_message(int log_level, const char * format, va_list argptr) {
+    (void)log_level;
+    char log_message_buffer[HCI_DUMP_MAX_MESSAGE_LEN];
+    if (!_print) {
+        return;
+    }
+    vsnprintf(log_message_buffer, sizeof(log_message_buffer), format, argptr);
+    _print->printf("[BT @%lu] LOG -- %s\n", millis(), log_message_buffer);
+}
+
+
+static const hci_dump_t hci_dump_instance = {
+    NULL,
+    _log_packet,
+    _log_message
+};
+
+
+void __EnableBluetoothDebug(Print &print) {
+    _print = &print;
+    hci_dump_init(&hci_dump_instance);
+}
+
+#endif

cores/rp2040/RP2040Support.h

@@ -157,6 +157,10 @@ extern RP2040 rp2040;
 extern "C" void main1();
 extern "C" char __StackLimit;
 extern "C" char __bss_end__;
+extern "C" void setup1() __attribute__((weak));
+extern "C" void loop1() __attribute__((weak));
+extern "C" bool core1_separate_stack;
+extern "C" uint32_t* core1_separate_stack_address;
 
 class RP2040 {
 public:
@@ -238,6 +242,25 @@ public:
         return &__StackLimit  - &__bss_end__;
     }
 
+    inline uint32_t getStackPointer() {
+        uint32_t *sp;
+        asm volatile("mov %0, sp" : "=r"(sp));
+        return (uint32_t)sp;
+    }
+
+    inline int getFreeStack() {
+        const unsigned int sp = getStackPointer();
+        uint32_t ref = 0x20040000;
+        if (setup1 || loop1) {
+            if (core1_separate_stack) {
+                ref = cpuid() ? (unsigned int)core1_separate_stack_address : 0x20040000;
+            } else {
+                ref = cpuid() ? 0x20040000 : 0x20041000;
+            }
+        }
+        return sp - ref;
+    }
+
     void idleOtherCore() {
         fifo.idleOtherCore();
     }

cores/rp2040/RP2040USB.cpp

@@ -83,6 +83,8 @@ static int __usb_task_irq;
   9, TUSB_DESC_INTERFACE, _itfnum, 0, 0, TUSB_CLASS_VENDOR_SPECIFIC, RESET_INTERFACE_SUBCLASS, RESET_INTERFACE_PROTOCOL, _stridx,
 
 
+int usb_hid_poll_interval __attribute__((weak)) = 10;
+
 const uint8_t *tud_descriptor_device_cb(void) {
     static tusb_desc_device_t usbd_desc_device = {
         .bLength = sizeof(tusb_desc_device_t),
@@ -263,7 +265,7 @@ void __SetupUSBDescriptor() {
         uint8_t hid_itf = __USBInstallSerial ? 2 : 0;
         uint8_t hid_desc[TUD_HID_DESC_LEN] = {
             // Interface number, string index, protocol, report descriptor len, EP In & Out address, size & polling interval
-            TUD_HID_DESCRIPTOR(hid_itf, 0, HID_ITF_PROTOCOL_NONE, hid_report_len, EPNUM_HID, CFG_TUD_HID_EP_BUFSIZE, 10)
+            TUD_HID_DESCRIPTOR(hid_itf, 0, HID_ITF_PROTOCOL_NONE, hid_report_len, EPNUM_HID, CFG_TUD_HID_EP_BUFSIZE, (uint8_t)usb_hid_poll_interval)
         };
 
         uint8_t msd_itf = interface_count - 1;
@@ -400,7 +402,7 @@ bool __USBHIDReady() {
 
     while (((millis() - start) < timeout) && tud_ready() && !tud_hid_ready()) {
         tud_task();
-        delay(1);
+        delayMicroseconds(1);
     }
     return tud_hid_ready();
 }

cores/rp2040/RP2040Version.h

@@ -1,5 +1,5 @@
 #pragma once
 #define ARDUINO_PICO_MAJOR 3
-#define ARDUINO_PICO_MINOR 4
+#define ARDUINO_PICO_MINOR 6
 #define ARDUINO_PICO_REVISION 1
-#define ARDUINO_PICO_VERSION_STR "3.4.1"
+#define ARDUINO_PICO_VERSION_STR "3.6.1"

cores/rp2040/SerialUSB.cpp

@@ -197,6 +197,14 @@ static void CheckSerialReset() {
     }
 }
 
+bool SerialUSB::dtr() {
+    return _dtr;
+}
+
+bool SerialUSB::rts() {
+    return _rts;
+}
+
 extern "C" void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts) {
     (void) itf;
     _dtr = dtr ? true : false;

cores/rp2040/SerialUSB.h

@@ -43,6 +43,8 @@ public:
     virtual size_t write(const uint8_t *p, size_t len) override;
     using Print::write;
     operator bool() override;
+    bool dtr();
+    bool rts();
 
     void ignoreFlowControl(bool ignore = true);
 

cores/rp2040/lwip_wrap.cpp

@@ -18,6 +18,7 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
+#include <Arduino.h>
 #include <pico/mutex.h>
 #include <lwip/pbuf.h>
 #include <lwip/udp.h>
@@ -26,20 +27,57 @@
 #include <lwip/raw.h>
 #include <lwip/timeouts.h>
 #include <pico/cyw43_arch.h>
+#include <pico/mutex.h>
+#include <sys/lock.h>
+
+extern void ethernet_arch_lwip_begin() __attribute__((weak));
+extern void ethernet_arch_lwip_end() __attribute__((weak));
+
+auto_init_recursive_mutex(__lwipMutex); // Only for case with no Ethernet or PicoW, but still doing LWIP (PPP?)
 
 class LWIPMutex {
 public:
     LWIPMutex() {
-        cyw43_arch_lwip_begin();
+#if defined(ARDUINO_RASPBERRY_PI_PICO_W)
+        if (rp2040.isPicoW()) {
+            cyw43_arch_lwip_begin();
+            return;
+        }
+#endif
+        if (ethernet_arch_lwip_begin) {
+            ethernet_arch_lwip_begin();
+        } else {
+            recursive_mutex_enter_blocking(&__lwipMutex);
+        }
     }
 
     ~LWIPMutex() {
-        cyw43_arch_lwip_end();
+#if defined(ARDUINO_RASPBERRY_PI_PICO_W)
+        if (rp2040.isPicoW()) {
+            cyw43_arch_lwip_end();
+            return;
+        }
+#endif
+        if (ethernet_arch_lwip_end) {
+            ethernet_arch_lwip_end();
+        } else {
+            recursive_mutex_exit(&__lwipMutex);
+        }
     }
 };
 
 extern "C" {
 
+    // Avoid calling lwip_init multiple times
+    extern void __real_lwip_init();
+    void __wrap_lwip_init() {
+        static bool initted = false;
+        if (!initted) {
+            __real_lwip_init();
+            initted = true;
+        }
+    }
+
     extern u8_t __real_pbuf_header(struct pbuf *p, s16_t header_size);
     u8_t __wrap_pbuf_header(struct pbuf *p, s16_t header_size) {
         LWIPMutex m;

cores/rp2040/main.cpp

@@ -27,6 +27,7 @@
 RP2040 rp2040;
 extern "C" {
     volatile bool __otherCoreIdled = false;
+    uint32_t* core1_separate_stack_address = nullptr;
 };
 
 extern void setup();
@@ -38,12 +39,14 @@ extern void startFreeRTOS() __attribute__((weak));
 bool __isFreeRTOS;
 volatile bool __freeRTOSinitted;
 
+extern void __EnableBluetoothDebug(Print &);
 
 // Weak empty variant initialization. May be redefined by variant files.
 void initVariant() __attribute__((weak));
 void initVariant() { }
 
 // Optional 2nd core setup and loop
+bool core1_separate_stack __attribute__((weak)) = false;
 extern void setup1() __attribute__((weak));
 extern void loop1() __attribute__((weak));
 extern "C" void main1() {
@@ -117,6 +120,9 @@ extern "C" int main() {
 #if defined DEBUG_RP2040_PORT
     if (!__isFreeRTOS) {
         DEBUG_RP2040_PORT.begin(115200);
+#if (defined(ENABLE_BLUETOOTH) || defined(ENABLE_BLE)) && defined(DEBUG_RP2040_BLUETOOTH)
+        __EnableBluetoothDebug(DEBUG_RP2040_PORT);
+#endif
     }
 #endif
 
@@ -132,7 +138,12 @@ extern "C" int main() {
     if (!__isFreeRTOS) {
         if (setup1 || loop1) {
             delay(1); // Needed to make Picoprobe upload start 2nd core
-            multicore_launch_core1(main1);
+            if (core1_separate_stack) {
+                core1_separate_stack_address = (uint32_t*)malloc(0x2000);
+                multicore_launch_core1_with_stack(main1, core1_separate_stack_address, 0x2000);
+            } else {
+                multicore_launch_core1(main1);
+            }
         }
         setup();
         while (true) {

cores/rp2040/posix.cpp

@@ -33,7 +33,9 @@
 
 extern "C" int errno;
 
-extern "C" ssize_t _write(int fd, const void *buf, size_t count) {
+extern "C"
+__attribute((weak))
+ssize_t _write(int fd, const void *buf, size_t count) {
 #if defined DEBUG_RP2040_PORT
     (void) fd;
     return DEBUG_RP2040_PORT.write((const char *)buf, count);
@@ -45,7 +47,9 @@ extern "C" ssize_t _write(int fd, const void *buf, size_t count) {
 #endif
 }
 
-extern "C" int _chown(const char *path, uid_t owner, gid_t group) {
+extern "C"
+__attribute((weak))
+int _chown(const char *path, uid_t owner, gid_t group) {
     (void) path;
     (void) owner;
     (void) group;
@@ -53,7 +57,9 @@ extern "C" int _chown(const char *path, uid_t owner, gid_t group) {
     return -1;
 }
 
-extern "C" int _close(int fd) {
+extern "C"
+__attribute((weak))
+int _close(int fd) {
     (void) fd;
     errno = ENOSYS;
     return -1;
@@ -72,7 +78,9 @@ extern "C" int _fork(void) {
     return -1;
 }
 
-extern "C" int _fstat(int fd, struct stat *st) {
+extern "C"
+__attribute((weak))
+int _fstat(int fd, struct stat *st) {
     (void) fd;
     (void) st;
     errno = ENOSYS;
@@ -115,7 +123,9 @@ extern "C" void __setSystemTime(unsigned long long sec, unsigned long usec) {
     __timedelta_us = newnow_us - now_us;
 }
 
-extern "C" int _isatty(int file) {
+extern "C"
+__attribute((weak))
+int _isatty(int file) {
     (void) file;
     errno = ENOSYS;
     return 0;
@@ -128,14 +138,18 @@ extern "C" int _kill(int pid, int sig) {
     return -1;
 }
 
-extern "C" int _link(char *existing, char *newlink) {
+extern "C"
+__attribute((weak))
+int _link(char *existing, char *newlink) {
     (void) existing;
     (void) newlink;
     errno = ENOSYS;
     return -1;
 }
 
-extern "C" int _lseek(int   file, int   ptr, int   dir) {
+extern "C"
+__attribute((weak))
+int _lseek(int   file, int   ptr, int   dir) {
     (void) file;
     (void) ptr;
     (void) dir;
@@ -143,7 +157,9 @@ extern "C" int _lseek(int   file, int   ptr, int   dir) {
     return -1;
 }
 
-extern "C" int _open(char *file, int   flags, int   mode) {
+extern "C"
+__attribute((weak))
+int _open(char *file, int   flags, int   mode) {
     (void) file;
     (void) flags;
     (void) mode;
@@ -151,7 +167,9 @@ extern "C" int _open(char *file, int   flags, int   mode) {
     return -1;
 }
 
-extern "C" int _read(int   file, char *ptr, int   len) {
+extern "C"
+__attribute((weak))
+int _read(int   file, char *ptr, int   len) {
     (void) file;
     (void) ptr;
     (void) len;
@@ -159,7 +177,9 @@ extern "C" int _read(int   file, char *ptr, int   len) {
     return -1;
 }
 
-extern "C" int _readlink(const char *path, char *buf, size_t bufsize) {
+extern "C"
+__attribute((weak))
+int _readlink(const char *path, char *buf, size_t bufsize) {
     (void) path;
     (void) buf;
     (void) bufsize;
@@ -167,14 +187,18 @@ extern "C" int _readlink(const char *path, char *buf, size_t bufsize) {
     return -1;
 }
 
-extern "C" int _stat(const char  *file, struct stat *st) {
+extern "C"
+__attribute((weak))
+int _stat(const char  *file, struct stat *st) {
     (void) file;
     (void) st;
     errno = ENOSYS;
     return -1;
 }
 
-extern "C" int _symlink(const char *path1, const char *path2) {
+extern "C"
+__attribute((weak))
+int _symlink(const char *path1, const char *path2) {
     (void) path1;
     (void) path2;
     errno = ENOSYS;
@@ -187,7 +211,9 @@ extern "C" clock_t _times(struct tms *buf) {
     return -1;
 }
 
-extern "C" int _unlink(char *name) {
+extern "C"
+__attribute((weak))
+int _unlink(char *name) {
     (void) name;
     errno = ENOSYS;
     return -1;

cores/rp2040/sdkoverride/att_db.h

@@ -0,0 +1,443 @@
+/*
+    Copyright (C) 2014 BlueKitchen GmbH
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holders nor the names of
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+    4. Any redistribution, use, or modification is done solely for
+      personal benefit and not for any commercial purpose or for
+      monetary gain.
+
+    THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
+    GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+    OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+    AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+    Please inquire about commercial licensing options at
+    contact@bluekitchen-gmbh.com
+
+*/
+
+/**
+    @title ATT Database Engine
+
+*/
+
+#ifndef ATT_DB_H
+#define ATT_DB_H
+
+#if defined ENABLE_CLASSIC
+
+#include <stdint.h>
+#include <sdkoverride/bluetooth.h>
+#include "btstack_linked_list.h"
+#include "btstack_defines.h"
+#include "btstack_bool.h"
+
+#if defined __cplusplus
+extern "C" {
+#endif
+
+    // MARK: Attribute PDU Opcodes
+#define ATT_ERROR_RESPONSE              0x01u
+
+#define ATT_EXCHANGE_MTU_REQUEST        0x02u
+#define ATT_EXCHANGE_MTU_RESPONSE       0x03u
+
+#define ATT_FIND_INFORMATION_REQUEST    0x04u
+#define ATT_FIND_INFORMATION_REPLY      0x05u
+#define ATT_FIND_BY_TYPE_VALUE_REQUEST  0x06u
+#define ATT_FIND_BY_TYPE_VALUE_RESPONSE 0x07u
+
+#define ATT_READ_BY_TYPE_REQUEST        0x08u
+#define ATT_READ_BY_TYPE_RESPONSE       0x09u
+#define ATT_READ_REQUEST                0x0au
+#define ATT_READ_RESPONSE               0x0bu
+#define ATT_READ_BLOB_REQUEST           0x0cu
+#define ATT_READ_BLOB_RESPONSE          0x0du
+#define ATT_READ_MULTIPLE_REQUEST       0x0eu
+#define ATT_READ_MULTIPLE_RESPONSE      0x0fu
+#define ATT_READ_BY_GROUP_TYPE_REQUEST  0x10u
+#define ATT_READ_BY_GROUP_TYPE_RESPONSE 0x11u
+
+#define ATT_WRITE_REQUEST               0x12u
+#define ATT_WRITE_RESPONSE              0x13u
+
+#define ATT_PREPARE_WRITE_REQUEST       0x16u
+#define ATT_PREPARE_WRITE_RESPONSE      0x17u
+#define ATT_EXECUTE_WRITE_REQUEST       0x18u
+#define ATT_EXECUTE_WRITE_RESPONSE      0x19u
+
+#define ATT_HANDLE_VALUE_NOTIFICATION   0x1bu
+#define ATT_HANDLE_VALUE_INDICATION     0x1du
+#define ATT_HANDLE_VALUE_CONFIRMATION   0x1eu
+
+#define ATT_READ_MULTIPLE_VARIABLE_REQ  0x20u
+#define ATT_READ_MULTIPLE_VARIABLE_RSP  0x21u
+#define ATT_MULTIPLE_HANDLE_VALUE_NTF   0x23u
+
+#define ATT_WRITE_COMMAND                0x52u
+#define ATT_SIGNED_WRITE_COMMAND         0xD2u
+
+
+    // internal additions
+    // 128 bit UUID used
+#define ATT_PROPERTY_UUID128             0x200u
+    // Read/Write Permission bits
+#define ATT_PROPERTY_READ_PERMISSION_BIT_0  0x0400u
+#define ATT_PROPERTY_READ_PERMISSION_BIT_1  0x0800u
+#define ATT_PROPERTY_WRITE_PERMISSION_BIT_0 0x0001u
+#define ATT_PROPERTY_WRITE_PERMISSION_BIT_1 0x0010u
+#define ATT_PROPERTY_READ_PERMISSION_SC     0x0020u
+#define ATT_PROPERTY_WRITE_PERMISSION_SC    0x0080u
+
+
+    typedef struct att_connection {
+        hci_con_handle_t con_handle;
+        uint16_t mtu;       // initialized to ATT_DEFAULT_MTU (23), negotiated during MTU exchange
+        uint16_t max_mtu;   // local maximal L2CAP_MTU, set to l2cap_max_le_mtu()
+        bool     mtu_exchanged;
+        uint8_t  encryption_key_size;
+        uint8_t  authenticated;
+        uint8_t  authorized;
+        uint8_t  secure_connection;
+    } att_connection_t;
+
+    /* API_START */
+
+    // map ATT ERROR CODES on to att_read_callback length
+#define ATT_READ_ERROR_CODE_OFFSET       0xfe00u
+
+    // custom BTstack ATT Response Pending for att_read_callback
+#define ATT_READ_RESPONSE_PENDING                 0xffffu
+
+    // internally used to signal write response pending
+#define ATT_INTERNAL_WRITE_RESPONSE_PENDING       0xfffeu
+
+    /**
+        @brief ATT Client Read Callback for Dynamic Data
+        - if buffer == NULL, don't copy data, just return size of value
+        - if buffer != NULL, copy data and return number bytes copied
+        If ENABLE_ATT_DELAYED_READ_RESPONSE is defined, you may return ATT_READ_RESPONSE_PENDING if data isn't available yet
+        @param con_handle of hci le connection
+        @param attribute_handle to be read
+        @param offset defines start of attribute value
+        @param buffer
+        @param buffer_size
+        @return size of value if buffer is NULL, otherwise number of bytes copied
+    */
+    typedef uint16_t (*att_read_callback_t)(hci_con_handle_t con_handle, uint16_t attribute_handle, uint16_t offset, uint8_t * buffer, uint16_t buffer_size);
+
+    /**
+        @brief ATT Client Write Callback for Dynamic Data
+        Each Prepared Write Request triggers a callback with transaction mode ATT_TRANSACTION_MODE_ACTIVE.
+        On Execute Write, the callback will be called with ATT_TRANSACTION_MODE_VALIDATE and allows to validate all queued writes and return an application error.
+        If none of the registered callbacks return an error for ATT_TRANSACTION_MODE_VALIDATE and the callback will be called with ATT_TRANSACTION_MODE_EXECUTE.
+        Otherwise, all callbacks will be called with ATT_TRANSACTION_MODE_CANCEL.
+
+        If the additional validation step is not needed, just return 0 for all callbacks with transaction mode ATT_TRANSACTION_MODE_VALIDATE.
+
+        @param con_handle of hci le connection
+        @param attribute_handle to be written
+        @param transaction - ATT_TRANSACTION_MODE_NONE for regular writes. For prepared writes: ATT_TRANSACTION_MODE_ACTIVE, ATT_TRANSACTION_MODE_VALIDATE, ATT_TRANSACTION_MODE_EXECUTE, ATT_TRANSACTION_MODE_CANCEL
+        @param offset into the value - used for queued writes and long attributes
+        @param buffer
+        @param buffer_size
+        @param signature used for signed write commands
+        @return 0 if write was ok, ATT_ERROR_PREPARE_QUEUE_FULL if no space in queue, ATT_ERROR_INVALID_OFFSET if offset is larger than max buffer
+    */
+    typedef int (*att_write_callback_t)(hci_con_handle_t con_handle, uint16_t attribute_handle, uint16_t transaction_mode, uint16_t offset, uint8_t *buffer, uint16_t buffer_size);
+
+    // Read & Write Callbacks for handle range
+    typedef struct att_service_handler {
+        btstack_linked_item_t * item;
+        uint16_t start_handle;
+        uint16_t end_handle;
+        att_read_callback_t read_callback;
+        att_write_callback_t write_callback;
+        btstack_packet_handler_t packet_handler;
+    } att_service_handler_t;
+
+    // MARK: ATT Operations
+
+    /**
+        @brief setup ATT database
+        @param db
+    */
+    void att_set_db(uint8_t const * db);
+
+    /*
+        @brief set callback for read of dynamic attributes
+        @param callback
+    */
+    void att_set_read_callback(att_read_callback_t callback);
+
+    /**
+        @brief set callback for write of dynamic attributes
+        @param callback
+    */
+    void att_set_write_callback(att_write_callback_t callback);
+
+    /**
+        @brief debug helper, dump ATT database to stdout using log_info
+    */
+    void att_dump_attributes(void);
+
+    /**
+        @brief process ATT request against database and put response into response buffer
+        @param att_connection used for mtu and security properties
+        @param request_buffer, request_len: ATT request from client
+        @param response_buffer for result
+        @return len of data in response buffer. 0 = no response,
+                ATT_READ_RESPONSE_PENDING if it was returned at least once for dynamic data (requires ENABLE_ATT_DELAYED_READ_RESPONSE)
+    */
+    uint16_t att_handle_request(att_connection_t * att_connection,
+                                uint8_t * request_buffer,
+                                uint16_t request_len,
+                                uint8_t * response_buffer);
+
+    /**
+        @brief setup value notification in response buffer for a given handle and value
+        @param att_connection
+        @param attribute_handle
+        @param value
+        @param value_len
+        @param response_buffer for notification
+    */
+    uint16_t att_prepare_handle_value_notification(att_connection_t * att_connection,
+            uint16_t attribute_handle,
+            const uint8_t *value,
+            uint16_t value_len,
+            uint8_t * response_buffer);
+
+    /**
+        @brief setup value notification in response buffer for multiple handles and values
+        @param att_connection
+        @param attribute_handle
+        @param value
+        @param value_len
+        @param response_buffer for notification
+    */
+    uint16_t att_prepare_handle_value_multiple_notification(att_connection_t * att_connection,
+            uint8_t num_attributes,
+            const uint16_t * attribute_handles,
+            const uint8_t ** values_data,
+            const uint16_t * values_len,
+            uint8_t * response_buffer);
+
+    /**
+        @brief setup value indication in response buffer for a given handle and value
+        @param att_connection
+        @param attribute_handle
+        @param value
+        @param value_len
+        @param response_buffer for indication
+    */
+    uint16_t att_prepare_handle_value_indication(att_connection_t * att_connection,
+            uint16_t attribute_handle,
+            const uint8_t *value,
+            uint16_t value_len,
+            uint8_t * response_buffer);
+
+    /**
+        @brief transcation queue of prepared writes, e.g., after disconnect
+        @return att_connection
+    */
+    void att_clear_transaction_queue(att_connection_t * att_connection);
+
+    // att_read_callback helpers for a various data types
+
+    /**
+        @brief Handle read of blob like data for att_read_callback
+        @param blob of data
+        @param blob_size of blob
+        @param offset from att_read_callback
+        @param buffer from att_read_callback
+        @param buffer_size from att_read_callback
+        @return value size for buffer == 0 and num bytes copied otherwise
+    */
+    uint16_t att_read_callback_handle_blob(const uint8_t * blob, uint16_t blob_size, uint16_t offset, uint8_t * buffer, uint16_t buffer_size);
+
+    /**
+        @brief Handle read of little endian unsigned 32 bit value for att_read_callback
+        @param value
+        @param offset from att_read_callback
+        @param buffer from att_read_callback
+        @param buffer_size from att_read_callback
+        @return value size for buffer == 0 and num bytes copied otherwise
+    */
+    uint16_t att_read_callback_handle_little_endian_32(uint32_t value, uint16_t offset, uint8_t * buffer, uint16_t buffer_size);
+
+    /**
+        @brief Handle read of little endian unsigned 16 bit value for att_read_callback
+        @param value
+        @param offset from att_read_callback
+        @param buffer from att_read_callback
+        @param buffer_size from att_read_callback
+        @return value size for buffer == 0 and num bytes copied otherwise
+    */
+    uint16_t att_read_callback_handle_little_endian_16(uint16_t value, uint16_t offset, uint8_t * buffer, uint16_t buffer_size);
+
+    /**
+        @brief Handle read of single byte for att_read_callback
+        @param blob of data
+        @param blob_size of blob
+        @param offset from att_read_callback
+        @param buffer from att_read_callback
+        @param buffer_size from att_read_callback
+        @return value size for buffer == 0 and num bytes copied otherwise
+    */
+    uint16_t att_read_callback_handle_byte(uint8_t value, uint16_t offset, uint8_t * buffer, uint16_t buffer_size);
+
+
+    // experimental client API
+    /**
+        @brief Get UUID for handle
+        @param attribute_handle
+        @return 0 if not found
+    */
+    uint16_t att_uuid_for_handle(uint16_t attribute_handle);
+
+    /**
+        @brief Get const value for handle
+        @param attribute_handle
+        @param out_value_len  output variable that hold value len
+        @return value
+    */
+
+    const uint8_t * gatt_server_get_const_value_for_handle(uint16_t attribute_handle, uint16_t * out_value_len);
+
+    // experimental GATT Server API
+
+    /**
+        @brief Get handle range for primary service.
+        @param uuid16
+        @param start_handle
+        @param end_handle
+        @return false if not found
+    */
+    bool gatt_server_get_handle_range_for_service_with_uuid16(uint16_t uuid16, uint16_t * start_handle, uint16_t * end_handle);
+
+    /**
+        @brief Get handle range for included service.
+        @param start_handle
+        @param end_handle
+        @param uuid16
+        @param out_included_service_handle
+        @param out_included_service_start_handle
+        @param out_included_service_end_handle
+        @return false if not found
+    */
+    bool gatt_server_get_included_service_with_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t uuid16,
+            uint16_t * out_included_service_handle, uint16_t * out_included_service_start_handle, uint16_t * out_included_service_end_handle);
+
+    /**
+        @brief Get value handle for characteristic.
+        @param start_handle
+        @param end_handle
+        @param uuid16
+        @return 0 if not found
+    */
+    uint16_t gatt_server_get_value_handle_for_characteristic_with_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t uuid16);
+
+    /**
+        @brief Get descriptor handle for characteristic.
+        @param start_handle
+        @param end_handle
+        @param characteristic_uuid16
+        @param descriptor_uuid16
+        @return 0 if not found
+    */
+    uint16_t gatt_server_get_descriptor_handle_for_characteristic_with_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t characteristic_uuid16, uint16_t descriptor_uuid16);
+
+    /**
+        @brief Get client configuration handle for characteristic.
+        @param start_handle
+        @param end_handle
+        @param characteristic_uuid16
+        @return 0 if not found
+    */
+    uint16_t gatt_server_get_client_configuration_handle_for_characteristic_with_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t characteristic_uuid16);
+
+    /**
+        @brief Get server configuration handle for characteristic.
+        @param start_handle
+        @param end_handle
+        @param characteristic_uuid16
+        @param descriptor_uuid16
+        @return 0 if not found
+    */
+    uint16_t gatt_server_get_server_configuration_handle_for_characteristic_with_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t characteristic_uuid16);
+
+
+    /**
+        @brief Get handle range for primary service.
+        @param uuid128
+        @param start_handle
+        @param end_handle
+        @return false if not found
+    */
+    bool gatt_server_get_handle_range_for_service_with_uuid128(const uint8_t * uuid128, uint16_t * start_handle, uint16_t * end_handle);
+
+    /**
+        @brief Get value handle.
+        @param start_handle
+        @param end_handle
+        @param uuid128
+        @return 0 if not found
+    */
+    uint16_t gatt_server_get_value_handle_for_characteristic_with_uuid128(uint16_t start_handle, uint16_t end_handle, const uint8_t * uuid128);
+
+    /**
+        @brief Get client configuration handle.
+        @param start_handle
+        @param end_handle
+        @param uuid128
+        @return 0 if not found
+    */
+    uint16_t gatt_server_get_client_configuration_handle_for_characteristic_with_uuid128(uint16_t start_handle, uint16_t end_handle, const uint8_t * uuid128);
+
+    /* API_END */
+
+    // non-user functionality for att_server
+
+    /**
+        @brief Check if writes to handle should be persistent
+        @param handle
+        @return 1 if persistent
+    */
+    bool att_is_persistent_ccc(uint16_t handle);
+
+
+
+    // auto-pts testing, returns response size
+#ifdef ENABLE_BTP
+    uint16_t btp_att_get_attributes_by_uuid16(uint16_t start_handle, uint16_t end_handle, uint16_t uuid16, uint8_t * response_buffer, uint16_t response_buffer_size);
+    uint16_t btp_att_get_attributes_by_uuid128(uint16_t start_handle, uint16_t end_handle, const uint8_t * uuid128, uint8_t * response_buffer, uint16_t response_buffer_size);
+    uint16_t btp_att_get_attribute_value(att_connection_t * att_connection, uint16_t attribute_handle, uint8_t * response_buffer, uint16_t response_buffer_size);
+#endif
+
+#if defined __cplusplus
+}
+#endif
+
+#endif
+
+#endif // ATT_H

cores/rp2040/sdkoverride/bluetooth.h

@@ -0,0 +1,926 @@
+/*
+    Copyright (C) 2015 BlueKitchen GmbH
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holders nor the names of
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+    4. Any redistribution, use, or modification is done solely for
+      personal benefit and not for any commercial purpose or for
+      monetary gain.
+
+    THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
+    GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+    OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+    AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+    Please inquire about commercial licensing options at
+    contact@bluekitchen-gmbh.com
+
+*/
+
+/*
+    bluetooth.h
+
+    Numbers defined or derived from the official Bluetooth specification
+*/
+
+#ifndef BLUETOOTH_H
+#define BLUETOOTH_H
+
+#include <stdint.h>
+
+/**
+    @brief hci connection handle type
+*/
+typedef uint16_t hci_con_handle_t;
+
+/**
+    @brief Length of a bluetooth device address.
+*/
+#define BD_ADDR_LEN 6
+
+/**
+    @brief Bluetooth address
+*/
+typedef uint8_t bd_addr_t[BD_ADDR_LEN];
+
+/**
+    Address types
+*/
+typedef enum {
+    // Public Device Address
+    BD_ADDR_TYPE_LE_PUBLIC = 0,
+    // Random Device Address
+    BD_ADDR_TYPE_LE_RANDOM = 1,
+    // Public Identity Address (Corresponds to Resolved Private Address)
+    BD_ADDR_TYPE_LE_PUBLIC_IDENTITY = 2,
+    // Random (static) Identity Address (Corresponds to Resolved Private Address)
+    BD_ADDR_TYPE_LE_RANDOM_IDENTITY = 3,
+    // internal BTstack addr types for Classic connections
+    BD_ADDR_TYPE_SCO       = 0xfc,
+    BD_ADDR_TYPE_ACL       = 0xfd,
+    BD_ADDR_TYPE_UNKNOWN   = 0xfe,  // also used as 'invalid'
+} bd_addr_type_t;
+
+/**
+    Link types for BR/EDR Connections
+*/
+typedef enum {
+    HCI_LINK_TYPE_SCO  = 0,
+    HCI_LINK_TYPE_ACL  = 1,
+    HCI_LINK_TYPE_ESCO = 2,
+} hci_link_type_t;
+
+
+/**
+    @brief link key
+*/
+#define LINK_KEY_LEN 16
+#define LINK_KEY_STR_LEN (LINK_KEY_LEN*2)
+typedef uint8_t link_key_t[LINK_KEY_LEN];
+
+/**
+    @brief link key type
+*/
+typedef enum {
+    INVALID_LINK_KEY = 0xffff,
+    COMBINATION_KEY = 0,  // standard pairing
+    LOCAL_UNIT_KEY,     // ?
+    REMOTE_UNIT_KEY,    // ?
+    DEBUG_COMBINATION_KEY,  // SSP with debug
+    UNAUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P192, // SSP Simple Pairing
+    AUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P192,   // SSP Passkey, Number confirm, OOB
+    CHANGED_COMBINATION_KEY,               // Link key changed using Change Connection Lnk Key
+    UNAUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P256, // SSP Simpe Pairing
+    AUTHENTICATED_COMBINATION_KEY_GENERATED_FROM_P256,   // SSP Passkey, Number confirm, OOB
+} link_key_type_t;
+
+/**
+    LE Privacy 1.2
+*/
+typedef enum {
+    LE_PRIVACY_MODE_NETWORK = 0,
+    LE_PRIVACY_MODE_DEVICE = 1,
+} le_privacy_mode_t;
+
+/**
+    @brief Extended Inquiry Response
+*/
+#define EXTENDED_INQUIRY_RESPONSE_DATA_LEN 240
+
+/**
+    @brief Inquiry modes
+*/
+typedef enum {
+    INQUIRY_MODE_STANDARD = 0,
+    INQUIRY_MODE_RSSI,
+    INQUIRY_MODE_RSSI_AND_EIR,
+} inquiry_mode_t;
+
+/**
+    @brief Page Scan Types
+*/
+typedef enum {
+    PAGE_SCAN_MODE_STANDARD = 0,
+    PAGE_SCAN_MODE_INTERLACED,
+} page_scan_type_t;
+
+/**
+    @brief Inquiry Scan Types
+*/
+typedef enum {
+    INQUIRY_SCAN_MODE_STANDARD = 0,
+    INQUIRY_SCAN_MODE_INTERLACED,
+} inquiry_scan_type_t;
+
+/**
+    Link Supervision Timeout Default, 0x7d00 * 0.625ms = 20s
+*/
+#define HCI_LINK_SUPERVISION_TIMEOUT_DEFAULT 0x7D00
+
+/**
+    Service Type used for QoS Setup and Flow Specification
+*/
+typedef enum {
+    HCI_SERVICE_TYPE_NO_TRAFFIC = 0,
+    HCI_SERVICE_TYPE_BEST_EFFORT,
+    HCI_SERVICE_TYPE_GUARANTEED,
+    HCI_SERVICE_TYPE_INVALID,
+} hci_service_type_t;
+
+/**
+    HCI Transport
+*/
+
+/**
+    packet types - used in BTstack and over the H4 UART interface
+*/
+#define HCI_COMMAND_DATA_PACKET 0x01
+#define HCI_ACL_DATA_PACKET     0x02
+#define HCI_SCO_DATA_PACKET     0x03
+#define HCI_EVENT_PACKET        0x04
+#define HCI_ISO_DATA_PACKET     0x05
+
+/**
+    Other assigned numbers, Assigned_Numbers_Host Controller Interface.pdf
+*/
+
+typedef enum {
+    HCI_AUDIO_CODING_FORMAT_U_LAW_LOG = 0x00,
+    HCI_AUDIO_CODING_FORMAT_A_LAW_LOG,
+    HCI_AUDIO_CODING_FORMAT_CVSD,
+    HCI_AUDIO_CODING_FORMAT_TRANSPARENT, // Indicates that the controller does not do any transcoding or resampling. This is also used for test mode.
+    HCI_AUDIO_CODING_FORMAT_LINEAR_PCM,
+    HCI_AUDIO_CODING_FORMAT_MSBC,
+    HCI_AUDIO_CODING_FORMAT_LC3,
+    HCI_AUDIO_CODING_FORMAT_G_729A,
+    HCI_AUDIO_CODING_FORMAT_RFU,
+    HCI_AUDIO_CODING_FORMAT_VENDOR_SPECIFIC = 0xFF
+} hci_audio_coding_format_t;
+
+/**
+    HCI Layer
+*/
+
+//
+// Error Codes rfom Bluetooth Core Specification
+//
+
+/* ENUM_START: BLUETOOTH_ERROR_CODE */
+#define ERROR_CODE_SUCCESS                                 0x00
+#define ERROR_CODE_UNKNOWN_HCI_COMMAND                     0x01
+#define ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER           0x02
+#define ERROR_CODE_HARDWARE_FAILURE                        0x03
+#define ERROR_CODE_PAGE_TIMEOUT                            0x04
+#define ERROR_CODE_AUTHENTICATION_FAILURE                  0x05
+#define ERROR_CODE_PIN_OR_KEY_MISSING                      0x06
+#define ERROR_CODE_MEMORY_CAPACITY_EXCEEDED                0x07
+#define ERROR_CODE_CONNECTION_TIMEOUT                      0x08
+#define ERROR_CODE_CONNECTION_LIMIT_EXCEEDED               0x09
+#define ERROR_CODE_SYNCHRONOUS_CONNECTION_LIMIT_TO_A_DEVICE_EXCEEDED  0x0A
+#define ERROR_CODE_ACL_CONNECTION_ALREADY_EXISTS           0x0B
+#define ERROR_CODE_COMMAND_DISALLOWED                      0x0C
+#define ERROR_CODE_CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES 0x0D
+#define ERROR_CODE_CONNECTION_REJECTED_DUE_TO_SECURITY_REASONS  0x0E
+#define ERROR_CODE_CONNECTION_REJECTED_DUE_TO_UNACCEPTABLE_BD_ADDR 0x0F
+#define ERROR_CODE_CONNECTION_ACCEPT_TIMEOUT_EXCEEDED      0x10
+#define ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE  0x11
+#define ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS          0x12
+#define ERROR_CODE_REMOTE_USER_TERMINATED_CONNECTION       0x13
+#define ERROR_CODE_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES 0x14
+#define ERROR_CODE_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_POWER_OFF     0x15
+#define ERROR_CODE_CONNECTION_TERMINATED_BY_LOCAL_HOST     0x16
+#define ERROR_CODE_REPEATED_ATTEMPTS                       0x17
+#define ERROR_CODE_PAIRING_NOT_ALLOWED                     0x18
+#define ERROR_CODE_UNKNOWN_LMP_PDU                         0x19
+#define ERROR_CODE_UNSUPPORTED_REMOTE_FEATURE_UNSUPPORTED_LMP_FEATURE 0x1A
+#define ERROR_CODE_SCO_OFFSET_REJECTED                     0x1B
+#define ERROR_CODE_SCO_INTERVAL_REJECTED                   0x1C
+#define ERROR_CODE_SCO_AIR_MODE_REJECTED                   0x1D
+#define ERROR_CODE_INVALID_LMP_PARAMETERS_INVALID_LL_PARAMETERS 0x1E
+#define ERROR_CODE_UNSPECIFIED_ERROR                       0x1F
+#define ERROR_CODE_UNSUPPORTED_LMP_PARAMETER_VALUE_UNSUPPORTED_LL_PARAMETER_VALUE 0x20
+#define ERROR_CODE_ROLE_CHANGE_NOT_ALLOWED                 0x21
+#define ERROR_CODE_LMP_RESPONSE_TIMEOUT_LL_RESPONSE_TIMEOUT 0x22
+#define ERROR_CODE_LMP_ERROR_TRANSACTION_COLLISION         0x23
+#define ERROR_CODE_LMP_PDU_NOT_ALLOWED                     0x24
+#define ERROR_CODE_ENCRYPTION_MODE_NOT_ACCEPTABLE          0x25
+#define ERROR_CODE_LINK_KEY_CANNOT_BE_CHANGED              0x26
+#define ERROR_CODE_REQUESTED_QOS_NOT_SUPPORTED             0x27
+#define ERROR_CODE_INSTANT_PASSED                          0x28
+#define ERROR_CODE_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED     0x29
+#define ERROR_CODE_DIFFERENT_TRANSACTION_COLLISION         0x2A
+#define ERROR_CODE_RESERVED                                0x2B
+#define ERROR_CODE_QOS_UNACCEPTABLE_PARAMETER              0x2C
+#define ERROR_CODE_QOS_REJECTED                            0x2D
+#define ERROR_CODE_CHANNEL_CLASSIFICATION_NOT_SUPPORTED    0x2E
+#define ERROR_CODE_INSUFFICIENT_SECURITY                   0x2F
+#define ERROR_CODE_PARAMETER_OUT_OF_MANDATORY_RANGE        0x30
+// #define ERROR_CODE_RESERVED
+#define ERROR_CODE_ROLE_SWITCH_PENDING                     0x32
+// #define ERROR_CODE_RESERVED
+#define ERROR_CODE_RESERVED_SLOT_VIOLATION                 0x34
+#define ERROR_CODE_ROLE_SWITCH_FAILED                      0x35
+#define ERROR_CODE_EXTENDED_INQUIRY_RESPONSE_TOO_LARGE     0x36
+#define ERROR_CODE_SECURE_SIMPLE_PAIRING_NOT_SUPPORTED_BY_HOST 0x37
+#define ERROR_CODE_HOST_BUSY_PAIRING                       0x38
+#define ERROR_CODE_CONNECTION_REJECTED_DUE_TO_NO_SUITABLE_CHANNEL_FOUND 0x39
+#define ERROR_CODE_CONTROLLER_BUSY                         0x3A
+#define ERROR_CODE_UNACCEPTABLE_CONNECTION_PARAMETERS      0x3B
+#define ERROR_CODE_DIRECTED_ADVERTISING_TIMEOUT            0x3C
+#define ERROR_CODE_CONNECTION_TERMINATED_DUE_TO_MIC_FAILURE 0x3D
+#define ERROR_CODE_CONNECTION_FAILED_TO_BE_ESTABLISHED     0x3E
+#define ERROR_CODE_MAC_CONNECTION_FAILED                   0x3F
+#define ERROR_CODE_COARSE_CLOCK_ADJUSTMENT_REJECTED_BUT_WILL_TRY_TO_ADJUST_USING_CLOCK_DRAGGING 0x40
+
+// BTstack defined ERRORS, mapped into BLuetooth status code range
+
+#define BTSTACK_CONNECTION_TO_BTDAEMON_FAILED              0x50
+#define BTSTACK_ACTIVATION_FAILED_SYSTEM_BLUETOOTH         0x51
+#define BTSTACK_ACTIVATION_POWERON_FAILED                  0x52
+#define BTSTACK_ACTIVATION_FAILED_UNKNOWN                  0x53
+#define BTSTACK_NOT_ACTIVATED                              0x54
+#define BTSTACK_BUSY                                       0x55
+#define BTSTACK_MEMORY_ALLOC_FAILED                        0x56
+#define BTSTACK_ACL_BUFFERS_FULL                           0x57
+
+// l2cap errors - enumeration by the command that created them
+#define L2CAP_COMMAND_REJECT_REASON_COMMAND_NOT_UNDERSTOOD 0x60
+#define L2CAP_COMMAND_REJECT_REASON_SIGNALING_MTU_EXCEEDED 0x61
+#define L2CAP_COMMAND_REJECT_REASON_INVALID_CID_IN_REQUEST 0x62
+
+#define L2CAP_CONNECTION_RESPONSE_RESULT_SUCCESSFUL        0x63
+#define L2CAP_CONNECTION_RESPONSE_RESULT_PENDING           0x64
+#define L2CAP_CONNECTION_RESPONSE_RESULT_REFUSED_PSM       0x65
+#define L2CAP_CONNECTION_RESPONSE_RESULT_REFUSED_SECURITY  0x66
+#define L2CAP_CONNECTION_RESPONSE_RESULT_REFUSED_RESOURCES 0x67
+#define L2CAP_CONNECTION_RESPONSE_RESULT_ERTM_NOT_SUPPORTED 0x68
+
+// should be L2CAP_CONNECTION_RTX_TIMEOUT
+#define L2CAP_CONNECTION_RESPONSE_RESULT_RTX_TIMEOUT       0x69
+#define L2CAP_CONNECTION_BASEBAND_DISCONNECT               0x6A
+#define L2CAP_SERVICE_ALREADY_REGISTERED                   0x6B
+#define L2CAP_DATA_LEN_EXCEEDS_REMOTE_MTU                  0x6C
+#define L2CAP_SERVICE_DOES_NOT_EXIST                       0x6D
+#define L2CAP_LOCAL_CID_DOES_NOT_EXIST                     0x6E
+#define L2CAP_CONNECTION_RESPONSE_UNKNOWN_ERROR            0x6F
+
+#define RFCOMM_MULTIPLEXER_STOPPED                         0x70
+#define RFCOMM_CHANNEL_ALREADY_REGISTERED                  0x71
+#define RFCOMM_NO_OUTGOING_CREDITS                         0x72
+#define RFCOMM_AGGREGATE_FLOW_OFF                          0x73
+#define RFCOMM_DATA_LEN_EXCEEDS_MTU                        0x74
+
+#define HFP_REMOTE_REJECTS_AUDIO_CONNECTION                0x7F
+
+#define SDP_HANDLE_ALREADY_REGISTERED                      0x80
+#define SDP_QUERY_INCOMPLETE                               0x81
+#define SDP_SERVICE_NOT_FOUND                              0x82
+#define SDP_HANDLE_INVALID                                 0x83
+#define SDP_QUERY_BUSY                                     0x84
+
+#define ATT_HANDLE_VALUE_INDICATION_IN_PROGRESS            0x90
+#define ATT_HANDLE_VALUE_INDICATION_TIMEOUT                0x91
+#define ATT_HANDLE_VALUE_INDICATION_DISCONNECT             0x92
+
+#define GATT_CLIENT_NOT_CONNECTED                          0x93
+#define GATT_CLIENT_BUSY                                   0x94
+#define GATT_CLIENT_IN_WRONG_STATE                         0x95
+#define GATT_CLIENT_DIFFERENT_CONTEXT_FOR_ADDRESS_ALREADY_EXISTS 0x96
+#define GATT_CLIENT_VALUE_TOO_LONG                         0x97
+#define GATT_CLIENT_CHARACTERISTIC_NOTIFICATION_NOT_SUPPORTED 0x98
+#define GATT_CLIENT_CHARACTERISTIC_INDICATION_NOT_SUPPORTED   0x99
+
+#define BNEP_SERVICE_ALREADY_REGISTERED                    0xA0
+#define BNEP_CHANNEL_NOT_CONNECTED                         0xA1
+#define BNEP_DATA_LEN_EXCEEDS_MTU                          0xA2
+
+// OBEX ERRORS
+#define OBEX_UNKNOWN_ERROR                                 0xB0
+#define OBEX_CONNECT_FAILED                                0xB1
+#define OBEX_DISCONNECTED                                  0xB2
+#define OBEX_NOT_FOUND                                     0xB3
+#define OBEX_NOT_ACCEPTABLE                                0xB4
+#define OBEX_ABORTED                                       0xB5
+
+#define MESH_ERROR_APPKEY_INDEX_INVALID                    0xD0
+/* ENUM_END */
+
+
+/* ENUM_START: AVRCP_BROWSING_ERROR_CODE */
+#define AVRCP_BROWSING_ERROR_CODE_INVALID_COMMAND                     0x00  // Sent if TG received a PDU that it did not understand. Valid for All.
+#define AVRCP_BROWSING_ERROR_CODE_INVALID_PARAMETER                   0x01  // Sent if the TG received a PDU with a parameter ID that it did not understand. Sent if there is only one parameter ID in the PDU. Valid for All.
+#define AVRCP_BROWSING_ERROR_CODE_SPECIFIED_PARAMETER_NOT_FOUND       0x02  // Sent if the parameter ID is understood, but content is wrong or corrupted. Valid for All.
+#define AVRCP_BROWSING_ERROR_CODE_INTERNAL_ERROR                      0x03  // Sent if there are error conditions not covered by a more specific error code. Valid for All.
+#define AVRCP_BROWSING_ERROR_CODE_SUCCESS                             0x04  // This is the status that should be returned if the operation was successful. Valid for All except where the response CType is AV/C REJECTED.
+#define AVRCP_BROWSING_ERROR_CODE_UID_CHANGED                         0x05  // The UIDs on the device have changed. Valid for All.
+#define AVRCP_BROWSING_ERROR_CODE_RESERVED_06                         0x06  // Valid for All.
+#define AVRCP_BROWSING_ERROR_CODE_INVALID_DIRECTION                   0x07  // The Direction parameter is invalid. Valid for Change Path.
+#define AVRCP_BROWSING_ERROR_CODE_NOT_A_DIRECTORY                     0x08  // The UID provided does not refer to a folder item. Valid for Change Path.
+#define AVRCP_BROWSING_ERROR_CODE_DOES_NOT_EXIST                      0x09  // The UID provided does not refer to any currently valid. Valid for Change Path, PlayItem, AddToNowPlaying, GetItemAttributes.
+#define AVRCP_BROWSING_ERROR_CODE_INVALID_SCOPE                       0x0a  // The scope parameter is invalid. Valid for GetFolderItems, PlayItem, AddToNowPlayer, GetItemAttributes,.
+#define AVRCP_BROWSING_ERROR_CODE_RANGE_OUT_OF_BOUNDS                 0x0b  // The start of range provided is not valid. Valid for GetFolderItems.
+#define AVRCP_BROWSING_ERROR_CODE_UID_IS_A_DIRECTORY                  0x0c  // The UID provided refers to a directory, which cannot be handled by this media player. Valid for PlayItem, AddToNowPlaying.
+#define AVRCP_BROWSING_ERROR_CODE_MEDIA_IN_USES                       0x0d  // The media is not able to be used for this operation at this time. Valid for PlayItem, AddToNowPlaying.
+#define AVRCP_BROWSING_ERROR_CODE_NOW_PLAYING_LIST_FULL               0x0e  // No more items can be added to the Now Playing List. Valid for AddToNowPlaying.
+#define AVRCP_BROWSING_ERROR_CODE_SEARCH_NOT_SUPPORTED                0x0f  // The Browsed Media Player does not support search. Valid for Search.
+#define AVRCP_BROWSING_ERROR_CODE_SEARCH_IN_PROGRESS                  0x10  // A search operation is already in progress. Valid for Search.
+#define AVRCP_BROWSING_ERROR_CODE_INVALID_PLAYER_ID                   0x11  // The specified Player Id does not refer to a valid player. Valid for SetAddressedPlayer, SetBrowsedPlayer.
+#define AVRCP_BROWSING_ERROR_CODE_PLAYER_NOT_BROWSABLE                0x12  // The Player Id supplied refers to a Media Player which does not support browsing. Valid for SetBrowsedPlayer.
+#define AVRCP_BROWSING_ERROR_CODE_PLAYER_NOT_ADDRESSED                0x13  // The Player Id supplied refers to a player which is not currently addressed, and the command is not able to be performed if the player is not set as addressed. Valid for Search SetBrowsedPlayer.
+#define AVRCP_BROWSING_ERROR_CODE_NO_VALID_SEARCH_RESULTS             0x14  // The Search result list does not contain valid entries, e.g. after being invalidated due to change of browsed player. Valid for GetFolderItems.
+#define AVRCP_BROWSING_ERROR_CODE_NO_AVAILABLE_PLAYERS                0x15  // Valid for All.
+#define AVRCP_BROWSING_ERROR_CODE_ADDRESSED_PLAYER_CHANGED            0x16  // Valid for Register Notification.
+// 0x17-0xff Reserved
+/* ENUM_END */
+
+// HCI roles
+typedef enum {
+    HCI_ROLE_MASTER = 0,
+    HCI_ROLE_SLAVE  = 1,
+    HCI_ROLE_INVALID = 0xff,
+} hci_role_t;
+
+// packet sizes (max payload)
+#define HCI_ACL_DM1_SIZE            17
+#define HCI_ACL_DH1_SIZE            27
+#define HCI_ACL_2DH1_SIZE           54
+#define HCI_ACL_3DH1_SIZE           83
+#define HCI_ACL_DM3_SIZE           121
+#define HCI_ACL_DH3_SIZE           183
+#define HCI_ACL_DM5_SIZE           224
+#define HCI_ACL_DH5_SIZE           339
+#define HCI_ACL_2DH3_SIZE          367
+#define HCI_ACL_3DH3_SIZE          552
+#define HCI_ACL_2DH5_SIZE          679
+#define HCI_ACL_3DH5_SIZE         1021
+#define HCI_SCO_HV1_SIZE            10
+#define HCI_SCO_HV2_SIZE            20
+#define HCI_SCO_HV3_SIZE            30
+#define HCI_SCO_EV3_SIZE            30
+#define HCI_SCO_EV4_SIZE           120
+#define HCI_SCO_EV5_SIZE           180
+#define HCI_SCO_2EV3_SIZE           60
+#define HCI_SCO_2EV5_SIZE          360
+#define HCI_SCO_3EV3_SIZE           90
+#define HCI_SCO_3EV5_SIZE          540
+
+#define LE_ADVERTISING_DATA_SIZE    31
+#define LE_EXTENDED_ADVERTISING_DATA_SIZE    229
+#define LE_EXTENDED_ADVERTISING_MAX_HANDLE 0xEFu
+#define LE_EXTENDED_ADVERTISING_MAX_CHUNK_LEN 251
+
+// advertising event properties for extended advertising
+#define LE_ADVERTISING_PROPERTIES_CONNECTABLE      (1u<<0)
+#define LE_ADVERTISING_PROPERTIES_SCANNABLE        (1u<<1)
+#define LE_ADVERTISING_PROPERTIES_DIRECTED         (1u<<2)
+#define LE_ADVERTISING_PROPERTIES_HIGH_DUTY_CYCLE  (1u<<3)
+#define LE_ADVERTISING_PROPERTIES_LEGACY           (1u<<4)
+#define LE_ADVERTISING_PROPERTIES_ANONYMOUS        (1u<<5)
+#define LE_ADVERTISING_PROPERTIES_INCLUDE_TX_POWER (1u<<6)
+
+
+// SCO Packet Types
+#define SCO_PACKET_TYPES_NONE  0x0000
+#define SCO_PACKET_TYPES_HV1   0x0001
+#define SCO_PACKET_TYPES_HV2   0x0002
+#define SCO_PACKET_TYPES_HV3   0x0004
+#define SCO_PACKET_TYPES_EV3   0x0008
+#define SCO_PACKET_TYPES_EV4   0x0010
+#define SCO_PACKET_TYPES_EV5   0x0020
+#define SCO_PACKET_TYPES_2EV3  0x0040
+#define SCO_PACKET_TYPES_3EV3  0x0080
+#define SCO_PACKET_TYPES_2EV5  0x0100
+#define SCO_PACKET_TYPES_3EV5  0x0200
+#define SCO_PACKET_TYPES_ALL   0x03FF
+#define SCO_PACKET_TYPES_SCO   0x0007
+#define SCO_PACKET_TYPES_ESCO  0x03F8
+
+// Link Policy Settings
+#define LM_LINK_POLICY_DISABLE_ALL_LM_MODES  0
+#define LM_LINK_POLICY_ENABLE_ROLE_SWITCH    1
+#define LM_LINK_POLICY_ENABLE_HOLD_MODE      2
+#define LM_LINK_POLICY_ENABLE_SNIFF_MODE     4
+
+// ACL Connection Modes
+#define ACL_CONNECTION_MODE_ACTIVE 0
+#define ACL_CONNECTION_MODE_HOLD   1
+#define ACL_CONNECTION_MODE_SNIFF  2
+
+/**
+    Default INQ Mode
+*/
+#define GAP_IAC_GENERAL_INQUIRY 0x9E8B33L // General/Unlimited Inquiry Access Code (GIAC)
+#define GAP_IAC_LIMITED_INQUIRY 0x9E8B00L // Limited Dedicated Inquiry Access Code (LIAC)
+
+/**
+    SSP IO Capabilities
+*/
+#define SSP_IO_CAPABILITY_DISPLAY_ONLY   0
+#define SSP_IO_CAPABILITY_DISPLAY_YES_NO 1
+#define SSP_IO_CAPABILITY_KEYBOARD_ONLY  2
+#define SSP_IO_CAPABILITY_NO_INPUT_NO_OUTPUT 3
+#define SSP_IO_CAPABILITY_UNKNOWN 0xff
+
+
+/**
+    SSP Authentication Requirements, see IO Capability Request Reply Command
+*/
+
+// Numeric comparison with automatic accept allowed.
+#define SSP_IO_AUTHREQ_MITM_PROTECTION_NOT_REQUIRED_NO_BONDING 0x00
+
+// Use IO Capabilities to deter- mine authentication procedure
+#define SSP_IO_AUTHREQ_MITM_PROTECTION_REQUIRED_NO_BONDING 0x01
+
+// Numeric compar- ison with automatic accept allowed.
+#define SSP_IO_AUTHREQ_MITM_PROTECTION_NOT_REQUIRED_DEDICATED_BONDING 0x02
+
+// Use IO Capabilities to determine authentication procedure
+#define SSP_IO_AUTHREQ_MITM_PROTECTION_REQUIRED_DEDICATED_BONDING 0x03
+
+// Numeric Compari- son with automatic accept allowed.
+#define SSP_IO_AUTHREQ_MITM_PROTECTION_NOT_REQUIRED_GENERAL_BONDING 0x04
+
+// Use IO capabilities to determine authentication procedure.
+#define SSP_IO_AUTHREQ_MITM_PROTECTION_REQUIRED_GENERAL_BONDING 0x05
+
+
+// OGFs
+#define OGF_LINK_CONTROL          0x01
+#define OGF_LINK_POLICY           0x02
+#define OGF_CONTROLLER_BASEBAND   0x03
+#define OGF_INFORMATIONAL_PARAMETERS 0x04
+#define OGF_STATUS_PARAMETERS     0x05
+#define OGF_TESTING               0x06
+#define OGF_LE_CONTROLLER 0x08
+#define OGF_VENDOR  0x3f
+
+
+
+
+/**
+    L2CAP Layer
+*/
+
+#define L2CAP_HEADER_SIZE 4
+
+// minimum signaling MTU
+#define L2CAP_MINIMAL_MTU 48
+#define L2CAP_DEFAULT_MTU 672
+
+// Minimum/default MTU
+#define L2CAP_LE_DEFAULT_MTU  23
+
+// L2CAP Fixed Channel IDs
+#define L2CAP_CID_SIGNALING                        0x0001
+#define L2CAP_CID_CONNECTIONLESS_CHANNEL           0x0002
+#define L2CAP_CID_ATTRIBUTE_PROTOCOL               0x0004
+#define L2CAP_CID_SIGNALING_LE                     0x0005
+#define L2CAP_CID_SECURITY_MANAGER_PROTOCOL        0x0006
+#define L2CAP_CID_BR_EDR_SECURITY_MANAGER          0x0007
+
+// L2CAP Channels in Basic and Enhanced Retransmission Mode
+
+// connection response result
+#define L2CAP_CONNECTION_RESULT_SUCCESS                         0x0000
+#define L2CAP_CONNECTION_RESULT_PENDING                         0x0001
+#define L2CAP_CONNECTION_RESULT_PSM_NOT_SUPPORTED               0x0002
+#define L2CAP_CONNECTION_RESULT_SECURITY_BLOCK                  0x0003
+#define L2CAP_CONNECTION_RESULT_NO_RESOURCES_AVAILABLE          0x0004
+#define L2CAP_CONNECTION_RESULT_INVALID_SOURCE_CID              0x0006
+#define L2CAP_CONNECTION_RESULT_SOURCE_CID_ALREADY_ALLOCATED    0x0007
+
+// L2CAP Channels in LE Credit-Based Flow-Control Mode
+
+// connection response result
+#define L2CAP_CBM_CONNECTION_RESULT_SUCCESS                         0x0000
+#define L2CAP_CBM_CONNECTION_RESULT_SPSM_NOT_SUPPORTED              0x0002
+#define L2CAP_CBM_CONNECTION_RESULT_NO_RESOURCES_AVAILABLE          0x0004
+#define L2CAP_CBM_CONNECTION_RESULT_INSUFFICIENT_AUTHENTICATION     0x0005
+#define L2CAP_CBM_CONNECTION_RESULT_INSUFFICIENT_AUTHORIZATION      0x0006
+#define L2CAP_CBM_CONNECTION_RESULT_ENCYRPTION_KEY_SIZE_TOO_SHORT   0x0007
+#define L2CAP_CBM_CONNECTION_RESULT_INSUFFICIENT_ENCRYPTION         0x0008
+#define L2CAP_CBM_CONNECTION_RESULT_INVALID_SOURCE_CID              0x0009
+#define L2CAP_CBM_CONNECTION_RESULT_SOURCE_CID_ALREADY_ALLOCATED    0x000A
+#define L2CAP_CBM_CONNECTION_RESULT_UNACCEPTABLE_PARAMETERS         0x000B
+
+
+// L2CAP Channels in Enhanced Credit-Based Flow-Control Mode
+
+// number of CIDs in single connection+reconfiguration request/response
+#define L2CAP_ECBM_MAX_CID_ARRAY_SIZE        5
+
+// connection response result
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_SUCCESS                                    0x0000
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_REFUSED_SPSM_NOT_SUPPORTED                 0x0002
+#define L2CAP_ECBM_CONNECTION_RESULT_SOME_REFUSED_INSUFFICIENT_RESOURCES_AVAILABLE  0x0004
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_REFUSED_INSUFFICIENT_AUTHENTICATION        0x0005
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_REFUSED_INSUFFICIENT_AUTHORIZATION         0x0006
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_REFUSED_ENCYRPTION_KEY_SIZE_TOO_SHORT      0x0007
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_REFUSED_INSUFFICIENT_ENCRYPTION            0x0008
+#define L2CAP_ECBM_CONNECTION_RESULT_SOME_REFUSED_INVALID_SOURCE_CID                0x0009
+#define L2CAP_ECBM_CONNECTION_RESULT_SOME_REFUSED_SOURCE_CID_ALREADY_ALOCATED       0x000A
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_REFUSED_UNACCEPTABLE_PARAMETERS            0x000B
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_REFUSED_INVALID_PARAMETERS                 0x000C
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_PENDING_NO_FURTHER_INFORMATION             0x000D
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_PENDING_AUTHENTICATION                     0x000E
+#define L2CAP_ECBM_CONNECTION_RESULT_ALL_PENDING_AUTHORIZATION                      0x000F
+
+
+// Result for Reconfigure Request
+#define L2CAP_ECBM_RECONFIGURE_SUCCESS                                 0
+#define L2CAP_ECBM_RECONFIGURE_FAILED_MTU_REDUCTION_NOT_ALLOWED        1
+#define L2CAP_ECBM_RECONFIGURE_FAILED_MPS_REDUCTION_MULTIPLE_CHANNELS  2
+#define L2CAP_ECBM_RECONFIGURE_FAILED_DESTINATION_CID_INVALID          3
+#define L2CAP_ECBM_RECONFIGURE_FAILED_UNACCEPTABLE_PARAMETERS          4
+
+/**
+    SDP Protocol
+*/
+
+// Device Vendor ID Sources
+#define DEVICE_ID_VENDOR_ID_SOURCE_BLUETOOTH 0x0001
+#define DEVICE_ID_VENDOR_ID_SOURCE_USB       0x0002
+
+// OBEX
+#define SDP_vCard_2_1       0x01
+#define SDP_vCard_3_0       0x02
+#define SDP_vCal_1_0        0x03
+#define SDP_iCal_2_0        0x04
+#define SDP_vNote           0x05
+#define SDP_vMessage        0x06
+#define SDP_OBEXFileTypeAny 0xFF
+
+/**
+    RFCOMM Protocol
+*/
+
+// Line Status
+#define LINE_STATUS_NO_ERROR       0x00
+#define LINE_STATUS_OVERRUN_ERROR  0x03
+#define LINE_STATUS_PARITY_ERORR   0x05
+#define LINE_STATUS_FRAMING_ERROR  0x09
+
+// Modem Status Flags
+#define MODEM_STATUS_FC   0x02
+#define MODEM_STATUS_RTC  0x04
+#define MODEM_STATUS_RTR  0x08
+#define MODEM_STATUS_IC   0x40
+#define MODEM_STATUS_DV   0x80
+
+typedef enum rpn_baud {
+    RPN_BAUD_2400 = 0,
+    RPN_BAUD_4800,
+    RPN_BAUD_7200,
+    RPN_BAUD_9600,
+    RPN_BAUD_19200,
+    RPN_BAUD_38400,
+    RPN_BAUD_57600,
+    RPN_BAUD_115200,
+    RPN_BAUD_230400
+} rpn_baud_t;
+
+typedef enum rpn_data_bits {
+    RPN_DATA_BITS_5 = 0,
+    RPN_DATA_BITS_6 = 0,
+    RPN_DATA_BITS_7 = 0,
+    RPN_DATA_BITS_8 = 0
+} rpn_data_bits_t;
+
+typedef enum rpn_stop_bits {
+    RPN_STOP_BITS_1_0 = 0,
+    RPN_STOP_BITS_1_5
+} rpn_stop_bits_t;
+
+typedef enum rpn_parity {
+    RPN_PARITY_NONE  = 0,
+    RPN_PARITY_ODD   = 1,
+    RPN_PARITY_EVEN  = 3,
+    RPN_PARITY_MARK  = 5,
+    RPN_PARITY_SPACE = 7,
+} rpn_parity_t;
+
+#define RPN_FLOW_CONTROL_XONXOFF_ON_INPUT  0x01
+#define RPN_FLOW_CONTROL_XONXOFF_ON_OUTPUT 0x02
+#define RPN_FLOW_CONTROL_RTR_ON_INPUT      0x04
+#define RPN_FLOW_CONTROL_RTR_ON_OUTPUT     0x08
+#define RPN_FLOW_CONTROL_RTC_ON_INPUT      0x10
+#define RPN_FLOW_CONTROL_RTC_ON_OUTPUT     0x20
+
+#define RPN_PARAM_MASK_0_BAUD             0x01
+#define RPN_PARAM_MASK_0_DATA_BITS        0x02
+#define RPN_PARAM_MASK_0_STOP_BITS        0x04
+#define RPN_PARAM_MASK_0_PARITY           0x08
+#define RPN_PARAM_MASK_0_PARITY_TYPE      0x10
+#define RPN_PARAM_MASK_0_XON_CHAR         0x20
+#define RPN_PARAM_MASK_0_XOFF_CHAR        0x40
+#define RPN_PARAM_MASK_0_RESERVED         0x80
+
+// @note: values are identical to rpn_flow_control_t
+#define RPN_PARAM_MASK_1_XONOFF_ON_INPUT  0x01
+#define RPN_PARAM_MASK_1_XONOFF_ON_OUTPUT 0x02
+#define RPN_PARAM_MASK_1_RTR_ON_INPUT     0x04
+#define RPN_PARAM_MASK_1_RTR_ON_OUTPUT    0x08
+#define RPN_PARAM_MASK_1_RTC_ON_INPUT     0x10
+#define RPN_PARAM_MASK_1_RTC_ON_OUTPUT    0x20
+#define RPN_PARAM_MASK_1_RESERVED_0       0x40
+#define RPN_PARAM_MASK_1_RESERVED_1       0x80
+
+/**
+    BNEP Protocol
+*/
+
+#ifndef ETHER_ADDR_LEN
+#define ETHER_ADDR_LEN 6
+#endif
+
+#ifndef ETHERTYPE_VLAN
+#define ETHERTYPE_VLAN                                  0x8100 /* IEEE 802.1Q VLAN tag */
+#endif
+
+#define BNEP_MTU_MIN                                    1691
+
+
+/**
+    PAN Profile
+*/
+
+typedef enum {
+    BNEP_SECURITY_NONE = 0x0000,
+    BNEP_SECURITY_SERVICE_LEVEL_ENFORCED,
+    BNEP_SECURITY_802_1X
+} security_description_t;
+
+typedef enum {
+    PAN_NET_ACCESS_TYPE_PSTN = 0x0000,
+    PAN_NET_ACCESS_TYPE_ISDN,
+    PAN_NET_ACCESS_TYPE_DSL,
+    PAN_NET_ACCESS_TYPE_CABLE_MODEM,
+    PAN_NET_ACCESS_TYPE_10MB_ETHERNET,
+    PAN_NET_ACCESS_TYPE_100MB_ETHERNET,
+    PAN_NET_ACCESS_TYPE_4MB_TOKEN_RING,
+    PAN_NET_ACCESS_TYPE_16MB_TOKEN_RING,
+    PAN_NET_ACCESS_TYPE_100MB_TOKEN_RING,
+    PAN_NET_ACCESS_TYPE_FDDI,
+    PAN_NET_ACCESS_TYPE_GSM,
+    PAN_NET_ACCESS_TYPE_CDMA,
+    PAN_NET_ACCESS_TYPE_GPRS,
+    PAN_NET_ACCESS_TYPE_3G,
+    PAN_NET_ACCESS_TYPE_CELULAR,
+    PAN_NET_ACCESS_TYPE_OTHER = 0xFFFE,
+    PAN_NET_ACCESS_TYPE_NONE
+} net_access_type_t;
+
+/**
+    ATT
+*/
+
+// Minimum/default MTU
+#define ATT_DEFAULT_MTU               23
+
+// MARK: ATT Error Codes
+#define ATT_ERROR_SUCCESS                          0x00
+#define ATT_ERROR_INVALID_HANDLE                   0x01
+#define ATT_ERROR_READ_NOT_PERMITTED               0x02
+#define ATT_ERROR_WRITE_NOT_PERMITTED              0x03
+#define ATT_ERROR_INVALID_PDU                      0x04
+#define ATT_ERROR_INSUFFICIENT_AUTHENTICATION      0x05
+#define ATT_ERROR_REQUEST_NOT_SUPPORTED            0x06
+#define ATT_ERROR_INVALID_OFFSET                   0x07
+#define ATT_ERROR_INSUFFICIENT_AUTHORIZATION       0x08
+#define ATT_ERROR_PREPARE_QUEUE_FULL               0x09
+#define ATT_ERROR_ATTRIBUTE_NOT_FOUND              0x0a
+#define ATT_ERROR_ATTRIBUTE_NOT_LONG               0x0b
+#define ATT_ERROR_INSUFFICIENT_ENCRYPTION_KEY_SIZE 0x0c
+#define ATT_ERROR_INVALID_ATTRIBUTE_VALUE_LENGTH   0x0d
+#define ATT_ERROR_UNLIKELY_ERROR                   0x0e
+#define ATT_ERROR_INSUFFICIENT_ENCRYPTION          0x0f
+#define ATT_ERROR_UNSUPPORTED_GROUP_TYPE           0x10
+#define ATT_ERROR_INSUFFICIENT_RESOURCES           0x11
+#define ATT_ERROR_VALUE_NOT_ALLOWED                0x13
+
+// MARK: ATT Error Codes defined by BTstack
+#define ATT_ERROR_HCI_DISCONNECT_RECEIVED          0x1f
+#define ATT_ERROR_BONDING_INFORMATION_MISSING      0x70
+#define ATT_ERROR_DATA_MISMATCH                    0x7e
+#define ATT_ERROR_TIMEOUT                          0x7F
+#define ATT_ERROR_WRITE_RESPONSE_PENDING           0x100
+
+// MARK: ATT Error Codes from Bluetooth Core Specification Supplement, Version 9 or later
+#define ATT_ERROR_WRITE_REQUEST_REJECTED                                                      0xFC
+#define ATT_ERROR_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR_IMPROPERLY_CONFIGURED        0xFD
+#define ATT_ERROR_PROCEDURE_ALREADY_IN_PROGRESS                                               0xFE
+#define ATT_ERROR_OUT_OF_RANGE                                                                0xFF
+
+// MARK: ATT Error Codes from Cycling Power Service spec
+#define CYCLING_POWER_ERROR_CODE_INAPPROPRIATE_CONNECTION_PARAMETERS                          0x80
+#define CYCLING_POWER_ERROR_CODE_PROCEDURE_ALREADY_IN_PROGRESS                                0xFE
+#define CYCLING_POWER_ERROR_CODE_CCC_DESCRIPTOR_IMPROPERLY_CONFIGURED                         0xFD
+
+// MARK: ATT Error Codes from Cycling Speed and Cadence Service spec
+#define CYCLING_SPEED_AND_CADENCE_ERROR_CODE_PROCEDURE_ALREADY_IN_PROGRESS                    0x80
+#define CYCLING_SPEED_AND_CADENCE_ERROR_CODE_CCC_DESCRIPTOR_IMPROPERLY_CONFIGURED             0x81
+
+
+// MARK: Attribute Property Flags
+#define ATT_PROPERTY_BROADCAST           0x01
+#define ATT_PROPERTY_READ                0x02
+#define ATT_PROPERTY_WRITE_WITHOUT_RESPONSE 0x04
+#define ATT_PROPERTY_WRITE               0x08
+#define ATT_PROPERTY_NOTIFY              0x10
+#define ATT_PROPERTY_INDICATE            0x20
+#define ATT_PROPERTY_AUTHENTICATED_SIGNED_WRITE 0x40
+#define ATT_PROPERTY_EXTENDED_PROPERTIES 0x80
+
+// MARK: Attribute Property Flag, BTstack extension
+// value is asked from client
+#define ATT_PROPERTY_DYNAMIC             0x100
+
+// Security levels
+#define ATT_SECURITY_NONE 0
+#define ATT_SECURITY_ENCRYPTED 1
+#define ATT_SECURITY_AUTHENTICATED 2
+#define ATT_SECURITY_AUTHORIZED 3
+#define ATT_SECURITY_AUTHENTICATED_SC 4
+
+// ATT Transaction Timeout of 30 seconds for Command/Response or Indication/Confirmation
+#define ATT_TRANSACTION_TIMEOUT_MS     30000
+
+#define ATT_TRANSACTION_MODE_NONE      0x0
+#define ATT_TRANSACTION_MODE_ACTIVE    0x1
+#define ATT_TRANSACTION_MODE_EXECUTE   0x2
+#define ATT_TRANSACTION_MODE_CANCEL    0x3
+#define ATT_TRANSACTION_MODE_VALIDATE  0x4
+
+// MARK: GATT UUIDs
+#define GATT_PRIMARY_SERVICE_UUID                   0x2800
+#define GATT_SECONDARY_SERVICE_UUID                 0x2801
+#define GATT_INCLUDE_SERVICE_UUID                   0x2802
+#define GATT_CHARACTERISTICS_UUID                   0x2803
+#define GATT_CHARACTERISTIC_EXTENDED_PROPERTIES     0x2900
+#define GATT_CHARACTERISTIC_USER_DESCRIPTION        0x2901
+#define GATT_CLIENT_CHARACTERISTICS_CONFIGURATION   0x2902
+#define GATT_SERVER_CHARACTERISTICS_CONFIGURATION   0x2903
+#define GATT_CHARACTERISTIC_PRESENTATION_FORMAT     0x2904
+#define GATT_CHARACTERISTIC_AGGREGATE_FORMAT        0x2905
+#define GATT_CLIENT_SUPPORTED_FEATURES              0x2B29
+#define GATT_SERVER_SUPPORTED_FEATURES              0x2B3A
+
+#define GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_NONE          0
+#define GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_NOTIFICATION  1
+#define GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_INDICATION    2
+
+#define GATT_CLIENT_ANY_CONNECTION      0xffff
+#define GATT_CLIENT_ANY_VALUE_HANDLE    0x0000
+
+// GAP Service and Characteristics
+#define GAP_SERVICE_UUID               0x1800
+#define GAP_DEVICE_NAME_UUID           0x2a00
+#define GAP_APPEARANCE_UUID            0x2a01
+#define GAP_PERIPHERAL_PRIVACY_FLAG    0x2a02
+#define GAP_RECONNECTION_ADDRESS_UUID  0x2a03
+#define GAP_PERIPHERAL_PREFERRED_CONNECTION_PARAMETERS_UUID 0x2a04
+#define GAP_SERVICE_CHANGED            0x2a05
+
+// Bluetooth GATT types
+
+typedef struct {
+    uint16_t year;      // 0 - year  is not known; or [1582,9999]
+    uint8_t  month;     // 0 - month is not known; or [1,12]
+    uint8_t  day;       // 0 - day   is not known; or [1,31]
+    uint8_t  hours;     // [0,23]
+    uint8_t  minutes;   // [0,59]
+    uint8_t  seconds;   // [0,59]
+} gatt_date_time_t;
+
+typedef enum {
+    GATT_MICROPHONE_CONTROL_MUTE_OFF = 0x00,
+    GATT_MICROPHONE_CONTROL_MUTE_ON,
+    GATT_MICROPHONE_CONTROL_MUTE_DISABLED
+} gatt_microphone_control_mute_t;
+
+/**
+    SM - LE Security Manager
+*/
+// Bluetooth Spec definitions
+typedef enum {
+    SM_CODE_PAIRING_REQUEST = 0X01,
+    SM_CODE_PAIRING_RESPONSE,
+    SM_CODE_PAIRING_CONFIRM,
+    SM_CODE_PAIRING_RANDOM,
+    SM_CODE_PAIRING_FAILED,
+    SM_CODE_ENCRYPTION_INFORMATION,
+    SM_CODE_MASTER_IDENTIFICATION,
+    SM_CODE_IDENTITY_INFORMATION,
+    SM_CODE_IDENTITY_ADDRESS_INFORMATION,
+    SM_CODE_SIGNING_INFORMATION,
+    SM_CODE_SECURITY_REQUEST,
+    SM_CODE_PAIRING_PUBLIC_KEY,
+    SM_CODE_PAIRING_DHKEY_CHECK,
+    SM_CODE_KEYPRESS_NOTIFICATION,
+} SECURITY_MANAGER_COMMANDS;
+
+// IO Capability Values
+typedef enum {
+    IO_CAPABILITY_DISPLAY_ONLY = 0,
+    IO_CAPABILITY_DISPLAY_YES_NO,
+    IO_CAPABILITY_KEYBOARD_ONLY,
+    IO_CAPABILITY_NO_INPUT_NO_OUTPUT,
+    IO_CAPABILITY_KEYBOARD_DISPLAY, // not used by secure simple pairing
+} io_capability_t;
+
+// Authentication requirement flags
+#define SM_AUTHREQ_NO_BONDING        0x00
+#define SM_AUTHREQ_BONDING           0x01
+#define SM_AUTHREQ_MITM_PROTECTION   0x04
+#define SM_AUTHREQ_SECURE_CONNECTION 0x08
+#define SM_AUTHREQ_KEYPRESS          0x10
+#define SM_AUTHREQ_CT2               0x20
+
+// Key distribution flags used by spec
+#define SM_KEYDIST_ENC_KEY  0x01
+#define SM_KEYDIST_ID_KEY   0x02
+#define SM_KEYDIST_SIGN     0x04
+#define SM_KEYDIST_LINK_KEY 0x08
+
+// Key distribution flags used internally
+#define SM_KEYDIST_FLAG_ENCRYPTION_INFORMATION       0x01
+#define SM_KEYDIST_FLAG_MASTER_IDENTIFICATION        0x02
+#define SM_KEYDIST_FLAG_IDENTITY_INFORMATION         0x04
+#define SM_KEYDIST_FLAG_IDENTITY_ADDRESS_INFORMATION 0x08
+#define SM_KEYDIST_FLAG_SIGNING_IDENTIFICATION       0x10
+
+// STK Generation Methods
+#define SM_STK_GENERATION_METHOD_JUST_WORKS          0x01
+#define SM_STK_GENERATION_METHOD_OOB                 0x02
+#define SM_STK_GENERATION_METHOD_PASSKEY             0x04
+#define SM_STK_GENERATION_METHOD_NUMERIC_COMPARISON  0x08
+
+// Pairing Failed Reasons
+#define SM_REASON_RESERVED                     0x00
+#define SM_REASON_PASSKEY_ENTRY_FAILED         0x01
+#define SM_REASON_OOB_NOT_AVAILABLE            0x02
+#define SM_REASON_AUTHENTHICATION_REQUIREMENTS 0x03
+#define SM_REASON_CONFIRM_VALUE_FAILED         0x04
+#define SM_REASON_PAIRING_NOT_SUPPORTED        0x05
+#define SM_REASON_ENCRYPTION_KEY_SIZE          0x06
+#define SM_REASON_COMMAND_NOT_SUPPORTED        0x07
+#define SM_REASON_UNSPECIFIED_REASON           0x08
+#define SM_REASON_REPEATED_ATTEMPTS            0x09
+#define SM_REASON_INVALID_PARAMETERS           0x0a
+#define SM_REASON_DHKEY_CHECK_FAILED           0x0b
+#define SM_REASON_NUMERIC_COMPARISON_FAILED    0x0c
+#define SM_REASON_BR_EDR_PAIRING_IN_PROGRESS   0x0d
+#define SM_REASON_CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED 0x0e
+#define SM_REASON_KEY_REJECTED                 0x0f
+
+// also, invalid parameters
+// and reserved
+
+// Keypress Notifications
+#define SM_KEYPRESS_PASSKEY_ENTRY_STARTED      0x00
+#define SM_KEYPRESS_PASSKEY_DIGIT_ENTERED      0x01
+#define SM_KEYPRESS_PASSKEY_DIGIT_ERASED       0x02
+#define SM_KEYPRESS_PASSKEY_CLEARED            0x03
+#define SM_KEYPRESS_PASSKEY_ENTRY_COMPLETED    0x04
+
+
+#endif

cores/rp2040/sdkoverride/hids_device.c

@@ -0,0 +1,524 @@
+/*
+    Copyright (C) 2014 BlueKitchen GmbH
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holders nor the names of
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+    4. Any redistribution, use, or modification is done solely for
+      personal benefit and not for any commercial purpose or for
+      monetary gain.
+
+    THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
+    GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+    OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+    AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+    Please inquire about commercial licensing options at
+    contact@bluekitchen-gmbh.com
+
+*/
+
+#if defined ENABLE_CLASSIC
+
+#define BTSTACK_FILE__ "hids_device.c"
+
+/**
+    Implementation of the GATT HIDS Device
+    To use with your application, add '#import <hids.gatt>' to your .gatt file
+*/
+
+#include "hids_device.h"
+
+#include "ble/att_db.h"
+#include "ble/att_server.h"
+#include "bluetooth_gatt.h"
+#include "btstack_util.h"
+#include "btstack_debug.h"
+
+#define HIDS_DEVICE_ERROR_CODE_INAPPROPRIATE_CONNECTION_PARAMETERS    0x80
+
+// storage for 'generic' HID Device with single Input, Output, and Feature Report
+static hids_device_report_t hid_reports_generic_storage[3];
+
+typedef struct {
+    uint16_t        con_handle;
+
+    uint8_t         hid_country_code;
+    const uint8_t * hid_descriptor;
+    uint16_t        hid_descriptor_size;
+
+    uint16_t        hid_report_map_handle;
+    uint8_t         hid_protocol_mode;
+    uint16_t        hid_protocol_mode_value_handle;
+
+    uint16_t        hid_boot_mouse_input_value_handle;
+    uint16_t        hid_boot_mouse_input_client_configuration_handle;
+    uint16_t        hid_boot_mouse_input_client_configuration_value;
+
+    uint16_t        hid_boot_keyboard_input_value_handle;
+    uint16_t        hid_boot_keyboard_input_client_configuration_handle;
+    uint16_t        hid_boot_keyboard_input_client_configuration_value;
+
+    hids_device_report_t * hid_reports;
+
+    uint8_t         hid_input_reports_num;
+    uint8_t         hid_output_reports_num;
+    uint8_t         hid_feature_reports_num;
+
+    uint16_t        hid_control_point_value_handle;
+    uint8_t         hid_control_point_suspend;
+
+    btstack_context_callback_registration_t  battery_callback;
+} hids_device_t;
+
+static hids_device_t hids_device;
+
+static btstack_packet_handler_t packet_handler;
+static att_service_handler_t hid_service;
+
+// TODO: store hids device connection into list
+static hids_device_t * hids_device_get_instance_for_con_handle(uint16_t con_handle) {
+    UNUSED(con_handle);
+    return &hids_device;
+}
+
+static hids_device_t * hids_device_create_instance(void) {
+    memset(&hids_device, 0, sizeof(hids_device_t));
+    return &hids_device;
+}
+
+static hids_device_report_t * hids_device_get_report_for_client_configuration_handle(hids_device_t * device, uint16_t client_configuration_handle) {
+    uint8_t pos;
+    uint8_t total_reports =  device->hid_input_reports_num + device->hid_output_reports_num + device->hid_feature_reports_num;
+    for (pos = 0 ; pos < total_reports ; pos++) {
+        if (device->hid_reports[pos].client_configuration_handle == client_configuration_handle) {
+            return &device->hid_reports[pos];
+        }
+    }
+    return NULL;
+}
+
+static hids_device_report_t *
+hids_device_get_report_for_id_and_type(hids_device_t *device, uint16_t report_id, hid_report_type_t type) {
+    uint8_t pos;
+    uint8_t total_reports =  device->hid_input_reports_num + device->hid_output_reports_num + device->hid_feature_reports_num;
+    for (pos = 0 ; pos < total_reports ; pos++) {
+        if ((device->hid_reports[pos].type == type) && (device->hid_reports[pos].id == report_id)) {
+            return &device->hid_reports[pos];
+        }
+    }
+    return NULL;
+}
+
+static void hids_device_emit_event_with_uint8(uint8_t event, hci_con_handle_t con_handle, uint8_t value) {
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return;
+    }
+
+    if (!packet_handler) {
+        return;
+    }
+    uint8_t buffer[6];
+    buffer[0] = HCI_EVENT_HIDS_META;
+    buffer[1] = 4;
+    buffer[2] = event;
+    little_endian_store_16(buffer, 3, (uint16_t) con_handle);
+    buffer[5] = value;
+    (*packet_handler)(HCI_EVENT_PACKET, 0, buffer, sizeof(buffer));
+}
+
+static void hids_device_emit_event_with_uint8_uint8_t(uint8_t event, hci_con_handle_t con_handle, uint8_t value_1, uint8_t value_2) {
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return;
+    }
+
+    if (!packet_handler) {
+        return;
+    }
+    uint8_t buffer[7];
+    buffer[0] = HCI_EVENT_HIDS_META;
+    buffer[1] = 4;
+    buffer[2] = event;
+    little_endian_store_16(buffer, 3, (uint16_t) con_handle);
+    buffer[5] = value_1;
+    buffer[6] = value_2;
+    (*packet_handler)(HCI_EVENT_PACKET, 0, buffer, sizeof(buffer));
+}
+
+static void hids_device_emit_event(uint8_t event, hci_con_handle_t con_handle) {
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return;
+    }
+
+    if (!packet_handler) {
+        return;
+    }
+    uint8_t buffer[5];
+    buffer[0] = HCI_EVENT_HIDS_META;
+    buffer[1] = 4;
+    buffer[2] = event;
+    little_endian_store_16(buffer, 3, (uint16_t) con_handle);
+    (*packet_handler)(HCI_EVENT_PACKET, 0, buffer, sizeof(buffer));
+}
+
+static void hids_device_can_send_now(void * context) {
+    hci_con_handle_t con_handle = (hci_con_handle_t)(uintptr_t) context;
+    // notify client
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return;
+    }
+
+    if (!packet_handler) {
+        return;
+    }
+    uint8_t buffer[5];
+    buffer[0] = HCI_EVENT_HIDS_META;
+    buffer[1] = 3;
+    buffer[2] = HIDS_SUBEVENT_CAN_SEND_NOW;
+    little_endian_store_16(buffer, 3, (uint16_t) con_handle);
+    (*packet_handler)(HCI_EVENT_PACKET, 0, buffer, sizeof(buffer));
+}
+
+// ATT Client Read Callback for Dynamic Data
+// - if buffer == NULL, don't copy data, just return size of value
+// - if buffer != NULL, copy data and return number bytes copied
+static uint16_t att_read_callback(hci_con_handle_t con_handle, uint16_t att_handle, uint16_t offset, uint8_t * buffer, uint16_t buffer_size) {
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return HIDS_DEVICE_ERROR_CODE_INAPPROPRIATE_CONNECTION_PARAMETERS;
+    }
+
+    if (att_handle == instance->hid_protocol_mode_value_handle) {
+        log_info("Read protocol mode");
+        return att_read_callback_handle_byte(instance->hid_protocol_mode, offset, buffer, buffer_size);
+    }
+
+    if (att_handle == instance->hid_report_map_handle) {
+        log_info("Read report map");
+        return att_read_callback_handle_blob(instance->hid_descriptor, instance->hid_descriptor_size, offset, buffer, buffer_size);
+    }
+
+    if (att_handle == instance->hid_boot_mouse_input_client_configuration_handle) {
+        return att_read_callback_handle_little_endian_16(instance->hid_boot_mouse_input_client_configuration_value, offset, buffer, buffer_size);
+    }
+
+    if (att_handle == instance->hid_boot_keyboard_input_client_configuration_handle) {
+        return att_read_callback_handle_little_endian_16(instance->hid_boot_keyboard_input_client_configuration_value, offset, buffer, buffer_size);
+    }
+
+    if (att_handle == instance->hid_control_point_value_handle) {
+        if (buffer && (buffer_size >= 1u)) {
+            buffer[0] = instance->hid_control_point_suspend;
+        }
+        return 1;
+    }
+
+    hids_device_report_t * report = hids_device_get_report_for_client_configuration_handle(instance, att_handle);
+    if (report != NULL) {
+        return att_read_callback_handle_little_endian_16(report->client_configuration_value, offset, buffer, buffer_size);
+    }
+    return 0;
+}
+
+static int att_write_callback(hci_con_handle_t con_handle, uint16_t att_handle, uint16_t transaction_mode, uint16_t offset, uint8_t *buffer, uint16_t buffer_size) {
+    UNUSED(transaction_mode);
+    UNUSED(buffer_size);
+    UNUSED(offset);
+
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return HIDS_DEVICE_ERROR_CODE_INAPPROPRIATE_CONNECTION_PARAMETERS;
+    }
+
+    if (att_handle == instance->hid_boot_mouse_input_client_configuration_handle) {
+        uint16_t new_value = little_endian_read_16(buffer, 0);
+        instance->hid_boot_mouse_input_client_configuration_value = new_value;
+        hids_device_emit_event_with_uint8(HIDS_SUBEVENT_BOOT_MOUSE_INPUT_REPORT_ENABLE, con_handle, (uint8_t) new_value);
+    }
+    if (att_handle == instance->hid_boot_keyboard_input_client_configuration_handle) {
+        uint16_t new_value = little_endian_read_16(buffer, 0);
+        instance->hid_boot_keyboard_input_client_configuration_value = new_value;
+        hids_device_emit_event_with_uint8(HIDS_SUBEVENT_BOOT_KEYBOARD_INPUT_REPORT_ENABLE, con_handle, (uint8_t) new_value);
+    }
+
+    if (att_handle == instance->hid_protocol_mode_value_handle) {
+        instance->hid_protocol_mode = buffer[0];
+        log_info("Set protocol mode: %u", instance->hid_protocol_mode);
+        hids_device_emit_event_with_uint8(HIDS_SUBEVENT_PROTOCOL_MODE, con_handle, instance->hid_protocol_mode);
+    }
+
+    if (att_handle == instance->hid_control_point_value_handle) {
+        if (buffer_size < 1u) {
+            return ATT_ERROR_INVALID_OFFSET;
+        }
+        instance->hid_control_point_suspend = buffer[0];
+        instance->con_handle = con_handle;
+        log_info("Set suspend tp: %u", instance->hid_control_point_suspend);
+        if (instance->hid_control_point_suspend == 0u) {
+            hids_device_emit_event(HIDS_SUBEVENT_SUSPEND, con_handle);
+        } else if (instance->hid_control_point_suspend == 1u) {
+            hids_device_emit_event(HIDS_SUBEVENT_EXIT_SUSPEND, con_handle);
+        }
+    }
+
+    hids_device_report_t * report = hids_device_get_report_for_client_configuration_handle(instance, att_handle);
+    if (report != NULL) {
+        uint16_t new_value = little_endian_read_16(buffer, 0);
+        report->client_configuration_value = new_value;
+        log_info("Enable Report (type %u) notifications: %x", (uint8_t) report->type, new_value);
+
+        switch (report->type) {
+        case HID_REPORT_TYPE_INPUT:
+            hids_device_emit_event_with_uint8_uint8_t(HIDS_SUBEVENT_INPUT_REPORT_ENABLE, con_handle, report->id, (uint8_t) new_value);
+            break;
+        case HID_REPORT_TYPE_OUTPUT:
+            hids_device_emit_event_with_uint8_uint8_t(HIDS_SUBEVENT_OUTPUT_REPORT_ENABLE, con_handle, report->id, (uint8_t) new_value);
+            break;
+        case HID_REPORT_TYPE_FEATURE:
+            hids_device_emit_event_with_uint8_uint8_t(HIDS_SUBEVENT_FEATURE_REPORT_ENABLE, con_handle, report->id, (uint8_t) new_value);
+            break;
+        default:
+            btstack_unreachable();
+            break;
+        }
+    }
+    return 0;
+}
+
+void hids_device_init_with_storage(uint8_t hid_country_code, const uint8_t * hid_descriptor, uint16_t hid_descriptor_size,
+                                   uint16_t num_reports, hids_device_report_t * report_storage) {
+
+    hids_device_t * instance = hids_device_create_instance();
+
+    btstack_assert(num_reports > 0);
+    btstack_assert(report_storage != NULL);
+
+    instance->hid_country_code    = hid_country_code;
+    instance->hid_descriptor      = hid_descriptor;
+    instance->hid_descriptor_size = hid_descriptor_size;
+
+    // default
+    instance->hid_protocol_mode   = 1;
+
+    // get service handle range
+    uint16_t start_handle = 0;
+    uint16_t end_handle   = 0xffff;
+    int service_found = gatt_server_get_handle_range_for_service_with_uuid16(ORG_BLUETOOTH_SERVICE_HUMAN_INTERFACE_DEVICE, &start_handle, &end_handle);
+    btstack_assert(service_found != 0);
+    UNUSED(service_found);
+
+    // get report map handle
+    instance->hid_report_map_handle                               = gatt_server_get_value_handle_for_characteristic_with_uuid16(start_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_REPORT_MAP);
+
+    // get report map handle
+    instance->hid_protocol_mode_value_handle                      = gatt_server_get_value_handle_for_characteristic_with_uuid16(start_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_PROTOCOL_MODE);
+
+    // get value and client configuration handles for boot mouse input, boot keyboard input and report input
+    instance->hid_boot_mouse_input_value_handle                   = gatt_server_get_value_handle_for_characteristic_with_uuid16(start_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_BOOT_MOUSE_INPUT_REPORT);
+    instance->hid_boot_mouse_input_client_configuration_handle    = gatt_server_get_client_configuration_handle_for_characteristic_with_uuid16(start_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_BOOT_MOUSE_INPUT_REPORT);
+
+    instance->hid_boot_keyboard_input_value_handle                = gatt_server_get_value_handle_for_characteristic_with_uuid16(start_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_INPUT_REPORT);
+    instance->hid_boot_keyboard_input_client_configuration_handle = gatt_server_get_client_configuration_handle_for_characteristic_with_uuid16(start_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_INPUT_REPORT);
+
+    instance->hid_control_point_value_handle = gatt_server_get_value_handle_for_characteristic_with_uuid16(start_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_HID_CONTROL_POINT);
+
+    log_info("hid_report_map_handle                               0x%02x", instance->hid_report_map_handle);
+    log_info("hid_protocol_mode_value_handle                      0x%02x", instance->hid_protocol_mode_value_handle);
+    log_info("hid_boot_mouse_input_value_handle                   0x%02x", instance->hid_boot_mouse_input_value_handle);
+    log_info("hid_boot_mouse_input_client_configuration_handle    0x%02x", instance->hid_boot_mouse_input_client_configuration_handle);
+    log_info("hid_boot_keyboard_input_value_handle                0x%02x", instance->hid_boot_keyboard_input_value_handle);
+    log_info("hid_boot_keyboard_input_client_configuration_handle 0x%02x", instance->hid_boot_keyboard_input_client_configuration_handle);
+    log_info("hid_control_point_value_handle                      0x%02x", instance->hid_control_point_value_handle);
+
+    instance->hid_reports = report_storage;
+
+    uint16_t hid_reports_num = num_reports;
+    uint16_t assigned_reports_num = 0;
+    uint16_t start_chr_handle = start_handle;
+
+    while ((start_chr_handle < end_handle) && (assigned_reports_num < hid_reports_num)) {
+        // mandatory
+        uint16_t chr_value_handle = gatt_server_get_value_handle_for_characteristic_with_uuid16(start_chr_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_REPORT);
+        if (chr_value_handle == 0) {
+            break;
+        }
+
+        // optional
+        uint16_t chr_client_configuration_handle = gatt_server_get_client_configuration_handle_for_characteristic_with_uuid16(start_chr_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_REPORT);
+
+        // mandatory
+        uint16_t report_reference_handle = gatt_server_get_descriptor_handle_for_characteristic_with_uuid16(start_chr_handle, end_handle, ORG_BLUETOOTH_CHARACTERISTIC_REPORT, ORG_BLUETOOTH_DESCRIPTOR_REPORT_REFERENCE);
+        if (report_reference_handle == 0) {
+            break;
+        }
+
+        // get report id and type from report reference
+        uint16_t report_reference_value_len;
+        const uint8_t * report_reference_value = gatt_server_get_const_value_for_handle(report_reference_handle, &report_reference_value_len);
+        if (report_reference_value == NULL) {
+            break;
+        }
+        if (report_reference_value_len != 2) {
+            break;
+        }
+        uint8_t report_id = report_reference_value[0];
+        hid_report_type_t report_type = (hid_report_type_t) report_reference_value[1];
+
+        // store report info
+        hids_device_report_t * report = &report_storage[assigned_reports_num];
+        report->value_handle = chr_value_handle;
+        report->client_configuration_handle = chr_client_configuration_handle;
+        report->client_configuration_value = 0;
+        report->id   = report_id;
+        report->type = report_type;
+
+        switch (report->type) {
+        case HID_REPORT_TYPE_INPUT:
+            instance->hid_input_reports_num++;
+            break;
+        case HID_REPORT_TYPE_OUTPUT:
+            instance->hid_output_reports_num++;
+            break;
+        case HID_REPORT_TYPE_FEATURE:
+            instance->hid_feature_reports_num++;
+            break;
+        default:
+            btstack_unreachable();
+            return;
+        }
+        log_info("hid_report_value_handle                       0x%02x, id %u, type %u", report->value_handle, report->id, (uint8_t)report->type);
+        if (report->client_configuration_handle != 0) {
+            log_info("hid_report_client_configuration_handle        0x%02x", report->client_configuration_handle);
+        }
+
+        assigned_reports_num++;
+        start_chr_handle = report_reference_handle + 1;
+    }
+
+    // register service with ATT Server
+    hid_service.start_handle   = start_handle;
+    hid_service.end_handle     = end_handle;
+    hid_service.read_callback  = &att_read_callback;
+    hid_service.write_callback = &att_write_callback;
+    att_server_register_service_handler(&hid_service);
+}
+
+/**
+    @brief Set up HIDS Device
+*/
+void hids_device_init(uint8_t country_code, const uint8_t * descriptor, uint16_t descriptor_size) {
+    uint16_t hid_reports_num = sizeof(hid_reports_generic_storage) / sizeof(hids_device_report_t);
+    hids_device_init_with_storage(country_code, descriptor, descriptor_size, hid_reports_num, hid_reports_generic_storage);
+}
+
+/**
+    @brief Register callback for the HIDS Device client.
+    @param callback
+*/
+void hids_device_register_packet_handler(btstack_packet_handler_t callback) {
+    packet_handler = callback;
+}
+
+/**
+    @brief Request can send now event to send HID Report
+    Generates an HIDS_SUBEVENT_CAN_SEND_NOW subevent
+    @param hid_cid
+*/
+void hids_device_request_can_send_now_event(hci_con_handle_t con_handle) {
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return;
+    }
+
+    instance->battery_callback.callback = &hids_device_can_send_now;
+    instance->battery_callback.context  = (void*)(uintptr_t) con_handle;
+    att_server_register_can_send_now_callback(&instance->battery_callback, con_handle);
+}
+
+uint8_t hids_device_send_input_report_for_id(hci_con_handle_t con_handle, uint16_t report_id, const uint8_t * report, uint16_t report_len) {
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
+    }
+
+    hids_device_report_t * report_storage = hids_device_get_report_for_id_and_type(instance, report_id,
+                                            HID_REPORT_TYPE_INPUT);
+    if (report_storage == NULL) {
+        return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
+    }
+
+    return att_server_notify(con_handle, report_storage->value_handle, report, report_len);
+}
+
+uint8_t hids_device_send_input_report(hci_con_handle_t con_handle, const uint8_t * report, uint16_t report_len) {
+    hids_device_t * device = hids_device_get_instance_for_con_handle(con_handle);
+    if (!device) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
+    }
+
+    uint8_t pos;
+    uint8_t total_reports =  device->hid_input_reports_num + device->hid_output_reports_num + device->hid_feature_reports_num;
+    for (pos = 0 ; pos < total_reports ; pos++) {
+        hids_device_report_t * report_storage = &device->hid_reports[pos];
+        if (report_storage->type == HID_REPORT_TYPE_INPUT) {
+            return att_server_notify(con_handle, report_storage->value_handle, report, report_len);
+        }
+    }
+    return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
+}
+
+/**
+    @brief Send HID Boot Mouse Input Report
+*/
+uint8_t hids_device_send_boot_mouse_input_report(hci_con_handle_t con_handle, const uint8_t * report, uint16_t report_len) {
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
+    }
+    return att_server_notify(con_handle, instance->hid_boot_mouse_input_value_handle, report, report_len);
+}
+
+/**
+    @brief Send HID Boot Mouse Input Report
+*/
+uint8_t hids_device_send_boot_keyboard_input_report(hci_con_handle_t con_handle, const uint8_t * report, uint16_t report_len) {
+    hids_device_t * instance = hids_device_get_instance_for_con_handle(con_handle);
+    if (!instance) {
+        log_error("no instance for handle 0x%02x", con_handle);
+        return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
+    }
+    return att_server_notify(con_handle, instance->hid_boot_keyboard_input_value_handle, report, report_len);
+}
+
+#endif

cores/rp2040/sdkoverride/hids_device.h

@@ -0,0 +1,143 @@
+/*
+    Copyright (C) 2014 BlueKitchen GmbH
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holders nor the names of
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+    4. Any redistribution, use, or modification is done solely for
+      personal benefit and not for any commercial purpose or for
+      monetary gain.
+
+    THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
+    GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+    OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+    AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+    Please inquire about commercial licensing options at
+    contact@bluekitchen-gmbh.com
+
+*/
+
+/**
+    @title HID Service Server
+
+*/
+
+#ifndef HIDS_DEVICE_H
+#define HIDS_DEVICE_H
+
+#if defined ENABLE_CLASSIC
+
+#include <sdkoverride/att_db.h>
+#include <stdint.h>
+#include "btstack_defines.h"
+#include "btstack_hid.h"
+#include "bluetooth.h"
+
+#if defined __cplusplus
+extern "C" {
+#endif
+
+    /* API_START */
+
+    typedef struct {
+        uint16_t value_handle;
+        uint16_t client_configuration_handle;
+        uint16_t client_configuration_value;
+
+        hid_report_type_t type;
+        uint16_t id;
+    } hids_device_report_t;
+
+    /**
+        @text Implementation of the GATT HIDS Device
+        To use with your application, add '#import <hids.gatt>' to your .gatt file
+    */
+
+    /**
+        @brief Set up HIDS Device with single INPUT, OUTPUT and FEATURE report
+    */
+    void hids_device_init(uint8_t hid_country_code, const uint8_t * hid_descriptor, uint16_t hid_descriptor_size);
+
+    /**
+        @brief Set up HIDS Device for multiple instances of INPUT, OUTPUT and FEATURE reports
+    */
+    void hids_device_init_with_storage(uint8_t hid_country_code, const uint8_t * hid_descriptor, uint16_t hid_descriptor_size,
+                                       uint16_t num_reports, hids_device_report_t * report_storage);
+
+    /**
+        @brief Register callback for the HIDS Device client.
+        @param callback
+    */
+    void hids_device_register_packet_handler(btstack_packet_handler_t callback);
+
+    /**
+        @brief Request can send now event to send HID Report
+        Generates an HIDS_SUBEVENT_CAN_SEND_NOW subevent
+        @param hid_cid
+    */
+    void hids_device_request_can_send_now_event(hci_con_handle_t con_handle);
+
+    /**
+        @brief Send HID Input Report for Report ID
+        @param con_handle
+        @param report_id
+        @param report
+        @param report_len
+        @returns status
+    */
+    uint8_t hids_device_send_input_report_for_id(hci_con_handle_t con_handle, uint16_t report_id, const uint8_t * report, uint16_t report_len);
+
+    /**
+        @brief Send HID Input Report for first Input Report
+        @param con_handle
+        @param report
+        @param report_len
+        @returns status
+    */
+    uint8_t hids_device_send_input_report(hci_con_handle_t con_handle, const uint8_t * report, uint16_t report_len);
+
+    /**
+        @brief Send HID Boot Mouse Input Report
+        @param con_handle
+        @param report
+        @param report_len
+        @returns status
+    */
+    uint8_t hids_device_send_boot_mouse_input_report(hci_con_handle_t con_handle, const uint8_t * report, uint16_t report_len);
+
+    /**
+        @brief Send HID Boot Mouse Input Report
+        @param con_handle
+        @param report
+        @param report_len
+        @returns status
+    */
+    uint8_t hids_device_send_boot_keyboard_input_report(hci_con_handle_t con_handle, const uint8_t * report, uint16_t report_len);
+
+    /* API_END */
+
+#if defined __cplusplus
+}
+#endif
+
+#endif
+
+#endif

docs/analog.rst

@@ -40,7 +40,9 @@ Analog Output Restrictions
 --------------------------
 
 The PWM generator source clock restricts the legal combinations of
-frequency and ranges.  For example, at 1MHz only about 6 bits of range
+frequency and ranges.  
+At a CPU frequency of 133MHz, the 16 bit maximum range decreases by 1 bit for every doubling of the default PWM frequency of 1 kHz.  
+For example, at 1MHz only about 6 bits of range
 are possible.  When you define an ``analogWriteFreq`` and ``analogWriteRange``
 that can't be fulfilled by the hardware, the frequency will be preserved
 but the accuracy (range) will be reduced automatically.  Your code will

docs/bearssl-server-secure-class.rst

@@ -13,7 +13,7 @@ Similar to the `BearSSL::WiFiClientSecure` method, sets the receive and transmit
 Setting Server Certificates
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-TLS servers require a certificate identifying itself and containing its public key, and a private key they will use to encrypt information with.  The application author is responsible for generating this certificate and key, either using a self-signed generator or using a commercial certification authority.  **Do not re-use the certificates included in the examples provided.**
+TLS servers require a certificate identifying itself and containing its public key, and a private key they will use to encrypt information with.  The application author is responsible for generating this certificate and key, either using a self-signed generator or using a commercial certification authority.  **Do not reuse the certificates included in the examples provided.**
 
 This example command will generate a RSA 2048-bit key and certificate:
 

docs/bootsel.rst

@@ -0,0 +1,21 @@
+BOOTSEL Button
+==============
+
+The BOOTSEL button on the Pico is not connected to a standard GPIO, so
+it cannot be read using the usual ``digitalRead`` function.  It **can**,
+however, be read using a special (relatively slow) method.
+
+The ``BOOTSEL`` object implements a simple way of reading the BOOTSEL
+button.  Simply use the object ``BOOTSEL`` as a boolean (as a conditional
+in an ``if`` or ``while``, or assigning to a ``bool``):
+
+.. code:: cpp
+
+    // Print "BEEP" if the BOOTSEL button is pressed
+    if (BOOTSEL) {
+        Serial.println("BEEP!");
+        // Wait until BOOTSEL is released
+        while (BOOTSEL) {
+            delay(1);
+        }
+    }

docs/conf.py

@@ -54,9 +54,9 @@ author = u'Earle F. Philhower, III'
 # built documents.
 #
 # The short X.Y version.
-version = u'3.4.1'
+version = u'3.6.1'
 # The full version, including alpha/beta/rc tags.
-release = u'3.4.1'
+release = u'3.6.1'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/ethernet.rst

@@ -0,0 +1,159 @@
+EthernetLWIP (Wired Ethernet) Support
+=====================================
+
+Wired Ethernet interfaces are supported for all the internal networking
+libraries (``WiFiClient``, ``WiFiClientSecure``, ``WiFiServer``,
+``WiFiServerSecure``, ``WiFiUDP``, ``WebServer``, ``Updater``,
+``HTTPClient``, etc.).
+
+Using these wired interfaces is very similar to using the Pico-W WiFi
+so most examples in the core only require minor modifications to use
+a wired interface.
+
+Supported Wired Ethernet Modules
+--------------------------------
+
+* Wiznet W5100(s)
+
+* Wiznet W5500
+
+* ENC28J60
+
+
+Enabling Wired Ethernet
+-----------------------
+
+Simply replace the WiFi include at the top with:
+
+.. code:: cpp
+
+    #include <W5500lwIP.h> // Or W5100lwIP.h or ENC28J60.h
+    
+
+And add a global Ethernet object of the same type:
+
+.. code:: cpp
+
+    Wiznet5500lwIP eth(1); // Parameter is the Chip Select pin
+
+In your ``setup()`` you may adjust the SPI pins you're using to
+match your hardware (be sure they are legal for the RP2040!), or
+skip this if you're using the default ones:
+
+.. code:: cpp
+
+    void setup() {
+        SPI.setRX(0);
+        SPI.setCS(1);
+        SPI.setSCK(2);
+        SPI.setTX(3);
+        ....
+    }
+
+And finally replace the ``WiFi.begin()`` and ``WiFi.connected()``
+calls with ``eth.begin()`` and ``eth.connected()``:
+
+.. code:: cpp
+
+    void setup() {
+        ....
+        // WiFi.begin(SSID, PASS)
+        eth.begin();
+        
+        //while (!WiFi.connected()) {
+        while (!eth.connected()) {
+            Serial.print(".");
+        }
+
+        Serial.print("IP address: ");
+        //Serial.println(WiFi.localIP());
+        Serial.println(eth.localIP());
+
+        ....
+    }
+
+Adjusting LWIP Polling
+----------------------
+
+LWIP operates in a polling mode for the wired Ethernet devices.  By default it will run
+every 20ms, meaning that on average it will take half that time (10ms) before a packet
+received in the Ethernet module is received and operated upon by the Pico.  This gives
+very low CPU utilization but in some cases this latency can affect performance.
+
+Adding a call to ``lwipPollingPeriod(XXX)`` (where ``XXXX`` is the polling period in
+milliseconds) can adjust this setting on the fly.  Note that if you set it too low, the
+Pico may not have enough time to service the Ethernet port before the timer fires again,
+leading to a lock up and hang.
+
+
+Adjusting SPI Speed
+-------------------
+
+By default a 4MHz clock will be used to clock data into and out of the Ethernet module.
+Depending on the module and your wiring, a higher SPI clock may increase performance (but
+too high of a clock will cause communications problems or hangs).
+
+This value may be adjusted using the ``eth.setSPISpeed(hz)`` call **before** starting the
+device.  (You may also use custom ``SPISettings`` instead via ``eth.setSPISettings(spis)```)
+
+For example, to set the W5500 to use a 30MHZ clock:
+
+.. code:: cpp
+
+    #include <W5500lwIP.h>
+    Wiznet5500lwIP eth(1);
+
+    void setup() {
+        eth.setSPISpeed(30000000);
+        lwipPollingPeriod(3);
+        ...
+        eth.begin();
+        ...
+    }
+
+Using the WIZnet W5100S-EVB-Pico
+--------------------------------
+
+You can use the onboard Ethernet chip with these drivers by utilizing the following options:
+
+.. code:: cpp
+
+    #include <W5100lwIP.h>
+    Wiznet5100lwIP eth(17);  // Note chip select is **17**
+
+    void setup() {
+        // Set SPI to the onboard Wiznet chip
+        SPI.setRX(16);
+        SPI.setCS(17);
+        SPI.setSCK(18);
+        SPI.setTX(19);
+        ...
+        eth.begin();
+        ...
+    }
+
+Example Code
+------------
+
+The following examples allow switching between WiFi and Ethernet:
+
+* ``WebServer/AdvancedWebServer``
+
+* ``HTTPClient/BasicHTTPSClient``
+
+Caveats
+-------
+
+The same restrictions for ``WiFi`` apply to these Ethernet classes, namely:
+
+* Only core 0 may run any networking related code.
+
+* In FreeRTOS, only the ``setup`` and ``loop`` task can call networking libraries, not any tasks.
+
+Special Thanks
+--------------
+
+* LWIPEthernet classes come from the ESP8266 Arduino team
+
+* Individual Ethernet drivers were written by Nicholas Humfrey
+

docs/fs.rst

@@ -18,12 +18,12 @@ The following diagram shows the flash layout used in Arduino-Pico:
 
 ::
 
-    |---------------------|-------------|----|
-    ^                     ^             ^
-    Sketch                File system   EEPROM
+    |----|---------------------|-------------|----|
+    ^    ^                     ^             ^
+    OTA  Sketch                File system   EEPROM
 
-The file system size is configurable via the IDE menus, rom 64k up to 15MB
-(assuming you have an RP2040 boad with that much flash)
+The file system size is configurable via the IDE menus, from 64k up to 15MB
+(assuming you have an RP2040 board with that much flash)
 
 **Note:** to use any of file system functions in the sketch, add the
 following include to the sketch:
@@ -38,14 +38,14 @@ following include to the sketch:
 Compatible Filesystem APIs
 --------------------------
 
-LittleFS is an onboard filesystem that sets asidesome program flash for
+LittleFS is an onboard filesystem that sets aside some program flash for
 use as a filesystem without requiring any external hardware.
 
 SDFS is a filesystem for SD cards, based on [SdFat 2.0](https://github.com/earlephilhower/ESP8266SdFat).
 It supports FAT16 and FAT32 formatted cards, and requires an external
 SD card reader.
 
-SD is the Arduino supported, somewhat old and limited SD card filesystem.
+SD is the Arduino-supported, somewhat old and limited SD card filesystem.
 It is recommended to use SDFS for new applications instead of SD.
 
 All three of these filesystems can open and manipulate ``File`` and ``Dir``
@@ -75,22 +75,28 @@ Uploading Files to the LittleFS File System
 menu item to **Tools** menu for uploading the contents of sketch data
 directory into a new LittleFS flash file system.
 
+**IDE 1.x**
+
 -  Download the tool: https://github.com/earlephilhower/arduino-pico-littlefs-plugin/releases
--  In your Arduino sketchbook directory, create ``tools`` directory if
-   it doesn't exist yet.
--  Unpack the tool into ``tools`` directory (the path will look like
-   ``<home_dir>/Arduino/tools/PicoLittleFS/tool/picolittlefs.jar``)
+-  In your Arduino sketchbook directory, create ``tools`` directory if it doesn't exist yet.
+-  Unpack the tool into ``tools`` directory (the path will look like ``<home_dir>/Arduino/tools/PicoLittleFS/tool/picolittlefs.jar``)
    If upgrading, overwrite the existing JAR file with the newer version.
 -  Restart Arduino IDE.
 -  Open a sketch (or create a new one and save it).
 -  Go to sketch directory (choose Sketch > Show Sketch Folder).
--  Create a directory named ``data`` and any files you want in the file
-   system there.
+-  Create a directory named ``data`` and any files you want in the file system there.
 -  Make sure you have selected a board, port, and closed Serial Monitor.
--  Double check theSerial Monitor is closed.  Uploads will fail if the Serial
-   Monitor has control of the serial port.
--  Select ``Tools > Pico LittleFS Data Upload``. This should start
-   uploading the files into the flash file system.
+-  Double check the Serial Monitor is closed.  Uploads will fail if the Serial Monitor has control of the serial port.
+-  Select ``Tools > Pico LittleFS Data Upload``. This should start uploading the files into the flash file system.
+
+**IDE 2.x**
+
+-  Download the new tool: https://github.com/earlephilhower/arduino-littlefs-upload/releases
+-  Exit the IDE, if running
+-  Copy the VSIX file manually to (Linux/Mac) ``~/.arduinoIDE/plugins/`` (you may need to make this directory yourself beforehand) or to (Windows) ``C:\Users\<username>\.arduinoIDE\``
+-  Restart the IDE
+-  Double check the Serial Monitor is closed.  Uploads will fail if the Serial Monitor has control of the serial port.
+-  Enter ``[Ctrl]`` + ``[Shift]`` + ``[P]`` to bring up the command palette, then select/type ``Upload LittleFS to Pico/ESP8266``
 
 SD Library Information
 ----------------------
@@ -131,7 +137,7 @@ before mounting.  All filesystems have their own ``*Config`` (i.e.
 All filesystems allow explicitly enabling/disabling formatting when
 mounts fail.  If you do not call this ``setConfig`` method before
 perforing ``begin()``, you will get the filesystem's default
-behavior and configuration. By default, SPIFFS will autoformat the
+behavior and configuration. By default, LittleFS will autoformat the
 filesystem if it cannot mount it, while SDFS will not.
 
 begin
@@ -144,11 +150,10 @@ begin
 
 This method mounts file system. It must be called before any
 other FS APIs are used. Returns *true* if file system was mounted
-successfully, false otherwise.  With no options it will format SPIFFS
-if it is unable to mount it on the first try.
+successfully, false otherwise.
 
 Note that LittleFS will automatically format the filesystem
-if one is not detected.  This is configurable via ``setConfig``
+if one is not detected.  This is configurable via ``setConfig``.
 
 end
 ~~~
@@ -181,8 +186,8 @@ open
 
 Opens a file. ``path`` should be an absolute path starting with a slash
 (e.g. ``/dir/filename.txt``). ``mode`` is a string specifying access
-mode. It can be one of "r", "w", "a", "r+", "w+", "a+". Meaning of these
-modes is the same as for ``fopen`` C function.
+mode. It can be one of "r", "w", "a", "r+", "w+", "a+". The meaning of these
+modes is the same as for the ``fopen`` C function.
 
 ::
 
@@ -258,8 +263,6 @@ openDir
     or LittleFS.openDir(path)
 
 Opens a directory given its absolute path. Returns a *Dir* object.
-Please note the previous discussion on the difference in behavior between
-LittleFS and SPIFFS for this call.
 
 remove
 ~~~~~~

docs/index.rst

@@ -30,6 +30,7 @@ For the latest version, always check https://github.com/earlephilhower/arduino-p
 
    Analog I/O <analog>
    Digital I/O <digital>
+   BOOTSEL Button <bootsel>
    EEPROM <eeprom>
    I2S Audio <i2s>
    PWM Audio <pwm>
@@ -50,6 +51,7 @@ For the latest version, always check https://github.com/earlephilhower/arduino-p
    FreeRTOS SMP (multicore) <freertos>
 
    WiFi (Pico-W Support) <wifi>
+   Ethernet (Wired) <ethernet>
    WiFiClient <wificlient>
    WiFiServer <wifiserver>
    WiFiUDP <wifiudp>

docs/install.rst

@@ -26,9 +26,7 @@ Arduino IDE Installation Warning
 the actual Arduino application because it has issues detecting attached Pico
 boards.  Use the "Windows ZIP" or plain "Windows" executable (EXE) download
 direct from https://arduino.cc. and allow it to install any device drivers
-it suggests.  Otherwise the Pico board may not be detected.  Also, if trying
-out the 2.0 beta Arduino please install the release 1.8 version beforehand
-to ensure needed device drivers are present.
+it suggests.  Otherwise the Pico board may not be detected.
 
 **Note for Linux Users**: If you installed the Arduino IDE using Flatpak, which 
 is common in Pop!_OS, Fedora, and Mint, among others, you may need to configure 
@@ -141,11 +139,13 @@ Uploading Filesystem Images
 ---------------------------
 The onboard flash filesystem for the Pico, LittleFS, lets you upload a filesystem image from the sketch directory for your sketch to use.  Download the needed plugin from
 
-* https://github.com/earlephilhower/arduino-pico-littlefs-plugin/releases
+* `IDE 1.x`: https://github.com/earlephilhower/arduino-pico-littlefs-plugin/releases
+* `IDE 2.x`: https://github.com/earlephilhower/arduino-littlefs-upload/releases
 
 To install, follow the directions in 
 
-* https://github.com/earlephilhower/arduino-pico-littlefs-plugin/blob/master/README.md 
+* `IDE 1.x`: https://github.com/earlephilhower/arduino-pico-littlefs-plugin/blob/master/README.md
+* `IDE 2.x`: https://github.com/earlephilhower/arduino-littlefs-upload/blob/main/README.md
 
 For detailed usage information, please check the repo documentation available at
 

docs/multicore.rst

@@ -16,6 +16,22 @@ not necessarily simultaneously!).
 See the ``Multicore.ino`` example in the ``rp2040`` example directory for a
 quick introduction.
 
+Stack Sizes
+-----------
+
+When the Pico is running in single core mode, core 0 has the full 8KB of stack
+space available to it.  When using multicore ``setup1``/``loop1`` the 8KB is split
+into two 4K stacks, one per core.  It is possible for core 0's stack to overwrite
+core 1's stack in this case, if you go beyond the 4K limitation.
+
+To allocate a separate 8K stack for core 1, resulting in 8K stacks being available
+for both cores, simply define the following variable in your sketch and set it
+to ``true``:
+
+.. code:: cpp
+
+    bool core1_separate_stack = true;
+
 Pausing Cores
 -------------
 

docs/rp2040.rst

@@ -81,8 +81,8 @@ overhead).
 Hardware Identification
 -----------------------
 
-bool isPicoW()
-~~~~~~~~~~~~~~
+bool rp2040.isPicoW()
+~~~~~~~~~~~~~~~~~~~~~
 Returns the core's best guess if this code is running on a Raspberry Pi Pico W.
 This would let you, possibly, use the same UF2 for Pico and PicoW by simply not
 doing any WiFi calls.

docs/serial.rst

@@ -55,3 +55,13 @@ void Serial.ignoreFlowControl(bool ignore)
 In some cases, the target application will not assert the DTR virtual line, thus preventing writing operations to succeed.
 
 For this reason, the SerialUSB::ignoreFlowControl() method disables the connection's state verification, enabling the program to write on the port, even though the data might be lost.
+
+bool Serial.dtr()
+~~~~~~~~~~~~~~~~~
+
+Returns the current state of the DTR virtual line. A USB CDC host (such as the Arduino serial monitor) typically raises the DTR pin when opening the device, and may lower it when closing the device.
+
+bool Serial.rts()
+~~~~~~~~~~~~~~~~~
+
+Returns the current state of the RTS virtual line.

docs/spi.rst

@@ -1,5 +1,5 @@
-SPI (Serial Peripheral Interface)
-=================================
+SPI Master (Serial Peripheral Interface)
+========================================
 
 The RP2040 has two hardware SPI interfaces, ``spi0 (SPI)`` and ``spi1 (SPI1)``.
 These interfaces are supported by the ``SPI`` library in master mode.
@@ -20,5 +20,26 @@ The Arduino `SPI documentation <https://www.arduino.cc/en/reference/SPI>`_ gives
 a detailed overview of the library, except for the following RP2040-specific
 changes:
 
-* ``SPI.begin(bool hwCS)`` can take an options ``hwCS`` parameter.  By passing in ``true`` for ``hwCS`` the sketch does not need to worry about asserting and deasserting the ``CS`` pin between transactions.  The default is ``false`` and requires the sketch to handle the CS pin itself, as is the standard way in Arduino.
-* The interrupt calls (``usingInterrupt``, ``notUsingInterrupt``, ``attachInterrupt``, and ``detachInterrpt``) are not implemented.
+* ``SPI.begin(bool hwCS)`` can take an options ``hwCS`` parameter.
+By passing in ``true`` for ``hwCS`` the sketch does not need to worry
+about asserting and deasserting the ``CS`` pin between transactions.
+The default is ``false`` and requires the sketch to handle the CS
+pin itself, as is the standard way in Arduino.
+
+* The interrupt calls (``attachInterrupt``, and ``detachInterrpt``) are not implemented.
+
+
+SPI Slave (SPISlave)
+====================
+
+Slave mode operation is also supported on either SPI interface.  Two callbacks are
+needed in your app, set through ``SPISlave.onDataRecv`` and ``SPISlave.onDataSent``,
+in order to consunme the received data and provide data to transmit.
+
+* The callbacks operate at IRQ time and may be called very frequently at high SPI frequencies.  So, make then small, fast, and with no memory allocations or locking.
+
+
+Examples
+~~~~~~~~
+
+See the SPItoMyself example for a complete Master and Slave application.

docs/usb.rst

@@ -14,13 +14,28 @@ from the IDE.
 The Arduino-Pico core includes ported versions of the basic Arduino
 ``Keyboard``, ``Mouse`` and ``Joystick`` libraries.  These libraries 
 allow you to emulate a keyboard, a gamepad or mouse (or all together) 
-with the Pico in your sketches.
+with the Pico in your sketches.  These libraries only are available
+when using the built-in USB, not the Adafruit library.
 
 See the examples and Arduino Reference at
 https://www.arduino.cc/reference/en/language/functions/usb/keyboard/
 and
 https://www.arduino.cc/reference/en/language/functions/usb/mouse
 
+HID Polling Interval
+--------------------
+By default, HID devices will request to be polled every 10ms (i.e. 100x
+per second).  If you have a higher performance need, you can override
+this value by creating a global variable in your main application, set
+to the polling period:
+
+.. code::  cpp
+
+    int usb_hid_poll_interval = 1; // Set HID poll interval to 1ms (1kHz)
+    void setup() {
+        ....
+    }
+
 Adafruit TinyUSB Arduino Support
 --------------------------------
 Examples are provided in the Adafruit_TinyUSB_Arduino for the more

docs/wifi.rst

@@ -40,9 +40,9 @@ Please note that WiFi on the Pico W is a work-in-progress and there are some imp
 
   * Combined STA/AP mode is not supported
 
-* Multicore is supported, but only one core may run ``WiFi`` code.
+* Multicore is supported, but only core 0 may run ``WiFi`` related code.
 
-  * FreeRTOS is not yet supported due to the requirement for a very different LWIP implementation.  PRs always appreciated!
+  * FreeRTOS is supported only on core 0 and from within ``setup`` and ``loop`, not tasks, due to the requirement for a very different LWIP implementation.  PRs always appreciated!
 
 The WiFi library borrows much work from the `ESP8266 Arduino Core <https://github.com/esp8266/Arduino>`__ , especially the ``WiFiClient`` and ``WiFiServer`` classes.
 

docs/wifintp.rst

@@ -5,7 +5,7 @@ NTP allows the Pico to set its internal clock using the internet, and is
 required for secure connections because the certificates used have valid
 date stamps.
 
-After ``WiFi.begin()`` use ``NTP.begin(s1)`` or ``NTP,begin(s1, s2)``  to
+After ``WiFi.begin()`` use ``NTP.begin(s1)`` or ``NTP.begin(s1, s2)``  to
 use one or two NTP servers (common ones are ``pool.ntp.org`` and
 ``time.nist.gov``) .
 

include/btstack_config.h

@@ -2,6 +2,7 @@
 
 // BTstack features that can be enabled
 #define ENABLE_LOG_INFO
+#define ENABLE_LOG_DEBUG
 #define ENABLE_LOG_ERROR
 #define ENABLE_PRINTF_HEXDUMP
 #define ENABLE_SCO_OVER_HCI

lib/platform_wrap.txt

@@ -152,6 +152,8 @@
 -Wl,--wrap=realloc
 -Wl,--wrap=free
 
+-Wl,--wrap=lwip_init
+
 -Wl,--wrap=pbuf_header
 -Wl,--wrap=pbuf_free
 -Wl,--wrap=pbuf_alloc

libraries/EEPROM/src/EEPROM.cpp

@@ -124,6 +124,7 @@ bool EEPROMClass::commit() {
     flash_range_program((intptr_t)_sector - (intptr_t)XIP_BASE, _data, _size);
     rp2040.resumeOtherCore();
     interrupts();
+    _dirty = false;
 
     return true;
 }

libraries/HID_Bluetooth/src/HID_Bluetooth.cpp

@@ -0,0 +1,224 @@
+#include "HID_Bluetooth.h"
+
+//setup the report map.
+//more generic function to be used with BLE & BT Classis
+void __SetupHIDreportmap(void (*WeakMouse)(), void (*WeakKeyboard)(), void (*WeakJoystick)(), bool absMouse, uint16_t *report_size, uint8_t **reportmap) {
+    //allocate memory for the HID report descriptors. We don't use them, but need the size here.
+    uint8_t desc_hid_report_mouse[] = { TUD_HID_REPORT_DESC_MOUSE(HID_REPORT_ID(1)) };
+    uint8_t desc_hid_report_absmouse[] = { TUD_HID_REPORT_DESC_ABSMOUSE(HID_REPORT_ID(1)) };
+    uint8_t desc_hid_report_joystick[] = { TUD_HID_REPORT_DESC_GAMEPAD(HID_REPORT_ID(1)) };
+    uint8_t desc_hid_report_keyboard[] = { TUD_HID_REPORT_DESC_KEYBOARD(HID_REPORT_ID(1)), TUD_HID_REPORT_DESC_CONSUMER(HID_REPORT_ID(2)) };
+    int size = 0;
+
+    //enable to debug the individual report maps
+#if 0
+    Serial.printf("Report mouse: %d bytes\n", sizeof(desc_hid_report_mouse));
+    for (uint16_t i = 0; i < sizeof(desc_hid_report_mouse); i++) {
+        Serial.print(desc_hid_report_mouse[i], HEX);
+        Serial.print(" ");
+        if (i % 4 == 3) {
+            Serial.print("\n");
+        }
+    }
+    Serial.printf("Report absmouse: %d bytes\n", sizeof(desc_hid_report_absmouse));
+    for (uint16_t i = 0; i < sizeof(desc_hid_report_absmouse); i++) {
+        Serial.print(desc_hid_report_absmouse[i], HEX);
+        Serial.print(" ");
+        if (i % 4 == 3) {
+            Serial.print("\n");
+        }
+    }
+    Serial.printf("Report kbd: %d bytes\n", sizeof(desc_hid_report_keyboard));
+    for (uint16_t i = 0; i < sizeof(desc_hid_report_keyboard); i++) {
+        Serial.print(desc_hid_report_keyboard[i], HEX);
+        Serial.print(" ");
+        if (i % 4 == 3) {
+            Serial.print("\n");
+        }
+    }
+    Serial.printf("Report joystick: %d bytes\n", sizeof(desc_hid_report_joystick));
+    for (uint16_t i = 0; i < sizeof(desc_hid_report_joystick); i++) {
+        Serial.print(desc_hid_report_joystick[i], HEX);
+        Serial.print(" ");
+        if (i % 4 == 3) {
+            Serial.print("\n");
+        }
+    }
+#endif
+
+    //accumulate the size of all used HID report descriptors
+    if (WeakKeyboard) {
+        size += sizeof(desc_hid_report_keyboard);
+    }
+    if (WeakMouse && absMouse == false) {
+        size += sizeof(desc_hid_report_mouse);
+    } else if (WeakMouse && absMouse == true) {
+        size += sizeof(desc_hid_report_absmouse);
+    }
+    if (WeakJoystick) {
+        size += sizeof(desc_hid_report_joystick);
+    }
+
+    //no HID used at all
+    if (size == 0) {
+        *report_size = 0;
+        return;
+    }
+
+    //allocate the "real" HID report descriptor
+    *reportmap = (uint8_t *)malloc(size);
+    if (*reportmap) {
+        *report_size = size;
+
+        //now copy the descriptors
+
+        //1.) keyboard descriptor, if requested
+        if (WeakKeyboard) {
+            memcpy(*reportmap, desc_hid_report_keyboard, sizeof(desc_hid_report_keyboard));
+        }
+
+        //2.) mouse descriptor, if necessary. Additional offset & new array is necessary if there is a keyboard.
+        if (WeakMouse && absMouse == false) {
+            //determine if we need an offset (USB keyboard is installed)
+            if (WeakKeyboard) {
+                uint8_t desc_local[] = { TUD_HID_REPORT_DESC_MOUSE(HID_REPORT_ID(3)) };
+                memcpy(*reportmap + sizeof(desc_hid_report_keyboard), desc_local, sizeof(desc_local));
+            } else {
+                memcpy(*reportmap, desc_hid_report_mouse, sizeof(desc_hid_report_mouse));
+            }
+        } else if (WeakMouse && absMouse == true) {
+            //determine if we need an offset (USB keyboard is installed)
+            if (WeakKeyboard) {
+                uint8_t desc_local[] = { TUD_HID_REPORT_DESC_ABSMOUSE(HID_REPORT_ID(3)) };
+                memcpy(*reportmap + sizeof(desc_hid_report_keyboard), desc_local, sizeof(desc_local));
+            } else {
+                memcpy(*reportmap, desc_hid_report_absmouse, sizeof(desc_hid_report_absmouse));
+            }
+        }
+
+        //3.) joystick descriptor. 2 additional checks are necessary for mouse and/or keyboard
+        if (WeakJoystick) {
+            uint8_t reportid = 1;
+            int offset = 0;
+            if (WeakKeyboard) {
+                reportid += 2;
+                offset += sizeof(desc_hid_report_keyboard);
+            }
+            if (WeakMouse && absMouse == false) {
+                reportid++;
+                offset += sizeof(desc_hid_report_mouse);
+            } else if (WeakMouse && absMouse == true) {
+                reportid++;
+                offset += sizeof(desc_hid_report_absmouse);
+            }
+            uint8_t desc_local[] = { TUD_HID_REPORT_DESC_GAMEPAD(HID_REPORT_ID(reportid)) };
+            memcpy(*reportmap + offset, desc_local, sizeof(desc_local));
+        }
+
+        //enable for debugging the final report map
+#if 0
+        Serial.begin(115200);
+        Serial.printf("Final map: %d bytes\n", size);
+        for (uint16_t i = 0; i < size; i++) {
+            Serial.print(*reportmap[i], HEX);
+            Serial.print(" ");
+            if (i % 4 == 3) {
+                Serial.print("\n");
+            }
+        }
+#endif
+    } else {
+        Serial.println("No report map pointer provided!");
+    }
+}
+
+
+//get Class of Device number for starting HID, type depends on activated libraries
+uint16_t __BTGetCOD() {
+    //mouse only
+    if (__BTInstallMouse && !__BTInstallKeyboard && !__BTInstallJoystick) {
+        return 0x2580;
+    }
+    //keyboard only
+    if (__BTInstallKeyboard && !__BTInstallMouse && !__BTInstallJoystick) {
+        return 0x2540;
+    }
+    //joystick only
+    if (__BTInstallJoystick && !__BTInstallKeyboard && !__BTInstallMouse) {
+        return 0x2508;
+    }
+    //any other combination will return "combo device"
+    return 0x25C0;
+}
+
+//get Class of Device number for starting HID, type depends on activated libraries
+uint16_t __BLEGetAppearance() {
+    //mouse only
+    if (__BLEInstallMouse && !__BLEInstallKeyboard && !__BLEInstallJoystick) {
+        return 0x03C2;
+    }
+    //keyboard only
+    if (__BLEInstallKeyboard && !__BLEInstallMouse && !__BLEInstallJoystick) {
+        return 0x03C1;
+    }
+    //joystick only
+    if (__BLEInstallJoystick && !__BLEInstallMouse && !__BLEInstallKeyboard) {
+        return 0x03C4;
+    }
+    //any other combination will return "generic HID"
+    return 0x03C0;
+}
+
+//keyboard report id is always 1 (compatibility with iOS)
+int __BTGetKeyboardReportID() {
+    return 1;
+}
+
+//
+int __BTGetMouseReportID() {
+    return __BTInstallKeyboard ? 3 : 1;
+}
+
+int __BTGetJoystickReportID() {
+    int i = 1;
+    if (__BTInstallKeyboard) {
+        i += 2;
+    }
+    if (__BTInstallMouse) {
+        i++;
+    }
+    return i;
+}
+
+int __BLEGetKeyboardReportID() {
+    return 1;
+}
+
+int __BLEGetMouseReportID() {
+    return __BLEInstallKeyboard ? 3 : 1;
+}
+
+int __BLEGetFeatureReportID() {
+    int feature = 1;
+    if (__BLEInstallKeyboard) {
+        feature += 2;
+    }
+    if (__BLEInstallMouse) {
+        feature ++;
+    }
+    if (__BLEInstallJoystick) {
+        feature ++;
+    }
+    return feature;
+}
+
+int __BLEGetJoystickReportID() {
+    int i = 1;
+    if (__BLEInstallKeyboard) {
+        i += 2;
+    }
+    if (__BLEInstallMouse) {
+        i++;
+    }
+    return i;
+}

libraries/HID_Bluetooth/src/HID_Bluetooth.h

@@ -5,3 +5,39 @@
 #ifdef ENABLE_BLE
 #include "PicoBluetoothBLEHID.h"
 #endif
+
+#pragma once
+
+//necessary to implement the absolute mouse descriptor define,
+//remove if merged into TinyUSB
+#include <sdkoverride/tusb_absmouse.h>
+
+
+//override weak declarations to include HID report to report map.
+//done in each library (KeyboardBT,...)
+extern void __BTInstallKeyboard() __attribute__((weak));
+extern void __BTInstallJoystick() __attribute__((weak));
+extern void __BTInstallMouse() __attribute__((weak));
+
+//override weak declarations to include HID report to report map.
+//done in each library (KeyboardBLE,...)
+extern void __BLEInstallKeyboard() __attribute__((weak));
+extern void __BLEInstallJoystick() __attribute__((weak));
+extern void __BLEInstallMouse() __attribute__((weak));
+
+//setup the report map.
+//more generic function to be used with BLE & BT Classis
+void __SetupHIDreportmap(void (*WeakMouse)(), void (*WeakKeyboard)(), void (*WeakJoystick)(), bool absMouse, uint16_t *report_size, uint8_t **reportmap);
+
+//get Class of Device number for starting HID, type depends on activated libraries
+uint16_t __BTGetCOD();
+//get Class of Device number for starting HID, type depends on activated libraries
+uint16_t __BLEGetAppearance();
+int __BTGetKeyboardReportID();
+int __BTGetMouseReportID();
+int __BTGetJoystickReportID();
+
+int __BLEGetKeyboardReportID();
+int __BLEGetMouseReportID();
+int __BLEGetJoystickReportID();
+int __BLEGetFeatureReportID();

libraries/HID_Bluetooth/src/PicoBluetoothBLEHID.h

@@ -21,17 +21,22 @@
 
 #pragma once
 
+#include <sdkoverride/bluetooth.h>
 #include <_needsbt.h>
 #include <Arduino.h>
 #include <functional>
 #include <pico/cyw43_arch.h>
 #include <class/hid/hid_device.h>
 
+#include "HID_Bluetooth.h"
+
 // The BTStack has redefinitions of this USB enum (same values, just redefined), so hide it to allow easy compilation
 #define HID_REPORT_TYPE_INPUT HID_REPORT_TYPE_INPUT_BT
 #define HID_REPORT_TYPE_OUTPUT HID_REPORT_TYPE_OUTPUT_BT
 #define HID_REPORT_TYPE_FEATURE HID_REPORT_TYPE_FEATURE_BT
 #define hid_report_type_t hid_report_type_t_bt
+#include <sdkoverride/hids_device.h>
+#include <sdkoverride/att_db.h>
 #include <btstack.h>
 #undef hid_report_type_t
 #undef HID_REPORT_TYPE_FEATURE
@@ -43,7 +48,9 @@
 #include <btstack_event.h>
 #include <ble/gatt-service/battery_service_server.h>
 #include <ble/gatt-service/device_information_service_server.h>
-#include <ble/gatt-service/hids_device.h>
+//#include <ble/gatt-service/hids_device.h>
+
+
 
 class PicoBluetoothBLEHID_;
 extern PicoBluetoothBLEHID_ PicoBluetoothBLEHID;
@@ -100,8 +107,20 @@ public:
         // Setup device information service
         device_information_service_server_init();
 
-        // Setup HID Device service
-        hids_device_init(0, hidDescriptor, hidDescriptorSize);
+        // Setup HID Device service, depending on activated reports
+        uint8_t numreports = 1; //start with 1 (feature report)
+        if (__BLEInstallKeyboard) {
+            numreports += 2; //add keycodes + consumer keys
+        }
+        if (__BLEInstallMouse) {
+            numreports += 1;
+        }
+        if (__BLEInstallJoystick) {
+            numreports += 1;
+        }
+        //allocate memory for hid reports
+        _reportStorage = (hids_device_report_t *) malloc(sizeof(hids_device_report_t) * numreports);
+        hids_device_init_with_storage(0, hidDescriptor, hidDescriptorSize, numreports, _reportStorage);
 
         // Setup advertisements
         uint16_t adv_int_min = 0x0030;
@@ -134,6 +153,9 @@ public:
     }
 
     void packetHandler(uint8_t type, uint16_t channel, uint8_t *packet, uint16_t size) {
+        uint8_t result;
+        uint8_t reportID;
+
         if (type != HCI_EVENT_PACKET) {
             return;
         }
@@ -174,10 +196,32 @@ public:
             case HIDS_SUBEVENT_CAN_SEND_NOW:
                 switch (_protocol_mode) {
                 case 0:
-                    hids_device_send_boot_keyboard_input_report(_con_handle, (const uint8_t *)_sendReport, _sendReportLen);
+                    //We cannot distinguish between kbd & mouse in boot mode.
+                    //If both are activated, we cannot send
+                    if (__BLEInstallKeyboard && !__BLEInstallMouse) {
+                        hids_device_send_boot_keyboard_input_report(_con_handle, &(((const uint8_t *)_sendReport)[1]), _sendReportLen);
+                    }
+                    if (__BLEInstallMouse && !__BLEInstallKeyboard) {
+                        hids_device_send_boot_mouse_input_report(_con_handle, &(((const uint8_t *)_sendReport)[1]), _sendReportLen);
+                    }
+                    if (__BLEInstallMouse && __BLEInstallJoystick) {
+                        printf("Error: BLE HID in boot mode, but mouse & keyboard are active\n");
+                    }
                     break;
                 case 1:
-                    hids_device_send_input_report(_con_handle, (const uint8_t *)_sendReport, _sendReportLen);
+                    reportID = ((const uint8_t *)_sendReport)[0];
+                    result = hids_device_send_input_report_for_id(_con_handle, (uint16_t)reportID, &(((const uint8_t *)_sendReport)[1]), _sendReportLen - 1);
+                    if (result) {
+                        Serial.printf("Error sending %d - report ID: %d\n", result, reportID);
+                    }
+                    //else Serial.printf("Sent report for ID: %d\n",reportID);
+#if 0
+                    Serial.printf("Sending report for ID %d, len: %d:\n", reportID, _sendReportLen);
+                    for (uint8_t i = 0; i < _sendReportLen; i++) {
+                        Serial.printf("0x%02X - ", ((const uint8_t *)_sendReport)[i]);
+                    }
+                    Serial.println("");
+#endif
                     break;
                 default:
                     break;
@@ -208,6 +252,10 @@ public:
     }
 
     bool send(void *rpt, int len) {
+        // Wait for another report to be sent
+        while (connected() && _needToSend) {
+            /* noop busy wait */
+        }
         _needToSend = true;
         _sendReport = rpt;
         _sendReportLen = len;
@@ -236,6 +284,9 @@ public:
         async_context_release_lock(cyw43_arch_async_context());
     }
 
+    uint8_t *_attdb = nullptr;
+    int _attdbLen = 0;
+
 private:
     bool _running = false;
 
@@ -280,10 +331,17 @@ private:
     }
     uint8_t *_advData = nullptr;
     uint8_t _advDataLen = 0;
+    hids_device_report_t *_reportStorage = nullptr;
 
     void _buildAttdb(const char *hidName) {
         free(_attdb);
-        _attdbLen = sizeof(_attdb_head) + 8 + strlen(hidName) + sizeof(_attdb_tail);
+        //add up all different parts of ATT DB
+        _attdbLen = sizeof(_attdb_head) + 8 + strlen(hidName) + sizeof(_attdb_tail) + sizeof(_attdb_batt_hidhead) + sizeof(_attdb_char);
+        //reports
+        _attdbLen += sizeof(_attdb_kbd_report) + sizeof(_attdb_mouse_report) + sizeof(_attdb_joystick_report);
+        //additional boot characteristics
+        _attdbLen += sizeof(_attdb_kbd_boot) + sizeof(_attdb_mouse_boot);
+
         _attdb = (uint8_t *) malloc(_attdbLen);
         memcpy(_attdb, _attdb_head, sizeof(_attdb_head));
         // 0x0003 VALUE CHARACTERISTIC-GAP_DEVICE_NAME - READ -'HID Mouse'
@@ -300,10 +358,35 @@ private:
         _attdb[i++] = 0x2a;
         memcpy(_attdb + i, hidName, strlen(hidName));
         i += strlen(hidName);
+
+        memcpy(_attdb + i, _attdb_batt_hidhead, sizeof(_attdb_batt_hidhead));
+        i += sizeof(_attdb_batt_hidhead);
+
+        //1.) KBD report mode
+        memcpy(_attdb + i, _attdb_kbd_report, sizeof(_attdb_kbd_report));
+        i += sizeof(_attdb_kbd_report);
+
+        //2.) mouse report mode
+        memcpy(_attdb + i, _attdb_mouse_report, sizeof(_attdb_mouse_report));
+        i += sizeof(_attdb_mouse_report);
+
+        //3.) joystick report mode
+        memcpy(_attdb + i, _attdb_joystick_report, sizeof(_attdb_joystick_report));
+        i += sizeof(_attdb_joystick_report);
+        //4.) report characteristics
+        memcpy(_attdb + i, _attdb_char, sizeof(_attdb_char));
+        i += sizeof(_attdb_char);
+
+        //5.) KBD boot mode (always included)
+        memcpy(_attdb + i, _attdb_kbd_boot, sizeof(_attdb_kbd_boot));
+        i += sizeof(_attdb_kbd_boot);
+
+        //6.) mouse boot mode (always included)
+        memcpy(_attdb + i, _attdb_mouse_boot, sizeof(_attdb_mouse_boot));
+        i += sizeof(_attdb_mouse_boot);
+        //7.) tail (report)
         memcpy(_attdb + i, _attdb_tail, sizeof(_attdb_tail));
     }
-    uint8_t *_attdb = nullptr;
-    int _attdbLen = 0;
 
     static constexpr const uint8_t _attdb_head[] = {
         // ATT DB Version
@@ -315,7 +398,7 @@ private:
         0x0d, 0x00, 0x02, 0x00, 0x02, 0x00, 0x03, 0x28, 0x02, 0x03, 0x00, 0x00, 0x2a,
     };
 
-    static constexpr const uint8_t _attdb_tail[] =  {
+    static constexpr const uint8_t _attdb_batt_hidhead[] = {
         // #import <battery_service.gatt> -- BEGIN
         // Specification Type org.bluetooth.service.battery_service
         // https://www.bluetooth.com/api/gatt/xmlfile?xmlFileName=org.bluetooth.service.battery_service.xml
@@ -333,6 +416,7 @@ private:
         // #import <battery_service.gatt> -- END
         // add Device ID Service
 
+
         // #import <device_information_service.gatt> -- BEGIN
         // Specification Type org.bluetooth.service.device_information
         // https://www.bluetooth.com/api/gatt/xmlfile?xmlFileName=org.bluetooth.service.device_information.xml
@@ -386,7 +470,6 @@ private:
         0x08, 0x00, 0x02, 0x01, 0x1a, 0x00, 0x50, 0x2a,
         // #import <device_information_service.gatt> -- END
 
-        // #import <hids.gatt> -- BEGIN
         // Specification Type org.bluetooth.service.human_interface_device
         // https://www.bluetooth.com/api/gatt/xmlfile?xmlFileName=org.bluetooth.service.human_interface_device.xml
         // Human Interface Device 1812
@@ -397,6 +480,9 @@ private:
         // 0x001d VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_PROTOCOL_MODE - DYNAMIC | READ | WRITE_WITHOUT_RESPONSE
         // READ_ANYBODY, WRITE_ANYBODY
         0x08, 0x00, 0x06, 0x01, 0x1d, 0x00, 0x4e, 0x2a,
+    };
+
+    static constexpr const uint8_t _attdb_kbd_report[] =  {
         // 0x001e CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | NOTIFY | ENCRYPTION_KEY_SIZE_16
         0x0d, 0x00, 0x02, 0x00, 0x1e, 0x00, 0x03, 0x28, 0x1a, 0x1f, 0x00, 0x4d, 0x2a,
         // 0x001f VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | NOTIFY | ENCRYPTION_KEY_SIZE_16
@@ -405,9 +491,10 @@ private:
         // 0x0020 CLIENT_CHARACTERISTIC_CONFIGURATION
         // READ_ANYBODY, WRITE_ENCRYPTED, ENCRYPTION_KEY_SIZE=16
         0x0a, 0x00, 0x0f, 0xf1, 0x20, 0x00, 0x02, 0x29, 0x00, 0x00,
-        // fixed report id = 1, type = Input (1)
+        // fixed report id = 1, type = Input (1); keycodes
         // 0x0021 REPORT_REFERENCE-READ-1-1
         0x0a, 0x00, 0x02, 0x00, 0x21, 0x00, 0x08, 0x29, 0x1, 0x1,
+
         // 0x0022 CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | NOTIFY | ENCRYPTION_KEY_SIZE_16
         0x0d, 0x00, 0x02, 0x00, 0x22, 0x00, 0x03, 0x28, 0x1a, 0x23, 0x00, 0x4d, 0x2a,
         // 0x0023 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | NOTIFY | ENCRYPTION_KEY_SIZE_16
@@ -416,9 +503,12 @@ private:
         // 0x0024 CLIENT_CHARACTERISTIC_CONFIGURATION
         // READ_ANYBODY, WRITE_ENCRYPTED, ENCRYPTION_KEY_SIZE=16
         0x0a, 0x00, 0x0f, 0xf1, 0x24, 0x00, 0x02, 0x29, 0x00, 0x00,
-        // fixed report id = 2, type = Output (2)
-        // 0x0025 REPORT_REFERENCE-READ-2-2
-        0x0a, 0x00, 0x02, 0x00, 0x25, 0x00, 0x08, 0x29, 0x2, 0x2,
+        // fixed report id = 2, type = Input (1) consumer
+        // 0x0025 REPORT_REFERENCE-READ-2-1
+        0x0a, 0x00, 0x02, 0x00, 0x25, 0x00, 0x08, 0x29, 0x2, 0x1,
+    };
+
+    static constexpr const uint8_t _attdb_mouse_report[] =  {
         // 0x0026 CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | NOTIFY | ENCRYPTION_KEY_SIZE_16
         0x0d, 0x00, 0x02, 0x00, 0x26, 0x00, 0x03, 0x28, 0x1a, 0x27, 0x00, 0x4d, 0x2a,
         // 0x0027 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | NOTIFY | ENCRYPTION_KEY_SIZE_16
@@ -427,59 +517,88 @@ private:
         // 0x0028 CLIENT_CHARACTERISTIC_CONFIGURATION
         // READ_ANYBODY, WRITE_ENCRYPTED, ENCRYPTION_KEY_SIZE=16
         0x0a, 0x00, 0x0f, 0xf1, 0x28, 0x00, 0x02, 0x29, 0x00, 0x00,
-        // fixed report id = 3, type = Feature (3)
-        // 0x0029 REPORT_REFERENCE-READ-3-3
-        0x0a, 0x00, 0x02, 0x00, 0x29, 0x00, 0x08, 0x29, 0x3, 0x3,
-        // 0x002a CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT_MAP - DYNAMIC | READ
-        0x0d, 0x00, 0x02, 0x00, 0x2a, 0x00, 0x03, 0x28, 0x02, 0x2b, 0x00, 0x4b, 0x2a,
-        // 0x002b VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT_MAP - DYNAMIC | READ
+        // fixed report id = 3, type = Input (1) mouse
+        // 0x0029 REPORT_REFERENCE-READ-3-1
+        0x0a, 0x00, 0x02, 0x00, 0x29, 0x00, 0x08, 0x29, 0x3, 0x1,
+    };
+    static constexpr const uint8_t _attdb_joystick_report[] =  {
+
+        // 0x002a CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | NOTIFY | ENCRYPTION_KEY_SIZE_16
+        0x0d, 0x00, 0x02, 0x00, 0x2a, 0x00, 0x03, 0x28, 0x1a, 0x2b, 0x00, 0x4d, 0x2a,
+        // 0x002b VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | NOTIFY | ENCRYPTION_KEY_SIZE_16
+        // READ_ENCRYPTED, WRITE_ENCRYPTED, ENCRYPTION_KEY_SIZE=16
+        0x08, 0x00, 0x0b, 0xf5, 0x2b, 0x00, 0x4d, 0x2a,
+        // 0x002c CLIENT_CHARACTERISTIC_CONFIGURATION
+        // READ_ANYBODY, WRITE_ENCRYPTED, ENCRYPTION_KEY_SIZE=16
+        0x0a, 0x00, 0x0f, 0xf1, 0x2c, 0x00, 0x02, 0x29, 0x00, 0x00,
+        // fixed report id = 4, type = Input (1) gamepad
+        // 0x002d REPORT_REFERENCE-READ-4-1
+        0x0a, 0x00, 0x02, 0x00, 0x2d, 0x00, 0x08, 0x29, 0x4, 0x1,
+    };
+
+    static constexpr const uint8_t _attdb_char[] =  {
+        // 0x002e CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | ENCRYPTION_KEY_SIZE_16
+        0x0d, 0x00, 0x02, 0x00, 0x2e, 0x00, 0x03, 0x28, 0x0a, 0x2f, 0x00, 0x4d, 0x2a,
+        // 0x002f VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT - DYNAMIC | READ | WRITE | ENCRYPTION_KEY_SIZE_16
+        // READ_ENCRYPTED, WRITE_ENCRYPTED, ENCRYPTION_KEY_SIZE=16
+        0x08, 0x00, 0x0b, 0xf5, 0x2f, 0x00, 0x4d, 0x2a,
+        // fixed report id = 5, type = Feature (3)
+        // 0x0030 REPORT_REFERENCE-READ-5-3
+        0x0a, 0x00, 0x02, 0x00, 0x30, 0x00, 0x08, 0x29, 0x5, 0x3,
+        // 0x0031 CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT_MAP - DYNAMIC | READ
+        0x0d, 0x00, 0x02, 0x00, 0x31, 0x00, 0x03, 0x28, 0x02, 0x32, 0x00, 0x4b, 0x2a,
+        // 0x0032 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_REPORT_MAP - DYNAMIC | READ
         // READ_ANYBODY
-        0x08, 0x00, 0x02, 0x01, 0x2b, 0x00, 0x4b, 0x2a,
-        // 0x002c CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_INPUT_REPORT - DYNAMIC | READ | WRITE | NOTIFY
-        0x0d, 0x00, 0x02, 0x00, 0x2c, 0x00, 0x03, 0x28, 0x1a, 0x2d, 0x00, 0x22, 0x2a,
-        // 0x002d VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_INPUT_REPORT - DYNAMIC | READ | WRITE | NOTIFY
+        0x08, 0x00, 0x02, 0x01, 0x32, 0x00, 0x4b, 0x2a,
+    };
+
+    static constexpr const uint8_t _attdb_kbd_boot[] =  {
+        // 0x0033 CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_INPUT_REPORT - DYNAMIC | READ | WRITE | NOTIFY
+        0x0d, 0x00, 0x02, 0x00, 0x33, 0x00, 0x03, 0x28, 0x1a, 0x34, 0x00, 0x22, 0x2a,
+        // 0x0034 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_INPUT_REPORT - DYNAMIC | READ | WRITE | NOTIFY
         // READ_ANYBODY, WRITE_ANYBODY
-        0x08, 0x00, 0x0a, 0x01, 0x2d, 0x00, 0x22, 0x2a,
-        // 0x002e CLIENT_CHARACTERISTIC_CONFIGURATION
+        0x08, 0x00, 0x0a, 0x01, 0x34, 0x00, 0x22, 0x2a,
+        // 0x0035 CLIENT_CHARACTERISTIC_CONFIGURATION
         // READ_ANYBODY, WRITE_ANYBODY
-        0x0a, 0x00, 0x0e, 0x01, 0x2e, 0x00, 0x02, 0x29, 0x00, 0x00,
-        // 0x002f CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_OUTPUT_REPORT - DYNAMIC | READ | WRITE | WRITE_WITHOUT_RESPONSE
-        0x0d, 0x00, 0x02, 0x00, 0x2f, 0x00, 0x03, 0x28, 0x0e, 0x30, 0x00, 0x32, 0x2a,
-        // 0x0030 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_OUTPUT_REPORT - DYNAMIC | READ | WRITE | WRITE_WITHOUT_RESPONSE
+        0x0a, 0x00, 0x0e, 0x01, 0x35, 0x00, 0x02, 0x29, 0x00, 0x00,
+
+
+        // 0x0036 CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_OUTPUT_REPORT - DYNAMIC | READ | WRITE | WRITE_WITHOUT_RESPONSE
+        0x0d, 0x00, 0x02, 0x00, 0x36, 0x00, 0x03, 0x28, 0x0e, 0x37, 0x00, 0x32, 0x2a,
+        // 0x0037 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_OUTPUT_REPORT - DYNAMIC | READ | WRITE | WRITE_WITHOUT_RESPONSE
         // READ_ANYBODY, WRITE_ANYBODY
-        0x08, 0x00, 0x0e, 0x01, 0x30, 0x00, 0x32, 0x2a,
-        // 0x0031 CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_MOUSE_INPUT_REPORT - DYNAMIC | READ | WRITE | NOTIFY
-        0x0d, 0x00, 0x02, 0x00, 0x31, 0x00, 0x03, 0x28, 0x1a, 0x32, 0x00, 0x33, 0x2a,
-        // 0x0032 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_MOUSE_INPUT_REPORT - DYNAMIC | READ | WRITE | NOTIFY
+        0x08, 0x00, 0x0e, 0x01, 0x37, 0x00, 0x32, 0x2a,
+    };
+
+    static constexpr const uint8_t _attdb_mouse_boot[] =  {
+        // 0x0038 CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_MOUSE_INPUT_REPORT - DYNAMIC | READ | WRITE | NOTIFY
+        0x0d, 0x00, 0x02, 0x00, 0x38, 0x00, 0x03, 0x28, 0x1a, 0x39, 0x00, 0x33, 0x2a,
+        // 0x0039 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_BOOT_MOUSE_INPUT_REPORT - DYNAMIC | READ | WRITE | NOTIFY
         // READ_ANYBODY, WRITE_ANYBODY
-        0x08, 0x00, 0x0a, 0x01, 0x32, 0x00, 0x33, 0x2a,
-        // 0x0033 CLIENT_CHARACTERISTIC_CONFIGURATION
+        0x08, 0x00, 0x0a, 0x01, 0x39, 0x00, 0x33, 0x2a,
+        // 0x003a CLIENT_CHARACTERISTIC_CONFIGURATION
         // READ_ANYBODY, WRITE_ANYBODY
-        0x0a, 0x00, 0x0e, 0x01, 0x33, 0x00, 0x02, 0x29, 0x00, 0x00,
+        0x0a, 0x00, 0x0e, 0x01, 0x3a, 0x00, 0x02, 0x29, 0x00, 0x00,
+    };
+
+    static constexpr const uint8_t _attdb_tail[] =  {
         // bcdHID = 0x101 (v1.0.1), bCountryCode 0, remote wakeable = 0 | normally connectable 2
-        // 0x0034 CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_HID_INFORMATION - READ
-        0x0d, 0x00, 0x02, 0x00, 0x34, 0x00, 0x03, 0x28, 0x02, 0x35, 0x00, 0x4a, 0x2a,
-        // 0x0035 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_HID_INFORMATION - READ -'01 01 00 02'
+        // 0x003b CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_HID_INFORMATION - READ
+        0x0d, 0x00, 0x02, 0x00, 0x3b, 0x00, 0x03, 0x28, 0x02, 0x3c, 0x00, 0x4a, 0x2a,
+        // 0x003c VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_HID_INFORMATION - READ -'01 01 00 02'
         // READ_ANYBODY
-        0x0c, 0x00, 0x02, 0x00, 0x35, 0x00, 0x4a, 0x2a, 0x01, 0x01, 0x00, 0x02,
-        // 0x0036 CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_HID_CONTROL_POINT - DYNAMIC | WRITE_WITHOUT_RESPONSE
-        0x0d, 0x00, 0x02, 0x00, 0x36, 0x00, 0x03, 0x28, 0x04, 0x37, 0x00, 0x4c, 0x2a,
-        // 0x0037 VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_HID_CONTROL_POINT - DYNAMIC | WRITE_WITHOUT_RESPONSE
+        0x0c, 0x00, 0x02, 0x00, 0x3c, 0x00, 0x4a, 0x2a, 0x01, 0x01, 0x00, 0x02,
+        // 0x003d CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_HID_CONTROL_POINT - DYNAMIC | WRITE_WITHOUT_RESPONSE
+        0x0d, 0x00, 0x02, 0x00, 0x3d, 0x00, 0x03, 0x28, 0x04, 0x3e, 0x00, 0x4c, 0x2a,
+        // 0x003e VALUE CHARACTERISTIC-ORG_BLUETOOTH_CHARACTERISTIC_HID_CONTROL_POINT - DYNAMIC | WRITE_WITHOUT_RESPONSE
         // WRITE_ANYBODY
-        0x08, 0x00, 0x04, 0x01, 0x37, 0x00, 0x4c, 0x2a,
-        // #import <hids.gatt> -- END
-        // 0x0038 PRIMARY_SERVICE-GATT_SERVICE
-        0x0a, 0x00, 0x02, 0x00, 0x38, 0x00, 0x00, 0x28, 0x01, 0x18,
-        // 0x0039 CHARACTERISTIC-GATT_DATABASE_HASH - READ
-        0x0d, 0x00, 0x02, 0x00, 0x39, 0x00, 0x03, 0x28, 0x02, 0x3a, 0x00, 0x2a, 0x2b,
-        // 0x003a VALUE CHARACTERISTIC-GATT_DATABASE_HASH - READ -''
-        // READ_ANYBODY
-        0x18, 0x00, 0x02, 0x00, 0x3a, 0x00, 0x2a, 0x2b, 0xc2, 0x10, 0xf5, 0x75, 0xf3, 0x9f, 0x50, 0xb6, 0x83, 0xc7, 0xfa, 0xac, 0xa6, 0x1b, 0x7d, 0x32,
+        0x08, 0x00, 0x04, 0x01, 0x3e, 0x00, 0x4c, 0x2a,
         // END
-        0x00, 0x00
+        0x00, 0x00,
     };
 
     volatile bool _needToSend = false;
     void *_sendReport;
+    uint8_t _sendReportID;
     int _sendReportLen;
 };

libraries/HID_Bluetooth/src/PicoBluetoothHID.h

@@ -21,6 +21,7 @@
 
 #pragma once
 
+#include <sdkoverride/bluetooth.h>
 #include <_needsbt.h>
 #include <Arduino.h>
 #include <functional>
@@ -32,6 +33,8 @@
 #define HID_REPORT_TYPE_OUTPUT HID_REPORT_TYPE_OUTPUT_BT
 #define HID_REPORT_TYPE_FEATURE HID_REPORT_TYPE_FEATURE_BT
 #define hid_report_type_t hid_report_type_t_bt
+#include <sdkoverride/hids_device.h>
+#include <sdkoverride/att_db.h>
 #include <btstack.h>
 #undef hid_report_type_t
 #undef HID_REPORT_TYPE_FEATURE

libraries/HTTPClient/examples/BasicHttpsClient/BasicHttpsClient.ino

@@ -6,7 +6,19 @@
 */
 
 #include <Arduino.h>
+
+
+// Example works with either Wired or WiFi Ethernet, define one of these values to 1, other to 0
+#define USE_WIFI 1
+#define USE_WIRED 0
+
+#if USE_WIFI
 #include <WiFi.h>
+#elif USE_WIRED
+#include <W5500lwIP.h> // Or W5100lwIP.h or ENC28J60lwIP.h
+Wiznet5500lwIP eth(1 /* chip select */); // or Wiznet5100lwIP or ENC28J60lwIP
+#endif
+
 #include <HTTPClient.h>
 
 #ifndef STASSID
@@ -34,8 +46,33 @@ void setup() {
     delay(1000);
   }
 
+#if USE_WIFI
   WiFi.mode(WIFI_STA);
   WiFiMulti.addAP(ssid, pass);
+#elif USE_WIRED
+  // Set up SPI pinout to match your HW
+  SPI.setRX(0);
+  SPI.setCS(1);
+  SPI.setSCK(2);
+  SPI.setTX(3);
+
+  // Start the Ethernet port
+  if (!eth.begin()) {
+    Serial.println("No wired Ethernet hardware detected. Check pinouts, wiring.");
+    while (1) {
+      delay(1000);
+    }
+  }
+
+  // Wait for connection
+  while (eth.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.print("IP address: ");
+  Serial.println(eth.localIP());
+#endif
+
 }
 
 const char *jigsaw_cert = R"EOF(
@@ -74,8 +111,12 @@ N6K5xrmaof185pVCxACPLc/BoKyUwMeC8iXCm00=
 static int cnt = 0;
 
 void loop() {
-  // wait for WiFi connection
-  if ((WiFiMulti.run() == WL_CONNECTED)) {
+#if USE_WIFI
+ // wait for WiFi connection
+ if ((WiFiMulti.run() == WL_CONNECTED)) {
+#elif USE_WIRED
+ if (eth.connected()) {
+#endif
     HTTPClient https;
     switch (cnt) {
       case 0:

libraries/I2S/src/I2S.cpp

@@ -134,7 +134,7 @@ bool I2S::setSysClk(int samplerate) { // optimise sys_clk for desired samplerate
 }
 
 bool I2S::setMCLKmult(int mult) {
-    if (_running || !_isOutput) {
+    if (_running) {
         return false;
     }
     if ((mult % 64) == 0) {

libraries/Joystick/examples/Joystick-AllFunctions/Joystick-AllFunctions.ino

@@ -20,9 +20,9 @@ void loop() {
       Joystick.button(i, true);
       delay(250);
       Joystick.button(i, false);
-      delay(10); //we need a short delay here, sending packets with less than 1ms leads to packet loss!
+      delay(10); // We need a short delay here, sending packets with less than 1ms leads to packet loss!
     }
-    //alternativ with manual send:
+    // Alternative with manual send:
     Joystick.useManualSend(true);
     Serial.println("Joystick buttons - manual send");
     for (uint8_t i = 1; i <= 32; i++) {
@@ -33,8 +33,8 @@ void loop() {
     }
     Joystick.useManualSend(false);
 
-    //iterate all joystick axis
-    //Note: although you can use 0-1023 here (10bit), internally 8bits are used (-127 to 127)
+    // Iterate all joystick axis
+    // Note: although you can use 0-1023 here (10bit), internally 8bits are used (-127 to 127)
     Serial.println("Joystick X");
     for (uint16_t i = 0; i < 1023; i++) {
       Joystick.X(i);
@@ -71,8 +71,8 @@ void loop() {
       delay(20);
     } Joystick.hat(-1);
 
-    //use int8 mode for the axis.
-    //Note: hat is not used differently.
+    // Use int8 mode for the axis.
+    // Note: hat is not used differently.
     Serial.println("Now all axis in 8bit mode, -127 to 127");
     Joystick.use8bit(true);
     Serial.println("Joystick X");

libraries/JoystickBLE/examples/BLEJoystick-AllFunctions/BLEJoystick-AllFunctions.ino

@@ -20,9 +20,9 @@ void loop() {
       JoystickBLE.button(i, true);
       delay(250);
       JoystickBLE.button(i, false);
-      delay(10); //we need a short delay here, sending packets with less than 1ms leads to packet loss!
+      delay(10); // We need a short delay here, sending packets with less than 1ms leads to packet loss!
     }
-    //alternativ with manual send:
+    // Alternative with manual send:
     JoystickBLE.useManualSend(true);
     Serial.println("Joystick buttons - manual send");
     for (uint8_t i = 1; i <= 32; i++) {
@@ -33,8 +33,8 @@ void loop() {
     }
     JoystickBLE.useManualSend(false);
 
-    //iterate all joystick axis
-    //Note: although you can use 0-1023 here (10bit), internally 8bits are used (-127 to 127)
+    // Iterate all joystick axis
+    // Note: although you can use 0-1023 here (10bit), internally 8bits are used (-127 to 127)
     Serial.println("Joystick X");
     for (uint16_t i = 0; i < 1023; i++) {
       JoystickBLE.X(i);
@@ -71,8 +71,8 @@ void loop() {
       delay(20);
     } JoystickBLE.hat(-1);
 
-    //use int8 mode for the axis.
-    //Note: hat is not used differently.
+    // Use int8 mode for the axis.
+    // Note: hat is not used differently.
     Serial.println("Now all axis in 8bit mode, -127 to 127");
     JoystickBLE.use8bit(true);
     Serial.println("Joystick X");

libraries/JoystickBLE/src/JoystickBLE.cpp

@@ -25,18 +25,22 @@
 
 #include "JoystickBLE.h"
 #include <Arduino.h>
+#include <HID_Bluetooth.h>
 #include <PicoBluetoothBLEHID.h>
 
 //================================================================================
 //================================================================================
 //	Joystick/Gamepad
 
+// Weak function override to add our descriptor to the list
+void __BLEInstallJoystick() { /* noop */ }
+
 JoystickBLE_::JoystickBLE_(void) {
     // Member vars set in base constructor
 }
 
-#define REPORT_ID 0x01
-static const uint8_t desc_joystick[] = {TUD_HID_REPORT_DESC_GAMEPAD(HID_REPORT_ID(REPORT_ID))};
+uint8_t *desc_joystickBLE;
+uint16_t desc_joystickBLE_length;
 
 void JoystickBLE_::begin(const char *localName, const char *hidName) {
     if (!localName) {
@@ -45,7 +49,10 @@ void JoystickBLE_::begin(const char *localName, const char *hidName) {
     if (!hidName) {
         hidName = localName;
     }
-    PicoBluetoothBLEHID.startHID(localName, hidName, 0x03c4, desc_joystick, sizeof(desc_joystick));
+
+    __SetupHIDreportmap(__BLEInstallMouse, __BLEInstallKeyboard, __BLEInstallJoystick, false, &desc_joystickBLE_length, &desc_joystickBLE);
+
+    PicoBluetoothBLEHID.startHID(localName, hidName, __BLEGetAppearance(), desc_joystickBLE, desc_joystickBLE_length);
 }
 
 void JoystickBLE_::end() {
@@ -57,7 +64,13 @@ void JoystickBLE_::setBattery(int lvl) {
 }
 
 void JoystickBLE_::send_now() {
-    PicoBluetoothBLEHID.send(&data, sizeof(data));
+    //insert report ID; not part of the hid_gamepad_report_t
+    uint8_t *report = (uint8_t *)malloc(sizeof(hid_gamepad_report_t) +1);
+    if (report) {
+        report[0] = __BLEGetJoystickReportID();
+        memcpy(&report[1], (uint8_t*)&data, sizeof(data));
+        PicoBluetoothBLEHID.send(report, sizeof(data) + 1);
+    }
 }
 
 JoystickBLE_ JoystickBLE;

libraries/JoystickBT/examples/BTJoystick-AllFunctions/BTJoystick-AllFunctions.ino

@@ -20,9 +20,9 @@ void loop() {
       JoystickBT.button(i, true);
       delay(250);
       JoystickBT.button(i, false);
-      delay(10); //we need a short delay here, sending packets with less than 1ms leads to packet loss!
+      delay(10); // We need a short delay here, sending packets with less than 1ms leads to packet loss!
     }
-    //alternativ with manual send:
+    // Alternative with manual send:
     JoystickBT.useManualSend(true);
     Serial.println("Joystick buttons - manual send");
     for (uint8_t i = 1; i <= 32; i++) {
@@ -33,8 +33,8 @@ void loop() {
     }
     JoystickBT.useManualSend(false);
 
-    //iterate all joystick axis
-    //Note: although you can use 0-1023 here (10bit), internally 8bits are used (-127 to 127)
+    // Iterate all joystick axis
+    // Note: although you can use 0-1023 here (10bit), internally 8bits are used (-127 to 127)
     Serial.println("Joystick X");
     for (uint16_t i = 0; i < 1023; i++) {
       JoystickBT.X(i);
@@ -71,8 +71,8 @@ void loop() {
       delay(20);
     } JoystickBT.hat(-1);
 
-    //use int8 mode for the axis.
-    //Note: hat is not used differently.
+    // Use int8 mode for the axis.
+    // Note: hat is not used differently.
     Serial.println("Now all axis in 8bit mode, -127 to 127");
     JoystickBT.use8bit(true);
     Serial.println("Joystick X");

libraries/JoystickBT/src/JoystickBT.cpp

@@ -25,18 +25,22 @@
 
 #include "JoystickBT.h"
 #include <Arduino.h>
+#include <HID_Bluetooth.h>
 #include <PicoBluetoothHID.h>
 
 //================================================================================
 //================================================================================
 //	Joystick/Gamepad
 
+// Weak function override to add our descriptor to the list
+void __BTInstallJoystick() { /* noop */ }
+
 JoystickBT_::JoystickBT_() {
     // HID_Joystick sets up all the member vars
 }
 
-#define REPORT_ID 0x01
-static const uint8_t desc_joystick[] = {TUD_HID_REPORT_DESC_GAMEPAD(HID_REPORT_ID(REPORT_ID))};
+uint8_t *desc_joystickBT;
+uint16_t desc_joystickBT_length;
 
 void JoystickBT_::begin(const char *localName, const char *hidName) {
     if (!localName) {
@@ -45,7 +49,10 @@ void JoystickBT_::begin(const char *localName, const char *hidName) {
     if (!hidName) {
         hidName = localName;
     }
-    PicoBluetoothHID.startHID(localName, hidName, 0x2508, 33, desc_joystick, sizeof(desc_joystick));
+
+    __SetupHIDreportmap(__BTInstallMouse, __BTInstallKeyboard, __BTInstallJoystick, false, &desc_joystickBT_length, &desc_joystickBT);
+
+    PicoBluetoothHID.startHID(localName, hidName, __BTGetCOD(), 33, desc_joystickBT, desc_joystickBT_length);
 }
 
 void JoystickBT_::end() {
@@ -54,7 +61,7 @@ void JoystickBT_::end() {
 
 //immediately send an HID report
 void JoystickBT_::send_now() {
-    PicoBluetoothHID.send(REPORT_ID, &data, sizeof(data));
+    PicoBluetoothHID.send(__BTGetJoystickReportID(), &data, sizeof(data));
 }
 
 JoystickBT_ JoystickBT;

libraries/KeyboardBLE/src/KeyboardBLE.cpp

@@ -22,19 +22,22 @@
 
 #include "KeyboardBLE.h"
 #include "KeyboardLayout.h"
+#include <HID_Bluetooth.h>
 #include <PicoBluetoothBLEHID.h>
 
 //================================================================================
 //================================================================================
 //  Keyboard
 
+// Weak function override to add our descriptor to the list
+void __BLEInstallKeyboard() { /* noop */ }
+
 KeyboardBLE_::KeyboardBLE_(void) {
     // Base class clears the members we care about
 }
 
-#define REPORT_ID 0x01
-
-static const uint8_t desc_keyboard[] = {TUD_HID_REPORT_DESC_KEYBOARD(HID_REPORT_ID(REPORT_ID))};
+uint8_t *desc_keyboardBLE;
+uint16_t desc_keyboardBLE_length;
 
 void KeyboardBLE_::begin(const char *localName, const char *hidName, const uint8_t *layout) {
     if (!localName) {
@@ -44,7 +47,10 @@ void KeyboardBLE_::begin(const char *localName, const char *hidName, const uint8
         hidName = localName;
     }
     _asciimap = layout;
-    PicoBluetoothBLEHID.startHID(localName, hidName, 0x03c1, desc_keyboard, sizeof(desc_keyboard));
+
+    __SetupHIDreportmap(__BLEInstallMouse, __BLEInstallKeyboard, __BLEInstallJoystick, false, &desc_keyboardBLE_length, &desc_keyboardBLE);
+
+    PicoBluetoothBLEHID.startHID(localName, hidName, __BLEGetAppearance(), desc_keyboardBLE, desc_keyboardBLE_length);
 }
 
 void KeyboardBLE_::end(void) {
@@ -60,12 +66,21 @@ void KeyboardBLE_::sendReport(KeyReport* keys) {
     data.modifier = keys->modifiers;
     data.reserved = 0;
     memcpy(data.keycode, keys->keys, sizeof(data.keycode));
-    PicoBluetoothBLEHID.send(&data, sizeof(data));
+
+    //stitch in report id
+    static uint8_t report[sizeof(hid_keyboard_report_t) +1];
+    report[0] = __BLEGetKeyboardReportID();
+    memcpy(&report[1], (uint8_t*)&data, sizeof(hid_keyboard_report_t));
+    PicoBluetoothBLEHID.send(&report, sizeof(hid_keyboard_report_t) +1);
 }
 
 void KeyboardBLE_::sendConsumerReport(uint16_t key) {
-    (void) key;
-    // TODO - Need some BLE-specific code to send 2nd report
+    uint8_t report[3];
+
+    report[0] = __BLEGetKeyboardReportID() + 1; //consumer report id
+    report[1] = key & 0xFF;
+    report[2] = (key >> 8) & 0xFF;
+    PicoBluetoothBLEHID.send(&report, 3);
 }
 
 KeyboardBLE_ KeyboardBLE;

libraries/KeyboardBT/src/KeyboardBT.cpp

@@ -22,19 +22,22 @@
 
 #include "KeyboardBT.h"
 #include "KeyboardLayout.h"
+#include <HID_Bluetooth.h>
 #include <PicoBluetoothHID.h>
 
 //================================================================================
 //================================================================================
 //  Keyboard
 
+// Weak function override to add our descriptor to the list
+void __BTInstallKeyboard() { /* noop */ }
+
 KeyboardBT_::KeyboardBT_(void) {
     // Base class clears the members we care about
 }
 
-#define REPORT_ID 0x01
-
-static const uint8_t desc_keyboard[] = {TUD_HID_REPORT_DESC_KEYBOARD(HID_REPORT_ID(REPORT_ID)), TUD_HID_REPORT_DESC_CONSUMER(HID_REPORT_ID(REPORT_ID + 1))};
+uint8_t *desc_keyboardBT;
+uint16_t desc_keyboardBT_length;
 
 static void _hidReportCB(uint16_t cid, hid_report_type_t report_type, uint16_t report_id, int report_size, uint8_t *report) {
     (void) cid;
@@ -56,7 +59,10 @@ void KeyboardBT_::begin(const char *localName, const char *hidName, const uint8_
     // Required because the hid_report_type_t overlap in BTStack and TUSB
     auto *fcn = (void (*)(short unsigned int, hid_report_type_t_bt, short unsigned int, int, unsigned char*))_hidReportCB;
     hid_device_register_report_data_callback(fcn);
-    PicoBluetoothHID.startHID(localName, hidName, 0x2540, 33, desc_keyboard, sizeof(desc_keyboard));
+
+    __SetupHIDreportmap(__BTInstallMouse, __BTInstallKeyboard, __BTInstallJoystick, false, &desc_keyboardBT_length, &desc_keyboardBT);
+
+    PicoBluetoothHID.startHID(localName, hidName, __BTGetCOD(), 33, desc_keyboardBT, desc_keyboardBT_length);
 }
 
 void KeyboardBT_::end(void) {
@@ -68,11 +74,11 @@ void KeyboardBT_::sendReport(KeyReport* keys) {
     data.modifier = keys->modifiers;
     data.reserved = 0;
     memcpy(data.keycode, keys->keys, sizeof(data.keycode));
-    PicoBluetoothHID.send(REPORT_ID, &data, sizeof(data));
+    PicoBluetoothHID.send(__BLEGetKeyboardReportID(), &data, sizeof(data));
 }
 
 void KeyboardBT_::sendConsumerReport(uint16_t key) {
-    PicoBluetoothHID.send(REPORT_ID + 1, &key, sizeof(key));
+    PicoBluetoothHID.send(__BLEGetKeyboardReportID() + 1, &key, sizeof(key));
 }
 
 KeyboardBT_ KeyboardBT;

libraries/LittleFS/src/LittleFS.h

@@ -106,7 +106,6 @@ public:
         if (!_mounted) {
             return false;
         }
-        info.maxOpenFiles = _maxOpenFds;
         info.blockSize = _blockSize;
         info.pageSize = _pageSize;
         info.maxOpenFiles = _maxOpenFds;

libraries/MouseBLE/examples/BLECircleKeysJoystick/BLECircleKeysJoystick.ino

@@ -0,0 +1,95 @@
+/* Earle F. Philhower, III <earlephilhower@yahoo.com>
+   Benjamin Aigner <beni@asterics-foundation.org> <aignerb@technikum-wien.at> */
+/* Released to the public domain */
+
+#define ENABLE_LOG_INFO
+#define ENABLE_LOG_DEBUG
+
+#define USE_MOUSE
+#define USE_KBD
+#define USE_JOYSTICK
+
+#ifdef USE_MOUSE
+#include <MouseBLE.h>
+#endif
+#ifdef USE_KBD
+#include <KeyboardBLE.h>
+#endif
+#ifdef USE_JOYSTICK
+#include <JoystickBLE.h>
+#endif
+
+void setup() {
+  Serial.begin(115200);
+
+  //If activated nothing happens until the serial port is opened
+  //while(!Serial);
+
+
+#if (defined(USE_KBD) || defined(USE_JOYSTICK)) && defined(USE_MOUSE)
+  MouseBLE.begin("BLE Composite");
+#elif defined(USE_MOUSE)
+  MouseBLE.begin("BLE Mouse");
+#endif
+
+#ifdef USE_KBD
+  KeyboardBLE.begin("BLE KBD");
+#endif
+
+#ifdef USE_JOYSTICK
+  JoystickBLE.begin("BLE JOY");
+#endif
+
+  Serial.printf("Press BOOTSEL to start action\n");
+#ifdef USE_MOUSE
+  Serial.println("First the mouse moves");
+#endif
+#ifdef USE_KBD
+  Serial.println("Then \"Hi\" will be printed");
+#endif
+#ifdef USE_JOYSTICK
+  Serial.println("Then joystick buttons & axis are changed");
+#endif
+}
+
+void loop() {
+  if (BOOTSEL) {
+#ifdef USE_MOUSE
+    Serial.println("ACTION!!!");
+    float r = 100;
+    float ox = 0.0;
+    float oy = 0.0;
+    for (float a = 0; a < 2.0 * 3.14159; a += 0.1) {
+      float ax = r * cos(a);
+      float ay = r * sin(a);
+      float dx = ax - ox;
+      float dy = ay - oy;
+      MouseBLE.move(dx, dy, 0);
+      ox = ax;
+      oy = ay;
+      delay(10);
+    }
+    MouseBLE.setBattery(random(0, 101)); // Set between 0...100%
+    delay(1000);
+#endif
+
+#ifdef USE_KBD
+    KeyboardBLE.print("Hi");
+#endif
+
+#ifdef USE_JOYSTICK
+    JoystickBLE.button(1, true);
+    JoystickBLE.X(0);
+    JoystickBLE.send_now();
+    delay(1000);
+
+    JoystickBLE.button(1, false);
+    JoystickBLE.X(512);
+    JoystickBLE.send_now();
+#endif
+
+    while (BOOTSEL) {
+      delay(1);
+    }
+  }
+}

libraries/MouseBLE/src/MouseBLE.cpp

@@ -21,15 +21,19 @@
 
 #include "MouseBLE.h"
 #include <sdkoverride/tusb_absmouse.h>
+#include <HID_Bluetooth.h>
 #include <PicoBluetoothBLEHID.h>
 
+// Weak function override to add our descriptor to the list
+void __BLEInstallMouse() { /* noop */ }
+
 MouseBLE_::MouseBLE_(bool absolute) : HID_Mouse(absolute) {
     _running = false;
 }
 
-#define REPORT_ID 0x01
-const uint8_t desc_mouse[] = {TUD_HID_REPORT_DESC_MOUSE(HID_REPORT_ID(REPORT_ID))};
-const uint8_t desc_absmouse[] = {TUD_HID_REPORT_DESC_ABSMOUSE(HID_REPORT_ID(REPORT_ID))};
+uint8_t *desc_mouseBLE;
+uint16_t desc_mouseBLE_length;
+
 void MouseBLE_::begin(const char *localName, const char *hidName) {
     if (!localName) {
         localName = "PicoW BLE Mouse";
@@ -37,7 +41,10 @@ void MouseBLE_::begin(const char *localName, const char *hidName) {
     if (!hidName) {
         hidName = localName;
     }
-    PicoBluetoothBLEHID.startHID(localName, hidName, 0x03c2, _absolute ? desc_absmouse : desc_mouse, _absolute ? sizeof(desc_absmouse) : sizeof(desc_mouse));
+
+    __SetupHIDreportmap(__BLEInstallMouse, __BLEInstallKeyboard, __BLEInstallJoystick, _absolute, &desc_mouseBLE_length, &desc_mouseBLE);
+
+    PicoBluetoothBLEHID.startHID(localName, hidName, __BLEGetAppearance(), desc_mouseBLE, desc_mouseBLE_length);
     _running = true;
 }
 
@@ -61,6 +68,8 @@ void MouseBLE_::setAbsolute(bool absolute) {
 }
 
 void MouseBLE_::move(int x, int y, signed char wheel) {
+    static uint8_t report[sizeof(hid_abs_mouse_report_t) +1];
+
     if (!_absolute) {
         hid_mouse_report_t data;
         data.buttons = _buttons;
@@ -68,7 +77,10 @@ void MouseBLE_::move(int x, int y, signed char wheel) {
         data.y = limit_xy(y);
         data.wheel = wheel;
         data.pan = 0;
-        PicoBluetoothBLEHID.send(&data, sizeof(data));
+
+        report[0] = __BLEGetMouseReportID();
+        memcpy(&report[1], (uint8_t*)&data, sizeof(data));
+        PicoBluetoothBLEHID.send(report, sizeof(data) + 1);
     } else {
         hid_abs_mouse_report_t data;
         data.buttons = _buttons;
@@ -76,7 +88,10 @@ void MouseBLE_::move(int x, int y, signed char wheel) {
         data.y = limit_xy(y);
         data.wheel = wheel;
         data.pan = 0;
-        PicoBluetoothBLEHID.send(&data, sizeof(data));
+
+        report[0] = __BLEGetMouseReportID();
+        memcpy(&report[1], (uint8_t*)&data, sizeof(data));
+        PicoBluetoothBLEHID.send(report, sizeof(data) + 1);
     }
 }
 

libraries/MouseBT/src/MouseBT.cpp

@@ -21,15 +21,18 @@
 
 #include "MouseBT.h"
 #include <sdkoverride/tusb_absmouse.h>
+#include <HID_Bluetooth.h>
 #include <PicoBluetoothHID.h>
 
+// Weak function override to add our descriptor to the list
+void __BTInstallMouse() { /* noop */ }
+
 MouseBT_::MouseBT_(bool absolute) : HID_Mouse(absolute) {
     _running = false;
 }
 
-#define REPORT_ID 0x01
-const uint8_t desc_mouse[] = {TUD_HID_REPORT_DESC_MOUSE(HID_REPORT_ID(REPORT_ID))};
-const uint8_t desc_absmouse[] = {TUD_HID_REPORT_DESC_ABSMOUSE(HID_REPORT_ID(REPORT_ID))};
+uint8_t *desc_mouseBT;
+uint16_t desc_mouseBT_length;
 
 void MouseBT_::begin(const char *localName, const char *hidName) {
     if (!localName) {
@@ -38,7 +41,10 @@ void MouseBT_::begin(const char *localName, const char *hidName) {
     if (!hidName) {
         hidName = localName;
     }
-    PicoBluetoothHID.startHID(localName, hidName, 0x2580, 33, _absolute ? desc_absmouse : desc_mouse, _absolute ? sizeof(desc_absmouse) : sizeof(desc_mouse));
+
+    __SetupHIDreportmap(__BTInstallMouse, __BTInstallKeyboard, __BTInstallJoystick, _absolute, &desc_mouseBT_length, &desc_mouseBT);
+
+    PicoBluetoothHID.startHID(localName, hidName, __BTGetCOD(), 33, desc_mouseBT, desc_mouseBT_length);
     _running = true;
 }
 
@@ -63,7 +69,7 @@ void MouseBT_::move(int x, int y, signed char wheel) {
         data.y = limit_xy(y);
         data.wheel = wheel;
         data.pan = 0;
-        PicoBluetoothHID.send(REPORT_ID, &data, sizeof(data));
+        PicoBluetoothHID.send(__BTGetMouseReportID(), &data, sizeof(data));
     } else {
         hid_abs_mouse_report_t data;
         data.buttons = _buttons;
@@ -71,7 +77,7 @@ void MouseBT_::move(int x, int y, signed char wheel) {
         data.y = limit_xy(y);
         data.wheel = wheel;
         data.pan = 0;
-        PicoBluetoothHID.send(REPORT_ID, &data, sizeof(data));
+        PicoBluetoothHID.send(__BTGetMouseReportID(), &data, sizeof(data));
     }
 }
 

libraries/SPI/keywords.txt

@@ -14,6 +14,9 @@ SPI1	KEYWORD1
 #######################################
 begin	KEYWORD2
 end	KEYWORD2
+beginTransaction	KEYWORD2
+endTransaction	KEYWORD2
+SPISettings	KEYWORD2
 transfer	KEYWORD2
 setBitOrder	KEYWORD2
 setDataMode	KEYWORD2

libraries/SPI/src/SPI.cpp

@@ -21,6 +21,8 @@
 #include "SPI.h"
 #include <hardware/spi.h>
 #include <hardware/gpio.h>
+#include <hardware/structs/iobank0.h>
+#include <hardware/irq.h>
 
 #ifdef USE_TINYUSB
 // For Serial when selecting TinyUSB.  Can't include in the core because Arduino IDE
@@ -108,7 +110,6 @@ byte SPIClassRP2040::transfer(uint8_t data) {
         return 0;
     }
     data = (_spis.getBitOrder() == MSBFIRST) ? data : reverseByte(data);
-    spi_set_format(_spi, 8, cpol(), cpha(), SPI_MSB_FIRST);
     DEBUGSPI("SPI::transfer(%02x), cpol=%d, cpha=%d\n", data, cpol(), cpha());
     spi_write_read_blocking(_spi, &data, &ret, 1);
     ret = (_spis.getBitOrder() == MSBFIRST) ? ret : reverseByte(ret);
@@ -122,9 +123,12 @@ uint16_t SPIClassRP2040::transfer16(uint16_t data) {
         return 0;
     }
     data = (_spis.getBitOrder() == MSBFIRST) ? data : reverse16Bit(data);
-    spi_set_format(_spi, 16, cpol(), cpha(), SPI_MSB_FIRST);
     DEBUGSPI("SPI::transfer16(%04x), cpol=%d, cpha=%d\n", data, cpol(), cpha());
-    spi_write16_read16_blocking(_spi, &data, &ret, 1);
+    uint8_t d[2];
+    d[0] = (data >> 8) & 0xff;
+    d[1] = data & 0xff;
+    spi_write_read_blocking(_spi, d, d, 2);
+    ret = ((d[0] << 8) | (d[1] & 0xff)) & 0xffff;
     ret = (_spis.getBitOrder() == MSBFIRST) ? ret : reverse16Bit(ret);
     DEBUGSPI("SPI: read back %02x\n", ret);
     return ret;
@@ -151,8 +155,6 @@ void SPIClassRP2040::transfer(const void *txbuf, void *rxbuf, size_t count) {
 
     // MSB version is easy!
     if (_spis.getBitOrder() == MSBFIRST) {
-        spi_set_format(_spi, 8, cpol(), cpha(), SPI_MSB_FIRST);
-
         if (rxbuf == nullptr) { // transmit only!
             spi_write_blocking(_spi, txbuff, count);
             return;
@@ -177,6 +179,7 @@ void SPIClassRP2040::transfer(const void *txbuf, void *rxbuf, size_t count) {
 }
 
 void SPIClassRP2040::beginTransaction(SPISettings settings) {
+    noInterrupts(); // Avoid possible race conditions if IRQ comes in while main app is in middle of this
     DEBUGSPI("SPI::beginTransaction(clk=%lu, bo=%s)\n", settings.getClockFreq(), (settings.getBitOrder() == MSBFIRST) ? "MSB" : "LSB");
     if (_initted && settings == _spis) {
         DEBUGSPI("SPI: Reusing existing initted SPI\n");
@@ -188,13 +191,40 @@ void SPIClassRP2040::beginTransaction(SPISettings settings) {
         }
         DEBUGSPI("SPI: initting SPI\n");
         spi_init(_spi, _spis.getClockFreq());
+        spi_set_format(_spi, 8, cpol(), cpha(), SPI_MSB_FIRST);
         DEBUGSPI("SPI: actual baudrate=%u\n", spi_get_baudrate(_spi));
         _initted = true;
     }
+    // Disable any IRQs that are being used for SPI
+    io_irq_ctrl_hw_t *irq_ctrl_base = get_core_num() ? &iobank0_hw->proc1_irq_ctrl : &iobank0_hw->proc0_irq_ctrl;
+    DEBUGSPI("SPI: IRQ masks before = %08x %08x %08x %08x\n", (unsigned)irq_ctrl_base->inte[0], (unsigned)irq_ctrl_base->inte[1], (unsigned)irq_ctrl_base->inte[2], (unsigned)irq_ctrl_base->inte[3]);
+    for (auto entry : _usingIRQs) {
+        int gpio = entry.first;
+
+        // There is no gpio_get_irq, so manually twiddle the register
+        io_rw_32 *en_reg = &irq_ctrl_base->inte[gpio / 8];
+        uint32_t val = ((*en_reg) >> (4 * (gpio % 8))) & 0xf;
+        _usingIRQs.insert_or_assign(gpio, val);
+        DEBUGSPI("SPI: GPIO %d = %d\n", gpio, val);
+        (*en_reg) ^= val << (4 * (gpio % 8));
+    }
+    DEBUGSPI("SPI: IRQ masks after = %08x %08x %08x %08x\n", (unsigned)irq_ctrl_base->inte[0], (unsigned)irq_ctrl_base->inte[1], (unsigned)irq_ctrl_base->inte[2], (unsigned)irq_ctrl_base->inte[3]);
+    interrupts();
 }
 
 void SPIClassRP2040::endTransaction(void) {
+    noInterrupts(); // Avoid race condition so the GPIO IRQs won't come back until all state is restored
     DEBUGSPI("SPI::endTransaction()\n");
+    // Re-enablke IRQs
+    for (auto entry : _usingIRQs) {
+        int gpio = entry.first;
+        int mode = entry.second;
+        gpio_set_irq_enabled(gpio, mode, true);
+    }
+    io_irq_ctrl_hw_t *irq_ctrl_base = get_core_num() ? &iobank0_hw->proc1_irq_ctrl : &iobank0_hw->proc0_irq_ctrl;
+    (void) irq_ctrl_base;
+    DEBUGSPI("SPI: IRQ masks = %08x %08x %08x %08x\n", (unsigned)irq_ctrl_base->inte[0], (unsigned)irq_ctrl_base->inte[1], (unsigned)irq_ctrl_base->inte[2], (unsigned)irq_ctrl_base->inte[3]);
+    interrupts();
 }
 
 bool SPIClassRP2040::setRX(pin_size_t pin) {
@@ -292,6 +322,7 @@ void SPIClassRP2040::begin(bool hwCS) {
     gpio_set_function(_TX, GPIO_FUNC_SPI);
     // Give a default config in case user doesn't use beginTransaction
     beginTransaction(_spis);
+    endTransaction();
 }
 
 void SPIClassRP2040::end() {
@@ -312,11 +343,13 @@ void SPIClassRP2040::end() {
 void SPIClassRP2040::setBitOrder(BitOrder order) {
     _spis = SPISettings(_spis.getClockFreq(), order, _spis.getDataMode());
     beginTransaction(_spis);
+    endTransaction();
 }
 
 void SPIClassRP2040::setDataMode(uint8_t uc_mode) {
     _spis = SPISettings(_spis.getClockFreq(), _spis.getBitOrder(), uc_mode);
     beginTransaction(_spis);
+    endTransaction();
 }
 
 void SPIClassRP2040::setClockDivider(uint8_t uc_div) {

libraries/SPI/src/SPI.h

@@ -23,6 +23,7 @@
 #include <Arduino.h>
 #include <api/HardwareSPI.h>
 #include <hardware/spi.h>
+#include <map>
 
 class SPIClassRP2040 : public arduino::HardwareSPI {
 public:
@@ -60,12 +61,12 @@ public:
     void setDataMode(uint8_t uc_mode) __attribute__((deprecated));
     void setClockDivider(uint8_t uc_div) __attribute__((deprecated));
 
-    // Unimplemented
+    // List of GPIO IRQs to disable during a transaction
     virtual void usingInterrupt(int interruptNumber) override {
-        (void) interruptNumber;
+        _usingIRQs.insert({interruptNumber, 0});
     }
     virtual void notUsingInterrupt(int interruptNumber) override {
-        (void) interruptNumber;
+        _usingIRQs.erase(interruptNumber);
     }
     virtual void attachInterrupt() override { /* noop */ }
     virtual void detachInterrupt() override { /* noop */ }
@@ -83,6 +84,8 @@ private:
     bool _hwCS;
     bool _running; // SPI port active
     bool _initted; // Transaction begun
+
+    std::map<int, int> _usingIRQs;
 };
 
 extern SPIClassRP2040 SPI;

libraries/SPISlave/examples/SPItoMyself/SPItoMyself.ino

@@ -0,0 +1,89 @@
+// Shows how to use SPISlave on a single device.
+// Core0 runs as an SPI master and initiates a transmission to the slave
+// Core1 runs the SPI Slave mode and provides a unique reply to messages from the master
+//
+// Released to the public domain 2023 by Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+#include <SPI.h>
+#include <SPISlave.h>
+
+// Wiring:
+// Master RX  GP0 <-> GP11  Slave TX
+// Master CS  GP1 <-> GP9   Slave CS
+// Master CK  GP2 <-> GP10  Slave CK
+// Master TX  GP3 <-> GP8   Slave RX
+
+SPISettings spisettings(1000000, MSBFIRST, SPI_MODE0);
+
+// Core 0 will be SPI master
+void setup() {
+  SPI.setRX(0);
+  SPI.setCS(1);
+  SPI.setSCK(2);
+  SPI.setTX(3);
+  SPI.begin(true);
+
+  delay(5000);
+}
+
+int transmits = 0;
+void loop() {
+  char msg[42];
+  memset(msg, 0, sizeof(msg));
+  sprintf(msg, "What's up? This is transmission %d", transmits);
+  Serial.printf("\n\nM-SEND: '%s'\n", msg);
+  SPI.beginTransaction(spisettings);
+  SPI.transfer(msg, sizeof(msg));
+  SPI.endTransaction();
+  Serial.printf("M-RECV: '%s'\n", msg);
+  transmits++;
+  delay(5000);
+}
+
+// Core 1 will be SPI slave
+
+volatile bool recvBuffReady = false;
+char recvBuff[42] = "";
+int recvIdx = 0;
+void recvCallback(uint8_t *data, size_t len) {
+  memcpy(recvBuff + recvIdx, data, len);
+  recvIdx += len;
+  if (recvIdx == sizeof(recvBuff)) {
+    recvBuffReady = true;
+    recvIdx = 0;
+  }
+}
+
+int sendcbs = 0;
+// Note that the buffer needs to be long lived, the SPISlave doesn't copy it.  So no local stack variables, only globals or heap(malloc/new) allocations.
+char sendBuff[42];
+void sentCallback() {
+  memset(sendBuff, 0, sizeof(sendBuff));
+  sprintf(sendBuff, "Slave to Master Xmission %d", sendcbs++);
+  SPISlave1.setData((uint8_t*)sendBuff, sizeof(sendBuff));
+}
+
+// Note that we use SPISlave1 here **not** because we're running on
+// Core 1, but because SPI0 is being used already.  You can use
+// SPISlave or SPISlave1 on any core.
+void setup1() {
+  SPISlave1.setRX(8);
+  SPISlave1.setCS(9);
+  SPISlave1.setSCK(10);
+  SPISlave1.setTX(11);
+  // Ensure we start with something to send...
+  sentCallback();
+  // Hook our callbacks into the slave
+  SPISlave1.onDataRecv(recvCallback);
+  SPISlave1.onDataSent(sentCallback);
+  SPISlave1.begin(spisettings);
+  delay(3000);
+  Serial.println("S-INFO: SPISlave started");
+}
+
+void loop1() {
+  if (recvBuffReady) {
+    Serial.printf("S-RECV: '%s'\n", recvBuff);
+    recvBuffReady = false;
+  }
+}

libraries/SPISlave/keywords.txt

@@ -0,0 +1,40 @@
+#######################################
+# Syntax Coloring Map SPI
+#######################################
+
+#######################################
+# Instances (KEYWORD2)
+#######################################
+
+SPISlave	KEYWORD1
+SPISlave1	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+begin	KEYWORD2
+end	KEYWORD2
+SPISettings	KEYWORD2
+setRX	KEYWORD2
+setTX	KEYWORD2
+setSCK	KEYWORD2
+setCS	KEYWORD2
+setData	KEYWORD2
+onDataRecv	KEYWORD2
+onDataSent	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+SPI_CLOCK_DIV4	LITERAL1
+SPI_CLOCK_DIV16	LITERAL1
+SPI_CLOCK_DIV64	LITERAL1
+SPI_CLOCK_DIV128	LITERAL1
+SPI_CLOCK_DIV2	LITERAL1
+SPI_CLOCK_DIV8	LITERAL1
+SPI_CLOCK_DIV32	LITERAL1
+SPI_CLOCK_DIV64	LITERAL1
+SPI_MODE0	LITERAL1
+SPI_MODE1	LITERAL1
+SPI_MODE2	LITERAL1
+SPI_MODE3	LITERAL1

libraries/SPISlave/library.properties

@@ -0,0 +1,10 @@
+name=SPISlave
+version=1.0
+author=Earle F. Philhower, III <earlephilhower@yahoo.com>
+maintainer=Earle F. Philhower, III <earlephilhower@yahoo.com>
+sentence=Enables the communication as a slave SPI devices.
+paragraph=
+category=Signal Input/Output
+url=https://github.com/earlephilhower/arduino-pico
+architectures=rp2040
+dot_a_linkage=true

libraries/SPISlave/src/SPISlave.cpp

@@ -0,0 +1,263 @@
+/*
+    SPI Slave library for the Raspberry Pi Pico RP2040
+
+    Copyright (c) 2023 Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "SPISlave.h"
+#include <hardware/spi.h>
+#include <hardware/gpio.h>
+#include <hardware/structs/iobank0.h>
+#include <hardware/irq.h>
+
+#ifdef USE_TINYUSB
+// For Serial when selecting TinyUSB.  Can't include in the core because Arduino IDE
+// will not link in libraries called from the core.  Instead, add the header to all
+// the standard libraries in the hope it will still catch some user cases where they
+// use these libraries.
+// See https://github.com/earlephilhower/arduino-pico/issues/167#issuecomment-848622174
+#include <Adafruit_TinyUSB.h>
+#endif
+
+SPISlaveClass::SPISlaveClass(spi_inst_t *spi, pin_size_t rx, pin_size_t cs, pin_size_t sck, pin_size_t tx) {
+    _spi = spi;
+    _running = false;
+    _initted = false;
+    _spis = SPISettings();
+    _RX = rx;
+    _TX = tx;
+    _SCK = sck;
+    _CS = cs;
+    _recvCB = nullptr;
+    _sentCB = nullptr;
+    _dataOut = nullptr;
+    _dataLeft = 0;
+}
+
+inline spi_cpol_t SPISlaveClass::cpol(SPISettings _spis) {
+    switch (_spis.getDataMode()) {
+    case SPI_MODE0:
+        return SPI_CPOL_0;
+    case SPI_MODE1:
+        return SPI_CPOL_0;
+    case SPI_MODE2:
+        return SPI_CPOL_1;
+    case SPI_MODE3:
+        return SPI_CPOL_1;
+    }
+    // Error
+    return SPI_CPOL_0;
+}
+
+inline spi_cpha_t SPISlaveClass::cpha(SPISettings _spis) {
+    switch (_spis.getDataMode()) {
+    case SPI_MODE0:
+        return SPI_CPHA_0;
+    case SPI_MODE1:
+        return SPI_CPHA_1;
+    case SPI_MODE2:
+        return SPI_CPHA_0;
+    case SPI_MODE3:
+        return SPI_CPHA_1;
+    }
+    // Error
+    return SPI_CPHA_0;
+}
+
+bool SPISlaveClass::setRX(pin_size_t pin) {
+    constexpr uint32_t valid[2] = { __bitset({0, 4, 16, 20}) /* SPI0 */,
+                                    __bitset({8, 12, 24, 28})  /* SPI1 */
+                                  };
+    if ((!_running) && ((1 << pin) & valid[spi_get_index(_spi)])) {
+        _RX = pin;
+        return true;
+    }
+
+    if (_RX == pin) {
+        return true;
+    }
+
+    if (_running) {
+        panic("FATAL: Attempting to set SPI%s.RX while running", spi_get_index(_spi) ? "1" : "");
+    } else {
+        panic("FATAL: Attempting to set SPI%s.RX to illegal pin %d", spi_get_index(_spi) ? "1" : "", pin);
+    }
+    return false;
+}
+
+bool SPISlaveClass::setCS(pin_size_t pin) {
+    constexpr uint32_t valid[2] = { __bitset({1, 5, 17, 21}) /* SPI0 */,
+                                    __bitset({9, 13, 25, 29})  /* SPI1 */
+                                  };
+    if ((!_running) && ((1 << pin) & valid[spi_get_index(_spi)])) {
+        _CS = pin;
+        return true;
+    }
+
+    if (_CS == pin) {
+        return true;
+    }
+
+    if (_running) {
+        panic("FATAL: Attempting to set SPI%s.CS while running", spi_get_index(_spi) ? "1" : "");
+    } else {
+        panic("FATAL: Attempting to set SPI%s.CS to illegal pin %d", spi_get_index(_spi) ? "1" : "", pin);
+    }
+    return false;
+}
+
+bool SPISlaveClass::setSCK(pin_size_t pin) {
+    constexpr uint32_t valid[2] = { __bitset({2, 6, 18, 22}) /* SPI0 */,
+                                    __bitset({10, 14, 26})  /* SPI1 */
+                                  };
+    if ((!_running) && ((1 << pin) & valid[spi_get_index(_spi)])) {
+        _SCK = pin;
+        return true;
+    }
+
+    if (_SCK == pin) {
+        return true;
+    }
+
+    if (_running) {
+        panic("FATAL: Attempting to set SPI%s.SCK while running", spi_get_index(_spi) ? "1" : "");
+    } else {
+        panic("FATAL: Attempting to set SPI%s.SCK to illegal pin %d", spi_get_index(_spi) ? "1" : "", pin);
+    }
+    return false;
+}
+
+bool SPISlaveClass::setTX(pin_size_t pin) {
+    constexpr uint32_t valid[2] = { __bitset({3, 7, 19, 23}) /* SPI0 */,
+                                    __bitset({11, 15, 27})  /* SPI1 */
+                                  };
+    if ((!_running) && ((1 << pin) & valid[spi_get_index(_spi)])) {
+        _TX = pin;
+        return true;
+    }
+
+    if (_TX == pin) {
+        return true;
+    }
+
+    if (_running) {
+        panic("FATAL: Attempting to set SPI%s.TX while running", spi_get_index(_spi) ? "1" : "");
+    } else {
+        panic("FATAL: Attempting to set SPI%s.TX to illegal pin %d", spi_get_index(_spi) ? "1" : "", pin);
+    }
+    return false;
+}
+
+void SPISlaveClass::_handleIRQ() {
+    // Attempt to read out all RX FIFO datra and return to callback
+    uint8_t buff[8]; // SPI FIFO 8 deep max
+    int cnt;
+    for (cnt = 0; (cnt < 8) && spi_is_readable(_spi); cnt++) {
+        buff[cnt] = spi_get_hw(_spi)->dr;
+    }
+    if (cnt && _recvCB) {
+        _recvCB(buff, cnt);
+    }
+    // Attempt to send as many ytes to the TX FIFO as we have/are free
+    while (spi_is_writable(_spi)) {
+        for (; _dataLeft && spi_is_writable(_spi); _dataLeft--) {
+            spi_get_hw(_spi)->dr = *(_dataOut++);
+        }
+        if (!_dataLeft && _sentCB) {
+            _sentCB();
+        }
+    }
+    // Disable the TX FIFO IRQ if there is still no data to send or we'd always be stuck in an IRQ
+    // Will be re-enabled once user does a setData
+    if (!_dataLeft) {
+        spi_get_hw(_spi)->imsc = 2 | 4; // RTIM + RXIM
+    }
+}
+
+void SPISlaveClass::_irq0() {
+    SPISlave._handleIRQ();
+}
+
+void SPISlaveClass::_irq1() {
+    SPISlave1._handleIRQ();
+}
+
+void SPISlaveClass::setData(const uint8_t *data, size_t len) {
+    _dataOut = data;
+    _dataLeft = len;
+    if (_initted) {
+        spi_get_hw(_spi)->imsc = 2 | 4 | 8;
+    }
+}
+
+
+void SPISlaveClass::begin(SPISettings spis) {
+    DEBUGSPI("SPISlave::begin(%d), rx=%d, cs=%d, sck=%d, tx=%d\n", hwCS, _RX, _CS, _SCK, _TX);
+    gpio_set_function(_RX, GPIO_FUNC_SPI);
+    gpio_set_function(_CS, GPIO_FUNC_SPI);
+    gpio_set_function(_SCK, GPIO_FUNC_SPI);
+    gpio_set_function(_TX, GPIO_FUNC_SPI);
+    if (_initted) {
+        DEBUGSPI("SPISlave: deinitting currently active SPI\n");
+        spi_deinit(_spi);
+    }
+    DEBUGSPI("SPISlave: initting SPI\n");
+    spi_init(_spi, _spis.getClockFreq());
+    DEBUGSPI("SPISlave: actual baudrate=%u\n", spi_get_baudrate(_spi));
+    spi_set_slave(_spi, true);
+    spi_set_format(_spi, 8, cpol(spis),	cpha(spis), SPI_MSB_FIRST);
+
+    // Install our IRQ handler
+    if (_spi == spi0) {
+        irq_set_exclusive_handler(SPI0_IRQ, _irq0);
+    } else {
+        irq_set_exclusive_handler(SPI1_IRQ, _irq1);
+    }
+
+    // Set to get IRQs on transmit and receive
+    spi_get_hw(_spi)->imsc = 2 | 4 | 8 ; // RTIM + RXIM + TXIM (not RORIM)
+    _initted = true;
+    irq_set_enabled(_spi == spi0 ? SPI0_IRQ : SPI1_IRQ, true);
+}
+
+void SPISlaveClass::end() {
+    DEBUGSPI("SPISlave::end()\n");
+    if (_initted) {
+        DEBUGSPI("SPISlave: deinitting currently active SPI\n");
+        if (_spi == spi0) {
+            irq_remove_handler(SPI0_IRQ, _irq0);
+        } else {
+            irq_remove_handler(SPI1_IRQ, _irq1);
+        }
+        spi_deinit(_spi);
+        _initted = false;
+    }
+    gpio_set_function(_RX, GPIO_FUNC_SIO);
+    gpio_set_function(_CS, GPIO_FUNC_SIO);
+    gpio_set_function(_SCK, GPIO_FUNC_SIO);
+    gpio_set_function(_TX, GPIO_FUNC_SIO);
+}
+
+#ifndef __SPI0_DEVICE
+#define __SPI0_DEVICE spi0
+#endif
+#ifndef __SPI1_DEVICE
+#define __SPI1_DEVICE spi1
+#endif
+
+SPISlaveClass SPISlave(__SPI0_DEVICE, PIN_SPI0_MISO, PIN_SPI0_SS, PIN_SPI0_SCK, PIN_SPI0_MOSI);
+SPISlaveClass SPISlave1(__SPI1_DEVICE, PIN_SPI1_MISO, PIN_SPI1_SS, PIN_SPI1_SCK, PIN_SPI1_MOSI);

libraries/SPISlave/src/SPISlave.h

@@ -0,0 +1,95 @@
+/*
+    SPI Slave library for the Raspberry Pi Pico RP2040
+
+    Copyright (c) 2023 Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#pragma once
+
+#include <Arduino.h>
+#include <api/HardwareSPI.h>
+#include <hardware/spi.h>
+#include <functional>
+
+typedef std::function<void(uint8_t *data, size_t len)> SPISlaveRecvHandler;
+typedef std::function<void(void)> SPISlaveSentHandler;
+
+class SPISlaveClass {
+public:
+    SPISlaveClass(spi_inst_t *spi, pin_size_t rx, pin_size_t cs, pin_size_t sck, pin_size_t tx);
+
+    // Assign pins, call before begin()
+    bool setRX(pin_size_t pin);
+    bool setCS(pin_size_t pin);
+    bool setSCK(pin_size_t pin);
+    bool setTX(pin_size_t pin);
+
+    void begin(SPISettings spis);
+    void end();
+
+    // May be set before the initial begin().  If not, then as soon as
+    // begin() is called you will get a callback.
+    void setData(const uint8_t * data, size_t len);
+    inline void setData(const char * data) {
+        setData((const uint8_t *)data, strlen(data));
+    }
+
+    // NOTE: These two callbacks are called from an IRQ context
+    // NOTE: They should also be called before begin()
+
+    // Called when bytes are available to be read from the SPI slave reception buffer
+    void onDataRecv(SPISlaveRecvHandler cb) {
+        _recvCB = cb;
+    }
+    // Called when there is space in the SPI transmission buffer
+    void onDataSent(SPISlaveSentHandler cb) {
+        _sentCB = cb;
+    }
+
+private:
+    // Naked IRQ callbacks, will thunk to real object ones below
+    static void _irq0();
+    static void _irq1();
+
+public:
+    void _handleIRQ();
+
+private:
+    spi_cpol_t cpol(SPISettings _spis);
+    spi_cpha_t cpha(SPISettings _spis);
+    uint8_t reverseByte(uint8_t b);
+    uint16_t reverse16Bit(uint16_t w);
+    void adjustBuffer(const void *s, void *d, size_t cnt, bool by16);
+
+    spi_inst_t *_spi;
+    SPISettings _spis;
+    pin_size_t _RX, _TX, _SCK, _CS;
+    bool _running; // SPI port active
+    bool _initted; // Transaction begun
+
+    SPISlaveRecvHandler _recvCB;
+    SPISlaveSentHandler _sentCB;
+
+    // The current data to be pumped into the transmit FIFO
+    const uint8_t *_dataOut;
+    size_t _dataLeft;
+
+    // Received data will be returned in small chunks directly from a local buffer in _handleIRQ()
+};
+
+extern SPISlaveClass SPISlave;
+extern SPISlaveClass SPISlave1;

libraries/WebServer/examples/AdvancedWebServer/AdvancedWebServer.ino

@@ -28,7 +28,17 @@
    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
+// Example works with either Wired or WiFi Ethernet, define one of these values to 1, other to 0
+#define USE_WIFI 1
+#define USE_WIRED 0
+
+#if USE_WIFI
 #include <WiFi.h>
+#elif USE_WIRED
+#include <W5500lwIP.h> // Or W5100lwIP.h or ENC28J60lwIP.h
+Wiznet5500lwIP eth(1 /* chip select */); // or Wiznet5100lwIP or ENC28J60lwIP
+#endif
+
 #include <WiFiClient.h>
 #include <WebServer.h>
 #include <LEAmDNS.h>
@@ -58,13 +68,13 @@ void handleRoot() {
   temp.printf("<html>\
   <head>\
     <meta http-equiv='refresh' content='5'/>\
-    <title>Pico-W Demo</title>\
+    <title>" BOARD_NAME " Demo</title>\
     <style>\
       body { background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }\
     </style>\
   </head>\
   <body>\
-    <h1>Hello from the Pico W!</h1>\
+    <h1>Hello from the " BOARD_NAME "!</h1>\
     <p>Uptime: %02d:%02d:%02d</p>\
     <p>Free Memory: %d</p>\
     <p>Page Count: %d</p>\
@@ -117,6 +127,8 @@ void setup(void) {
   pinMode(led, OUTPUT);
   digitalWrite(led, 0);
   Serial.begin(115200);
+
+#if USE_WIFI
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
   Serial.println("");
@@ -130,8 +142,32 @@ void setup(void) {
   Serial.println("");
   Serial.print("Connected to ");
   Serial.println(ssid);
+
   Serial.print("IP address: ");
   Serial.println(WiFi.localIP());
+#elif USE_WIRED
+  // Set up SPI pinout to match your HW
+  SPI.setRX(0);
+  SPI.setCS(1);
+  SPI.setSCK(2);
+  SPI.setTX(3);
+
+  // Start the Ethernet port
+  if (!eth.begin()) {
+    Serial.println("No wired Ethernet hardware detected. Check pinouts, wiring.");
+    while (1) {
+      delay(1000);
+    }
+  }
+
+  // Wait for connection
+  while (eth.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.print("IP address: ");
+  Serial.println(eth.localIP());
+#endif
 
   if (MDNS.begin("picow")) {
     Serial.println("MDNS responder started");

libraries/WiFi/examples/WiFiClient/WiFiClient.ino

@@ -61,7 +61,7 @@ void loop() {
   // This will send a string to the server
   Serial.println("sending data to server");
   if (client.connected()) {
-    client.println("hello from ESP8266");
+    client.println("hello from RP2040");
   }
 
   // wait for data to be available

libraries/WiFi/keywords.txt

@@ -1,5 +1,5 @@
 #######################################
-# Syntax Coloring Map For WiFiNINA
+# Syntax Coloring Map For WiFi
 #######################################
 
 #######################################
@@ -7,7 +7,6 @@
 #######################################
 
 WiFi	KEYWORD1
-WiFiPico	KEYWORD1
 WiFiUdp	KEYWORD1
 WiFiClient	KEYWORD1
 WiFiSSLClient	KEYWORD1
@@ -51,6 +50,7 @@ remoteIP	KEYWORD2
 remotePort	KEYWORD2
 mode	KEYWORD2
 addAP	KEYWORD2
+hostByName	KEYWORD2
 
 beginAP	KEYWORD2
 beginEnterprise	KEYWORD2

libraries/WiFi/library.properties

@@ -9,4 +9,4 @@ url=http://github.com/earlephilhower/arduino-pico
 architectures=rp2040
 includes=WiFi.h
 dot_a_linkage=true
-depends=MD5Header
+depends=MD5Header,Updater,LWIPEthernet

libraries/WiFi/src/WiFiClass.cpp

@@ -583,9 +583,9 @@ uint8_t WiFiClass::reasonCode() {
     @return 1 if aIPAddrString was successfully converted to an IP address,
             else 0
 */
-
+// Note that there is now a global FCN for name lookup to use all Ethernet ports, no need to call WiFi.hostByName, just ::hostByName
 int WiFiClass::hostByName(const char* aHostname, IPAddress& aResult, int timeout_ms) {
-    return _wifi.hostByName(aHostname, aResult, timeout_ms);
+    return ::hostByName(aHostname, aResult, timeout_ms);
 }
 
 // TODO

libraries/WiFi/src/WiFiClass.h

@@ -23,6 +23,7 @@
 #pragma once
 
 #include <Arduino.h>
+#include <lwIP_CYW43.h>
 #include "WiFi.h"
 
 #include <inttypes.h>

libraries/WiFi/src/WiFiClient.cpp

@@ -113,7 +113,7 @@ WiFiClient& WiFiClient::operator=(const WiFiClient& other) {
 
 int WiFiClient::connect(const char* host, uint16_t port) {
     IPAddress remote_addr;
-    if (WiFi.hostByName(host, remote_addr, _timeout)) {
+    if (::hostByName(host, remote_addr, _timeout)) {
         return connect(remote_addr, port);
     }
     return 0;
@@ -360,7 +360,6 @@ void WiFiClient::stopAllExcept(WiFiClient* except) {
     }
 }
 
-
 void WiFiClient::keepAlive(uint16_t idle_sec, uint16_t intv_sec, uint8_t count) {
     _client->keepAlive(idle_sec, intv_sec, count);
 }
@@ -380,28 +379,3 @@ uint16_t WiFiClient::getKeepAliveInterval() const {
 uint8_t WiFiClient::getKeepAliveCount() const {
     return _client->getKeepAliveCount();
 }
-
-//bool WiFiClient::hasPeekBufferAPI () const
-//{
-//    return true;
-//}
-
-// return a pointer to available data buffer (size = peekAvailable())
-// semantic forbids any kind of read() before calling peekConsume()
-//const char* WiFiClient::peekBuffer ()
-//{
-//    return _client? _client->peekBuffer(): nullptr;
-//}
-
-// return number of byte accessible by peekBuffer()
-//size_t WiFiClient::peekAvailable ()
-//{
-//    return _client? _client->peekAvailable(): 0;
-//}
-
-// consume bytes after use (see peekBuffer)
-//void WiFiClient::peekConsume (size_t consume)
-//{
-//    if (_client)
-//        _client->peekConsume(consume);
-//}

libraries/WiFi/src/WiFiClientSecureBearSSL.cpp

@@ -240,7 +240,7 @@ int WiFiClientSecureCtx::connect(IPAddress ip, uint16_t port) {
 
 int WiFiClientSecureCtx::connect(const char* name, uint16_t port) {
     IPAddress remote_addr;
-    if (!WiFi.hostByName(name, remote_addr)) {
+    if (!::hostByName(name, remote_addr)) {
         DEBUG_BSSL("connect: Name lookup failure\n");
         return 0;
     }
@@ -1457,7 +1457,7 @@ int WiFiClientSecureCtx::getLastSSLError(char *dest, size_t len) {
 
 bool WiFiClientSecure::probeMaxFragmentLength(const char* name, uint16_t port, uint16_t len) {
     IPAddress remote_addr;
-    if (!WiFi.hostByName(name, remote_addr)) {
+    if (!::hostByName(name, remote_addr)) {
         DEBUG_BSSL("probeMaxFragmentLength: Can't resolve host\n");
         return false;
     }

libraries/WiFi/src/WiFiClientSecureBearSSL.h

@@ -25,6 +25,7 @@
 
 #include <vector>
 #include "WiFiClient.h"
+#include <LwipEthernet.h>
 #include <bearssl/bearssl.h>
 #include "BearSSLHelpers.h"
 #include "CertStoreBearSSL.h"
@@ -247,7 +248,7 @@ public:
     }
     int connect(const char *host, uint16_t port, const char *rootCABuff, const char *cli_cert, const char *cli_key) {
         IPAddress ip;
-        if (WiFi.hostByName(host, ip, _timeout)) {
+        if (::hostByName(host, ip, _timeout)) {
             return connect(ip, port, rootCABuff, cli_cert, cli_key);
         } else {
             return 0;

libraries/WiFi/src/WiFiNTP.h

@@ -58,7 +58,7 @@ public:
 
     void begin(const char *server, int timeout = 3600) {
         IPAddress addr;
-        if (WiFi.hostByName(server, addr)) {
+        if (::hostByName(server, addr)) {
             begin(addr, timeout);
         }
         _running = true;
@@ -66,8 +66,8 @@ public:
 
     void begin(const char *s1, const char *s2, int timeout = 3600) {
         IPAddress a1, a2;
-        if (WiFi.hostByName(s1, a1)) {
-            if (WiFi.hostByName(s2, a2)) {
+        if (::hostByName(s1, a1)) {
+            if (::hostByName(s2, a2)) {
                 begin(a1, a2, timeout);
             } else {
                 begin(a1, timeout);

libraries/WiFi/src/WiFiUdp.cpp

@@ -133,7 +133,7 @@ void WiFiUDP::stop() {
 
 int WiFiUDP::beginPacket(const char *host, uint16_t port) {
     IPAddress remote_addr;
-    if (WiFi.hostByName(host, remote_addr)) {
+    if (::hostByName(host, remote_addr)) {
         return beginPacket(remote_addr, port);
     }
     return 0;

libraries/WiFi/src/include/ClientContext.h

@@ -37,9 +37,9 @@ bool getDefaultPrivateGlobalSyncValue();
 template <typename T>
 inline void esp_delay(const uint32_t timeout_ms, T&& blocked, const uint32_t intvl_ms) {
     const auto start_ms = millis();
+    (void) intvl_ms;
     while ((((uint32_t)millis() - start_ms) < timeout_ms) && blocked()) {
-        sys_check_timeouts();
-        delay(intvl_ms);
+        delay(1);
     }
 }
 

libraries/Wire/src/Wire.cpp

@@ -262,6 +262,9 @@ size_t TwoWire::requestFrom(uint8_t address, size_t quantity, bool stopBit) {
 
     _buffLen = i2c_read_blocking_until(_i2c, address, _buff, quantity, !stopBit, make_timeout_time_ms(_timeout));
     if ((_buffLen == PICO_ERROR_GENERIC) || (_buffLen == PICO_ERROR_TIMEOUT)) {
+        if (_buffLen == PICO_ERROR_TIMEOUT) {
+            _handleTimeout(_reset_with_timeout);
+        }
         _buffLen = 0;
     }
     _buffOff = 0;
@@ -335,12 +338,32 @@ stop:
     return ack;
 }
 
+void TwoWire::_handleTimeout(bool reset) {
+    _timeoutFlag = true;
+
+    if (reset) {
+        if (_slave) {
+            uint8_t prev_addr = _addr;
+            int prev_clkHz = _clkHz;
+            end();
+            setClock(prev_clkHz);
+            begin(prev_addr);
+        } else {
+            int prev_clkHz = _clkHz;
+            end();
+            setClock(prev_clkHz);
+            begin();
+        }
+    }
+}
+
 // Errors:
 //  0 : Success
 //  1 : Data too long
 //  2 : NACK on transmit of address
 //  3 : NACK on transmit of data
 //  4 : Other error
+//  5 : Timeout
 uint8_t TwoWire::endTransmission(bool stopBit) {
     if (!_running || !_txBegun) {
         return 4;
@@ -352,6 +375,10 @@ uint8_t TwoWire::endTransmission(bool stopBit) {
     } else {
         auto len = _buffLen;
         auto ret = i2c_write_blocking_until(_i2c, _addr, _buff, _buffLen, !stopBit, make_timeout_time_ms(_timeout));
+        if (ret == PICO_ERROR_TIMEOUT) {
+            _handleTimeout(_reset_with_timeout);
+            return 5;
+        }
         _buffLen = 0;
         return (ret == len) ? 0 : 4;
     }
@@ -422,6 +449,20 @@ void TwoWire::onRequest(void(*function)(void)) {
     _onRequestCallback = function;
 }
 
+void TwoWire::setTimeout(uint32_t timeout, bool reset_with_timeout) {
+    _timeoutFlag = false;
+    Stream::setTimeout(timeout);
+    _reset_with_timeout = reset_with_timeout;
+}
+
+bool TwoWire::getTimeoutFlag() {
+    return _timeoutFlag;
+}
+
+void TwoWire::clearTimeoutFlag() {
+    _timeoutFlag = false;
+}
+
 #ifndef __WIRE0_DEVICE
 #define __WIRE0_DEVICE i2c0
 #endif

libraries/Wire/src/Wire.h

@@ -82,6 +82,10 @@ public:
     }
     using Print::write;
 
+    void setTimeout(uint32_t timeout = 25, bool reset_with_timeout = false);     // sets the maximum number of milliseconds to wait
+    bool getTimeoutFlag(void);
+    void clearTimeoutFlag(void);
+
     // IRQ callback
     void onIRQ();
 
@@ -96,6 +100,10 @@ private:
     uint8_t _addr;
     bool _txBegun;
 
+    bool _timeoutFlag;
+    bool _reset_with_timeout;
+    void _handleTimeout(bool reset);
+
     uint8_t _buff[WIRE_BUFFER_SIZE];
     int _buffLen;
     int _buffOff;

libraries/lwIP_CYW43/src/utility/CYW43shim.h

@@ -66,6 +66,27 @@ public:
     */
     uint16_t readFrame(uint8_t* buffer, uint16_t bufsize);
 
+    // -------------  Dummy handler, actually run in the SDK async context  -------------
+    void handlePackets() {
+    }
+
+    // ------------- Dummy handler for linkage, but never called at runtime -------------
+    uint16_t readFrameSize() {
+        return 0;
+    }
+
+    // ------------- Dummy handler for linkage, but never called at runtime -------------
+    void discardFrame(uint16_t ign) {
+        (void) ign;
+    }
+
+    // ------------- Dummy handler for linkage, but never called at runtime -------------
+    uint16_t readFrameData(uint8_t *ign1, uint16_t ign2) {
+        (void) ign1;
+        (void) ign2;
+        return 0;
+    }
+
     bool interruptIsPossible() {
         return true;
     }
@@ -94,6 +115,10 @@ public:
         _timeout = timeout;
     }
 
+    constexpr bool needsSPI() const {
+        return false;
+    }
+
     // LWIP netif for the IRQ packet processing
     static netif   *_netif;
 protected:

libraries/lwIP_Ethernet/keywords.txt

@@ -0,0 +1,19 @@
+#######################################
+# Syntax Coloring Map
+#######################################
+
+#######################################
+# Library (KEYWORD1)
+#######################################
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+lwipPollingPeriod	KEYWORD2
+setSPISpeed	KEYWORD2
+setSPISettings	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

libraries/lwIP_Ethernet/library.properties

@@ -6,5 +6,6 @@ sentence=Helper for ethernet drivers
 paragraph=Example repository for Ethernet drivers
 category=Communication
 url=https://github.com/esp8266/Arduino
-architectures=esp8266,rp2040
+architectures=rp2040
 dot_a_linkage=true
+depends=WiFi,Updater

libraries/lwIP_Ethernet/src/LwipEthernet.cpp

@@ -1,14 +1,179 @@
+/*
+    LwipEthernet.cpp
+
+    Handles the async context for wired Ethernet
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
 
 #include <LwipEthernet.h>
-//#include <SPI.h>
+#include <lwip/timeouts.h>
+#include <lwip/dns.h>
+#include <pico/mutex.h>
+#include <pico/cyw43_arch.h>
+#include <pico/async_context_threadsafe_background.h>
+#include <functional>
+#include <map>
 
-//#ifndef ETHERNET_SPI_CLOCK_DIV
-//#define ETHERNET_SPI_CLOCK_DIV SPI_CLOCK_DIV4  // 4MHz (SPI.h)
-//#endif
+bool __ethernetContextInitted = false;
 
-void SPI4EthInit() {
-    //SPI.begin();
-    //    SPI.setClockDivider(ETHERNET_SPI_CLOCK_DIV);
-    //    SPI.setBitOrder(MSBFIRST);
-    //    SPI.setDataMode(SPI_MODE0);
+// Async context that pumps the ethernet controllers
+static async_context_threadsafe_background_t lwip_ethernet_async_context_threadsafe_background;
+static async_when_pending_worker_t always_pending_update_timeout_worker;
+static async_at_time_worker_t ethernet_timeout_worker;
+
+static async_context_t *_context = nullptr;
+
+// Theoretically support multiple interfaces
+static std::map<int, std::function<void(void)>> _handlePacketList;
+
+void ethernet_arch_lwip_begin() {
+#if defined(ARDUINO_RASPBERRY_PI_PICO_W)
+    if (rp2040.isPicoW()) {
+        cyw43_arch_lwip_begin();
+        return;
+    }
+#endif
+    async_context_acquire_lock_blocking(&lwip_ethernet_async_context_threadsafe_background.core);
+}
+
+void ethernet_arch_lwip_end() {
+#if defined(ARDUINO_RASPBERRY_PI_PICO_W)
+    if (rp2040.isPicoW()) {
+        cyw43_arch_lwip_end();
+        return;
+    }
+#endif
+    async_context_release_lock(&lwip_ethernet_async_context_threadsafe_background.core);
+}
+
+int __addEthernetPacketHandler(std::function<void(void)> _packetHandler) {
+    static int id = 0xdead;
+    ethernet_arch_lwip_begin();
+    _handlePacketList.insert({id, _packetHandler});
+    ethernet_arch_lwip_end();
+    return id++;
+}
+
+void __removeEthernetPacketHandler(int id) {
+    ethernet_arch_lwip_begin();
+    _handlePacketList.erase(id);
+    ethernet_arch_lwip_end();
+}
+
+static volatile bool _dns_lookup_pending = false;
+
+static void _dns_found_callback(const char *name, const ip_addr_t *ipaddr, void *callback_arg) {
+    (void) name;
+    if (!_dns_lookup_pending) {
+        return;
+    }
+    if (ipaddr) {
+        *(IPAddress *)callback_arg = IPAddress(ipaddr);
+    }
+    _dns_lookup_pending = false; // resume hostByName
+}
+
+int hostByName(const char* aHostname, IPAddress& aResult, int timeout_ms) {
+    ip_addr_t addr;
+    aResult = static_cast<uint32_t>(0xffffffff);
+
+    if (aResult.fromString(aHostname)) {
+        // Host name is a IP address use it!
+        return 1;
+    }
+
+#if LWIP_IPV4 && LWIP_IPV6
+    err_t err = dns_gethostbyname_addrtype(aHostname, &addr, &_dns_found_callback, &aResult, LWIP_DNS_ADDRTYPE_DEFAULT);
+#else
+    err_t err = dns_gethostbyname(aHostname, &addr, &_dns_found_callback, &aResult);
+#endif
+    if (err == ERR_OK) {
+        aResult = IPAddress(&addr);
+    } else if (err == ERR_INPROGRESS) {
+        _dns_lookup_pending = true;
+        uint32_t now = millis();
+        while ((millis() - now < (uint32_t)timeout_ms) && _dns_lookup_pending) {
+            delay(1);
+        }
+        _dns_lookup_pending = false;
+        if (aResult.isSet()) {
+            err = ERR_OK;
+        }
+    }
+
+    if (err == ERR_OK) {
+        return 1;
+    }
+
+    return 0;
+}
+
+static async_context_t *lwip_ethernet_init_default_async_context(void) {
+    async_context_threadsafe_background_config_t config = async_context_threadsafe_background_default_config();
+    if (async_context_threadsafe_background_init(&lwip_ethernet_async_context_threadsafe_background, &config)) {
+        return &lwip_ethernet_async_context_threadsafe_background.core;
+    }
+    return NULL;
+}
+
+// This will only be called under the protection of the async context mutex, so no re-entrancy checks needed
+static void ethernet_timeout_reached(__unused async_context_t *context, __unused async_at_time_worker_t *worker) {
+    assert(worker == &ethernet_timeout_worker);
+    for (auto handlePacket : _handlePacketList) {
+        handlePacket.second();
+    }
+#if defined(ARDUINO_RASPBERRY_PI_PICO_W)
+    if (!rp2040.isPicoW()) {
+        sys_check_timeouts();
+    }
+#else
+    sys_check_timeouts();
+#endif
+}
+
+static uint32_t _pollingPeriod = 20;
+static void update_next_timeout(async_context_t *context, async_when_pending_worker_t *worker) {
+    assert(worker == &always_pending_update_timeout_worker);
+    worker->work_pending = true;
+    async_context_add_at_time_worker_in_ms(context, &ethernet_timeout_worker, _pollingPeriod);
+}
+
+void __startEthernetContext() {
+    if (__ethernetContextInitted) {
+        return;
+    }
+#if defined(ARDUINO_RASPBERRY_PI_PICO_W)
+    if (rp2040.isPicoW()) {
+        _context = cyw43_arch_async_context();
+    } else {
+        _context = lwip_ethernet_init_default_async_context();
+    }
+#else
+    _context = lwip_ethernet_init_default_async_context();
+#endif
+    always_pending_update_timeout_worker.work_pending = true;
+    always_pending_update_timeout_worker.do_work = update_next_timeout;
+    ethernet_timeout_worker.do_work = ethernet_timeout_reached;
+    async_context_add_when_pending_worker(_context, &always_pending_update_timeout_worker);
+    __ethernetContextInitted = true;
+}
+
+void lwipPollingPeriod(int ms) {
+    if (ms > 0) {
+        // No need for mutexes, this is an atomic 32b write
+        _pollingPeriod = ms;
+    }
 }

libraries/lwIP_Ethernet/src/LwipEthernet.h

@@ -20,53 +20,22 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
+#pragma once
 
-//#include <ESP8266WiFi.h>  // tcp API
-//#include <debug.h>
 #include <Arduino.h>
+#include <functional>
 
-#include <lwIP_CYW43.h>
-//#include <W5100lwIP.h>
-//#include <W5500lwIP.h>
-//#include <ENC28J60lwIP.h>
+void ethernet_arch_lwip_begin() __attribute__((weak));
+void ethernet_arch_lwip_end() __attribute__((weak));
 
-// One of them is to be declared in the main sketch
-// and passed to ethInitDHCP() or ethInitStatic():
-// Wiznet5500lwIP eth(CSPIN);
-// Wiznet5100lwIP eth(CSPIN);
-// ENC28J60lwIP eth(CSPIN);
+// Internal Ethernet helper functions
+void __startEthernetContext();
 
-void SPI4EthInit();
+int __addEthernetPacketHandler(std::function<void(void)> _packetHandler);
+void __removeEthernetPacketHandler(int id);
 
-template<class EthImpl>
-bool ethInitDHCP(EthImpl& eth) {
-    SPI4EthInit();
+// Used by WiFiClient to get DNS lookup
+int hostByName(const char *aHostname, IPAddress &aResult, int timeout_ms = 5000);
 
-    if (!eth.begin()) {
-        // hardware not responding
-        //        DEBUGV("ethInitDHCP: hardware not responding\n");
-        return false;
-    }
-
-    return true;
-}
-
-template<class EthImpl>
-bool ethInitStatic(EthImpl& eth, IPAddress IP, IPAddress gateway, IPAddress netmask, IPAddress dns1,
-                   IPAddress dns2 = IPADDR_NONE) {
-    SPI4EthInit();
-
-    if (!eth.config(IP, gateway, netmask, dns1, dns2)) {
-        // invalid arguments
-        //        DEBUGV("ethInitStatic: invalid arguments\n");
-        return false;
-    }
-
-    if (!eth.begin()) {
-        // hardware not responding
-        //        DEBUGV("ethInitStatic: hardware not responding\n");
-        return false;
-    }
-
-    return true;
-}
+// Set the LWIP polling time (default 50ms).  Lower polling times == lower latency but higher CPU usage
+void lwipPollingPeriod(int ms);

libraries/lwIP_Ethernet/src/LwipIntfDev.h

@@ -40,24 +40,24 @@
 #include <lwip/inet_chksum.h>
 #include <lwip/apps/sntp.h>
 
-//#include <user_interface.h>  // wifi_get_macaddr()
 
 #include "SPI.h"
-//#include "Schedule.h"
 #include "LwipIntf.h"
+#include "LwipEthernet.h"
 #include "wl_definitions.h"
 
 #ifndef DEFAULT_MTU
 #define DEFAULT_MTU 1500
 #endif
 
+
 extern "C" void cyw43_hal_generate_laa_mac(__unused int idx, uint8_t buf[6]);
 
 template<class RawDev>
 class LwipIntfDev: public LwipIntf, public RawDev {
 public:
     LwipIntfDev(int8_t cs = SS, SPIClass& spi = SPI, int8_t intr = -1) :
-        RawDev(cs, spi, intr), _mtu(DEFAULT_MTU), _intrPin(intr), _started(false), _default(false) {
+        RawDev(cs, spi, intr), _spiUnit(spi), _mtu(DEFAULT_MTU), _intrPin(intr), _started(false), _default(false) {
         memset(&_netif, 0, sizeof(_netif));
     }
 
@@ -109,6 +109,14 @@ public:
 
     int hostByName(const char* aHostname, IPAddress& aResult, int timeout);
 
+    inline void setSPISpeed(int mhz) {
+        setSPISettings(SPISettings(mhz, MSBFIRST, SPI_MODE0));
+    }
+
+    void setSPISettings(SPISettings s) {
+        _spiSettings = s;
+    }
+
     // ESP8266WiFi API compatibility
 
     wl_status_t status();
@@ -121,12 +129,13 @@ protected:
     static err_t netif_init_s(netif* netif);
     static err_t linkoutput_s(netif* netif, struct pbuf* p);
     static void  netif_status_callback_s(netif* netif);
-
+public:
     // called on a regular basis or on interrupt
     err_t handlePackets();
-
+protected:
     // members
-
+    SPIClass& _spiUnit;
+    SPISettings _spiSettings = SPISettings(4000000, MSBFIRST, SPI_MODE0);
     netif _netif;
 
     uint16_t _mtu;
@@ -141,65 +150,14 @@ protected:
     volatile int _ping_ttl;
     static u8_t _pingCB(void *arg, struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *addr);
 
-    // DNS lookup callback
-    bool _dns_lookup_pending = false;
-    typedef struct {
-        IPAddress *ip;
-        LwipIntfDev<RawDev> *wifi;
-    } _dns_cb_t;
-    static void _dns_found_callback(const char *name, const ip_addr_t *ipaddr, void *callback_arg);
+    // Packet handler number
+    int _phID = -1;
 };
 
 
-template<class RawDev>
-void LwipIntfDev<RawDev>::_dns_found_callback(const char *name, const ip_addr_t *ipaddr, void *callback_arg) {
-    (void) name;
-    _dns_cb_t *cb = (_dns_cb_t *)callback_arg;
-    if (!cb->wifi->_dns_lookup_pending) {
-        return;
-    }
-    if (ipaddr) {
-        *(cb->ip) = IPAddress(ipaddr);
-    }
-    cb->wifi->_dns_lookup_pending = false; // resume hostByName
-}
-
 template<class RawDev>
 int LwipIntfDev<RawDev>::hostByName(const char* aHostname, IPAddress& aResult, int timeout_ms) {
-    ip_addr_t addr;
-    aResult = static_cast<uint32_t>(0xffffffff);
-
-    if (aResult.fromString(aHostname)) {
-        // Host name is a IP address use it!
-        return 1;
-    }
-
-    _dns_cb_t cb = { &aResult, this };
-#if LWIP_IPV4 && LWIP_IPV6
-    err_t err = dns_gethostbyname_addrtype(aHostname, &addr, &_dns_found_callback, &cb, LWIP_DNS_ADDRTYPE_DEFAULT);
-#else
-    err_t err = dns_gethostbyname(aHostname, &addr, &_dns_found_callback, &cb);
-#endif
-    if (err == ERR_OK) {
-        aResult = IPAddress(&addr);
-    } else if (err == ERR_INPROGRESS) {
-        _dns_lookup_pending = true;
-        uint32_t now = millis();
-        while ((millis() - now < (uint32_t)timeout_ms) && _dns_lookup_pending) {
-            sys_check_timeouts();
-            delay(10);
-        }
-        _dns_lookup_pending = false;
-        if (aResult.isSet()) {
-            err = ERR_OK;
-        }
-    }
-
-    if (err == ERR_OK) {
-        return 1;
-    }
-
-    return 0;
+    return ::hostByName(aHostname, aResult, timeout_ms);
 }
 
 template<class RawDev>
@@ -293,7 +251,16 @@ bool LwipIntfDev<RawDev>::config(const IPAddress& localIP, const IPAddress& gate
 }
 extern char wifi_station_hostname[];
 template<class RawDev>
-boolean LwipIntfDev<RawDev>::begin(const uint8_t* macAddress, const uint16_t mtu) {
+bool LwipIntfDev<RawDev>::begin(const uint8_t* macAddress, const uint16_t mtu) {
+    lwip_init();
+    __startEthernetContext();
+
+    if (RawDev::needsSPI()) {
+        _spiUnit.begin();
+        // Set SPI clocks/etc. per request, doesn't seem to be direct way other than a fake transaction
+        _spiUnit.beginTransaction(_spiSettings);
+        _spiUnit.endTransaction();
+    }
     if (mtu) {
         _mtu = mtu;
     }
@@ -343,6 +310,8 @@ boolean LwipIntfDev<RawDev>::begin(const uint8_t* macAddress, const uint16_t mtu
         return false;
     }
 
+    _phID = __addEthernetPacketHandler([this] { this->handlePackets(); });
+
     if (localIP().v4() == 0) {
         // IP not set, starting DHCP
         _netif.flags |= NETIF_FLAG_UP;
@@ -383,24 +352,15 @@ boolean LwipIntfDev<RawDev>::begin(const uint8_t* macAddress, const uint16_t mtu
         }
     }
 
-#if 0
-    if (_intrPin < 0
-            && !schedule_recurrent_function_us(
-    [&]() {
-    this->handlePackets();
-        return true;
-    },
-    100)) {
-        netif_remove(&_netif);
-        return false;
-    }
-#endif
     return true;
 }
 
 template<class RawDev>
 void LwipIntfDev<RawDev>::end() {
+    __removeEthernetPacketHandler(_phID);
+
     RawDev::end();
+
     netif_remove(&_netif);
     memset(&_netif, 0, sizeof(_netif));
     _started = false;
@@ -415,7 +375,7 @@ wl_status_t LwipIntfDev<RawDev>::status() {
 template<class RawDev>
 err_t LwipIntfDev<RawDev>::linkoutput_s(netif* netif, struct pbuf* pbuf) {
     LwipIntfDev* lid = (LwipIntfDev*)netif->state;
-
+    ethernet_arch_lwip_begin();
     uint16_t len = lid->sendFrame((const uint8_t*)pbuf->payload, pbuf->len);
 
 #if PHY_HAS_CAPTURE
@@ -424,7 +384,7 @@ err_t LwipIntfDev<RawDev>::linkoutput_s(netif* netif, struct pbuf* pbuf) {
                     /*success*/ len == pbuf->len);
     }
 #endif
-
+    ethernet_arch_lwip_end();
     return len == pbuf->len ? ERR_OK : ERR_MEM;
 }
 

libraries/lwIP_enc28j60/examples/WiFiClient-ENC28J60/WiFiClient-ENC28J60.ino

@@ -0,0 +1,95 @@
+/*
+    This sketch establishes a TCP connection to a "quote of the day" service.
+    It sends a "hello" message, and then prints received data.
+*/
+
+#include <ENC28J60lwIP.h>
+
+const char* host = "djxmmx.net";
+const uint16_t port = 17;
+
+ENC28J60lwIP eth(1 /* chip select */);
+
+void setup() {
+  // Set up SPI pinout to match your HW
+  SPI.setRX(0);
+  SPI.setCS(1);
+  SPI.setSCK(2);
+  SPI.setTX(3);
+
+  Serial.begin(115200);
+  delay(5000);
+  Serial.println();
+  Serial.println();
+  Serial.println("Starting Ethernet port");
+
+  // Start the Ethernet port
+  if (!eth.begin()) {
+    Serial.println("No wired Ethernet hardware detected. Check pinouts, wiring.");
+    while (1) {
+      delay(1000);
+    }
+  }
+
+  while (!eth.connected()) {
+    Serial.print(".");
+    delay(500);
+  }
+
+  Serial.println("");
+  Serial.println("Ethernet connected");
+  Serial.println("IP address: ");
+  Serial.println(eth.localIP());
+}
+
+void loop() {
+  static bool wait = false;
+
+  Serial.print("connecting to ");
+  Serial.print(host);
+  Serial.print(':');
+  Serial.println(port);
+
+  // Use WiFiClient class to create TCP connections
+  WiFiClient client;
+  if (!client.connect(host, port)) {
+    Serial.println("connection failed");
+    delay(5000);
+    return;
+  }
+
+  // This will send a string to the server
+  Serial.println("sending data to server");
+  if (client.connected()) {
+    client.println("hello from RP2040");
+  }
+
+  // wait for data to be available
+  unsigned long timeout = millis();
+  while (client.available() == 0) {
+    if (millis() - timeout > 5000) {
+      Serial.println(">>> Client Timeout !");
+      client.stop();
+      delay(60000);
+      return;
+    }
+  }
+
+  // Read all the lines of the reply from server and print them to Serial
+  Serial.println("receiving from remote server");
+  // not testing 'client.connected()' since we do not need to send data here
+  while (client.available()) {
+    char ch = static_cast<char>(client.read());
+    Serial.print(ch);
+  }
+
+  // Close the connection
+  Serial.println();
+  Serial.println("closing connection");
+  client.stop();
+
+  if (wait) {
+    delay(300000);  // execute once every 5 minutes, don't flood remote service
+  }
+  wait = true;
+}

libraries/lwIP_enc28j60/keywords.txt

@@ -0,0 +1,17 @@
+#######################################
+# Syntax Coloring Map
+#######################################
+
+#######################################
+# Library (KEYWORD1)
+#######################################
+
+ENC28J60lwIP	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+#######################################

libraries/lwIP_enc28j60/library.properties

@@ -0,0 +1,10 @@
+name=lwIP_enc28j60
+version=1
+author=Nicholas Humfrey
+maintainer=esp8266/Arduino
+sentence=Ethernet driver
+paragraph=ENC28J60 ethernet drivers for lwIP and esp8266 Arduino from https://github.com/njh/EtherSia/tree/master/src/enc28j60.cpp
+category=Communication
+url=https://github.com/esp8266/Arduino
+architectures=rp2040
+dot_a_linkage=true

libraries/lwIP_enc28j60/src/ENC28J60lwIP.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <LwipIntfDev.h>
+#include <utility/enc28j60.h>
+#include <LwipEthernet.h>
+#include <WiFi.h>
+
+using ENC28J60lwIP = LwipIntfDev<ENC28J60>;

libraries/lwIP_enc28j60/src/utility/enc28j60.cpp

@@ -0,0 +1,704 @@
+/*
+    Copyright (c) 2012-2013, Thingsquare, http://www.thingsquare.com/.
+    Copyright (c) 2016, Nicholas Humfrey
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+    1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holder nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+    COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+    OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+// original sources: https://github.com/njh/EtherSia/tree/master/src/enc28j60.cpp
+
+#include <Arduino.h>
+#include <SPI.h>
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <LwipEthernet.h>
+
+#include "enc28j60.h"
+
+#define DEBUG 0
+#if DEBUG
+#define PRINTF(...) printf(__VA_ARGS__)
+#else
+#define PRINTF(...)                                                                                \
+    do                                                                                             \
+    {                                                                                              \
+        (void)0;                                                                                   \
+    } while (0)
+#endif
+
+#define EIE 0x1b
+#define EIR 0x1c
+#define ESTAT 0x1d
+#define ECON2 0x1e
+#define ECON1 0x1f
+
+#define ESTAT_CLKRDY 0x01
+#define ESTAT_TXABRT 0x02
+
+#define ECON1_RXEN 0x04
+#define ECON1_TXRTS 0x08
+
+#define ECON2_AUTOINC 0x80
+#define ECON2_PKTDEC 0x40
+
+#define EIR_TXIF 0x08
+
+#define ERXTX_BANK 0x00
+
+#define ERDPTL 0x00
+#define ERDPTH 0x01
+#define EWRPTL 0x02
+#define EWRPTH 0x03
+#define ETXSTL 0x04
+#define ETXSTH 0x05
+#define ETXNDL 0x06
+#define ETXNDH 0x07
+#define ERXSTL 0x08
+#define ERXSTH 0x09
+#define ERXNDL 0x0a
+#define ERXNDH 0x0b
+#define ERXRDPTL 0x0c
+#define ERXRDPTH 0x0d
+
+#define RX_BUF_START 0x0000
+#define RX_BUF_END 0x0fff
+
+#define TX_BUF_START 0x1200
+
+/* MACONx registers are in bank 2 */
+#define MACONX_BANK 0x02
+
+#define MACON1 0x00
+#define MACSTAT1 0x01
+#define MACON3 0x02
+#define MACON4 0x03
+#define MABBIPG 0x04
+#define MAIPGL 0x06
+#define MAIPGH 0x07
+#define MAMXFLL 0x0a
+#define MAMXFLH 0x0b
+#define MACON2 0x10
+#define MACSTAT2 0x11
+#define MICMD 0x12
+#define MIREGADR 0x14
+#define MIRDL 0x18
+#define MIRDH 0x19
+
+/* MICMD Register Bit Definitions */
+#define MICMD_MIISCAN 0x02
+#define MICMD_MIIRD 0x01
+
+#define MACON1_TXPAUS 0x08
+#define MACON1_RXPAUS 0x04
+#define MACON1_MARXEN 0x01
+
+#define MACON3_PADCFG_FULL 0xe0
+#define MACON3_TXCRCEN 0x10
+#define MACON3_FRMLNEN 0x02
+#define MACON3_FULDPX 0x01
+
+#define MAX_MAC_LENGTH 1518
+
+#define MAADRX_BANK 0x03
+#define MAADR1 0x04 /* MAADR<47:40> */
+#define MAADR2 0x05 /* MAADR<39:32> */
+#define MAADR3 0x02 /* MAADR<31:24> */
+#define MAADR4 0x03 /* MAADR<23:16> */
+#define MAADR5 0x00 /* MAADR<15:8> */
+#define MAADR6 0x01 /* MAADR<7:0> */
+#define MISTAT 0x0a
+#define EREVID 0x12
+
+/* MISTAT Register Bit Definitions */
+#define MISTAT_BUSY 0x01
+
+#define EPKTCNT_BANK 0x01
+#define ERXFCON 0x18
+#define EPKTCNT 0x19
+
+#define ERXFCON_UCEN 0x80
+#define ERXFCON_ANDOR 0x40
+#define ERXFCON_CRCEN 0x20
+#define ERXFCON_MCEN 0x02
+#define ERXFCON_BCEN 0x01
+
+// The ENC28J60 SPI Interface supports clock speeds up to 20 MHz
+static const SPISettings spiSettings(20000000, MSBFIRST, SPI_MODE0);
+
+ENC28J60::ENC28J60(int8_t cs, SPIClass& spi, int8_t intr) : _bank(ERXTX_BANK), _cs(cs), _spi(spi) {
+    (void)intr;
+}
+
+void ENC28J60::enc28j60_arch_spi_select(void) {
+    SPI.beginTransaction(spiSettings);
+    digitalWrite(_cs, LOW);
+}
+
+void ENC28J60::enc28j60_arch_spi_deselect(void) {
+    digitalWrite(_cs, HIGH);
+    SPI.endTransaction();
+}
+
+/*---------------------------------------------------------------------------*/
+uint8_t ENC28J60::is_mac_mii_reg(uint8_t reg) {
+    /* MAC or MII register (otherwise, ETH register)? */
+    switch (_bank) {
+    case MACONX_BANK:
+        return reg < EIE;
+    case MAADRX_BANK:
+        return reg <= MAADR2 || reg == MISTAT;
+    case ERXTX_BANK:
+    case EPKTCNT_BANK:
+    default:
+        return 0;
+    }
+}
+/*---------------------------------------------------------------------------*/
+uint8_t ENC28J60::readreg(uint8_t reg) {
+    uint8_t r;
+    enc28j60_arch_spi_select();
+    SPI.transfer(0x00 | (reg & 0x1f));
+    if (is_mac_mii_reg(reg)) {
+        /* MAC and MII registers require that a dummy byte be read first. */
+        SPI.transfer(0);
+    }
+    r = SPI.transfer(0);
+    enc28j60_arch_spi_deselect();
+    return r;
+}
+/*---------------------------------------------------------------------------*/
+void ENC28J60::writereg(uint8_t reg, uint8_t data) {
+    enc28j60_arch_spi_select();
+    SPI.transfer(0x40 | (reg & 0x1f));
+    SPI.transfer(data);
+    enc28j60_arch_spi_deselect();
+}
+/*---------------------------------------------------------------------------*/
+void ENC28J60::setregbitfield(uint8_t reg, uint8_t mask) {
+    if (is_mac_mii_reg(reg)) {
+        writereg(reg, readreg(reg) | mask);
+    } else {
+        enc28j60_arch_spi_select();
+        SPI.transfer(0x80 | (reg & 0x1f));
+        SPI.transfer(mask);
+        enc28j60_arch_spi_deselect();
+    }
+}
+/*---------------------------------------------------------------------------*/
+void ENC28J60::clearregbitfield(uint8_t reg, uint8_t mask) {
+    if (is_mac_mii_reg(reg)) {
+        writereg(reg, readreg(reg) & ~mask);
+    } else {
+        enc28j60_arch_spi_select();
+        SPI.transfer(0xa0 | (reg & 0x1f));
+        SPI.transfer(mask);
+        enc28j60_arch_spi_deselect();
+    }
+}
+/*---------------------------------------------------------------------------*/
+void ENC28J60::setregbank(uint8_t new_bank) {
+    writereg(ECON1, (readreg(ECON1) & 0xfc) | (new_bank & 0x03));
+    _bank = new_bank;
+}
+/*---------------------------------------------------------------------------*/
+void ENC28J60::writedata(const uint8_t* data, int datalen) {
+    int i;
+    enc28j60_arch_spi_select();
+    /* The Write Buffer Memory (WBM) command is 0 1 1 1 1 0 1 0  */
+    SPI.transfer(0x7a);
+    for (i = 0; i < datalen; i++) {
+        SPI.transfer(data[i]);
+    }
+    enc28j60_arch_spi_deselect();
+}
+/*---------------------------------------------------------------------------*/
+void ENC28J60::writedatabyte(uint8_t byte) {
+    writedata(&byte, 1);
+}
+/*---------------------------------------------------------------------------*/
+int ENC28J60::readdata(uint8_t* buf, int len) {
+    int i;
+    enc28j60_arch_spi_select();
+    /* THe Read Buffer Memory (RBM) command is 0 0 1 1 1 0 1 0 */
+    SPI.transfer(0x3a);
+    for (i = 0; i < len; i++) {
+        buf[i] = SPI.transfer(0);
+    }
+    enc28j60_arch_spi_deselect();
+    return i;
+}
+/*---------------------------------------------------------------------------*/
+uint8_t ENC28J60::readdatabyte(void) {
+    uint8_t r;
+    readdata(&r, 1);
+    return r;
+}
+
+/*---------------------------------------------------------------------------*/
+void ENC28J60::softreset(void) {
+    enc28j60_arch_spi_select();
+    /* The System Command (soft reset) is 1 1 1 1 1 1 1 1 */
+    SPI.transfer(0xff);
+    enc28j60_arch_spi_deselect();
+    _bank = ERXTX_BANK;
+}
+
+/*---------------------------------------------------------------------------*/
+//#if DEBUG
+uint8_t ENC28J60::readrev(void) {
+    uint8_t rev;
+    setregbank(MAADRX_BANK);
+    rev = readreg(EREVID);
+    switch (rev) {
+    case 2:
+        return 1;
+    case 6:
+        return 7;
+    default:
+        return rev;
+    }
+}
+//#endif
+
+/*---------------------------------------------------------------------------*/
+
+bool ENC28J60::reset(void) {
+    PRINTF("enc28j60: resetting chip\n");
+
+    pinMode(_cs, OUTPUT);
+    digitalWrite(_cs, HIGH);
+    SPI.begin();
+
+    /*
+        6.0 INITIALIZATION
+
+        Before the ENC28J60 can be used to transmit and receive packets,
+        certain device settings must be initialized. Depending on the
+        application, some configuration options may need to be
+        changed. Normally, these tasks may be accomplished once after
+        Reset and do not need to be changed thereafter.
+
+        6.1 Receive Buffer
+
+        Before receiving any packets, the receive buffer must be
+        initialized by programming the ERXST and ERXND pointers. All
+        memory between and including the ERXST and ERXND addresses will be
+        dedicated to the receive hardware. It is recommended that the
+        ERXST pointer be programmed with an even address.
+
+        Applications expecting large amounts of data and frequent packet
+        delivery may wish to allocate most of the memory as the receive
+        buffer. Applications that may need to save older packets or have
+        several packets ready for transmission should allocate less
+        memory.
+
+        When programming the ERXST pointer, the ERXWRPT registers will
+        automatically be updated with the same values. The address in
+        ERXWRPT will be used as the starting location when the receive
+        hardware begins writing received data. For tracking purposes, the
+        ERXRDPT registers should additionally be programmed with the same
+        value. To program ERXRDPT, the host controller must write to
+        ERXRDPTL first, followed by ERXRDPTH.  See Section 7.2.4 “Freeing
+        Receive Buffer Space for more information
+
+        6.2 Transmission Buffer
+
+        All memory which is not used by the receive buffer is considered
+        the transmission buffer. Data which is to be transmitted should be
+        written into any unused space.  After a packet is transmitted,
+        however, the hardware will write a seven-byte status vector into
+        memory after the last byte in the packet. Therefore, the host
+        controller should leave at least seven bytes between each packet
+        and the beginning of the receive buffer. No explicit action is
+        required to initialize the transmission buffer.
+
+        6.3 Receive Filters
+
+        The appropriate receive filters should be enabled or disabled by
+        writing to the ERXFCON register. See Section 8.0 “Receive Filters
+        for information on how to configure it.
+
+        6.4 Waiting For OST
+
+        If the initialization procedure is being executed immediately
+        following a Power-on Reset, the ESTAT.CLKRDY bit should be polled
+        to make certain that enough time has elapsed before proceeding to
+        modify the MAC and PHY registers. For more information on the OST,
+        see Section 2.2 “Oscillator Start-up Timer.
+    */
+
+    softreset();
+
+    /* Workaround for erratum #2. */
+    delayMicroseconds(1000);
+
+    /* Wait for OST */
+    PRINTF("waiting for ESTAT_CLKRDY\n");
+    while ((readreg(ESTAT) & ESTAT_CLKRDY) == 0) { };
+    PRINTF("ESTAT_CLKRDY\n");
+
+    setregbank(ERXTX_BANK);
+    /* Set up receive buffer */
+    writereg(ERXSTL, RX_BUF_START & 0xff);
+    writereg(ERXSTH, RX_BUF_START >> 8);
+    writereg(ERXNDL, RX_BUF_END & 0xff);
+    writereg(ERXNDH, RX_BUF_END >> 8);
+    writereg(ERDPTL, RX_BUF_START & 0xff);
+    writereg(ERDPTH, RX_BUF_START >> 8);
+    writereg(ERXRDPTL, RX_BUF_END & 0xff);
+    writereg(ERXRDPTH, RX_BUF_END >> 8);
+
+    /* Receive filters */
+    setregbank(EPKTCNT_BANK);
+    writereg(ERXFCON, ERXFCON_UCEN | ERXFCON_CRCEN | ERXFCON_MCEN);
+
+    /*
+        6.5 MAC Initialization Settings
+
+        Several of the MAC registers require configuration during
+        initialization. This only needs to be done once; the order of
+        programming is unimportant.
+
+        1. Set the MARXEN bit in MACON1 to enable the MAC to receive
+        frames. If using full duplex, most applications should also set
+        TXPAUS and RXPAUS to allow IEEE defined flow control to function.
+
+        2. Configure the PADCFG, TXCRCEN and FULDPX bits of MACON3. Most
+        applications should enable automatic padding to at least 60 bytes
+        and always append a valid CRC. For convenience, many applications
+        may wish to set the FRMLNEN bit as well to enable frame length
+        status reporting. The FULDPX bit should be set if the application
+        will be connected to a full-duplex configured remote node;
+        otherwise, it should be left clear.
+
+        3. Configure the bits in MACON4. For conformance to the IEEE 802.3
+        standard, set the DEFER bit.
+
+        4. Program the MAMXFL registers with the maximum frame length to
+        be permitted to be received or transmitted. Normal network nodes
+        are designed to handle packets that are 1518 bytes or less.
+
+        5. Configure the Back-to-Back Inter-Packet Gap register,
+        MABBIPG. Most applications will program this register with 15h
+        when Full-Duplex mode is used and 12h when Half-Duplex mode is
+        used.
+
+        6. Configure the Non-Back-to-Back Inter-Packet Gap register low
+        byte, MAIPGL. Most applications will program this register with
+        12h.
+
+        7. If half duplex is used, the Non-Back-to-Back Inter-Packet Gap
+        register high byte, MAIPGH, should be programmed. Most
+        applications will program this register to 0Ch.
+
+        8. If Half-Duplex mode is used, program the Retransmission and
+        Collision Window registers, MACLCON1 and MACLCON2. Most
+        applications will not need to change the default Reset values.  If
+        the network is spread over exceptionally long cables, the default
+        value of MACLCON2 may need to be increased.
+
+        9. Program the local MAC address into the MAADR1:MAADR6 registers.
+    */
+
+    setregbank(MACONX_BANK);
+
+    /* Turn on reception and IEEE-defined flow control */
+    setregbitfield(MACON1, MACON1_MARXEN | MACON1_TXPAUS | MACON1_RXPAUS);
+
+    /* Set padding, crc, full duplex */
+    setregbitfield(MACON3, MACON3_PADCFG_FULL | MACON3_TXCRCEN | MACON3_FULDPX | MACON3_FRMLNEN);
+
+    /* Don't modify MACON4 */
+
+    /* Set maximum frame length in MAMXFL */
+    writereg(MAMXFLL, MAX_MAC_LENGTH & 0xff);
+    writereg(MAMXFLH, MAX_MAC_LENGTH >> 8);
+
+    /* Set back-to-back inter packet gap */
+    writereg(MABBIPG, 0x15);
+
+    /* Set non-back-to-back packet gap */
+    writereg(MAIPGL, 0x12);
+
+    /* Set MAC address */
+    setregbank(MAADRX_BANK);
+    writereg(MAADR6, _localMac[5]);
+    writereg(MAADR5, _localMac[4]);
+    writereg(MAADR4, _localMac[3]);
+    writereg(MAADR3, _localMac[2]);
+    writereg(MAADR2, _localMac[1]);
+    writereg(MAADR1, _localMac[0]);
+
+    /*
+        6.6 PHY Initialization Settings
+
+        Depending on the application, bits in three of the PHY module’s
+        registers may also require configuration.  The PHCON1.PDPXMD bit
+        partially controls the device’s half/full-duplex
+        configuration. Normally, this bit is initialized correctly by the
+        external circuitry (see Section 2.6 “LED Configuration). If the
+        external circuitry is not present or incorrect, however, the host
+        controller must program the bit properly. Alternatively, for an
+        externally configurable system, the PDPXMD bit may be read and the
+        FULDPX bit be programmed to match.
+
+        For proper duplex operation, the PHCON1.PDPXMD bit must also match
+        the value of the MACON3.FULDPX bit.
+
+        If using half duplex, the host controller may wish to set the
+        PHCON2.HDLDIS bit to prevent automatic loopback of the data which
+        is transmitted.  The PHY register, PHLCON, controls the outputs of
+        LEDA and LEDB. If an application requires a LED configuration
+        other than the default, PHLCON must be altered to match the new
+        requirements. The settings for LED operation are discussed in
+        Section 2.6 “LED Configuration. The PHLCON register is shown in
+        Register 2-2 (page 9).
+    */
+
+    /* Don't worry about PHY configuration for now */
+
+    /* Turn on autoincrement for buffer access */
+    setregbitfield(ECON2, ECON2_AUTOINC);
+
+    /* Turn on reception */
+    writereg(ECON1, ECON1_RXEN);
+
+    return true;
+}
+/*---------------------------------------------------------------------------*/
+bool ENC28J60::begin(const uint8_t* address, netif *net) {
+    _localMac = address;
+    _netif = net;
+
+    bool    ret = reset();
+    uint8_t rev = readrev();
+
+    PRINTF("ENC28J60 rev. B%d\n", rev);
+
+    return ret && rev != 255;
+}
+
+/*---------------------------------------------------------------------------*/
+
+uint16_t ENC28J60::sendFrame(const uint8_t* data, uint16_t datalen) {
+    uint16_t dataend;
+
+    /*
+        1. Appropriately program the ETXST pointer to point to an unused
+         location in memory. It will point to the per packet control
+         byte. In the example, it would be programmed to 0120h. It is
+         recommended that an even address be used for ETXST.
+
+        2. Use the WBM SPI command to write the per packet control byte,
+         the destination address, the source MAC address, the
+         type/length and the data payload.
+
+        3. Appropriately program the ETXND pointer. It should point to the
+         last byte in the data payload.  In the example, it would be
+         programmed to 0156h.
+
+        4. Clear EIR.TXIF, set EIE.TXIE and set EIE.INTIE to enable an
+         interrupt when done (if desired).
+
+        5. Start the transmission process by setting
+         ECON1.TXRTS.
+    */
+
+    setregbank(ERXTX_BANK);
+    /* Set up the transmit buffer pointer */
+    writereg(ETXSTL, TX_BUF_START & 0xff);
+    writereg(ETXSTH, TX_BUF_START >> 8);
+    writereg(EWRPTL, TX_BUF_START & 0xff);
+    writereg(EWRPTH, TX_BUF_START >> 8);
+
+    /*  Write the transmission control register as the first byte of the
+        output packet. We write 0x00 to indicate that the default
+        configuration (the values in MACON3) will be used.  */
+    writedatabyte(0x00); /* MACON3 */
+
+    writedata(data, datalen);
+
+    /* Write a pointer to the last data byte. */
+    dataend = TX_BUF_START + datalen;
+    writereg(ETXNDL, dataend & 0xff);
+    writereg(ETXNDH, dataend >> 8);
+
+    /* Clear EIR.TXIF */
+    clearregbitfield(EIR, EIR_TXIF);
+
+    /* Don't care about interrupts for now */
+
+    /* Send the packet */
+    setregbitfield(ECON1, ECON1_TXRTS);
+    while ((readreg(ECON1) & ECON1_TXRTS) > 0)
+        ;
+
+#if DEBUG
+    if ((readreg(ESTAT) & ESTAT_TXABRT) != 0) {
+        uint16_t erdpt;
+        uint8_t  tsv[7];
+        erdpt = (readreg(ERDPTH) << 8) | readreg(ERDPTL);
+        writereg(ERDPTL, (dataend + 1) & 0xff);
+        writereg(ERDPTH, (dataend + 1) >> 8);
+        readdata(tsv, sizeof(tsv));
+        writereg(ERDPTL, erdpt & 0xff);
+        writereg(ERDPTH, erdpt >> 8);
+        PRINTF("enc28j60: tx err: %d: %02x:%02x:%02x:%02x:%02x:%02x\n"
+               "                  tsv: %02x%02x%02x%02x%02x%02x%02x\n",
+               datalen, 0xff & data[0], 0xff & data[1], 0xff & data[2], 0xff & data[3],
+               0xff & data[4], 0xff & data[5], tsv[6], tsv[5], tsv[4], tsv[3], tsv[2], tsv[1],
+               tsv[0]);
+    } else {
+        PRINTF("enc28j60: tx: %d: %02x:%02x:%02x:%02x:%02x:%02x\n", datalen, 0xff & data[0],
+               0xff & data[1], 0xff & data[2], 0xff & data[3], 0xff & data[4], 0xff & data[5]);
+    }
+#endif
+
+    // sent_packets++;
+    // PRINTF("enc28j60: sent_packets %d\n", sent_packets);
+    return datalen;
+}
+
+/*---------------------------------------------------------------------------*/
+
+uint16_t ENC28J60::readFrame(uint8_t* buffer, uint16_t bufsize) {
+    readFrameSize();
+    return readFrameData(buffer, bufsize);
+}
+
+uint16_t ENC28J60::readFrameSize() {
+    uint8_t n;
+
+    uint8_t nxtpkt[2];
+    uint8_t status[2];
+    uint8_t length[2];
+
+    setregbank(EPKTCNT_BANK);
+    n = readreg(EPKTCNT);
+
+    if (n == 0) {
+        return 0;
+    }
+
+    PRINTF("enc28j60: EPKTCNT 0x%02x\n", n);
+
+    setregbank(ERXTX_BANK);
+    /* Read the next packet pointer */
+    nxtpkt[0] = readdatabyte();
+    nxtpkt[1] = readdatabyte();
+    _next     = (nxtpkt[1] << 8) + nxtpkt[0];
+
+    PRINTF("enc28j60: nxtpkt 0x%02x%02x\n", _nxtpkt[1], _nxtpkt[0]);
+
+    length[0] = readdatabyte();
+    length[1] = readdatabyte();
+    _len      = (length[1] << 8) + length[0];
+
+    PRINTF("enc28j60: length 0x%02x%02x\n", length[1], length[0]);
+
+    status[0] = readdatabyte();
+    status[1] = readdatabyte();
+
+    /* This statement is just to avoid a compiler warning: */
+    (void)status[0];
+    PRINTF("enc28j60: status 0x%02x%02x\n", status[1], status[0]);
+
+    return _len;
+}
+
+void ENC28J60::discardFrame(uint16_t framesize) {
+    (void)framesize;
+    (void)readFrameData(nullptr, 0);
+}
+
+uint16_t ENC28J60::readFrameData(uint8_t* buffer, uint16_t framesize) {
+    if (framesize < _len) {
+        buffer = nullptr;
+
+        /* flush rx fifo */
+        for (uint16_t i = 0; i < _len; i++) {
+            readdatabyte();
+        }
+    } else {
+        readdata(buffer, _len);
+    }
+
+    /* Read an additional byte at odd lengths, to avoid FIFO corruption */
+    if ((_len % 2) != 0) {
+        readdatabyte();
+    }
+
+    /* Errata #14 */
+    if (_next == RX_BUF_START) {
+        _next = RX_BUF_END;
+    } else {
+        _next = _next - 1;
+    }
+    writereg(ERXRDPTL, _next & 0xff);
+    writereg(ERXRDPTH, _next >> 8);
+
+    setregbitfield(ECON2, ECON2_PKTDEC);
+
+    if (!buffer) {
+        PRINTF("enc28j60: rx err: flushed %d\n", _len);
+        return 0;
+    }
+    PRINTF("enc28j60: rx: %d: %02x:%02x:%02x:%02x:%02x:%02x\n", _len, 0xff & buffer[0],
+           0xff & buffer[1], 0xff & buffer[2], 0xff & buffer[3], 0xff & buffer[4],
+           0xff & buffer[5]);
+
+    // received_packets++;
+    // PRINTF("enc28j60: received_packets %d\n", received_packets);
+
+    return _len;
+}
+
+uint16_t ENC28J60::phyread(uint8_t reg) {
+    // ( https://github.com/JAndrassy/EthernetENC/tree/master/src/utility/enc28j60.h )
+
+    setregbank(MACONX_BANK);
+    writereg(MIREGADR, reg);
+    writereg(MICMD, MICMD_MIIRD);
+    // wait until the PHY read completes
+    while (readreg(MISTAT) & MISTAT_BUSY) {
+        delayMicroseconds(15);
+    }
+    writereg(MICMD, 0);
+    return (readreg(MIRDL) | readreg(MIRDH) << 8);
+}
+
+bool ENC28J60::isLinked() {
+    // ( https://github.com/JAndrassy/EthernetENC/tree/master/src/utility/enc28j60.h )
+    ethernet_arch_lwip_begin();
+    auto ret = !!(phyread(MACSTAT2) & 0x400);
+    ethernet_arch_lwip_end();
+    return ret;
+}

libraries/lwIP_enc28j60/src/utility/enc28j60.h

@@ -0,0 +1,165 @@
+/**
+    Header file for direct Ethernet frame access to the ENC28J60 controller
+    @file enc28j60.h
+*/
+
+/*
+    Copyright (c) 2012-2013, Thingsquare, http://www.thingsquare.com/.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+    1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holder nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+    COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+    OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+// original sources: https://github.com/njh/EtherSia/tree/master/src/enc28j60.h
+
+#ifndef ENC28J60_H
+#define ENC28J60_H
+
+#include <SPI.h>
+
+/**
+    Send and receive Ethernet frames directly using a ENC28J60 controller.
+*/
+class ENC28J60 {
+public:
+    /**
+        Constructor that uses the default hardware SPI pins
+        @param cs the Arduino Chip Select / Slave Select pin (default 10 on Uno)
+    */
+    ENC28J60(int8_t cs = SS, SPIClass& spi = SPI, int8_t intr = -1);
+
+    /**
+        Initialise the Ethernet controller
+        Must be called before sending or receiving Ethernet frames
+
+        @param address the local MAC address for the Ethernet interface
+        @return Returns true if setting up the Ethernet interface was successful
+    */
+    bool begin(const uint8_t* address, netif *net);
+
+    /**
+        Send an Ethernet frame
+        @param data a pointer to the data to send
+        @param datalen the length of the data in the packet
+        @return the number of bytes transmitted
+    */
+    virtual uint16_t sendFrame(const uint8_t* data, uint16_t datalen);
+
+    /**
+        Read an Ethernet frame
+        @param buffer a pointer to a buffer to write the packet to
+        @param bufsize the available space in the buffer
+        @return the length of the received packet
+               or 0 if no packet was received
+    */
+    virtual uint16_t readFrame(uint8_t* buffer, uint16_t bufsize);
+
+    /**
+        Check physical link
+        @return true when physical link is up
+    */
+    bool isLinked();
+
+    /**
+        Report whether ::isLinked() API is implemented
+        @return true when ::isLinked() API is implemented
+    */
+    constexpr bool isLinkDetectable() const {
+        return true;
+    }
+
+    constexpr bool needsSPI() const {
+        return true;
+    }
+
+    netif *_netif;
+protected:
+    static constexpr bool interruptIsPossible() {
+        return false;
+    }
+
+    /**
+        Read an Ethernet frame size
+        @return the length of data do receive
+               or 0 if no frame was received
+    */
+    uint16_t readFrameSize();
+
+    /**
+        discard an Ethernet frame
+        @param framesize readFrameSize()'s result
+    */
+    void discardFrame(uint16_t framesize);
+
+    /**
+        Read an Ethernet frame data
+           readFrameSize() must be called first,
+           its result must be passed into framesize parameter
+        @param buffer a pointer to a buffer to write the frame to
+        @param framesize readFrameSize()'s result
+        @return the length of the received frame
+               or 0 if a problem occurred
+    */
+    uint16_t readFrameData(uint8_t* frame, uint16_t framesize);
+
+private:
+    uint8_t is_mac_mii_reg(uint8_t reg);
+    uint8_t readreg(uint8_t reg);
+    void    writereg(uint8_t reg, uint8_t data);
+    void    setregbitfield(uint8_t reg, uint8_t mask);
+    void    clearregbitfield(uint8_t reg, uint8_t mask);
+    void    setregbank(uint8_t new_bank);
+    void    writedata(const uint8_t* data, int datalen);
+    void    writedatabyte(uint8_t byte);
+    int     readdata(uint8_t* buf, int len);
+    uint8_t readdatabyte(void);
+    void    softreset(void);
+    uint8_t readrev(void);
+    bool    reset(void);
+
+    void    enc28j60_arch_spi_init(void);
+    uint8_t enc28j60_arch_spi_write(uint8_t data);
+    uint8_t enc28j60_arch_spi_read(void);
+    void    enc28j60_arch_spi_select(void);
+    void    enc28j60_arch_spi_deselect(void);
+
+    // Previously defined in contiki/core/sys/clock.h
+    void clock_delay_usec(uint16_t dt);
+
+    uint16_t phyread(uint8_t reg);
+
+    uint8_t   _bank;
+    int8_t    _cs;
+    SPIClass& _spi;
+
+    const uint8_t* _localMac;
+
+    /* readFrame*() state */
+    uint16_t _next, _len;
+};
+
+#endif /* ENC28J60_H */

libraries/lwIP_w5100/examples/WiFiClient-W5100/WiFiClient-W5100.ino

@@ -0,0 +1,95 @@
+/*
+    This sketch establishes a TCP connection to a "quote of the day" service.
+    It sends a "hello" message, and then prints received data.
+*/
+
+#include <W5100lwIP.h>
+
+const char* host = "djxmmx.net";
+const uint16_t port = 17;
+
+Wiznet5100lwIP eth(1 /* chip select */);
+
+void setup() {
+  // Set up SPI pinout to match your HW
+  SPI.setRX(0);
+  SPI.setCS(1);
+  SPI.setSCK(2);
+  SPI.setTX(3);
+
+  Serial.begin(115200);
+  delay(5000);
+  Serial.println();
+  Serial.println();
+  Serial.println("Starting Ethernet port");
+
+  // Start the Ethernet port
+  if (!eth.begin()) {
+    Serial.println("No wired Ethernet hardware detected. Check pinouts, wiring.");
+    while (1) {
+      delay(1000);
+    }
+  }
+
+  while (!eth.connected()) {
+    Serial.print(".");
+    delay(500);
+  }
+
+  Serial.println("");
+  Serial.println("Ethernet connected");
+  Serial.println("IP address: ");
+  Serial.println(eth.localIP());
+}
+
+void loop() {
+  static bool wait = false;
+
+  Serial.print("connecting to ");
+  Serial.print(host);
+  Serial.print(':');
+  Serial.println(port);
+
+  // Use WiFiClient class to create TCP connections
+  WiFiClient client;
+  if (!client.connect(host, port)) {
+    Serial.println("connection failed");
+    delay(5000);
+    return;
+  }
+
+  // This will send a string to the server
+  Serial.println("sending data to server");
+  if (client.connected()) {
+    client.println("hello from RP2040");
+  }
+
+  // wait for data to be available
+  unsigned long timeout = millis();
+  while (client.available() == 0) {
+    if (millis() - timeout > 5000) {
+      Serial.println(">>> Client Timeout !");
+      client.stop();
+      delay(60000);
+      return;
+    }
+  }
+
+  // Read all the lines of the reply from server and print them to Serial
+  Serial.println("receiving from remote server");
+  // not testing 'client.connected()' since we do not need to send data here
+  while (client.available()) {
+    char ch = static_cast<char>(client.read());
+    Serial.print(ch);
+  }
+
+  // Close the connection
+  Serial.println();
+  Serial.println("closing connection");
+  client.stop();
+
+  if (wait) {
+    delay(300000);  // execute once every 5 minutes, don't flood remote service
+  }
+  wait = true;
+}

libraries/lwIP_w5100/keywords.txt

@@ -0,0 +1,18 @@
+#######################################
+# Syntax Coloring Map
+#######################################
+
+#######################################
+# Library (KEYWORD1)
+#######################################
+
+W5100lwIP	KEYWORD1
+Wiznet5100lwIP	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+#######################################

libraries/lwIP_w5100/library.properties

@@ -0,0 +1,10 @@
+name=lwIP_w5100
+version=1
+author=Nicholas Humfrey
+maintainer=esp8266/Arduino
+sentence=Ethernet driver
+paragraph=Wiznet5100 ethernet drivers for lwIP and esp8266 Arduino from https://github.com/njh/W5100MacRaw
+category=Communication
+url=https://github.com/esp8266/Arduino
+architectures=rp2040
+dot_a_linkage=true

libraries/lwIP_w5100/src/W5100lwIP.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <LwipIntfDev.h>
+#include <utility/w5100.h>
+#include <LwipEthernet.h>
+#include <WiFi.h>
+
+using Wiznet5100lwIP = LwipIntfDev<Wiznet5100>;

libraries/lwIP_w5100/src/utility/w5100.cpp

@@ -0,0 +1,319 @@
+/*
+    Copyright (c) 2013, WIZnet Co., Ltd.
+    Copyright (c) 2016, Nicholas Humfrey
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+    1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holder nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+    COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+    OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+// original sources: https://github.com/njh/W5100MacRaw
+
+#include <SPI.h>
+#include "w5100.h"
+
+uint8_t Wiznet5100::wizchip_read(uint16_t address) {
+    uint8_t ret;
+
+    wizchip_cs_select();
+    _spi.transfer(0x0F);
+    _spi.transfer((address & 0xFF00) >> 8);
+    _spi.transfer((address & 0x00FF) >> 0);
+    ret = _spi.transfer(0);
+    wizchip_cs_deselect();
+
+    return ret;
+}
+
+uint16_t Wiznet5100::wizchip_read_word(uint16_t address) {
+    return ((uint16_t)wizchip_read(address) << 8) + wizchip_read(address + 1);
+}
+
+void Wiznet5100::wizchip_read_buf(uint16_t address, uint8_t* pBuf, uint16_t len) {
+    for (uint16_t i = 0; i < len; i++) {
+        pBuf[i] = wizchip_read(address + i);
+    }
+}
+
+void Wiznet5100::wizchip_write(uint16_t address, uint8_t wb) {
+    wizchip_cs_select();
+    _spi.transfer(0xF0);
+    _spi.transfer((address & 0xFF00) >> 8);
+    _spi.transfer((address & 0x00FF) >> 0);
+    _spi.transfer(wb);  // Data write (write 1byte data)
+    wizchip_cs_deselect();
+}
+
+void Wiznet5100::wizchip_write_word(uint16_t address, uint16_t word) {
+    wizchip_write(address, (uint8_t)(word >> 8));
+    wizchip_write(address + 1, (uint8_t)word);
+}
+
+void Wiznet5100::wizchip_write_buf(uint16_t address, const uint8_t* pBuf, uint16_t len) {
+    for (uint16_t i = 0; i < len; i++) {
+        wizchip_write(address + i, pBuf[i]);
+    }
+}
+
+void Wiznet5100::setSn_CR(uint8_t cr) {
+    // Write the command to the Command Register
+    wizchip_write(Sn_CR, cr);
+
+    // Now wait for the command to complete
+    while (wizchip_read(Sn_CR))
+        ;
+}
+
+uint16_t Wiznet5100::getSn_TX_FSR() {
+    uint16_t val = 0, val1 = 0;
+    do {
+        val1 = wizchip_read_word(Sn_TX_FSR);
+        if (val1 != 0) {
+            val = wizchip_read_word(Sn_TX_FSR);
+        }
+    } while (val != val1);
+    return val;
+}
+
+uint16_t Wiznet5100::getSn_RX_RSR() {
+    uint16_t val = 0, val1 = 0;
+    do {
+        val1 = wizchip_read_word(Sn_RX_RSR);
+        if (val1 != 0) {
+            val = wizchip_read_word(Sn_RX_RSR);
+        }
+    } while (val != val1);
+    return val;
+}
+
+void Wiznet5100::wizchip_send_data(const uint8_t* wizdata, uint16_t len) {
+    uint16_t ptr;
+    uint16_t size;
+    uint16_t dst_mask;
+    uint16_t dst_ptr;
+
+    ptr = getSn_TX_WR();
+
+    dst_mask = ptr & TxBufferMask;
+    dst_ptr  = TxBufferAddress + dst_mask;
+
+    if (dst_mask + len > TxBufferLength) {
+        size = TxBufferLength - dst_mask;
+        wizchip_write_buf(dst_ptr, wizdata, size);
+        wizdata += size;
+        size    = len - size;
+        dst_ptr = TxBufferAddress;
+        wizchip_write_buf(dst_ptr, wizdata, size);
+    } else {
+        wizchip_write_buf(dst_ptr, wizdata, len);
+    }
+
+    ptr += len;
+
+    setSn_TX_WR(ptr);
+}
+
+void Wiznet5100::wizchip_recv_data(uint8_t* wizdata, uint16_t len) {
+    uint16_t ptr;
+    uint16_t size;
+    uint16_t src_mask;
+    uint16_t src_ptr;
+
+    ptr = getSn_RX_RD();
+
+    src_mask = ptr & RxBufferMask;
+    src_ptr  = RxBufferAddress + src_mask;
+
+    if ((src_mask + len) > RxBufferLength) {
+        size = RxBufferLength - src_mask;
+        wizchip_read_buf(src_ptr, wizdata, size);
+        wizdata += size;
+        size    = len - size;
+        src_ptr = RxBufferAddress;
+        wizchip_read_buf(src_ptr, wizdata, size);
+    } else {
+        wizchip_read_buf(src_ptr, wizdata, len);
+    }
+
+    ptr += len;
+
+    setSn_RX_RD(ptr);
+}
+
+void Wiznet5100::wizchip_recv_ignore(uint16_t len) {
+    uint16_t ptr;
+
+    ptr = getSn_RX_RD();
+    ptr += len;
+    setSn_RX_RD(ptr);
+}
+
+void Wiznet5100::wizchip_sw_reset() {
+    setMR(MR_RST);
+    getMR();  // for delay
+
+    setSHAR(_mac_address);
+}
+
+Wiznet5100::Wiznet5100(int8_t cs, SPIClass& spi, int8_t intr) : _spi(spi), _cs(cs) {
+    (void)intr;
+}
+
+bool Wiznet5100::begin(const uint8_t* mac_address, netif *net) {
+    memcpy(_mac_address, mac_address, 6);
+    _netif = net;
+
+    pinMode(_cs, OUTPUT);
+    wizchip_cs_deselect();
+
+#if 0
+    _spi.begin();
+    _spi.setClockDivider(SPI_CLOCK_DIV4); // 4 MHz?
+    _spi.setBitOrder(MSBFIRST);
+    _spi.setDataMode(SPI_MODE0);
+#endif
+
+    wizchip_sw_reset();
+
+    // Set the size of the Rx and Tx buffers
+    wizchip_write(RMSR, RxBufferSize);
+    wizchip_write(TMSR, TxBufferSize);
+
+    // Set our local MAC address
+    setSHAR(_mac_address);
+
+    // Open Socket 0 in MACRaw mode
+    setSn_MR(Sn_MR_MACRAW);
+    setSn_CR(Sn_CR_OPEN);
+    if (getSn_SR() != SOCK_MACRAW) {
+        // Failed to put socket 0 into MACRaw mode
+        return false;
+    }
+
+    // Success
+    return true;
+}
+
+void Wiznet5100::end() {
+    setSn_CR(Sn_CR_CLOSE);
+
+    // clear all interrupt of the socket
+    setSn_IR(0xFF);
+
+    // Wait for socket to change to closed
+    while (getSn_SR() != SOCK_CLOSED)
+        ;
+}
+
+uint16_t Wiznet5100::readFrame(uint8_t* buffer, uint16_t bufsize) {
+    uint16_t data_len = readFrameSize();
+
+    if (data_len == 0) {
+        return 0;
+    }
+
+    if (data_len > bufsize) {
+        // Packet is bigger than buffer - drop the packet
+        discardFrame(data_len);
+        return 0;
+    }
+
+    return readFrameData(buffer, data_len);
+}
+
+uint16_t Wiznet5100::readFrameSize() {
+    uint16_t len = getSn_RX_RSR();
+
+    if (len == 0) {
+        return 0;
+    }
+
+    uint8_t  head[2];
+    uint16_t data_len = 0;
+
+    wizchip_recv_data(head, 2);
+    setSn_CR(Sn_CR_RECV);
+
+    data_len = head[0];
+    data_len = (data_len << 8) + head[1];
+    data_len -= 2;
+
+    return data_len;
+}
+
+void Wiznet5100::discardFrame(uint16_t framesize) {
+    wizchip_recv_ignore(framesize);
+    setSn_CR(Sn_CR_RECV);
+}
+
+uint16_t Wiznet5100::readFrameData(uint8_t* buffer, uint16_t framesize) {
+    wizchip_recv_data(buffer, framesize);
+    setSn_CR(Sn_CR_RECV);
+
+#if 1
+    // let lwIP deal with mac address filtering
+    return framesize;
+#else
+    // W5100 doesn't have any built-in MAC address filtering
+    if ((buffer[0] & 0x01) || memcmp(&buffer[0], _mac_address, 6) == 0) {
+        // Addressed to an Ethernet multicast address or our unicast address
+        return framesize;
+    } else {
+        return 0;
+    }
+#endif
+}
+
+uint16_t Wiznet5100::sendFrame(const uint8_t* buf, uint16_t len) {
+    // Wait for space in the transmit buffer
+    while (1) {
+        uint16_t freesize = getSn_TX_FSR();
+        if (getSn_SR() == SOCK_CLOSED) {
+            return -1;
+        }
+        if (len <= freesize) {
+            break;
+        }
+    };
+
+    wizchip_send_data(buf, len);
+    setSn_CR(Sn_CR_SEND);
+
+    while (1) {
+        uint8_t tmp = getSn_IR();
+        if (tmp & Sn_IR_SENDOK) {
+            setSn_IR(Sn_IR_SENDOK);
+            // Packet sent ok
+            break;
+        } else if (tmp & Sn_IR_TIMEOUT) {
+            setSn_IR(Sn_IR_TIMEOUT);
+            // There was a timeout
+            return -1;
+        }
+    }
+
+    return len;
+}

libraries/lwIP_w5100/src/utility/w5100.h

@@ -0,0 +1,495 @@
+/*
+    Copyright (c) 2013, WIZnet Co., Ltd.
+    Copyright (c) 2016, Nicholas Humfrey
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+    1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holder nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+    COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+    OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+// original sources: https://github.com/njh/W5100MacRaw
+
+#ifndef W5100_H
+#define W5100_H
+
+#include <stdint.h>
+#include <Arduino.h>
+#include <SPI.h>
+
+class Wiznet5100 {
+public:
+    /**
+        Constructor that uses the default hardware SPI pins
+        @param cs the Arduino Chip Select / Slave Select pin (default 10)
+    */
+    Wiznet5100(int8_t cs = SS, SPIClass& spi = SPI, int8_t intr = -1);
+
+    /**
+        Initialise the Ethernet controller
+        Must be called before sending or receiving Ethernet frames
+
+        @param address the local MAC address for the Ethernet interface
+        @return Returns true if setting up the Ethernet interface was successful
+    */
+    bool begin(const uint8_t* address, netif *net);
+
+    /**
+        Shut down the Ethernet controlled
+    */
+    void end();
+
+    /**
+        Send an Ethernet frame
+        @param data a pointer to the data to send
+        @param datalen the length of the data in the packet
+        @return the number of bytes transmitted
+    */
+    uint16_t sendFrame(const uint8_t* data, uint16_t datalen);
+
+    /**
+        Read an Ethernet frame
+        @param buffer a pointer to a buffer to write the packet to
+        @param bufsize the available space in the buffer
+        @return the length of the received packet
+               or 0 if no packet was received
+    */
+    uint16_t readFrame(uint8_t* buffer, uint16_t bufsize);
+
+    /**
+        Check physical link
+        @return true when physical link is up
+    */
+    bool isLinked() const {
+        return true;  //XXX TODO
+    }
+
+    /**
+        Report whether ::isLinked() API is implemented
+        @return true when ::isLinked() API is implemented
+    */
+    constexpr bool isLinkDetectable() const {
+        return false;
+    }
+
+    constexpr bool needsSPI() const {
+        return true;
+    }
+
+    netif *_netif;
+protected:
+    static constexpr bool interruptIsPossible() {
+        return false;
+    }
+
+    /**
+        Read an Ethernet frame size
+        @return the length of data do receive
+               or 0 if no frame was received
+    */
+    uint16_t readFrameSize();
+
+    /**
+        discard an Ethernet frame
+        @param framesize readFrameSize()'s result
+    */
+    void discardFrame(uint16_t framesize);
+
+    /**
+        Read an Ethernet frame data
+           readFrameSize() must be called first,
+           its result must be passed into framesize parameter
+        @param buffer a pointer to a buffer to write the frame to
+        @param framesize readFrameSize()'s result
+        @return the length of the received frame
+               or 0 if a problem occurred
+    */
+    uint16_t readFrameData(uint8_t* frame, uint16_t framesize);
+
+private:
+    static const uint16_t TxBufferAddress = 0x4000; /* Internal Tx buffer address of the iinchip */
+    static const uint16_t RxBufferAddress = 0x6000; /* Internal Rx buffer address of the iinchip */
+    static const uint8_t  TxBufferSize
+        = 0x3; /* Buffer size configuration: 0=1kb, 1=2kB, 2=4kB, 3=8kB */
+    static const uint8_t RxBufferSize
+        = 0x3; /* Buffer size configuration: 0=1kb, 1=2kB, 2=4kB, 3=8kB */
+    static const uint16_t TxBufferLength = (1 << TxBufferSize)
+                                           << 10; /* Length of Tx buffer in bytes */
+    static const uint16_t RxBufferLength = (1 << RxBufferSize)
+                                           << 10; /* Length of Rx buffer in bytes */
+    static const uint16_t TxBufferMask = TxBufferLength - 1;
+    static const uint16_t RxBufferMask = RxBufferLength - 1;
+
+    SPIClass& _spi;
+    int8_t    _cs;
+    uint8_t   _mac_address[6];
+
+    /**
+        Default function to select chip.
+        @note This function help not to access wrong address. If you do not describe this function
+        or register any functions, null function is called.
+    */
+    inline void wizchip_cs_select() {
+        digitalWrite(_cs, LOW);
+    }
+
+    /**
+        Default function to deselect chip.
+        @note This function help not to access wrong address. If you do not describe this function
+        or register any functions, null function is called.
+    */
+    inline void wizchip_cs_deselect() {
+        digitalWrite(_cs, HIGH);
+    }
+
+    /**
+        Read a 1 byte value from a register.
+        @param address Register address
+        @return The value of register
+    */
+    uint8_t wizchip_read(uint16_t address);
+
+    /**
+        Reads a 2 byte value from a register.
+        @param address Register address
+        @return The value of register
+    */
+    uint16_t wizchip_read_word(uint16_t address);
+
+    /**
+        It reads sequence data from registers.
+        @param address Register address
+        @param pBuf Pointer buffer to read data
+        @param len Data length
+    */
+    void wizchip_read_buf(uint16_t address, uint8_t* pBuf, uint16_t len);
+
+    /**
+        Write a 1 byte value to a register.
+        @param address Register address
+        @param wb Write data
+        @return void
+    */
+    void wizchip_write(uint16_t address, uint8_t wb);
+
+    /**
+        Write a 2 byte value to a register.
+        @param address Register address
+        @param wb Write data
+        @return void
+    */
+    void wizchip_write_word(uint16_t address, uint16_t word);
+
+    /**
+        It writes sequence data to registers.
+        @param address Register address
+        @param pBuf Pointer buffer to write data
+        @param len Data length
+    */
+    void wizchip_write_buf(uint16_t address, const uint8_t* pBuf, uint16_t len);
+
+    /**
+        Reset WIZCHIP by softly.
+    */
+    void wizchip_sw_reset(void);
+
+    /**
+        It copies data to internal TX memory
+
+        @details This function reads the Tx write pointer register and after that,
+        it copies the <i>wizdata(pointer buffer)</i> of the length of <i>len(variable)</i> bytes to
+        internal TX memory and updates the Tx write pointer register. This function is being called
+        by send() and sendto() function also.
+
+        @param wizdata Pointer buffer to write data
+        @param len Data length
+        @sa wizchip_recv_data()
+    */
+    void wizchip_send_data(const uint8_t* wizdata, uint16_t len);
+
+    /**
+        It copies data to your buffer from internal RX memory
+
+        @details This function read the Rx read pointer register and after that,
+        it copies the received data from internal RX memory
+        to <i>wizdata(pointer variable)</i> of the length of <i>len(variable)</i> bytes.
+        This function is being called by recv() also.
+
+        @param wizdata Pointer buffer to read data
+        @param len Data length
+        @sa wizchip_send_data()
+    */
+    void wizchip_recv_data(uint8_t* wizdata, uint16_t len);
+
+    /**
+        It discard the received data in RX memory.
+        @details It discards the data of the length of <i>len(variable)</i> bytes in internal RX
+        memory.
+        @param len Data length
+    */
+    void wizchip_recv_ignore(uint16_t len);
+
+    /**
+        Get @ref Sn_TX_FSR register
+        @return uint16_t. Value of @ref Sn_TX_FSR.
+    */
+    uint16_t getSn_TX_FSR();
+
+    /**
+        Get @ref Sn_RX_RSR register
+        @return uint16_t. Value of @ref Sn_RX_RSR.
+    */
+    uint16_t getSn_RX_RSR();
+
+    /** Common registers */
+    enum {
+        MR   = 0x0000,  ///< Mode Register address (R/W)
+        GAR  = 0x0001,  ///< Gateway IP Register address (R/W)
+        SUBR = 0x0005,  ///< Subnet mask Register address (R/W)
+        SHAR = 0x0009,  ///< Source MAC Register address (R/W)
+        SIPR = 0x000F,  ///< Source IP Register address (R/W)
+        IR   = 0x0015,  ///< Interrupt Register (R/W)
+        IMR  = 0x0016,  ///< Socket Interrupt Mask Register (R/W)
+        RTR  = 0x0017,  ///< Timeout register address (1 is 100us) (R/W)
+        RCR  = 0x0019,  ///< Retry count register (R/W)
+        RMSR = 0x001A,  ///< Receive Memory Size
+        TMSR = 0x001B,  ///< Transmit Memory Size
+    };
+
+    /** Socket registers */
+    enum {
+        Sn_MR     = 0x0400,  ///< Socket Mode register(R/W)
+        Sn_CR     = 0x0401,  ///< Socket command register (R/W)
+        Sn_IR     = 0x0402,  ///< Socket interrupt register (R)
+        Sn_SR     = 0x0403,  ///< Socket status register (R)
+        Sn_PORT   = 0x0404,  ///< Source port register (R/W)
+        Sn_DHAR   = 0x0406,  ///< Peer MAC register address (R/W)
+        Sn_DIPR   = 0x040C,  ///< Peer IP register address (R/W)
+        Sn_DPORT  = 0x0410,  ///< Peer port register address (R/W)
+        Sn_MSSR   = 0x0412,  ///< Maximum Segment Size(Sn_MSSR0) register address (R/W)
+        Sn_PROTO  = 0x0414,  ///< IP Protocol(PROTO) Register (R/W)
+        Sn_TOS    = 0x0415,  ///< IP Type of Service(TOS) Register (R/W)
+        Sn_TTL    = 0x0416,  ///< IP Time to live(TTL) Register (R/W)
+        Sn_TX_FSR = 0x0420,  ///< Transmit free memory size register (R)
+        Sn_TX_RD  = 0x0422,  ///< Transmit memory read pointer register address (R)
+        Sn_TX_WR  = 0x0424,  ///< Transmit memory write pointer register address (R/W)
+        Sn_RX_RSR = 0x0426,  ///< Received data size register (R)
+        Sn_RX_RD  = 0x0428,  ///< Read point of Receive memory (R/W)
+        Sn_RX_WR  = 0x042A,  ///< Write point of Receive memory (R)
+    };
+
+    /** Mode register values */
+    enum {
+        MR_RST = 0x80,  ///< Reset
+        MR_PB  = 0x10,  ///< Ping block
+        MR_AI  = 0x02,  ///< Address Auto-Increment in Indirect Bus Interface
+        MR_IND = 0x01,  ///< Indirect Bus Interface mode
+    };
+
+    /** Socket Mode Register values @ref Sn_MR */
+    enum {
+        Sn_MR_CLOSE  = 0x00,  ///< Unused socket
+        Sn_MR_TCP    = 0x01,  ///< TCP
+        Sn_MR_UDP    = 0x02,  ///< UDP
+        Sn_MR_IPRAW  = 0x03,  ///< IP LAYER RAW SOCK
+        Sn_MR_MACRAW = 0x04,  ///< MAC LAYER RAW SOCK
+        Sn_MR_ND     = 0x20,  ///< No Delayed Ack(TCP) flag
+        Sn_MR_MF     = 0x40,  ///< Use MAC filter
+        Sn_MR_MULTI  = 0x80,  ///< support multicating
+    };
+
+    /** Socket Command Register values */
+    enum {
+        Sn_CR_OPEN      = 0x01,  ///< Initialise or open socket
+        Sn_CR_CLOSE     = 0x10,  ///< Close socket
+        Sn_CR_SEND      = 0x20,  ///< Update TX buffer pointer and send data
+        Sn_CR_SEND_MAC  = 0x21,  ///< Send data with MAC address, so without ARP process
+        Sn_CR_SEND_KEEP = 0x22,  ///< Send keep alive message
+        Sn_CR_RECV      = 0x40,  ///< Update RX buffer pointer and receive data
+    };
+
+    /** Socket Interrupt register values */
+    enum {
+        Sn_IR_CON     = 0x01,  ///< CON Interrupt
+        Sn_IR_DISCON  = 0x02,  ///< DISCON Interrupt
+        Sn_IR_RECV    = 0x04,  ///< RECV Interrupt
+        Sn_IR_TIMEOUT = 0x08,  ///< TIMEOUT Interrupt
+        Sn_IR_SENDOK  = 0x10,  ///< SEND_OK Interrupt
+    };
+
+    /** Socket Status Register values */
+    enum {
+        SOCK_CLOSED      = 0x00,  ///< Closed
+        SOCK_INIT        = 0x13,  ///< Initiate state
+        SOCK_LISTEN      = 0x14,  ///< Listen state
+        SOCK_SYNSENT     = 0x15,  ///< Connection state
+        SOCK_SYNRECV     = 0x16,  ///< Connection state
+        SOCK_ESTABLISHED = 0x17,  ///< Success to connect
+        SOCK_FIN_WAIT    = 0x18,  ///< Closing state
+        SOCK_CLOSING     = 0x1A,  ///< Closing state
+        SOCK_TIME_WAIT   = 0x1B,  ///< Closing state
+        SOCK_CLOSE_WAIT  = 0x1C,  ///< Closing state
+        SOCK_LAST_ACK    = 0x1D,  ///< Closing state
+        SOCK_UDP         = 0x22,  ///< UDP socket
+        SOCK_IPRAW       = 0x32,  ///< IP raw mode socket
+        SOCK_MACRAW      = 0x42,  ///< MAC raw mode socket
+    };
+
+    /**
+        Set Mode Register
+        @param (uint8_t)mr The value to be set.
+        @sa getMR()
+    */
+    inline void setMR(uint8_t mode) {
+        wizchip_write(MR, mode);
+    }
+
+    /**
+        Get Mode Register
+        @return uint8_t. The value of Mode register.
+        @sa setMR()
+    */
+    inline uint8_t getMR() {
+        return wizchip_read(MR);
+    }
+
+    /**
+        Set local MAC address
+        @param (uint8_t*)shar Pointer variable to set local MAC address. It should be allocated 6
+        bytes.
+        @sa getSHAR()
+    */
+    inline void setSHAR(const uint8_t* macaddr) {
+        wizchip_write_buf(SHAR, macaddr, 6);
+    }
+
+    /**
+        Get local MAC address
+        @param (uint8_t*)shar Pointer variable to get local MAC address. It should be allocated 6
+        bytes.
+        @sa setSHAR()
+    */
+    inline void getSHAR(uint8_t* macaddr) {
+        wizchip_read_buf(SHAR, macaddr, 6);
+    }
+
+    /**
+        Get @ref Sn_TX_WR register
+        @param (uint16_t)txwr Value to set @ref Sn_TX_WR
+        @sa GetSn_TX_WR()
+    */
+    inline uint16_t getSn_TX_WR() {
+        return wizchip_read_word(Sn_TX_WR);
+    }
+
+    /**
+        Set @ref Sn_TX_WR register
+        @param (uint16_t)txwr Value to set @ref Sn_TX_WR
+        @sa GetSn_TX_WR()
+    */
+    inline void setSn_TX_WR(uint16_t txwr) {
+        wizchip_write_word(Sn_TX_WR, txwr);
+    }
+
+    /**
+        Get @ref Sn_RX_RD register
+        @regurn uint16_t. Value of @ref Sn_RX_RD.
+        @sa setSn_RX_RD()
+    */
+    inline uint16_t getSn_RX_RD() {
+        return wizchip_read_word(Sn_RX_RD);
+    }
+
+    /**
+        Set @ref Sn_RX_RD register
+        @param (uint16_t)rxrd Value to set @ref Sn_RX_RD
+        @sa getSn_RX_RD()
+    */
+    inline void setSn_RX_RD(uint16_t rxrd) {
+        wizchip_write_word(Sn_RX_RD, rxrd);
+    }
+
+    /**
+        Set @ref Sn_MR register
+        @param (uint8_t)mr Value to set @ref Sn_MR
+        @sa getSn_MR()
+    */
+    inline void setSn_MR(uint8_t mr) {
+        wizchip_write(Sn_MR, mr);
+    }
+
+    /**
+        Get @ref Sn_MR register
+        @return uint8_t. Value of @ref Sn_MR.
+        @sa setSn_MR()
+    */
+    inline uint8_t getSn_MR() {
+        return wizchip_read(Sn_MR);
+    }
+
+    /**
+        Set @ref Sn_CR register, then wait for the command to execute
+        @param (uint8_t)cr Value to set @ref Sn_CR
+        @sa getSn_CR()
+    */
+    void setSn_CR(uint8_t cr);
+
+    /**
+        Get @ref Sn_CR register
+        @return uint8_t. Value of @ref Sn_CR.
+        @sa setSn_CR()
+    */
+    inline uint8_t getSn_CR() {
+        return wizchip_read(Sn_CR);
+    }
+
+    /**
+        Get @ref Sn_SR register
+        @return uint8_t. Value of @ref Sn_SR.
+    */
+    inline uint8_t getSn_SR() {
+        return wizchip_read(Sn_SR);
+    }
+
+    /**
+        Get @ref Sn_IR register
+        @return uint8_t. Value of @ref Sn_IR.
+        @sa setSn_IR()
+    */
+    inline uint8_t getSn_IR() {
+        return wizchip_read(Sn_IR);
+    }
+
+    /**
+        Set @ref Sn_IR register
+        @param (uint8_t)ir Value to set @ref Sn_IR
+        @sa getSn_IR()
+    */
+    inline void setSn_IR(uint8_t ir) {
+        wizchip_write(Sn_IR, ir);
+    }
+};
+
+#endif  // W5100_H

libraries/lwIP_w5500/examples/WiFiClient-W5500/WiFiClient-W5500.ino

@@ -0,0 +1,95 @@
+/*
+    This sketch establishes a TCP connection to a "quote of the day" service.
+    It sends a "hello" message, and then prints received data.
+*/
+
+#include <W5500lwIP.h>
+
+const char* host = "djxmmx.net";
+const uint16_t port = 17;
+
+Wiznet5500lwIP eth(1 /* chip select */);
+
+void setup() {
+  // Set up SPI pinout to match your HW
+  SPI.setRX(0);
+  SPI.setCS(1);
+  SPI.setSCK(2);
+  SPI.setTX(3);
+
+  Serial.begin(115200);
+  delay(5000);
+  Serial.println();
+  Serial.println();
+  Serial.println("Starting Ethernet port");
+
+  // Start the Ethernet port
+  if (!eth.begin()) {
+    Serial.println("No wired Ethernet hardware detected. Check pinouts, wiring.");
+    while (1) {
+      delay(1000);
+    }
+  }
+
+  while (!eth.connected()) {
+    Serial.print(".");
+    delay(500);
+  }
+
+  Serial.println("");
+  Serial.println("Ethernet connected");
+  Serial.println("IP address: ");
+  Serial.println(eth.localIP());
+}
+
+void loop() {
+  static bool wait = false;
+
+  Serial.print("connecting to ");
+  Serial.print(host);
+  Serial.print(':');
+  Serial.println(port);
+
+  // Use WiFiClient class to create TCP connections
+  WiFiClient client;
+  if (!client.connect(host, port)) {
+    Serial.println("connection failed");
+    delay(5000);
+    return;
+  }
+
+  // This will send a string to the server
+  Serial.println("sending data to server");
+  if (client.connected()) {
+    client.println("hello from RP2040");
+  }
+
+  // wait for data to be available
+  unsigned long timeout = millis();
+  while (client.available() == 0) {
+    if (millis() - timeout > 5000) {
+      Serial.println(">>> Client Timeout !");
+      client.stop();
+      delay(60000);
+      return;
+    }
+  }
+
+  // Read all the lines of the reply from server and print them to Serial
+  Serial.println("receiving from remote server");
+  // not testing 'client.connected()' since we do not need to send data here
+  while (client.available()) {
+    char ch = static_cast<char>(client.read());
+    Serial.print(ch);
+  }
+
+  // Close the connection
+  Serial.println();
+  Serial.println("closing connection");
+  client.stop();
+
+  if (wait) {
+    delay(300000);  // execute once every 5 minutes, don't flood remote service
+  }
+  wait = true;
+}

libraries/lwIP_w5500/keywords.txt

@@ -0,0 +1,18 @@
+#######################################
+# Syntax Coloring Map
+#######################################
+
+#######################################
+# Library (KEYWORD1)
+#######################################
+
+W5500lwIP	KEYWORD1
+Wiznet5500lwIP	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+#######################################

libraries/lwIP_w5500/library.properties

@@ -0,0 +1,10 @@
+name=lwIP_w5500
+version=1
+author=Nicholas Humfrey
+maintainer=esp8266/Arduino
+sentence=Ethernet driver
+paragraph=Wiznet5500 ethernet drivers for lwIP and esp8266 Arduino from https://github.com/njh/W5500MacRaw
+category=Communication
+url=https://github.com/esp8266/Arduino
+architectures=rp2040
+dot_a_linkage=true