rp2040js 1.0.1 → 1.1.0

package/README.md

@@ -28,6 +28,15 @@ npm install
 npm start
 ```
 
+You can also specify the path to the image on the command line and/or load an UF2 image:
+
+```sh
+npm run start -- --image ./my-pico-project.uf2
+```
+
+A GDB server will be available on port 3333, and the data written to UART0 will be printed
+to the console.
+
 ### MicroPython code
 
 To run the MicroPython demo, first download [RPI_PICO-20230426-v1.20.0.uf2](https://micropython.org/resources/firmware/RPI_PICO-20230426-v1.20.0.uf2), place it in the rp2040js root directory, then run:

package/dist/cjs/cortex-m0-core.d.ts

@@ -13,7 +13,7 @@ declare enum StackPointerBank {
 }
 export declare class CortexM0Core {
     readonly rp2040: RP2040;
-    readonly registers: Uint32Array;
+    readonly registers: Uint32Array<ArrayBuffer>;
     bankedSP: number;
     cycles: number;
     eventRegistered: boolean;

package/dist/cjs/gdb/gdb-tcp-server.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Socket } from 'net';
 import { GDBServer } from './gdb-server.js';
 import { IGDBTarget } from './gdb-target.js';

package/dist/cjs/gdb/gdb-utils.d.ts

@@ -2,8 +2,8 @@ export declare function encodeHexByte(value: number): string;
 export declare function encodeHexBuf(buf: Uint8Array): string;
 export declare function encodeHexUint32BE(value: number): string;
 export declare function encodeHexUint32(value: number): string;
-export declare function decodeHexBuf(encoded: string): Uint8Array;
-export declare function decodeHexUint32Array(encoded: string): Uint32Array;
+export declare function decodeHexBuf(encoded: string): Uint8Array<ArrayBuffer>;
+export declare function decodeHexUint32Array(encoded: string): Uint32Array<ArrayBuffer>;
 export declare function decodeHexUint32(encoded: string): number;
 export declare function gdbChecksum(text: string): string;
 export declare function gdbMessage(value: string): string;

package/dist/cjs/gdb/gdb-utils.js

@@ -1,23 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gdbMessage = exports.gdbChecksum = exports.decodeHexUint32 = exports.decodeHexUint32Array = exports.decodeHexBuf = exports.encodeHexUint32 = exports.encodeHexUint32BE = exports.encodeHexBuf = exports.encodeHexByte = void 0;
+exports.encodeHexByte = encodeHexByte;
+exports.encodeHexBuf = encodeHexBuf;
+exports.encodeHexUint32BE = encodeHexUint32BE;
+exports.encodeHexUint32 = encodeHexUint32;
+exports.decodeHexBuf = decodeHexBuf;
+exports.decodeHexUint32Array = decodeHexUint32Array;
+exports.decodeHexUint32 = decodeHexUint32;
+exports.gdbChecksum = gdbChecksum;
+exports.gdbMessage = gdbMessage;
 function encodeHexByte(value) {
     return (value >> 4).toString(16) + (value & 0xf).toString(16);
 }
-exports.encodeHexByte = encodeHexByte;
 function encodeHexBuf(buf) {
     return Array.from(buf).map(encodeHexByte).join('');
 }
-exports.encodeHexBuf = encodeHexBuf;
 function encodeHexUint32BE(value) {
     return encodeHexBuf(new Uint8Array([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff]));
 }
-exports.encodeHexUint32BE = encodeHexUint32BE;
 function encodeHexUint32(value) {
     const buf = new Uint32Array([value]);
     return encodeHexBuf(new Uint8Array(buf.buffer));
 }
-exports.encodeHexUint32 = encodeHexUint32;
 function decodeHexBuf(encoded) {
     const result = new Uint8Array(encoded.length / 2);
     for (let i = 0; i < result.length; i++) {
@@ -25,15 +29,12 @@ function decodeHexBuf(encoded) {
     }
     return result;
 }
-exports.decodeHexBuf = decodeHexBuf;
 function decodeHexUint32Array(encoded) {
     return new Uint32Array(decodeHexBuf(encoded).buffer);
 }
-exports.decodeHexUint32Array = decodeHexUint32Array;
 function decodeHexUint32(encoded) {
     return decodeHexUint32Array(encoded)[0];
 }
-exports.decodeHexUint32 = decodeHexUint32;
 function gdbChecksum(text) {
     const value = text
         .split('')
@@ -41,8 +42,6 @@ function gdbChecksum(text) {
         .reduce((a, b) => a + b, 0) & 0xff;
     return encodeHexByte(value);
 }
-exports.gdbChecksum = gdbChecksum;
 function gdbMessage(value) {
     return `$${value}#${gdbChecksum(value)}`;
 }
-exports.gdbMessage = gdbMessage;

package/dist/cjs/gpio-pin.d.ts

@@ -4,7 +4,8 @@ export declare enum GPIOPinState {
     High = 1,
     Input = 2,
     InputPullUp = 3,
-    InputPullDown = 4
+    InputPullDown = 4,
+    InputBusKeeper = 5
 }
 export declare const FUNCTION_PWM = 4;
 export declare const FUNCTION_SIO = 5;

package/dist/cjs/gpio-pin.js

@@ -9,6 +9,7 @@ var GPIOPinState;
     GPIOPinState[GPIOPinState["Input"] = 2] = "Input";
     GPIOPinState[GPIOPinState["InputPullUp"] = 3] = "InputPullUp";
     GPIOPinState[GPIOPinState["InputPullDown"] = 4] = "InputPullDown";
+    GPIOPinState[GPIOPinState["InputBusKeeper"] = 5] = "InputBusKeeper";
 })(GPIOPinState || (exports.GPIOPinState = GPIOPinState = {}));
 exports.FUNCTION_PWM = 4;
 exports.FUNCTION_SIO = 5;
@@ -149,10 +150,15 @@ class GPIOPin {
         }
         else {
             // TODO: check what happens when we enable both pullup/pulldown
-            if (this.pulldownEnabled) {
+            // ANSWER: It is valid, see: 2.19.4.1. Bus Keeper Mode, datasheet p240
+            if (this.pulldownEnabled && this.pullupEnabled) {
+                // Pull high when high, pull low when low:
+                return GPIOPinState.InputBusKeeper;
+            }
+            else if (this.pulldownEnabled) {
                 return GPIOPinState.InputPullDown;
             }
-            if (this.pullupEnabled) {
+            else if (this.pullupEnabled) {
                 return GPIOPinState.InputPullUp;
             }
             return GPIOPinState.Input;

package/dist/cjs/peripherals/clocks.d.ts

@@ -1,8 +1,26 @@
 import { RP2040 } from '../rp2040.js';
 import { BasePeripheral, Peripheral } from './peripheral.js';
 export declare class RPClocks extends BasePeripheral implements Peripheral {
+    gpout0Ctrl: number;
+    gpout0Div: number;
+    gpout1Ctrl: number;
+    gpout1Div: number;
+    gpout2Ctrl: number;
+    gpout2Div: number;
+    gpout3Ctrl: number;
+    gpout3Div: number;
     refCtrl: number;
+    refDiv: number;
+    periCtrl: number;
+    periDiv: number;
+    usbCtrl: number;
+    usbDiv: number;
     sysCtrl: number;
+    sysDiv: number;
+    adcCtrl: number;
+    adcDiv: number;
+    rtcCtrl: number;
+    rtcDiv: number;
     constructor(rp2040: RP2040, name: string);
     readUint32(offset: number): number;
     writeUint32(offset: number, value: number): void;

package/dist/cjs/peripherals/clocks.js

@@ -2,37 +2,195 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RPClocks = void 0;
 const peripheral_js_1 = require("./peripheral.js");
+const CLK_GPOUT0_CTRL = 0x00;
+const CLK_GPOUT0_DIV = 0x04;
+const CLK_GPOUT0_SELECTED = 0x8;
+const CLK_GPOUT1_CTRL = 0x0c;
+const CLK_GPOUT1_DIV = 0x10;
+const CLK_GPOUT1_SELECTED = 0x14;
+const CLK_GPOUT2_CTRL = 0x18;
+const CLK_GPOUT2_DIV = 0x01c;
+const CLK_GPOUT2_SELECTED = 0x20;
+const CLK_GPOUT3_CTRL = 0x24;
+const CLK_GPOUT3_DIV = 0x28;
+const CLK_GPOUT3_SELECTED = 0x2c;
 const CLK_REF_CTRL = 0x30;
+const CLK_REF_DIV = 0x34;
 const CLK_REF_SELECTED = 0x38;
 const CLK_SYS_CTRL = 0x3c;
+const CLK_SYS_DIV = 0x40;
 const CLK_SYS_SELECTED = 0x44;
+const CLK_PERI_CTRL = 0x48;
+const CLK_PERI_DIV = 0x4c;
+const CLK_PERI_SELECTED = 0x50;
+const CLK_USB_CTRL = 0x54;
+const CLK_USB_DIV = 0x58;
+const CLK_USB_SELECTED = 0x5c;
+const CLK_ADC_CTRL = 0x60;
+const CLK_ADC_DIV = 0x64;
+const CLK_ADC_SELECTED = 0x68;
+const CLK_RTC_CTRL = 0x6c;
+const CLK_RTC_DIV = 0x70;
+const CLK_RTC_SELECTED = 0x74;
+const CLK_SYS_RESUS_CTRL = 0x78;
+const CLK_SYS_RESUS_STATUS = 0x7c;
 class RPClocks extends peripheral_js_1.BasePeripheral {
     constructor(rp2040, name) {
         super(rp2040, name);
+        this.gpout0Ctrl = 0;
+        this.gpout0Div = 0x100;
+        this.gpout1Ctrl = 0;
+        this.gpout1Div = 0x100;
+        this.gpout2Ctrl = 0;
+        this.gpout2Div = 0x100;
+        this.gpout3Ctrl = 0;
+        this.gpout3Div = 0x100;
         this.refCtrl = 0;
+        this.refDiv = 0x100;
+        this.periCtrl = 0;
+        this.periDiv = 0x100;
+        this.usbCtrl = 0;
+        this.usbDiv = 0x100;
         this.sysCtrl = 0;
+        this.sysDiv = 0x100;
+        this.adcCtrl = 0;
+        this.adcDiv = 0x100;
+        this.rtcCtrl = 0;
+        this.rtcDiv = 0x100;
     }
     readUint32(offset) {
         switch (offset) {
+            case CLK_GPOUT0_CTRL:
+                return this.gpout0Ctrl & 0b100110001110111100000;
+            case CLK_GPOUT0_DIV:
+                return this.gpout0Div;
+            case CLK_GPOUT0_SELECTED:
+                return 1;
+            case CLK_GPOUT1_CTRL:
+                return this.gpout1Ctrl & 0b100110001110111100000;
+            case CLK_GPOUT1_DIV:
+                return this.gpout1Div;
+            case CLK_GPOUT1_SELECTED:
+                return 1;
+            case CLK_GPOUT2_CTRL:
+                return this.gpout2Ctrl & 0b100110001110111100000;
+            case CLK_GPOUT2_DIV:
+                return this.gpout2Div;
+            case CLK_GPOUT2_SELECTED:
+                return 1;
+            case CLK_GPOUT3_CTRL:
+                return this.gpout3Ctrl & 0b100110001110111100000;
+            case CLK_GPOUT3_DIV:
+                return this.gpout3Div;
+            case CLK_GPOUT3_SELECTED:
+                return 1;
             case CLK_REF_CTRL:
-                return this.refCtrl;
+                return this.refCtrl & 0b000001100011;
+            case CLK_REF_DIV:
+                return this.refDiv & 0x30; // b8..9 = int divisor. no frac divisor present
             case CLK_REF_SELECTED:
                 return 1 << (this.refCtrl & 0x03);
             case CLK_SYS_CTRL:
-                return this.sysCtrl;
+                return this.sysCtrl & 0b000011100001;
+            case CLK_SYS_DIV:
+                return this.sysDiv;
             case CLK_SYS_SELECTED:
                 return 1 << (this.sysCtrl & 0x01);
+            case CLK_PERI_CTRL:
+                return this.periCtrl & 0b110011100000;
+            case CLK_PERI_DIV:
+                return this.periDiv;
+            case CLK_PERI_SELECTED:
+                return 1;
+            case CLK_USB_CTRL:
+                return this.usbCtrl & 0b100110000110011100000;
+            case CLK_USB_DIV:
+                return this.usbDiv;
+            case CLK_USB_SELECTED:
+                return 1;
+            case CLK_ADC_CTRL:
+                return this.adcCtrl & 0b100110000110011100000;
+            case CLK_ADC_DIV:
+                return this.adcDiv & 0x30;
+            case CLK_ADC_SELECTED:
+                return 1;
+            case CLK_RTC_CTRL:
+                return this.rtcCtrl & 0b100110000110011100000;
+            case CLK_RTC_DIV:
+                return this.rtcDiv & 0x30;
+            case CLK_RTC_SELECTED:
+                return 1;
+            case CLK_SYS_RESUS_CTRL:
+                return 0xff;
+            case CLK_SYS_RESUS_STATUS:
+                return 0; /* clock resus not implemented */
         }
         return super.readUint32(offset);
     }
     writeUint32(offset, value) {
         switch (offset) {
+            case CLK_GPOUT0_CTRL:
+                this.gpout0Ctrl = value;
+                break;
+            case CLK_GPOUT0_DIV:
+                this.gpout0Div = value;
+                break;
+            case CLK_GPOUT1_CTRL:
+                this.gpout1Ctrl = value;
+                break;
+            case CLK_GPOUT1_DIV:
+                this.gpout1Div = value;
+                break;
+            case CLK_GPOUT2_CTRL:
+                this.gpout2Ctrl = value;
+                break;
+            case CLK_GPOUT2_DIV:
+                this.gpout2Div = value;
+                break;
+            case CLK_GPOUT3_CTRL:
+                this.gpout3Ctrl = value;
+                break;
+            case CLK_GPOUT3_DIV:
+                this.gpout3Div = value;
+                break;
             case CLK_REF_CTRL:
                 this.refCtrl = value;
                 break;
+            case CLK_REF_DIV:
+                this.refDiv = value;
+                break;
             case CLK_SYS_CTRL:
                 this.sysCtrl = value;
                 break;
+            case CLK_SYS_DIV:
+                this.sysDiv = value;
+                break;
+            case CLK_PERI_CTRL:
+                this.periCtrl = value;
+                break;
+            case CLK_PERI_DIV:
+                this.periDiv = value;
+                break;
+            case CLK_USB_CTRL:
+                this.usbCtrl = value;
+                break;
+            case CLK_USB_DIV:
+                this.usbDiv = value;
+                break;
+            case CLK_ADC_CTRL:
+                this.adcCtrl = value;
+                break;
+            case CLK_ADC_DIV:
+                this.adcDiv = value;
+                break;
+            case CLK_RTC_CTRL:
+                this.rtcCtrl = value;
+                break;
+            case CLK_RTC_DIV:
+                this.rtcDiv = value;
+                break;
+            case CLK_SYS_RESUS_CTRL:
+                return; /* clock resus not implemented */
             default:
                 super.writeUint32(offset, value);
                 break;

package/dist/cjs/peripherals/i2c.d.ts

@@ -37,6 +37,7 @@ export declare class RPI2C extends BasePeripheral implements Peripheral {
     abortSource: number;
     intRaw: number;
     intEnable: number;
+    private spikelen;
     get intStatus(): number;
     get speed(): I2CSpeed;
     get sclLowPeriod(): number;

package/dist/cjs/peripherals/i2c.js

@@ -180,6 +180,7 @@ class RPI2C extends peripheral_js_1.BasePeripheral {
         this.abortSource = 0;
         this.intRaw = 0;
         this.intEnable = 0;
+        this.spikelen = 0x07;
     }
     checkInterrupts() {
         this.rp2040.setInterrupt(this.irq, !!this.intStatus);
@@ -396,11 +397,18 @@ class RPI2C extends peripheral_js_1.BasePeripheral {
                 return this.txFIFO.itemCount;
             case IC_RXFLR:
                 return this.rxFIFO.itemCount;
+            case IC_SDA_HOLD:
+                return 0x01;
             case IC_TX_ABRT_SOURCE: {
                 const value = this.abortSource;
                 this.abortSource &= ABRT_SBYTE_NORSTRT; // Clear IC_TX_ABRT_SOURCE, expect for bit 9
                 return value;
             }
+            case IC_ENABLE_STATUS:
+                // I2C status - read only. bit 0 reflects IC_ENABLE, bit 1,2 relate to i2c slave mode.
+                return this.enable & 0x1;
+            case IC_FS_SPKLEN:
+                return this.spikelen & 0xff;
             case IC_COMP_PARAM_1:
                 // From the datasheet:
                 // Note This register is not implemented and therefore reads as 0. If it was implemented it would be a constant read-only
@@ -449,6 +457,13 @@ class RPI2C extends peripheral_js_1.BasePeripheral {
             case IC_FS_SCL_LCNT:
                 this.fsClockLowPeriod = value & 0xffff;
                 return;
+            case IC_SDA_HOLD:
+                if (!(value & ENABLE)) {
+                    if (value != 0x1) {
+                        this.warn('Unimplemented write to IC_SDA_HOLD');
+                    }
+                }
+                return;
             case IC_RX_TL:
                 this.rxThreshold = value & 0xff;
                 if (this.rxThreshold > this.rxFIFO.size) {
@@ -480,6 +495,11 @@ class RPI2C extends peripheral_js_1.BasePeripheral {
                 this.enable = value;
                 this.nextCommand(); // TX_CMD_BLOCK may have changed
                 return;
+            case IC_FS_SPKLEN:
+                if (!(value & ENABLE) && value > 0) {
+                    this.spikelen = value;
+                }
+                return;
             default:
                 super.writeUint32(offset, value);
         }

package/dist/cjs/peripherals/peripheral.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnimplementedPeripheral = exports.BasePeripheral = exports.atomicUpdate = void 0;
+exports.UnimplementedPeripheral = exports.BasePeripheral = void 0;
+exports.atomicUpdate = atomicUpdate;
 const ATOMIC_NORMAL = 0;
 const ATOMIC_XOR = 1;
 const ATOMIC_SET = 2;
@@ -18,7 +19,6 @@ function atomicUpdate(currentValue, atomicType, newValue) {
             return newValue;
     }
 }
-exports.atomicUpdate = atomicUpdate;
 class BasePeripheral {
     constructor(rp2040, name) {
         this.rp2040 = rp2040;
@@ -26,14 +26,14 @@ class BasePeripheral {
         this.rawWriteValue = 0;
     }
     readUint32(offset) {
-        this.warn(`Unimplemented peripheral read from ${offset.toString(16)}`);
+        this.warn(`Unimplemented peripheral read from 0x${offset.toString(16)}`);
         if (offset > 0x1000) {
             this.warn('Unimplemented read from peripheral in the atomic operation region');
         }
         return 0xffffffff;
     }
     writeUint32(offset, value) {
-        this.warn(`Unimplemented peripheral write to ${offset.toString(16)}: ${value}`);
+        this.warn(`Unimplemented peripheral write to 0x${offset.toString(16)}: 0x${value.toString(16)}`);
     }
     writeUint32Atomic(offset, value, atomicType) {
         this.rawWriteValue = value;

package/dist/cjs/peripherals/pio.d.ts

@@ -86,7 +86,7 @@ export declare class StateMachine {
 export declare class RPPIO extends BasePeripheral implements Peripheral {
     readonly firstIrq: number;
     readonly index: number;
-    readonly instructions: Uint32Array;
+    readonly instructions: Uint32Array<ArrayBuffer>;
     readonly dreqRx: DREQChannel[];
     readonly dreqTx: DREQChannel[];
     readonly machines: StateMachine[];

package/dist/cjs/peripherals/ssi.d.ts

@@ -1,6 +1,15 @@
 import { BasePeripheral, Peripheral } from './peripheral.js';
 export declare class RPSSI extends BasePeripheral implements Peripheral {
     private dr0;
+    private txflr;
+    private rxflr;
+    private baudr;
+    private crtlr0;
+    private crtlr1;
+    private ssienr;
+    private spictlr0;
+    private rxsampldly;
+    private txddriveedge;
     readUint32(offset: number): number;
     writeUint32(offset: number, value: number): void;
 }

package/dist/cjs/peripherals/ssi.js

@@ -2,34 +2,80 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RPSSI = void 0;
 const peripheral_js_1 = require("./peripheral.js");
+/* See RP2040 datasheet sect 4.10.13 */
+const SSI_CTRLR0 = 0x00000000;
+const SSI_CTRLR1 = 0x00000004;
+const SSI_SSIENR = 0x00000008;
+const SSI_MWCR = 0x0000000c;
+const SSI_SER = 0x00000010;
+const SSI_BAUDR = 0x00000014;
+const SSI_TXFTLR = 0x00000018;
+const SSI_RXFTLR = 0x0000001c;
 const SSI_TXFLR = 0x00000020;
 const SSI_RXFLR = 0x00000024;
 const SSI_SR = 0x00000028;
-const SSI_DR0 = 0x00000060;
 const SSI_SR_TFNF_BITS = 0x00000002;
 const SSI_SR_TFE_BITS = 0x00000004;
 const SSI_SR_RFNE_BITS = 0x00000008;
+const SSI_IMR = 0x0000002c;
+const SSI_ISR = 0x00000030;
+const SSI_RISR = 0x00000034;
+const SSI_TXOICR = 0x00000038;
+const SSI_RXOICR = 0x0000003c;
+const SSI_RXUICR = 0x00000040;
+const SSI_MSTICR = 0x00000044;
+const SSI_ICR = 0x00000048;
+const SSI_DMACR = 0x0000004c;
+const SSI_DMATDLR = 0x00000050;
+const SSI_DMARDLR = 0x00000054;
 /** Identification register */
 const SSI_IDR = 0x00000058;
 const SSI_VERSION_ID = 0x0000005c;
+const SSI_DR0 = 0x00000060;
+const SSI_RX_SAMPLE_DLY = 0x000000f0;
+const SSI_SPI_CTRL_R0 = 0x000000f4;
+const SSI_TXD_DRIVE_EDGE = 0x000000f8;
 const CMD_READ_STATUS = 0x05;
 class RPSSI extends peripheral_js_1.BasePeripheral {
     constructor() {
         super(...arguments);
         this.dr0 = 0;
+        this.txflr = 0;
+        this.rxflr = 0;
+        this.baudr = 0;
+        this.crtlr0 = 0;
+        this.crtlr1 = 0;
+        this.ssienr = 0;
+        this.spictlr0 = 0;
+        this.rxsampldly = 0;
+        this.txddriveedge = 0;
     }
     readUint32(offset) {
         switch (offset) {
             case SSI_TXFLR:
-                return 0;
+                return this.txflr;
             case SSI_RXFLR:
-                return 0;
+                return this.rxflr;
+            case SSI_CTRLR0:
+                return this.crtlr0; /*  & 0x017FFFFF = b23,b25..31 reserved */
+            case SSI_CTRLR1:
+                return this.crtlr1;
+            case SSI_SSIENR:
+                return this.ssienr;
+            case SSI_BAUDR:
+                return this.baudr;
             case SSI_SR:
                 return SSI_SR_TFE_BITS | SSI_SR_RFNE_BITS | SSI_SR_TFNF_BITS;
             case SSI_IDR:
                 return 0x51535049;
             case SSI_VERSION_ID:
                 return 0x3430312a;
+            case SSI_RX_SAMPLE_DLY:
+                return this.rxsampldly;
+            case SSI_TXD_DRIVE_EDGE:
+                return this.txddriveedge;
+            case SSI_SPI_CTRL_R0:
+                return this.spictlr0; /* b6,7,10,19..23 reserved */
             case SSI_DR0:
                 return this.dr0;
         }
@@ -37,6 +83,33 @@ class RPSSI extends peripheral_js_1.BasePeripheral {
     }
     writeUint32(offset, value) {
         switch (offset) {
+            case SSI_TXFLR:
+                this.txflr = value;
+                return;
+            case SSI_RXFLR:
+                this.rxflr = value;
+                return;
+            case SSI_CTRLR0:
+                this.crtlr0 = value; /*  & 0x017FFFFF = b23,b25..31 reserved */
+                return;
+            case SSI_CTRLR1:
+                this.crtlr1 = value;
+                return;
+            case SSI_SSIENR:
+                this.ssienr = value;
+                return;
+            case SSI_BAUDR:
+                this.baudr = value;
+                return;
+            case SSI_RX_SAMPLE_DLY:
+                this.rxsampldly = value & 0xff;
+                return;
+            case SSI_TXD_DRIVE_EDGE:
+                this.txddriveedge = value & 0xff;
+                return;
+            case SSI_SPI_CTRL_R0:
+                this.spictlr0 = value;
+                return;
             case SSI_DR0:
                 if (value === CMD_READ_STATUS) {
                     this.dr0 = 0; // tell stage2 that we completed a write

package/dist/cjs/peripherals/usb.d.ts

@@ -1,6 +1,7 @@
 import { RP2040 } from '../rp2040.js';
 import { BasePeripheral } from './peripheral.js';
 export declare class RPUSBController extends BasePeripheral {
+    private addrEndp;
     private mainCtrl;
     private intRaw;
     private intEnable;

package/dist/cjs/peripherals/usb.js

@@ -20,6 +20,7 @@ const USB_BUF_CTRL_LEN_MASK = 0x3ff;
 const USB_BUF1_SHIFT = 16;
 const USB_BUF1_OFFSET = 64;
 // USB Peripheral Register
+const ADDR_ENDP = 0x0;
 const MAIN_CTRL = 0x40;
 const SIE_STATUS = 0x50;
 const BUFF_STATUS = 0x58;
@@ -97,6 +98,7 @@ class RPUSBController extends peripheral_js_1.BasePeripheral {
     }
     constructor(rp2040, name) {
         super(rp2040, name);
+        this.addrEndp = 0;
         this.mainCtrl = 0;
         this.intRaw = 0;
         this.intEnable = 0;
@@ -130,6 +132,8 @@ class RPUSBController extends peripheral_js_1.BasePeripheral {
     }
     readUint32(offset) {
         switch (offset) {
+            case ADDR_ENDP:
+                return this.addrEndp & 0b1111000000001111111;
             case MAIN_CTRL:
                 return this.mainCtrl;
             case SIE_STATUS:
@@ -152,6 +156,9 @@ class RPUSBController extends peripheral_js_1.BasePeripheral {
     writeUint32(offset, value) {
         var _a, _b;
         switch (offset) {
+            case ADDR_ENDP:
+                this.addrEndp = value;
+                break;
             case MAIN_CTRL:
                 this.mainCtrl = value & (SIM_TIMING | CONTROLLER_EN | HOST_NDEVICE);
                 if (value & CONTROLLER_EN && !(value & HOST_NDEVICE)) {

package/dist/cjs/peripherals/watchdog.d.ts

@@ -4,7 +4,7 @@ import { BasePeripheral, Peripheral } from './peripheral.js';
 export declare class RPWatchdog extends BasePeripheral implements Peripheral {
     readonly timer: Timer32;
     readonly alarm: Timer32PeriodicAlarm;
-    readonly scratchData: Uint32Array;
+    readonly scratchData: Uint32Array<ArrayBuffer>;
     private enable;
     private tickEnable;
     private reason;

package/dist/cjs/rp2040.d.ts

@@ -21,14 +21,14 @@ export declare const DPRAM_START_ADDRESS = 1343225856;
 export declare const SIO_START_ADDRESS = 3489660928;
 export declare class RP2040 {
     readonly clock: IClock;
-    readonly bootrom: Uint32Array;
-    readonly sram: Uint8Array;
-    readonly sramView: DataView;
-    readonly flash: Uint8Array;
-    readonly flash16: Uint16Array;
-    readonly flashView: DataView;
-    readonly usbDPRAM: Uint8Array;
-    readonly usbDPRAMView: DataView;
+    readonly bootrom: Uint32Array<ArrayBuffer>;
+    readonly sram: Uint8Array<ArrayBuffer>;
+    readonly sramView: DataView<ArrayBuffer>;
+    readonly flash: Uint8Array<ArrayBuffer>;
+    readonly flash16: Uint16Array<ArrayBuffer>;
+    readonly flashView: DataView<ArrayBuffer>;
+    readonly usbDPRAM: Uint8Array<ArrayBuffer>;
+    readonly usbDPRAMView: DataView<ArrayBuffer>;
     readonly core: CortexM0Core;
     clkSys: number;
     clkPeri: number;