@aptre/v86 0.5.0

package/package.json

@@ -0,0 +1,75 @@
+{
+    "name": "@aptre/v86",
+    "version": "0.5.0",
+    "license": "BSD-2-Clause",
+    "description": "x86 PC emulator and x86-to-wasm JIT, running in the browser",
+    "homepage": "https://github.com/aperturerobotics/v86",
+    "repository": "github:aperturerobotics/v86",
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./dist/v86.d.ts",
+            "import": "./dist/v86.js"
+        },
+        "./fs": {
+            "types": "./dist/fs.d.ts",
+            "import": "./dist/fs.js"
+        },
+        "./9p": {
+            "types": "./dist/9p.d.ts",
+            "import": "./dist/9p.js"
+        },
+        "./bus": {
+            "types": "./dist/bus.d.ts",
+            "import": "./dist/bus.js"
+        }
+    },
+    "files": [
+        "!**/*.tsbuildinfo",
+        "dist",
+        "src",
+        "lib",
+        "gen",
+        "Readme.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "clean": "rimraf ./dist",
+        "build": "bun build.mjs",
+        "build:debug": "bun build.mjs --debug",
+        "typecheck": "tsgo --noEmit",
+        "lint": "eslint ./",
+        "format": "prettier --write 'src/**/*.{js,ts}' 'lib/**/*.{js,ts}' 'gen/**/*.{js,ts}' 'tests/**/*.{js,ts}'",
+        "format:check": "prettier --check 'src/**/*.{js,ts}' 'lib/**/*.{js,ts}' 'gen/**/*.{js,ts}' 'tests/**/*.{js,ts}'",
+        "format:config": "prettier --write tsconfig.json package.json",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "prepare": "husky",
+        "precommit": "lint-staged",
+        "release": "npm version patch --no-git-tag-version && bun run release:commit",
+        "release:minor": "npm version minor --no-git-tag-version && bun run release:commit",
+        "release:commit": "git reset && git add package.json && git commit -s -m \"release: v$(bun -e \"console.log(require('./package.json').version)\")\" && git tag v$(bun -e \"console.log(require('./package.json').version)\")",
+        "release:publish": "git push && git push --tags"
+    },
+    "lint-staged": {
+        "package.json": "prettier --config .prettierrc.yaml --write",
+        "./{src,lib,gen,tests}/**/*.{ts,js}": "prettier --config .prettierrc.yaml --write"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.27.0",
+        "@types/node": "^25.5.0",
+        "@typescript/native-preview": "^7.0.0-dev.20250601",
+        "esbuild": "^0.25.4",
+        "eslint": "^9.27.0",
+        "eslint-config-prettier": "^10.1.5",
+        "eslint-plugin-unused-imports": "^4.4.1",
+        "globals": "^16.1.0",
+        "husky": "^9.1.7",
+        "lint-staged": "^16.0.0",
+        "prettier": "^3.5.3",
+        "rimraf": "^6.0.1",
+        "typescript": "^5.8.3",
+        "typescript-eslint": "^8.32.1",
+        "vitest": "^3.1.4"
+    }
+}

package/src/acpi.ts

@@ -0,0 +1,267 @@
+// http://www.uefi.org/sites/default/files/resources/ACPI_6_1.pdf
+
+import { v86 } from './main.js'
+import { LOG_ACPI } from '../src/const.js'
+import { h } from './lib.js'
+import { dbg_log, dbg_assert } from './log.js'
+import { IO } from './io.js'
+
+// Minimal interface for the CPU fields ACPI needs
+interface ACPICpu {
+    io: IO
+    devices: {
+        pci: {
+            register_device(device: any): void
+        }
+    }
+    device_raise_irq(irq: number): void
+    device_lower_irq(irq: number): void
+}
+
+const PMTIMER_FREQ_SECONDS = 3579545
+
+export class ACPI {
+    name: string
+    cpu: ACPICpu
+    timer_last_value: number
+    timer_imprecision_offset: number
+    status: number
+    pm1_status: number
+    pm1_enable: number
+    last_timer: number
+    gpe: Uint8Array
+
+    constructor(cpu: ACPICpu) {
+        this.name = 'acpi'
+        this.cpu = cpu
+
+        const io = cpu.io
+
+        const acpi = {
+            pci_id: 0x07 << 3,
+            pci_space: [
+                0x86, 0x80, 0x13, 0x71, 0x07, 0x00, 0x80, 0x02, 0x08, 0x00,
+                0x80, 0x06, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x09, 0x01, 0x00, 0x00,
+            ],
+            pci_bars: [],
+            name: 'acpi',
+        }
+
+        // 00:07.0 Bridge: Intel Corporation 82371AB/EB/MB PIIX4 ACPI (rev 08)
+        cpu.devices.pci.register_device(acpi)
+
+        this.timer_last_value = 0
+        this.timer_imprecision_offset = 0
+
+        this.status = 1
+        this.pm1_status = 0
+        this.pm1_enable = 0
+        this.last_timer = this.get_timer(v86.microtick())
+
+        this.gpe = new Uint8Array(4)
+
+        io.register_read(
+            0xb000,
+            this,
+            undefined,
+            function (this: ACPI): number {
+                dbg_log('ACPI pm1_status read', LOG_ACPI)
+                return this.pm1_status
+            },
+        )
+        io.register_write(
+            0xb000,
+            this,
+            undefined,
+            function (this: ACPI, value: number): void {
+                dbg_log('ACPI pm1_status write: ' + h(value, 4), LOG_ACPI)
+                this.pm1_status &= ~value
+            },
+        )
+
+        io.register_read(
+            0xb002,
+            this,
+            undefined,
+            function (this: ACPI): number {
+                dbg_log('ACPI pm1_enable read', LOG_ACPI)
+                return this.pm1_enable
+            },
+        )
+        io.register_write(
+            0xb002,
+            this,
+            undefined,
+            function (this: ACPI, value: number): void {
+                dbg_log('ACPI pm1_enable write: ' + h(value), LOG_ACPI)
+                this.pm1_enable = value
+            },
+        )
+
+        // ACPI status
+        io.register_read(
+            0xb004,
+            this,
+            function (this: ACPI): number {
+                dbg_log('ACPI status read8', LOG_ACPI)
+                return this.status & 0xff
+            },
+            function (this: ACPI): number {
+                dbg_log('ACPI status read', LOG_ACPI)
+                return this.status
+            },
+        )
+        io.register_write(
+            0xb004,
+            this,
+            undefined,
+            function (this: ACPI, value: number): void {
+                dbg_log('ACPI status write: ' + h(value), LOG_ACPI)
+                this.status = value
+            },
+        )
+
+        // ACPI, pmtimer
+        io.register_read(
+            0xb008,
+            this,
+            undefined,
+            undefined,
+            function (this: ACPI): number {
+                const value = this.get_timer(v86.microtick()) & 0xffffff
+                //dbg_log("pmtimer read: " + h(value >>> 0), LOG_ACPI);
+                return value
+            },
+        )
+
+        // ACPI, gpe
+        io.register_read(0xafe0, this, function (this: ACPI): number {
+            dbg_log('Read gpe#0', LOG_ACPI)
+            return this.gpe[0]
+        })
+        io.register_read(0xafe1, this, function (this: ACPI): number {
+            dbg_log('Read gpe#1', LOG_ACPI)
+            return this.gpe[1]
+        })
+        io.register_read(0xafe2, this, function (this: ACPI): number {
+            dbg_log('Read gpe#2', LOG_ACPI)
+            return this.gpe[2]
+        })
+        io.register_read(0xafe3, this, function (this: ACPI): number {
+            dbg_log('Read gpe#3', LOG_ACPI)
+            return this.gpe[3]
+        })
+
+        io.register_write(
+            0xafe0,
+            this,
+            function (this: ACPI, value: number): void {
+                dbg_log('Write gpe#0: ' + h(value), LOG_ACPI)
+                this.gpe[0] = value
+            },
+        )
+        io.register_write(
+            0xafe1,
+            this,
+            function (this: ACPI, value: number): void {
+                dbg_log('Write gpe#1: ' + h(value), LOG_ACPI)
+                this.gpe[1] = value
+            },
+        )
+        io.register_write(
+            0xafe2,
+            this,
+            function (this: ACPI, value: number): void {
+                dbg_log('Write gpe#2: ' + h(value), LOG_ACPI)
+                this.gpe[2] = value
+            },
+        )
+        io.register_write(
+            0xafe3,
+            this,
+            function (this: ACPI, value: number): void {
+                dbg_log('Write gpe#3: ' + h(value), LOG_ACPI)
+                this.gpe[3] = value
+            },
+        )
+    }
+
+    timer(now: number): number {
+        const timer = this.get_timer(now)
+        const highest_bit_changed =
+            ((timer ^ this.last_timer) & (1 << 23)) !== 0
+
+        if (this.pm1_enable & 1 && highest_bit_changed) {
+            dbg_log('ACPI raise irq', LOG_ACPI)
+            this.pm1_status |= 1
+            this.cpu.device_raise_irq(9)
+        } else {
+            this.cpu.device_lower_irq(9)
+        }
+
+        this.last_timer = timer
+        return 100 // TODO
+    }
+
+    get_timer(now: number): number {
+        const t = Math.round(now * (PMTIMER_FREQ_SECONDS / 1000))
+
+        // Due to the low precision of JavaScript's time functions we increment the
+        // returned timer value every time it is read
+
+        if (t === this.timer_last_value) {
+            // don't go past 1ms
+
+            if (this.timer_imprecision_offset < PMTIMER_FREQ_SECONDS / 1000) {
+                this.timer_imprecision_offset++
+            }
+        } else {
+            dbg_assert(t > this.timer_last_value)
+
+            const previous_timer =
+                this.timer_last_value + this.timer_imprecision_offset
+
+            // don't go back in time
+
+            if (previous_timer <= t) {
+                this.timer_imprecision_offset = 0
+                this.timer_last_value = t
+            } else {
+                dbg_log(
+                    'Warning: Overshot pmtimer, waiting;' +
+                        ' current=' +
+                        t +
+                        ' last=' +
+                        this.timer_last_value +
+                        ' offset=' +
+                        this.timer_imprecision_offset,
+                    LOG_ACPI,
+                )
+            }
+        }
+
+        return this.timer_last_value + this.timer_imprecision_offset
+    }
+
+    get_state(): [number, number, number, Uint8Array] {
+        const state: [number, number, number, Uint8Array] = [
+            this.status,
+            this.pm1_status,
+            this.pm1_enable,
+            this.gpe,
+        ]
+        return state
+    }
+
+    set_state(state: [number, number, number, Uint8Array]): void {
+        this.status = state[0]
+        this.pm1_status = state[1]
+        this.pm1_enable = state[2]
+        this.gpe = state[3]
+    }
+}

package/src/browser/dummy_screen.ts

@@ -0,0 +1,106 @@
+import { dbg_assert } from '../log.js'
+import { get_charmap } from '../lib.js'
+
+interface DummyScreenOptions {
+    encoding?: string
+}
+
+export class DummyScreenAdapter {
+    FLAG_BLINKING = 0x01
+    FLAG_FONT_PAGE_B = 0x02
+
+    private cursor_row = 0
+    private cursor_col = 0
+    private graphical_mode_width = 0
+    private graphical_mode_height = 0
+    private is_graphical = false
+    private text_mode_data: Uint8Array
+    private text_mode_width = 0
+    private text_mode_height = 0
+    private charmap: string
+
+    constructor(options?: DummyScreenOptions) {
+        this.charmap = get_charmap(options?.encoding || '')
+        this.text_mode_data = new Uint8Array(0)
+        this.set_size_text(80, 25)
+    }
+
+    put_char(
+        row: number,
+        col: number,
+        chr: number,
+        _blinking: number,
+        _bg_color: number,
+        _fg_color: number,
+    ): void {
+        dbg_assert(row >= 0 && row < this.text_mode_height)
+        dbg_assert(col >= 0 && col < this.text_mode_width)
+        this.text_mode_data[row * this.text_mode_width + col] = chr
+    }
+
+    destroy(): void {}
+    pause(): void {}
+    continue(): void {}
+
+    set_mode(graphical: boolean): void {
+        this.is_graphical = graphical
+    }
+
+    set_font_bitmap(
+        _height: number,
+        _width_9px: boolean,
+        _width_dbl: boolean,
+        _copy_8th_col: boolean,
+        _bitmap: Uint8Array,
+        _bitmap_changed: boolean,
+    ): void {}
+
+    set_font_page(_page_a: number, _page_b: number): void {}
+
+    clear_screen(): void {}
+
+    set_size_text(cols: number, rows: number): void {
+        if (cols === this.text_mode_width && rows === this.text_mode_height) {
+            return
+        }
+
+        this.text_mode_data = new Uint8Array(cols * rows)
+        this.text_mode_width = cols
+        this.text_mode_height = rows
+    }
+
+    set_size_graphical(width: number, height: number): void {
+        this.graphical_mode_width = width
+        this.graphical_mode_height = height
+    }
+
+    set_scale(_s_x: number, _s_y: number): void {}
+
+    update_cursor_scanline(_start: number, _end: number, _max: number): void {}
+
+    update_cursor(row: number, col: number): void {
+        this.cursor_row = row
+        this.cursor_col = col
+    }
+
+    update_buffer(_layers: any[]): void {}
+
+    get_text_screen(): string[] {
+        const screen: string[] = []
+
+        for (let i = 0; i < this.text_mode_height; i++) {
+            screen.push(this.get_text_row(i))
+        }
+
+        return screen
+    }
+
+    get_text_row(y: number): string {
+        const begin = y * this.text_mode_width
+        const end = begin + this.text_mode_width
+        return Array.from(
+            this.text_mode_data.subarray(begin, end),
+            (chr) => this.charmap[chr],
+        ).join('')
+    }
+}