Merge "hackdoc: when redirecting, skip ref if default"
diff --git a/dc/hbj11/README.md b/dc/hbj11/README.md
new file mode 100644
index 0000000..9649da1
--- /dev/null
+++ b/dc/hbj11/README.md
@@ -0,0 +1,16 @@
+hbj11 - the Hackerspace Blade JBOD adapter
+===
+
+Replacement cards for M610 blades at the hackerspace.
+
+
+
+Hardware
+--------
+
+To be published.
+
+EEPROM & flasher
+----------------
+
+See [flasher](flasher) for a WebUSB/STM32 based flasher for the cards.
diff --git a/dc/hbj11/doc/bluepill.jpg b/dc/hbj11/doc/bluepill.jpg
new file mode 100644
index 0000000..23667b3
--- /dev/null
+++ b/dc/hbj11/doc/bluepill.jpg
Binary files differ
diff --git a/dc/hbj11/doc/hbj11-a0-photo.jpg b/dc/hbj11/doc/hbj11-a0-photo.jpg
new file mode 100644
index 0000000..7ff08a9
--- /dev/null
+++ b/dc/hbj11/doc/hbj11-a0-photo.jpg
Binary files differ
diff --git a/dc/hbj11/doc/webi2c.png b/dc/hbj11/doc/webi2c.png
new file mode 100644
index 0000000..3a3b020
--- /dev/null
+++ b/dc/hbj11/doc/webi2c.png
Binary files differ
diff --git a/dc/hbj11/flasher/README.md b/dc/hbj11/flasher/README.md
new file mode 100644
index 0000000..b6a69e7
--- /dev/null
+++ b/dc/hbj11/flasher/README.md
@@ -0,0 +1,20 @@
+HBJ11 Flasher
+=============
+
+This is a EEPROM flashing tool for the HBJ11 cards designed at the Warsaw Hackerspace.
+
+It's made up of two parts:
+
+The Device (Bluepill)
+---------------------
+
+An USB/I2C adapter based on an STM32 Bluepill devboard. See [bluepill](bluepill/) for more information. You will need one physically plugged into your machine and wired up to a PCIe socket to insert the HBJ11s into.
+
+
+
+The Web Interface (WebI2C)
+---------------------------
+
+A WebUSB-based flashing tool that will run under any Chromium-based browser (eg. Chrome, Edge. See [web](web/) for more information and a link to a publicly available instance.
+
+
diff --git a/dc/hbj11/flasher/bluepill/.cargo/config b/dc/hbj11/flasher/bluepill/.cargo/config
new file mode 100644
index 0000000..128b9c4
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/.cargo/config
@@ -0,0 +1,3 @@
+[build]
+target = "thumbv7m-none-eabi"
+rustflags = [ "-C", "link-arg=-Tlink.x", "-C", "inline-threshold=255"]
diff --git a/dc/hbj11/flasher/bluepill/.gitignore b/dc/hbj11/flasher/bluepill/.gitignore
new file mode 100644
index 0000000..eb5a316
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/.gitignore
@@ -0,0 +1 @@
+target
diff --git a/dc/hbj11/flasher/bluepill/Cargo.lock b/dc/hbj11/flasher/bluepill/Cargo.lock
new file mode 100644
index 0000000..ff7488c
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/Cargo.lock
@@ -0,0 +1,460 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "aligned"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c19796bd8d477f1a9d4ac2465b464a8b1359474f06a96bb3cda650b4fca309bf"
+dependencies = [
+ "as-slice",
+]
+
+[[package]]
+name = "as-slice"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb4d1c23475b74e3672afa8c2be22040b8b7783ad9b461021144ed10a46bb0e6"
+dependencies = [
+ "generic-array 0.12.3",
+ "generic-array 0.13.2",
+ "generic-array 0.14.4",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "bare-metal"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5deb64efa5bd81e31fcd1938615a6d98c82eafcbcd787162b6f63b91d6bac5b3"
+dependencies = [
+ "rustc_version",
+]
+
+[[package]]
+name = "bitfield"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46afbd2983a5d5a7bd740ccb198caf5b82f45c40c09c0eed36052d91cb92e719"
+
+[[package]]
+name = "byteorder"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae44d1a3d5a19df61dd0c8beb138458ac2a53a7ac09eba97d55592540004306b"
+
+[[package]]
+name = "cast"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b9434b9a5aa1450faa3f9cb14ea0e8c53bb5d2b3c1bfd1ab4fc03e9f33fbfb0"
+dependencies = [
+ "rustc_version",
+]
+
+[[package]]
+name = "cortex-m"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9075300b07c6a56263b9b582c214d0ff037b00d45ec9fde1cc711490c56f1bb9"
+dependencies = [
+ "aligned",
+ "bare-metal",
+ "bitfield",
+ "cortex-m 0.7.1",
+ "volatile-register",
+]
+
+[[package]]
+name = "cortex-m"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0b756a8bffc56025de45218a48ff9b801180440c0ee49a722b32d49dcebc771"
+dependencies = [
+ "bare-metal",
+ "bitfield",
+ "embedded-hal",
+ "volatile-register",
+]
+
+[[package]]
+name = "cortex-m-rt"
+version = "0.6.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "980c9d0233a909f355ed297ef122f257942de5e0a2cb1c39f60684b65bcb90fb"
+dependencies = [
+ "cortex-m-rt-macros",
+ "r0",
+]
+
+[[package]]
+name = "cortex-m-rt-macros"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4717562afbba06e760d34451919f5c3bf3ac15c7bb897e8b04862a7428378647"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "cortex-m-rtic"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b30efcb6b7920d9016182c485687f0012487032a14c415d2fce6e9862ef8260e"
+dependencies = [
+ "cortex-m 0.6.7",
+ "cortex-m-rt",
+ "cortex-m-rtic-macros",
+ "heapless",
+ "rtic-core",
+ "version_check",
+]
+
+[[package]]
+name = "cortex-m-rtic-macros"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a1a6a4c9550373038c0e21a78d44d529bd697c25bbf6b8004bddc6e63b119c7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rtic-syntax",
+ "syn",
+]
+
+[[package]]
+name = "cortex-m-semihosting"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bffa6c1454368a6aa4811ae60964c38e6996d397ff8095a8b9211b1c1f749bc"
+dependencies = [
+ "cortex-m 0.7.1",
+]
+
+[[package]]
+name = "embedded-hal"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa998ce59ec9765d15216393af37a58961ddcefb14c753b4816ba2191d865fcb"
+dependencies = [
+ "nb 0.1.3",
+ "void",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ed1e761351b56f54eb9dcd0cfaca9fd0daecf93918e1cfc01c8a3d26ee7adcd"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "hash32"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4041af86e63ac4298ce40e5cca669066e75b6f1aa3390fe2561ffa5e1d9f4cc"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
+
+[[package]]
+name = "hbj11-flasher-bluepill"
+version = "0.1.0"
+dependencies = [
+ "cortex-m 0.6.7",
+ "cortex-m-rt",
+ "cortex-m-rtic",
+ "cortex-m-semihosting",
+ "embedded-hal",
+ "nb 0.1.3",
+ "num-derive",
+ "num-traits",
+ "panic-halt",
+ "panic-semihosting",
+ "stm32f1xx-hal",
+ "usb-device",
+ "usbd-webusb",
+]
+
+[[package]]
+name = "heapless"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74911a68a1658cfcfb61bc0ccfbd536e3b6e906f8c2f7883ee50157e3e2184f1"
+dependencies = [
+ "as-slice",
+ "generic-array 0.13.2",
+ "hash32",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb1fa934250de4de8aef298d81c729a7d33d8c239daa3a7575e6b92bfc7313b"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "nb"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "801d31da0513b6ec5214e9bf433a77966320625a37860f910be265be6e18d06f"
+dependencies = [
+ "nb 1.0.0",
+]
+
+[[package]]
+name = "nb"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae"
+
+[[package]]
+name = "num-derive"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "panic-halt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de96540e0ebde571dc55c73d60ef407c653844e6f9a1e2fdbd40c07b9252d812"
+
+[[package]]
+name = "panic-semihosting"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d55dedd501dfd02514646e0af4d7016ce36bc12ae177ef52056989966a1eec"
+dependencies = [
+ "cortex-m 0.7.1",
+ "cortex-m-semihosting",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r0"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2a38df5b15c8d5c7e8654189744d8e396bddc18ad48041a500ce52d6948941f"
+
+[[package]]
+name = "rtic-core"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bd58a6949de8ff797a346a28d9f13f7b8f54fa61bb5e3cb0985a4efb497a5ef"
+
+[[package]]
+name = "rtic-syntax"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8152fcaa845720d61e6cc570548b89144c2c307f18a480bbd97e55e9f6eeff04"
+dependencies = [
+ "indexmap",
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "semver"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
+dependencies = [
+ "semver-parser",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "stm32-usbd"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70d13eca735cae37df697f599777b000cc0ee924df8452f2b4bfaa6798ab0338"
+dependencies = [
+ "cortex-m 0.6.7",
+ "usb-device",
+ "vcell",
+]
+
+[[package]]
+name = "stm32f1"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "849b1e8d9bcfd792c9d9178cf86165d299a661c26e35d9322ae9382d3f3fe460"
+dependencies = [
+ "bare-metal",
+ "cortex-m 0.6.7",
+ "cortex-m-rt",
+ "vcell",
+]
+
+[[package]]
+name = "stm32f1xx-hal"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af9b9e5d7c2901ee39fc9527412327a1fe08f1d84e9d7f4b3497448e655e5098"
+dependencies = [
+ "as-slice",
+ "cast",
+ "cortex-m 0.6.7",
+ "cortex-m-rt",
+ "embedded-hal",
+ "nb 0.1.3",
+ "stm32-usbd",
+ "stm32f1",
+ "void",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c700597eca8a5a762beb35753ef6b94df201c81cca676604f547495a0d7f0081"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "typenum"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
+
+[[package]]
+name = "usb-device"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "849eed9b4dc61a1f17ba1d7a5078ceb095b9410caa38a506eb281ed5eff12fbd"
+
+[[package]]
+name = "usbd-webusb"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed33ecaa7a26365f13059e753bfa23f0a4a557565499f46d255c51e737464bd8"
+dependencies = [
+ "usb-device",
+]
+
+[[package]]
+name = "vcell"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77439c1b53d2303b20d9459b1ade71a83c716e3f9c34f3228c00e6f185d6c002"
+
+[[package]]
+name = "version_check"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"
+
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+
+[[package]]
+name = "volatile-register"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d67cb4616d99b940db1d6bd28844ff97108b498a6ca850e5b6191a532063286"
+dependencies = [
+ "vcell",
+]
diff --git a/dc/hbj11/flasher/bluepill/Cargo.toml b/dc/hbj11/flasher/bluepill/Cargo.toml
new file mode 100644
index 0000000..efa7892
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "hbj11-flasher-bluepill"
+version = "0.1.0"
+authors = ["Serge Bazanski <q3k@hackerspace.pl>"]
+edition = "2018"
+
+[profile.dev]
+opt-level = 3
+
+[profile.release]
+opt-level = 'z'
+lto = true
+
+[dependencies]
+cortex-m = "^0.6.3"
+cortex-m-rtic = "^0.5.5"
+cortex-m-rt = "^0.6.12"
+cortex-m-semihosting = "^0.3.7"
+embedded-hal = "^0.2.4"
+panic-halt = "^0.2.0"
+usb-device = "^0.2.7"
+usbd-webusb = "^1.0.2"
+panic-semihosting = "^0.5.0"
+nb = "^0.1.3"
+num-derive = "0.3"
+
+[dependencies.num-traits]
+default-features = false
+features = []
+version = "0.2"
+
+[dependencies.stm32f1xx-hal]
+features = ["stm32f103", "rt", "medium", "stm32-usbd"]
+version = "^0.6.1"
diff --git a/dc/hbj11/flasher/bluepill/README.md b/dc/hbj11/flasher/bluepill/README.md
new file mode 100644
index 0000000..67af491
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/README.md
@@ -0,0 +1,79 @@
+STM32 Bluepill-based I2C Flasher
+================================
+
+
+[TOC]
+
+
+
+This is a Rust project that runs on an STM32F103C8T6 on a common [bluepill](https://stm32-base.org/boards/STM32F103C8T6-Blue-Pill.html) board.
+
+It acts as a USB device, exposing an interface to perform arbitrary I2C operations.
+
+Hardware
+--------
+
+You will need a buepill with an STM32103C8T6 and a way to flash ELFs on it. An ST-Link or BlackMagicProbe (potentially running on another Bluepill) are good choices.
+
+For flashing the HBJ11 (or any other Dell M610 storage card) you will also need a PCIe x8 socket. The connections to make are as follows:
+
+| Bluepill/STM32 | Function | PCIe Slot |
+| -------------- | -------- | --------- |
+| G/GND | Ground | B7 |
+| 3.3/VCC | 3.3V | B10 |
+| B6 | SCL | B11 |
+| B7 | SDA | B12 |
+
+Note: the PCIe slot pin numbering follows the same convention as Dell parts (they have A1-A49/B1-B49 markers) and as [the Wikipedia article on PCIe](https://en.wikipedia.org/wiki/PCI_Express#Pinout).
+
+Note: you will need to add pull up resistors for SCL and SDA. 4k7 is a good value to start with. Use a scope to make sure the open drain/pullup behaviour looks sensible.
+
+Note: we run the I2C bus and EEPROM at 3.3V, even though it runs at 5V while in a server. This is fine for HBJ11 flashing, but might lead to issues when attempting to read/program Dell parts, like CERC6/i or the JM475.
+
+Firmware
+--------
+
+To build the firmware, you will need Rust with the thumbv7m-none-eabi target. We unfortunately don't have Bazel integration yet, as rules\_rust don't integrate fully with Bazel's toolchain/configurability system. This should be revisited at some point.
+
+To get Rust with the right target, rustup is recommended (Nix users: `nix-shell -p rustup`):
+
+ $ rustup update
+ $ rustup default stable
+ $ rustup target add thumbv7m-none-eabi
+
+Then, to build:
+
+ $ cargo build --release
+ $ file target/thumbv7m-none-eabi/release/hbj11-flasher-bluepill
+ target/thumbv7m-none-eabi/release/hbj11-flasher-bluepill: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, with debug_info, not stripped
+
+Debug builds are also available, but they require a semihosting debugger attached - otherwise, they will immediately get stuck trying to log debug messages to the host.
+
+Flashing Firmware
+-----------------
+
+If using a BlackMagicProbe:
+
+ $ arm-none-eabi-gdb -x flash.gdb target/thumbv7m-none-eabi/release/hbj11-flasher-bluepill
+ [...]
+ Loading section .vector_table, size 0x130 lma 0x8000000
+ Loading section .text, size 0x3820 lma 0x8000130
+ Loading section .rodata, size 0xd88 lma 0x8003950
+ Start address 0x08000130, load size 18136
+ Transfer rate: 15 KB/sec, 906 bytes/write.
+
+You can then C-c C-d and let the device run, or keep running it under the debugger. It should enumerate via USB:
+
+ $ lsusb -v | grep -A 4 0x16c0
+ idVendor 0x16c0 Van Ooijen Technische Informatica
+ idProduct 0x27d8 libusb-bound devices
+ bcdDevice 0.10
+ iManufacturer 1 Warsaw Hackerspace
+ iProduct 2 Web I2C Programmer
+
+We currently use an, uh, _community_ VID/PID. This will change in the future as we apply for a pair from pid.codes or elsewhere.
+
+Usage
+-----
+
+The flasher is controller via [WebI2C](../web/) (through WebUSB).
diff --git a/dc/hbj11/flasher/bluepill/flash.gdb b/dc/hbj11/flasher/bluepill/flash.gdb
new file mode 100644
index 0000000..e447bfc
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/flash.gdb
@@ -0,0 +1,7 @@
+# Flash script for BlackMagicProbe
+target extended-remote /dev/ttyACM0
+monitor swdp_scan
+attach 1
+load
+# Attach to the running process. C-c and C-d to detach.
+run
diff --git a/dc/hbj11/flasher/bluepill/memory.x b/dc/hbj11/flasher/bluepill/memory.x
new file mode 100644
index 0000000..d152927
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/memory.x
@@ -0,0 +1,7 @@
+MEMORY
+{
+ /* Flash memory begins at 0x80000000 and has a size of 64kB*/
+ FLASH : ORIGIN = 0x08000000, LENGTH = 64K
+ /* RAM begins at 0x20000000 and has a size of 20kB*/
+ RAM : ORIGIN = 0x20000000, LENGTH = 20K
+}
diff --git a/dc/hbj11/flasher/bluepill/src/i2c.rs b/dc/hbj11/flasher/bluepill/src/i2c.rs
new file mode 100644
index 0000000..35f52d6
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/src/i2c.rs
@@ -0,0 +1,372 @@
+/// USB Device Class for I2C transactions.
+//
+// It's not very good, and the API is weird. Someone with more USB device design experience could
+// easily come up with something better.
+//
+// Control OUT transactions are used to perform I2C transfers to/from an internal buffer.
+// Bulk IN/OUT transactions are used to transfer contents of the buffer to the host. It has not
+// been optimized for speed or pipelining.
+//
+// To perform an I2C read:
+// 1) Control OUT: ReadI2C(Address: 0xAA, Length: N)
+// (0xAA is the device address, N is the amount of bytes to read. Cannot be larger than
+// BUFFER_SIZE).
+// This performs an I2C read of N bytes into the inne buffer of the device, starting at
+// address 0.
+// 2) Control IN: GetStatus()
+// The host ensures that the transaction was either ACK or NACK by getting one byte of status
+// from the device.
+// 3) Control OUT: ReadBuffer(Address: X, Length: N)
+// (X is the address within the buffer, N is the amount of bytes to transfer to the host. N
+// cannot be larger than PACKET_SIZE).
+// 4) Bulk IN: Read PACKET_SIZE bytes.
+// Steps 3/4 can be skipped for scanning (the device won't mind the inner buffer not being read).
+//
+// To perform an I2C write:
+// 1) Control OUT: SetWritePointer(Addrss: X)
+// 2) Bulk OUT: Write at most PACKET_SIZE bytes.
+// Repeat steps 1/2 to fill buffer with an I2c transaction.
+// 3) Control OUT: WriteI2C(Address: 0x00, Length: N)
+// (0xAA is the device address, N is the amount of bytes to write. Cannot be larger than
+// BUFFER_SIZE).
+// 4) Control IN: GetStatus()
+// The host ensures that the transaction was either ACK or NACK by getting one byte of status
+// from the device.
+
+use embedded_hal::digital::v2::OutputPin;
+use usb_device::class_prelude::*;
+use nb::Error as NbError;
+use stm32f1xx_hal::{
+ gpio::{gpiob::*, Alternate, OpenDrain},
+ i2c::{BlockingI2c, Error as I2CError},
+ pac::I2C1,
+ prelude::*,
+};
+
+use num_derive::FromPrimitive;
+use num_traits::FromPrimitive;
+
+use crate::{hprint, hprintln};
+
+// Size of buffer within class, in bytes. Dictates maximum I2C transaction size.
+const BUFFER_SIZE: usize = 1024;
+// Size of bulk packets.
+const PACKET_SIZE: usize = 64;
+
+// All IN/OUT references bellow conform to typical USB naming, where IN: from device to host; OUT:
+// from host to device.
+
+/// Request number passed within Control IN requests to the I2C interface (ie. 'gets' from device).
+#[derive(FromPrimitive)]
+#[repr(u8)]
+enum ControlInRequest {
+ /// Write the current status as a single byte in response.
+ GetStatus = 1,
+}
+
+/// Request number passed within Control OUT requests to the I2C interface (ie. 'sets' from the
+/// host).
+#[derive(FromPrimitive)]
+#[repr(u8)]
+enum ControlOutRequest {
+ /// Set LED on or off (value == 0 -> off; on otherwise).
+ SetLED = 1,
+
+ /// Perform I2C bus read of a given length from a given I2C address.
+ /// I2C Address: lower 8 bits of value.
+ /// Read Length: upper 8 bits of value.
+ ReadI2C = 2,
+
+ /// Schedule a BULK IN transaction on the USB bus with the contents of the inner buffer.
+ /// Buffer start address: lower 8 bits of value
+ /// Read Length: upper 8 bits of value.
+ ReadBuffer = 3,
+
+ /// Perform I2C bus write of a given length to a given I2C address.
+ /// I2C Address: lower 8 bits of value.
+ /// Read Length: upper 8 bits of value.
+ WriteI2C = 4,
+
+ /// Set inner buffer write pointer. Any subsequent BULK OUT will write to the buffer at that
+ /// address (but will not auto advance the pointer).
+ SetWritePointer = 5,
+}
+
+/// Status of the I2C class. Combines information about requested transactions and I2C bus
+/// responses.
+#[derive(Copy, Clone)]
+#[repr(u8)]
+enum Status {
+ /// Last request okay.
+ OK = 0,
+ /// Last request contained an invalid argument.
+ InvalidArgument = 1,
+ /// Last request okay, resulted in a successful I2C transaction.
+ Ack = 2,
+ /// Last request okay, resulted in a NACKd I2C transaction.
+ Nack = 3,
+ /// Last request okay, resulted in a fully failed I2C transaction.
+ BusError = 4,
+}
+
+pub struct I2CClass<'a, B: UsbBus, LED> {
+ interface: InterfaceNumber,
+ /// Bulk IN endpoint for buffer transfers to host.
+ ep_in: EndpointIn<'a, B>,
+ /// Bulk OUT endpoint for buffer transfers from host.
+ ep_out: EndpointOut<'a, B>,
+
+ /// LED used for debugging.
+ led: LED,
+
+ /// The underlying I2C device.
+ i2c_dev: BlockingI2c<I2C1, (PB6<Alternate<OpenDrain>>, PB7<Alternate<OpenDrain>>)>,
+
+ /// Marker that is true when the host requested a BULK OUT via ReadBuffer.
+ expect_bulk_out: bool,
+
+ /// The underlying buffer and its write pointer.
+ buffer: [u8; BUFFER_SIZE],
+ write_pointer: usize,
+
+ /// The device's main status byte, used by host to check whether operations were succesful.
+ status: Status,
+}
+
+impl<B: UsbBus, LED: OutputPin> I2CClass<'_, B, LED> {
+ pub fn new(
+ alloc: &UsbBusAllocator<B>,
+ led: LED,
+ i2c_dev: BlockingI2c<I2C1, (PB6<Alternate<OpenDrain>>, PB7<Alternate<OpenDrain>>)>,
+ ) -> I2CClass<'_, B, LED> {
+ I2CClass {
+ interface: alloc.interface(),
+ ep_in: alloc.bulk(PACKET_SIZE as u16),
+ ep_out: alloc.bulk(PACKET_SIZE as u16),
+ led, i2c_dev,
+
+ expect_bulk_out: false,
+
+ buffer: [0; BUFFER_SIZE],
+ write_pointer: 0usize,
+ status: Status::OK,
+ }
+ }
+}
+
+impl<'a, B: UsbBus, LED: OutputPin> UsbClass<B> for I2CClass<'a, B, LED> {
+ fn reset(&mut self) {
+ self.expect_bulk_out = false;
+ self.status = Status::OK,
+ }
+
+ fn control_in(&mut self, xfer: ControlIn<B>) {
+ let req = xfer.request();
+
+ if req.request_type != control::RequestType::Vendor
+ || req.recipient != control::Recipient::Interface
+ || req.index != u8::from(self.interface) as u16 {
+ return
+ }
+
+ match FromPrimitive::from_u8(req.request) {
+ /// Serve GetStatus: return this.status.
+ Some(ControlInRequest::GetStatus) => {
+ let status = self.status.clone() as u8;
+ xfer.accept(|buf| {
+ buf[0] = status;
+ Ok(1usize)
+ }).ok();
+ },
+ _ => {
+ hprintln!("Unhandled control in on iface: {:?}", req).unwrap();
+ },
+ }
+ }
+
+ fn control_out(&mut self, xfer: ControlOut<B>) {
+ let req = xfer.request();
+
+ if req.request_type != control::RequestType::Vendor
+ || req.recipient != control::Recipient::Interface
+ || req.index != u8::from(self.interface) as u16 {
+ return
+ }
+
+ match FromPrimitive::from_u8(req.request) {
+ // Serve SetLED.
+ Some(ControlOutRequest::SetLED) => {
+ let on: bool = req.value > 0;
+ match on {
+ true => self.led.set_low(),
+ false => self.led.set_high(),
+ }.ok();
+ xfer.accept().ok();
+ },
+
+ // Serve ReadI2C: read len bytes from I2C addr into internal buffer.
+ Some(ControlOutRequest::ReadI2C) => {
+ let addr: u8 = (req.value & 0xff) as u8;
+ let len: u8 = (req.value >> 8) as u8;
+ if len as usize > BUFFER_SIZE || len < 1u8 {
+ self.status = Status::InvalidArgument;
+ xfer.accept().ok();
+ return
+ }
+ if addr > 127u8 {
+ self.status = Status::InvalidArgument;
+ xfer.accept().ok();
+ return
+ }
+ match self.i2c_dev.read(addr, &mut self.buffer[0usize..(len as usize)]) {
+ Ok(_) => {
+ self.status = Status::Ack;
+ },
+ Err(NbError::Other(I2CError::Acknowledge)) => {
+ self.status = Status::Nack;
+ },
+ Err(e) => {
+ hprintln!("When reading I2C (addr {}, {} bytes): {:?}", addr, len, e).ok();
+ self.status = Status::BusError;
+ },
+ }
+ xfer.accept().ok();
+ },
+
+ // Serve ReadBuffer: send BULK IN with slice of buffer.
+ Some(ControlOutRequest::ReadBuffer) => {
+ let addr: u8 = (req.value & 0xff) as u8;
+ let len: u8 = (req.value >> 8) as u8;
+
+ if len as usize > PACKET_SIZE || len < 1u8 {
+ self.status = Status::InvalidArgument;
+ xfer.accept().ok();
+ return
+ }
+
+ let start = addr as usize;
+ let end = (addr + len) as usize;
+ if end as usize > BUFFER_SIZE {
+ self.status = Status::InvalidArgument;
+ xfer.accept().ok();
+ return
+ }
+
+ hprintln!("READ BUFFER, addr: {}, len: {}", addr, len).ok();
+
+ self.status = Status::OK;
+ xfer.accept().ok();
+ match self.ep_in.write(&self.buffer[start..end]) {
+ Ok(count) => {
+ },
+ Err(UsbError::WouldBlock) => {},
+ Err(err) => {
+ hprintln!("bulk write failed: {:?}", err).ok();
+ },
+ }
+ },
+
+ // Serve WriteI2C: write len bytes to I2C bus at addr from internal buffer.
+ Some(ControlOutRequest::WriteI2C) => {
+ let addr: u8 = (req.value & 0xff) as u8;
+ let len: u8 = (req.value >> 8) as u8;
+ if len as usize > BUFFER_SIZE || len < 1u8 {
+ self.status = Status::InvalidArgument;
+ xfer.accept().ok();
+ return
+ }
+ if addr > 127u8 {
+ self.status = Status::InvalidArgument;
+ xfer.accept().ok();
+ return
+ }
+
+ hprintln!("WRITE I2C, addr: {}, len: {}", addr, len).ok();
+ match self.i2c_dev.write(addr, &self.buffer[0usize..(len as usize)]) {
+ Ok(_) => {
+ self.status = Status::Ack;
+ },
+ Err(NbError::Other(I2CError::Acknowledge)) => {
+ self.status = Status::Nack;
+ },
+ Err(e) => {
+ hprintln!("When writing I2C (addr {}, {} bytes): {:?}", addr, len, e).ok();
+ self.status = Status::BusError;
+ },
+ }
+ xfer.accept().ok();
+ },
+
+ // Serve SetWritePointer: set start address at which bytes from a BULK OUT will be
+ // written to. The write pointer does _not_ increment on every write, so will need to
+ // be manually controler after every BULK transfer.
+ Some(ControlOutRequest::SetWritePointer) => {
+ let pointer = req.value;
+ if (pointer as usize) >= BUFFER_SIZE {
+ self.status = Status::InvalidArgument;
+ xfer.accept().ok();
+ return
+ }
+ hprintln!("SET WRITE PTR, pointer: {}", pointer).ok();
+ self.write_pointer = pointer as usize;
+ self.status = Status::OK;
+ xfer.accept().ok();
+ },
+ _ => {
+ hprintln!("Unhandled control out on iface: {:?}", req).ok();
+ },
+ }
+ }
+
+ fn get_configuration_descriptors(
+ &self,
+ writer: &mut DescriptorWriter,
+ ) -> usb_device::Result<()> {
+ writer.interface(
+ self.interface,
+ 0xff,
+ 21, 37,
+ )?;
+ writer.endpoint(&self.ep_in)?;
+ writer.endpoint(&self.ep_out)?;
+
+ Ok(())
+ }
+
+ fn poll(&mut self) {
+ let mut temp_buf = [0; PACKET_SIZE];
+ // Serve BULK OUT writes - copy bytes into internal buffer.
+ match self.ep_out.read(&mut temp_buf) {
+ Ok(count) => {
+ if self.expect_bulk_out {
+ self.expect_bulk_out = false;
+ } else {
+ panic!("unexpectedly read data from bulk out endpoint");
+ }
+ hprintln!("SET BUFFER: ptr {}, {} bytes", self.write_pointer, count).ok();
+ for (i, c) in temp_buf.iter().enumerate() {
+ let ptr = self.write_pointer + i;
+ // Silently drop bytes that do not fit in buffer.
+ if ptr >= BUFFER_SIZE {
+ continue;
+ }
+ self.buffer[ptr] = c.clone();
+ }
+ },
+ Err(UsbError::WouldBlock) => {},
+ Err(err) => panic!("bulk read {:?}", err),
+ }
+ }
+
+ fn endpoint_out(&mut self, addr: EndpointAddress) {
+ if addr == self.ep_out.address() {
+ self.expect_bulk_out = true;
+ }
+ }
+
+ fn endpoint_in_complete(&mut self, addr: EndpointAddress) {
+ if addr == self.ep_in.address() {
+ // TODO(q3k): should we be doing something here?
+ }
+ }
+}
diff --git a/dc/hbj11/flasher/bluepill/src/main.rs b/dc/hbj11/flasher/bluepill/src/main.rs
new file mode 100644
index 0000000..da6cefd
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/src/main.rs
@@ -0,0 +1,136 @@
+#![no_main]
+#![no_std]
+
+extern crate panic_semihosting;
+
+use rtic::app;
+
+use cortex_m::asm::delay;
+use stm32f1xx_hal::{
+ gpio::{gpioc::*, Output, PushPull},
+ i2c::{BlockingI2c, Mode},
+ pac::{Peripherals},
+ prelude::*,
+ usb::{Peripheral, UsbBus, UsbBusType},
+};
+use embedded_hal::digital::v2::OutputPin;
+
+use usb_device::bus;
+use usb_device::prelude::*;
+
+use usbd_webusb::WebUsb;
+
+mod i2c;
+mod print;
+
+/// The main RTIC application object. See RTIC documentation for more information about how to read
+/// this.
+#[app(device = stm32f1xx_hal::stm32, peripherals = true)]
+const APP: () = {
+ struct Resources {
+ usb_dev: UsbDevice<'static, UsbBusType>,
+ webusb: WebUsb<UsbBusType>,
+ // The I2C USB device class that performs the main logic of accessing the I2C bus over USB
+ // for users of the device.
+ i2c: i2c::I2CClass<'static, UsbBusType, PC13<Output<PushPull>>>,
+ }
+
+ /// Idle loop to prevent WFI which in turn prevents debugging.
+ // TODO: make this only happen on debug builds?
+ #[idle]
+ fn idle(_: idle::Context) -> ! {
+ loop {}
+ }
+
+ #[init]
+ fn init(cx: init::Context) -> init::LateResources {
+ static mut USB_BUS: Option<bus::UsbBusAllocator<UsbBusType>> = None;
+
+ let mut flash = cx.device.FLASH.constrain();
+ let mut rcc = cx.device.RCC.constrain();
+
+ let clocks = rcc
+ .cfgr
+ .use_hse(8.mhz())
+ .sysclk(48.mhz())
+ .pclk1(24.mhz())
+ .freeze(&mut flash.acr);
+
+ assert!(clocks.usbclk_valid());
+
+ let mut gpioa = cx.device.GPIOA.split(&mut rcc.apb2);
+ let mut gpiob = cx.device.GPIOB.split(&mut rcc.apb2);
+ let mut gpioc = cx.device.GPIOC.split(&mut rcc.apb2);
+
+ // Active-low LED on bluepill board.
+ let mut led = gpioc.pc13.into_push_pull_output(&mut gpioc.crh);
+ led.set_high().ok();
+
+ let mut afio = cx.device.AFIO.constrain(&mut rcc.apb2);
+
+ // BluePill board has a pull-up resistor on the D+ line.
+ // Pull the D+ pin down to send a RESET condition to the USB bus.
+ // This forced reset is needed only for development, without it host
+ // will not reset your device when you upload new firmware.
+ let mut usb_dp = gpioa.pa12.into_push_pull_output(&mut gpioa.crh);
+ usb_dp.set_low().unwrap();
+ delay(clocks.sysclk().0 / 100);
+
+ let usb_dm = gpioa.pa11;
+ let usb_dp = usb_dp.into_floating_input(&mut gpioa.crh);
+
+ let usb = Peripheral {
+ usb: cx.device.USB,
+ pin_dm: usb_dm,
+ pin_dp: usb_dp,
+ };
+
+ *USB_BUS = Some(UsbBus::new(usb));
+
+ let i2c_pins = (
+ gpiob.pb6.into_alternate_open_drain(&mut gpiob.crl),
+ gpiob.pb7.into_alternate_open_drain(&mut gpiob.crl),
+ );
+
+ // Blocking I2C peripheral for use by the I2C app.
+ let i2c_dev = BlockingI2c::i2c1(
+ cx.device.I2C1,
+ i2c_pins,
+ &mut afio.mapr,
+ Mode::standard(100.khz()),
+ clocks,
+ &mut rcc.apb1,
+ 1000, 10, 1000, 1000,
+ );
+
+ // I2C app.
+ let i2c = i2c::I2CClass::new(
+ USB_BUS.as_ref().unwrap(),
+ led, i2c_dev,
+ );
+
+ let usb_dev = UsbDeviceBuilder::new(USB_BUS.as_ref().unwrap(), UsbVidPid(0x16c0, 0x27d8))
+ .manufacturer("Warsaw Hackerspace")
+ .product("Web I2C Programmer")
+ // TODO(q3k): generate serial at build time?
+ .serial_number("2137")
+ .build();
+
+ init::LateResources {
+ usb_dev, i2c,
+ webusb: WebUsb::new(
+ USB_BUS.as_ref().unwrap(),
+ usbd_webusb::url_scheme::HTTPS,
+ "hackdoc.hackerspace.pl/dc/hbj11/flasher",
+ ),
+ }
+ }
+
+ #[task(binds = USB_LP_CAN_RX0, resources = [usb_dev, webusb, i2c])]
+ fn usb_lp(cx: usb_lp::Context) {
+ cx.resources
+ .usb_dev
+ .poll(&mut [cx.resources.webusb, cx.resources.i2c]);
+ }
+};
+
diff --git a/dc/hbj11/flasher/bluepill/src/print.rs b/dc/hbj11/flasher/bluepill/src/print.rs
new file mode 100644
index 0000000..3693b00
--- /dev/null
+++ b/dc/hbj11/flasher/bluepill/src/print.rs
@@ -0,0 +1,40 @@
+// Wrappers around hprint(ln) that get disabled during release builds. This prevents us from
+// getting stuck in an hprint when a debugger is detached.
+
+#[cfg(debug_assertions)]
+#[macro_export]
+macro_rules! hprint {
+ ($s:expr) => {
+ cortex_m_semihosting::export::hstdout_str($s)
+ };
+ ($($tt:tt)*) => {
+ cortex_m_semihosting::export::hstdout_fmt(format_args!($($tt)*))
+ };
+}
+#[cfg(debug_assertions)]
+#[macro_export]
+macro_rules! hprintln {
+ () => {
+ cortex_m_semihosting::export::hstdout_str("\n")
+ };
+ ($s:expr) => {
+ cortex_m_semihosting::export::hstdout_str(concat!($s, "\n"))
+ };
+ ($s:expr, $($tt:tt)*) => {
+ cortex_m_semihosting::export::hstdout_fmt(format_args!(concat!($s, "\n"), $($tt)*))
+ };
+}
+
+#[cfg(not(debug_assertions))]
+#[macro_export]
+macro_rules! hprint {
+ () => { Result::<(), ()>::Ok(()) };
+ ($s:expr, $($tt:tt)*) => { Result::<(), ()>::Ok(()) };
+}
+#[cfg(not(debug_assertions))]
+#[macro_export]
+macro_rules! hprintln {
+ () => { Result::<(), ()>::Ok(()) };
+ ($s:expr) => { Result::<(), ()>::Ok(()) };
+ ($s:expr, $($tt:tt)*) => { Result::<(), ()>::Ok(()) };
+}
diff --git a/dc/hbj11/flasher/web/README.md b/dc/hbj11/flasher/web/README.md
new file mode 100644
index 0000000..7301255
--- /dev/null
+++ b/dc/hbj11/flasher/web/README.md
@@ -0,0 +1,18 @@
+WebI2C
+======
+
+A WebUSB interface for flashing I2C EEPROMs, notably the HJB11 FRU EEPROM.
+
+Usage
+-----
+
+TODO(q3k): host public instance
+
+Development
+-----------
+
+Plain javascript, bring a static file server, eg. Python's builtin one:
+
+ $ cd hscloud/dc/hjb11/flasher/web/
+ $ python3 -m http.server
+
diff --git a/dc/hbj11/flasher/web/fru.js b/dc/hbj11/flasher/web/fru.js
new file mode 100644
index 0000000..a06fec9
--- /dev/null
+++ b/dc/hbj11/flasher/web/fru.js
@@ -0,0 +1,284 @@
+/*
+ * Platform Management FRU Information Storage Definition v1.0
+ * Document Revision 1.3, March 24, 2015
+ *
+ * From: https://www.intel.com/content/www/us/en/servers/ipmi/ipmi-platform-mgt-fru-infostorage-def-v1-0-rev-1-3-spec-update.html
+ */
+export class FRUParser {
+ constructor(data) {
+ this.data = data
+ }
+
+ parseCommon(data) {
+ // 8. Common Header Format
+ let version = data[0];
+ if ((version >> 4) !== 0) throw new Error("Invalid Common Header version");
+ if ((version & 0b1111) !== 1) throw new Error("Invalid Common Header version");
+
+ let res = {};
+ res.version = version;
+ res.internalUseStart = data[1] * 8;
+ res.chassisInfoStart = data[2] * 8;
+ res.boardInfoStart = data[3] * 8;
+ res.productInfoStart = data[4] * 8;
+ res.multiRecordInfoStart = data[5] * 8;
+
+ let sum = data.reduce((a, b) => a + b, 0) & 0xff;
+ if (sum !== 0) throw new Error("Common area checksum error");
+
+ return res;
+ }
+
+ parseBoardInfo(data) {
+ // 11. Board Info Area Format
+ let res = {};
+
+ let version = data[0];
+ if ((version >> 4) !== 0) throw new Error("Invalid Board Info version");
+ if ((version & 0b1111) !== 1) throw new Error("Invalid Board Info version");
+ res.version = version;
+
+ let areaLength = data[1] * 8;
+ if (areaLength > data.length) throw new Error("Invalid Board Info length");
+ data = data.slice(0, areaLength);
+
+ let sum = data.reduce((a, b) => a + b, 0) & 0xff;
+ if (sum !== 0) throw new Error("Board Info Area checksum error");
+
+ let r = new Reader(data);
+ r.skip(2);
+
+ res.language = r.readLanguageCode();
+ res.manufacturingDate = r.readDateTime();
+ res.manufacturerName = r.readTypeLength(res.language);
+ res.productName = r.readTypeLength(res.language);
+ res.serialNumber = r.readTypeLength(res.language);
+ res.partNumber = r.readTypeLength(res.language);
+ res.fruFileID = r.readTypeLength(res.language);
+ res.custom = r.readTypeLength(res.language);
+ // Not sure if this is up to standard - the standard seems to say that
+ // C1 must always appear, but the Dell storage cards I've looked at
+ // skip it. There's an earlier C1, but that's part of the FRU File ID.
+ if (res.length > 0) {
+ if (r.readByte() !== 0xc1) throw new Error("Custom area must end with C1");
+ }
+ return res;
+ }
+
+ parseInternalUseDell(data) {
+ let version = data[0];
+ if ((version >> 4) !== 0) throw new Error("Invalid Internal Use version");
+ if ((version & 0b1111) !== 1) throw new Error("Invalid Internal Use version");
+
+ if ((new TextDecoder().decode(data.slice(1,5))) !== "DELL") {
+ throw new Error("Invalid 'DELL' magic in internal area");
+ }
+
+ let sum = data.reduce((a, b) => a + b, 0) & 0xff;
+ if (sum !== 0) throw new Error("Dell Internal Area checksum error");
+
+ return {};
+ }
+
+ parse() {
+ this.common = this.parseCommon(this.data.slice(0, 8))
+
+ if (this.common.boardInfoStart !== 0) {
+ let data = this.data.slice(this.common.boardInfoStart, this.data.length);
+ this.boardInfo = this.parseBoardInfo(data);
+ } else {
+ this.boardInfo = {};
+ }
+ this.internalUse = {};
+ if (this.common.internalUseStart !== 0) {
+ let data = this.data.slice(this.common.internalUseStart, this.data.length);
+ this.internalUse.dell = this.parseInternalUseDell(data);
+ }
+ }
+
+ stringify() {
+ let res = [];
+ res.push(`Version: ${this.common.version}`)
+ res.push(`Board Info:`)
+ let bi = this.boardInfo;
+ res.push(` Language: ${bi.language}`)
+ if (bi.manufacturingDate !== undefined)
+ res.push(` Manufacturing Date: ${bi.manufacturingDate}`);
+ res.push(` Manufacturer Name: ${bi.manufacturerName}`)
+ res.push(` Product Name: ${bi.productName}`)
+ res.push(` Serial Number: ${bi.serialNumber}`)
+ res.push(` PartNumber: ${bi.partNumber}`)
+ res.push(` FRU File ID: ${bi.fruFileID}`)
+
+ if (this.internalUse.dell !== undefined) {
+ res.push("Internal Use: DELL-specific")
+ }
+ return res.join("\n");
+ }
+}
+
+class Reader {
+ constructor(data) {
+ this.data = data;
+ }
+ skip(n) {
+ this.data = this.data.slice(n);
+ }
+ readByte() {
+ let num = this.data[0];
+ this.data = this.data.slice(1);
+ return num;
+ }
+ readLanguageCode() {
+ let num = this.readByte();
+ let encoding = num >> 6;
+ let language = [
+ "en", "aa", "ab", "af", "am", "ar", "as", "ay", "az", "ba", "be",
+ "bg", "bh", "bi", "bn", "bo", "br", "ca", "co", "cs", "cy", "da",
+ "de", "dz", "el", "en", "eo", "es", "et", "eu", "fa", "fi", "fj",
+ "fo", "fr", "fy", "ga", "gd", "gl", "gn", "gu", "ha", "hi", "hr",
+ "hu", "hy", "ia", "ie", "ik", "in", "is", "it", "iw", "ja", "ji",
+ "jw", "ka", "kk", "kl", "km", "kn", "ko", "ks", "ku", "ky", "la",
+ "ln", "lo", "lt", "lv", "mg", "mi", "mk", "ml", "mn", "mo", "mr",
+ "ms", "mt", "my", "na", "ne", "nl", "no", "oc", "om", "or", "pa",
+ "pl", "ps", "pt", "qu", "rm", "rn", "ro", "ru", "rw", "sa", "sd",
+ "sg", "sh", "di", "sk", "dl", "sm", "sn", "so", "sq", "sr", "ss",
+ "st", "su", "sv", "sw", "ta", "te", "tg", "th", "ti", "tk", "tl",
+ "tn", "to", "tr", "ts", "tt", "tw", "uk", "ur", "uz", "vi", "vo",
+ "wo", "xh", "yo", "zh", "zu",
+ ][num & 0b111111];
+ return language;
+ }
+ readTypeLength(language) {
+ let tag = this.readByte();
+ let type = tag >> 6;
+ let len = tag & 0b111111;
+ switch (type) {
+ case 0:
+ return this.readTLBinary(len);
+ case 1:
+ return this.readTLBCDPlus(len);
+ case 2:
+ return this.readTL6BASCII(len);
+ case 3:
+ return this.readTLString(len, language);
+ }
+ }
+ readTLBinary(len) {
+ let data = this.data.slice(0, len);
+ this.data = this.data.slice(len);
+ return data;
+ }
+ readTLBCDPlus(len) {
+ let data = this.data.slice(0, len);
+ this.data = this.data.slice(len);
+ const lookup = "012345689 -.???";
+ let res = [];
+ for (const c of data) {
+ let upper = lookup[c >> 4];
+ let lower = lookup[c & 0b1111];
+ if ((upper === "?") || (lower === "?")) {
+ throw new Error("Invalid BCD Plus data");
+ }
+ res.push(upper);
+ res.push(lower);
+ }
+ return res.join("");
+ }
+ readTL6BASCII(len) {
+ let data = this.data.slice(0, len);
+ this.data = this.data.slice(len);
+ const lookup =
+ " !\"#$%&'()*+,-./" +
+ "0123456789:;<=>?" +
+ "@ABCDEFGHIJKLMNO" +
+ "PQRSTUVWXYZ[\\]^_";
+
+ let res = [];
+ let availbits = 0;
+ let bits = 0;
+ while ((data.length > 0) || (availbits >= 6)) {
+ if (availbits < 6) {
+ bits |= (data[0] << availbits);
+ availbits += 8;
+ data = data.slice(1);
+ }
+ let n = bits & 0b111111;
+ availbits -= 6;
+ bits >>= 6;
+ res.push(lookup[n]);
+ }
+ return res.join("");
+ }
+ readTLString(len, language) {
+ let data = this.data.slice(0, len);
+ this.data = this.data.slice(len);
+ // 13. Type/Length Byte Format
+ // Yikes, Intel.
+ if (language !== "en") {
+ throw new Error("Unicode unimplemented");
+ }
+ // This should be 'ASCII + Latin 1', but this is a good enough approximation.
+ return new TextDecoder().decode(data);
+ }
+ readDateTime() {
+ let minutes = this.readByte() | (this.readByte() << 8) | (this.readByte() << 16);
+ if (minutes !== 0) throw new Error("Datetime parsing not implemented");
+ return undefined;
+ }
+}
+
+export class HBJ11FRUAssembler {
+ constructor(serial) {
+ this.serial = serial;
+ }
+
+ assemble() {
+ // Strings can be longer in FRU spec, but let's keep it conservative.
+ if (this.serial.length > 8) {
+ throw new Error("Serial too long");
+ }
+ // Same layout as DELL FRUs, board specific after common, internal use after board specific.
+ let common = [0x01, 0x0a, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf4];
+
+ // Similar layout to DELL FRUs, 72 bytes.
+ let board = [
+ 0x01, // Version 1
+ 0x09, // Length (9*8 == 72 bytes)
+ 0x00, 0x00, 0x00, 0x00, // Manufacturing time (unspecified)
+ 0xC7, 98, 103, 112, 46, 119, 116, 102, // Manufacturer: bgp.wtf
+ 0xDE, 83, 65, 84, 65, 32, 82, 101, 112, 101, 97, 116, 101, 114, // Product name: SATA Repeater
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, // ... pad above to 30 chars.
+ ];
+ // Serial number tag/length.
+ board.push(0xC0 | (this.serial.length));
+ // Serial number.
+ for (const c of this.serial) {
+ board.push(c.charCodeAt());
+ }
+ board = board.concat([
+ 0xC7, 72, 66, 74, 49, 49, 65, 48, // Part number: HBJ11A0
+ 0xC1, 0x02, 0xC1, 0x00, // FRU File ID 2, one-byte custom area/end? Weird shit.
+ ]);
+ if (board.length > 71) {
+ throw new Error("Board Area too long!");
+ }
+ // Pad with zeroes.
+ board = board.concat(Array(71 - board.length).fill(0));
+ // Calculate checksum.
+ let sum = (0xff ^ (board.reduce((a, b) => a + b, 0) & 0xff));
+ board.push((sum + 1) & 0xff);
+
+ // Dell internal use.
+ let dell = [
+ 0x01, 0x44, 0x45, 0x4c, 0x4c, 0xf7, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x01, 0x13, 0x58, 0x01,
+ 0x0f, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0d, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x01,
+ 0x00, 0x01, 0x01, 0x00,
+ ];
+
+ let eeprom = common.concat(board).concat(dell);
+ // Pad to 256 bytes.
+ eeprom = eeprom.concat(Array(256 - eeprom.length).fill(0));
+ return new Uint8Array(eeprom);
+ }
+}
diff --git a/dc/hbj11/flasher/web/i2c.js b/dc/hbj11/flasher/web/i2c.js
new file mode 100644
index 0000000..6aa4ed7
--- /dev/null
+++ b/dc/hbj11/flasher/web/i2c.js
@@ -0,0 +1,159 @@
+/**
+ * Low-level interface to programmer's I2C USB class.
+ *
+ * See //dc/hbj11/flasher/bluepill/src/i2c.rs for more information.
+ */
+
+const ControlInRequest = Object.freeze({
+ 'GetStatus': 1,
+});
+
+const ControlOutRequest = Object.freeze({
+ 'SetLED': 1,
+ 'ReadI2C': 2,
+ 'ReadBuffer': 3,
+ 'WriteI2C': 4,
+ 'SetWritePointer': 5,
+});
+
+export const Status = Object.freeze({
+ 'Idle': 0,
+ 'InvalidArgument': 1,
+ 'Ack': 2,
+ 'Nack': 3,
+ 'BusError': 4,
+});
+
+export const StatusFromU8 = function(u8) {
+ for (const label of Object.keys(Status)) {
+ let val = Status[label];
+ if (val === u8) {
+ return label;
+ }
+ }
+};
+
+/**
+ * Low-level interface to programmer's I2C USB class. Thinly wraps available
+ * USB transfers.
+ */
+export class USBI2CClassInterface {
+ /**
+ * @param {USBDevice} usb - The WebUSB device that backs this USB class.
+ */
+ constructor(device) {
+ this.usb = device;
+ this.BUFFER_SIZE = 1024;
+ this.PACKET_SIZE = 64;
+ }
+
+ /**
+ * Open this programmer via WebUSB and finds all required endpoints.
+ */
+ async open() {
+ await this.usb.open();
+ await this.usb.selectConfiguration(1);
+ await this.usb.claimInterface(0);
+
+ let eps = this.usb.configuration.interfaces[0].alternate.endpoints;
+ this.bulk_out = null;
+ this.bulk_in = null;
+ for (const ep of eps) {
+ if (ep.direction == "out" && ep.type == "bulk") {
+ this.bulk_out = ep;
+ }
+ if (ep.direction == "in" && ep.type == "bulk") {
+ this.bulk_in = ep;
+ }
+ }
+ if (this.bulk_out === null) {
+ throw new Error("Could not find bulk out endpoint");
+ }
+ if (this.bulk_in === null) {
+ throw new Error("Could not find bulk in endpoint");
+ }
+ }
+
+ /**
+ * Performs a USB Control OUT request to the I2C class.
+ * @param {number} request - Request number for transfer (0-255).
+ * @param {number} value - Value for transfer (0-65535).
+ * @returns {Promise<USBOutTransferResult>} The underlying WebUSB transfer result.
+ */
+ async controlOut(request, value) {
+ return await this.usb.controlTransferOut({
+ requestType: "vendor",
+ recipient: "interface",
+ request: request,
+ value: value,
+ index: 0,
+ });
+ }
+
+ /**
+ * Read status from programmer.
+ * @returns {Status} The status of the programmer.
+ */
+ async getStatus() {
+ let res = await this.usb.controlTransferIn({
+ requestType: "vendor",
+ recipient: "interface",
+ request: ControlInRequest.GetStatus,
+ value: 0,
+ index: 0
+ }, 1);
+ if (res.data.byteLength < 1) {
+ throw new Error('returned data too short')
+ }
+ return res.data.getInt8(0);
+ }
+
+ /**
+ * Sends SetLED control OUT request.
+ */
+ async setLED(on) {
+ return await this.controlOut(ControlOutRequest.SetLED, on ? 1 : 0);
+ }
+
+ /**
+ * Sends ReadI2C control OUT request.
+ */
+ async readI2C(addr, length) {
+ return await this.controlOut(ControlOutRequest.ReadI2C, (length << 8) | addr);
+ }
+
+ /**
+ * Sends ReadBuffer control OUT request.
+ */
+ async readBuffer(addr, length) {
+ return await this.controlOut(ControlOutRequest.ReadBuffer, (length << 8) | addr);
+ }
+
+ /**
+ * Sends WriteI2C control OUT request.
+ */
+ async writeI2C(addr, length) {
+ return await this.controlOut(ControlOutRequest.WriteI2C, (length << 8) | addr);
+ }
+
+ /**
+ * Sends SetWritePointer control OUT request.
+ */
+ async setWritePointer(addr) {
+ return await this.controlOut(ControlOutRequest.SetWritePointer, addr);
+ }
+
+ /**
+ * Requets bulk IN data.
+ */
+ async bulkIn(length) {
+ return await this.usb.transferIn(this.bulk_in.endpointNumber, length);
+ }
+
+ /**
+ * Sends bulk OUT data.
+ */
+ async bulkOut(data) {
+ return await this.usb.transferOut(this.bulk_out.endpointNumber, data);
+ }
+}
diff --git a/dc/hbj11/flasher/web/index.html b/dc/hbj11/flasher/web/index.html
new file mode 100644
index 0000000..24e1a64
--- /dev/null
+++ b/dc/hbj11/flasher/web/index.html
@@ -0,0 +1,142 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta charset="utf-8">
+ <title>Web I2C Flasher</title>
+ <style>
+ html {
+ background-color: #f0f0f0;
+ }
+ body {
+ padding: 0;
+ margin: 0;
+ }
+ header {
+ padding: 1rem;
+ background-color: #fff;
+ box-shadow: 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24);
+ }
+ #document {
+ margin: 40px auto;
+ max-width: 750px;
+ }
+ button {
+ display: inline-block;
+ border: 0;
+ background-color: #f8f8f8;
+ color: #333;
+ border: 1px solid #dedede;
+ padding: 0.2rem 0.8rem 0.2rem 0.8rem;
+ font-family: Verdana, Sans-Serif;
+ font-size: 0.65rem;
+ font-weight: 700;
+ text-transform: uppercase;
+ outline: 0;
+ }
+ button + button {
+ margin-left: 0.5rem;
+ }
+ button:hover {
+ background-color: #fefefe;
+ }
+ button:active {
+ background-color: #f0f0f0;
+ }
+ button:disabled {
+ color: #888;
+ }
+ button:disabled:hover {
+ background-color: #f8f8f8;
+ border: 1px solid #dedede;
+ }
+ button.btn-red {
+ padding: 0.4rem 1rem 0.4rem 1rem;
+ background-color: #ff4949;
+ color: #fff;
+ border: 1px solid #8a1c05;
+ }
+ button.btn-red:hover {
+ background-color: #ff5959;
+ border: 1px solid #8a1c05;
+ }
+ button.btn-red:active {
+ background-color: #ff3939;
+ border: 1px solid #8a1c05;
+ }
+ h1,h2,h3 {
+ font-family: Helvetica, Sans-Serif;
+ margin: 0;
+ color: #111;
+ }
+ h1 {
+ font-size: 1.5rem;
+ color: #333;
+ }
+ h2 {
+ margin-bottom: 0.3rem;
+ font-size: 1.2rem;
+ }
+ h3 {
+ font-size: 0.8rem;
+ margin: 0.3rem;
+ }
+ #programmers {
+ }
+ .programmer {
+ width: 100%;
+ margin-top: 1rem;
+ background-color: #fff;
+ box-shadow: 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24);
+ }
+ .programmerName {
+ font-family: Verdana, sans-serif;
+ font-size: 0.9rem;
+ padding: 1rem;
+ border-bottom: 1px solid #ddd;
+ background-color: #fff;
+ }
+ .programmerOptions {
+ float: right;
+ }
+ .devices {
+ padding: 2rem;
+ }
+ .device {
+ clear: both;
+ background-color: #fafafa;
+ padding: 1rem;
+ border: 1px solid #eee;
+ }
+ .device + .device {
+ margin-top: 1rem;
+ }
+ .deviceName {
+ font-family: Verdana, sans-serif;
+ }
+ .deviceOptions {
+ float: right;
+ }
+ .deviceDump {
+ color: #fff;
+ background-color: #1c1c1c;
+ display: block;
+ clear: both;
+ padding: 1rem;
+ font-family: monospace;
+ margin-top: 1rem;
+ border-radius: 0.3rem;
+ }
+ </style>
+ </head>
+<body>
+ <header>
+ <h1>Web I2C Flash</h1>
+ </header>
+ <div id="document">
+ <button id="connect" class="btn-red">Add...</button>
+ <div id="programmers">
+ </div>
+ </div>
+ <script src="main.js" type="module"></script>
+</body>
+</html>
diff --git a/dc/hbj11/flasher/web/main.js b/dc/hbj11/flasher/web/main.js
new file mode 100644
index 0000000..9691f9c
--- /dev/null
+++ b/dc/hbj11/flasher/web/main.js
@@ -0,0 +1,472 @@
+/*
+ * WebI2C, a web interface for flashing I2C EEPROMS, notably FRU EEPROMs for
+ * the HBJ11.
+ */
+
+import { FRUParser, HBJ11FRUAssembler } from './fru.js';
+import { Status, StatusFromU8, USBI2CClassInterface } from './i2c.js';
+
+/**
+ * I2CDevice is an I2C device (eg. EEPROM) on the I2C bus, attached via a
+ * Programmer.
+ */
+class I2CDevice {
+ constructor(programmer, addr) {
+ this.programmer = programmer;
+ this.addr = addr;
+ this.dump = "";
+ }
+
+ /**
+ * Treat this device as an I2C EEPROM (eg. 24C02) and read its content.
+ * @param {number} addr - The address in the EEPROM to start reading at.
+ * @param {number} length - Count of bytes to read starting at address.
+ * @returns {Promise<Uint8Array>} Contents of the EEPROM.
+ */
+ async readFlash(addr, length) {
+ // Always send a non-zero seek, otherwise 24C02 sometimes NACKs?
+ await this.programmer.writeI2C(this.addr, new Uint8Array([1]));
+ await this.programmer.readI2C(this.addr, 1);
+
+ // Chunk up reads into 128 bytes.
+ let i = 0;
+ const max_chunk_size = 128;
+ let flash = new Uint8Array(length);
+ while (i < length) {
+ await this.programmer.writeI2C(this.addr, new Uint8Array([i]));
+ let chunk_size = length - i;
+ if (chunk_size > max_chunk_size) {
+ chunk_size = max_chunk_size;
+ }
+ let res = await this.programmer.readI2C(this.addr, chunk_size);
+ flash.set(new Uint8Array(res.buffer), i);
+ i += chunk_size;
+ }
+ return flash;
+ }
+
+ /**
+ * Threat this devices as an I2C EEPROM on a HBJ11 and flash it with a given
+ * serial nyumber.
+ * @param {string} serial - The serial number of the HJB11 to brand it with.
+ * @param {HTMLButtonelement} button - Button used to trigger this action,
+ * will be disabled while the flashing is
+ * performed.
+ */
+ async writeHBJ11(serial, button) {
+ // Always send a non-zero seek, otherwise 24C02 sometimes NACKs?
+ await this.programmer.writeI2C(this.addr, new Uint8Array([1]));
+ await this.programmer.readI2C(this.addr, 1);
+
+ let text = button.innerText;
+ button.disabled = true;
+ button.innerText = "Flashing...";
+
+ let data = new HBJ11FRUAssembler(serial).assemble();
+
+ // Chunk up writes into 16 bytes.
+ let chunks = [];
+ for (let i = 0; i < data.length; i+= 16) {
+ chunks.push([i].concat(Array.from(data.slice(i, i+16))));
+ }
+
+ for (const chunk of chunks) {
+ await this.programmer.writeI2C(this.addr, new Uint8Array(chunk));
+ }
+
+ button.disabled = false;
+ button.innerText = text;
+ }
+
+ render(div) {
+ div.innerHTML = "";
+ let deviceName = document.createElement("div");
+ deviceName.className = "deviceName";
+ deviceName.appendChild(document.createTextNode(`Device 0x${this.addr.toString(16)}`));
+
+ div.appendChild(deviceName);
+
+ let deviceOptions = document.createElement("div");
+ deviceOptions.className = "deviceOptions";
+
+ let readButton = document.createElement("button");
+ readButton.appendChild(document.createTextNode("Read flash"));
+ readButton.onclick = async () => {
+ let res = await this.readFlash(this.addr, 256);
+
+ this.dump = "";
+ const hex = "0123456789ABCDEF";
+ for (let i = 0; i < res.length; i += 16) {
+ let block = res.slice(i, Math.min(i+16, res.length));
+ let addr = ("0000" + i.toString(16)).slice(-4);
+ let codes = Array.from(block.values()).map((code) => {
+ return " " + hex[(0xF0 & code) >> 4] + hex[0x0f & code];
+ }).join("");
+ codes += " ".repeat(16 - block.length);
+ let chars = Array.from(block.values()).map((code) => {
+ if (code < 0x20 || code > 0x7e) {
+ return ".";
+ }
+ return String.fromCharCode(code);
+ }).join("");
+ codes += " ".repeat(16 - block.length);
+ this.dump += (addr + " " + codes + " " + chars + "\n");
+ }
+
+ let p = new FRUParser(res);
+ try {
+ p.parse();
+ this.dump += "\nFRU EEPROM:\n";
+ this.dump += p.stringify();
+ } catch(err) {
+ this.dump += "\nNot an FRU EEPROM: " + err;
+ }
+
+ console.log(this.dump);
+
+ this.render(div);
+ };
+ deviceOptions.appendChild(readButton);
+
+ let makeButton = document.createElement("button");
+ makeButton.appendChild(document.createTextNode("Make HBJ11"));
+ makeButton.onclick = async () => {
+ await this.writeHBJ11(window.prompt("Enter HBJ11 Serial", "A0000"), makeButton);
+ };
+ deviceOptions.appendChild(makeButton);
+
+ deviceName.appendChild(deviceOptions);
+
+ if (this.dump.length > 0) {
+ let deviceDump = document.createElement("pre");
+
+ deviceDump.className = "deviceDump";
+ deviceDump.innerText = this.dump;
+ div.appendChild(deviceDump);
+ }
+ }
+}
+
+/**
+ * A list of I2CDevices, eg. EEPROMs. Used for DOM rendering.
+ */
+class I2CDeviceList {
+ constructor() {
+ this.list = [];
+ }
+
+ set(devices) {
+ this.list = devices;
+ }
+
+ render(div) {
+ if (this.list.length === 0) {
+ div.innerHTML = "<i>No devices...</i>";
+ return;
+ }
+
+ for (const device of this.list) {
+ let deviceDiv = document.createElement("div");
+ deviceDiv.className = "device";
+ device.render(deviceDiv);
+ div.appendChild(deviceDiv);
+ }
+ }
+}
+
+/**
+ * A WebI2C compatible programmer accessed over USB.
+ */
+class Programmer {
+ /**
+ * @param {USBDevice} usb - The WebUSB device that backs this programmer.
+ */
+ constructor(usb) {
+ this.usb = usb;
+ this.i2c = new USBI2CClassInterface(usb);
+ this.devices = new I2CDeviceList();
+ }
+ /**
+ * Get programmer manufacturer name.
+ * @returns {string} The name.
+ */
+ get manufacturerName() {
+ return this.usb.manufacturerName;
+ }
+
+ /**
+ * Get programmer product name.
+ * @returns {string} The name.
+ */
+ get productName() {
+ return this.usb.productName;
+ }
+
+ /**
+ * Get programmer serial number.
+ * @returns {string} The name.
+ */
+ get serialNumber() {
+ return this.usb.serialNumber;
+ }
+
+ /**
+ * Compares two Programmers and checks if they're using the same WebUSB
+ * device underneath. This is used for housekeeping of the ProgrammerList.
+ */
+ equal(other) {
+ let one = this.usb;
+ let two = other.usb;
+ return (one.vendorId == two.vendorId)
+ && (one.productId == two.productId)
+ && (one.serialNumber == two.serialNumber);
+ }
+
+ /**
+ * Performs an I2C read on the bus of the programmer and reads the resulting
+ * data from the buffer. The readout is performed in chunks over multiple
+ * Bulk transfer.
+ * @param {number} addr - Address of the I2C device to read from.
+ * @param {number} length - Number of bytes to read from I2C (not larger than
+ * BUFFER_SIZE).
+ * @returns {object} Object with status and bufer keys. TODO(q3k): declare type.
+ */
+ async readI2C(addr, length) {
+ await this.i2c.readI2C(addr, length);
+ let status = await this.i2c.getStatus();
+ if (status !== Status.Ack) {
+ return {status: status, buffer: null};
+ }
+ let buffer = new Uint8Array(length);
+ let i = 0;
+ while (i < length) {
+ let chunkSize = length - i;
+ if (chunkSize > this.i2c.PACKET_SIZE) {
+ chunkSize = this.i2c.PACKET_SIZE;
+ }
+ let chunk = await this.readBuffer(i, chunkSize);
+ buffer.set(new Uint8Array(chunk.buffer), i);
+ i += chunkSize;
+ }
+ return {status: status, buffer: buffer};
+ }
+
+ /**
+ * Transfers data to internal buffer of programmers and performs an I2C write
+ * with the given data.
+ * @param {number} addr - Address of the I2C to write data to.
+ * @param {ArrayBuffer} data - Data to write to device.
+ */
+ async writeI2C(addr, data) {
+ let i = 0;
+ while (i < data.length) {
+ let end = i + this.i2c.PACKET_SIZE;
+ if (end > data.length) {
+ end = data.length;
+ }
+ let chunk = data.slice(i, end);
+ await this.writeBuffer(i, chunk);
+ i = end;
+ }
+ await this.i2c.writeI2C(addr, data.length);
+ }
+
+ /**
+ * Performs a scan of the I2C bus for all connected devices and upgrades the
+ * internal I2CDeviceList with found I2CDevices.
+ * @param {HTMLButtonElement} button - Button that will be disabled when the
+ * Scan is performed.
+ */
+ async scan(button) {
+ let text = button.innerText;
+ button.innerText = "Scanning...";
+ button.disabled = true;
+
+ let present = [];
+ for (let i = 0; i < 127; i++) {
+ let res = await this.readI2C(i, 1);
+ switch (res.status) {
+ case Status.Ack:
+ present.push(new I2CDevice(this, i));
+ break;
+ case Status.Nack:
+ break;
+ default:
+ throw new Error(`When scanning ${i}: ${StatusFromU8(res.status)}`);
+ }
+ }
+ this.devices.set(present);
+
+ button.disabled = false;
+ button.innerText = text;
+ }
+
+ /**
+ * Blinks the programmer's LED.
+ * @param {HTMLButtonElement} button - Button that will be disabled when the
+ * LED blinks.
+ */
+ async blink(button) {
+ let on = true;
+ button.disabled = true;
+ let text = button.innerText;
+ button.innerText = "Blinking...";
+ for (let i = 0; i < 20; i++) {
+ await this.i2c.setLED(on);
+ await new Promise(r => setTimeout(r, 100));
+ on = !on;
+ }
+ button.disabled = false;
+ button.innerText = text;
+ }
+
+ /**
+ * Requests buffer readout from device via ReadBuffer control transfer and
+ * then performs a single read via the Bulk IN endpoint.
+ * @param {number} addr - Address within the buffer to start read at.
+ * @param {number} length - Number of bytes to read (not larger than
+ * PACKET_SIZE).
+ * @returns {ArrayBuffer} Data read from buffer.
+ */
+ async readBuffer(addr, length) {
+ await this.i2c.readBuffer(addr, length);
+ let status = await this.i2c.getStatus();
+ if (status !== Status.Idle) {
+ throw new Error(`When requesting buffer: ${StatusFromU8(res.status)}`);
+ }
+ let res = await this.i2c.bulkIn(length);
+ return res.data;
+ }
+
+ /**
+ * Writes bytes to internal buffer.
+ * @param {number} addr - Address within the buffer to start write at.
+ * @param {ArrayBuffer} data - Data to write to buffer (must not be longer
+ * than PACKET_SIZE).
+ */
+ async writeBuffer(addr, data) {
+ await this.i2c.setWritePointer(addr);
+ let status = await this.i2c.getStatus();
+ if (status !== Status.Idle) {
+ throw new Error(`When setting pointer: ${StatusFromU8(res.status)}`);
+ }
+ await this.i2c.bulkOut(data);
+ }
+
+
+ render(div) {
+ let programmer = document.createElement("div");
+ programmer.className = "programmer";
+ let programmerName = document.createElement("div");
+ programmerName.className = "programmerName";
+ programmerName.appendChild(document.createTextNode(this.manufacturerName));
+ programmerName.appendChild(document.createTextNode(" "));
+ let b = document.createElement("b");
+ b.textContent = this.productName;
+ programmerName.appendChild(b);
+
+ let programmerOptions = document.createElement("div");
+ programmerOptions.className = "programmerOptions";
+
+ let blinkButton = document.createElement("button");
+ blinkButton.appendChild(document.createTextNode("Blink LED"));
+ blinkButton.onclick = async () => {
+ await this.blink(blinkButton);
+ };
+ programmerOptions.appendChild(blinkButton);
+
+ let devices = document.createElement("div");
+ devices.className = "devices";
+
+ let scanButton = document.createElement("button");
+ scanButton.appendChild(document.createTextNode("Scan I2C Bus"));
+ scanButton.onclick = async () => {
+ await this.scan(scanButton);
+ devices.innerText = "";
+ this.devices.render(devices)
+ };
+ programmerOptions.appendChild(scanButton);
+
+ programmerName.appendChild(programmerOptions);
+ programmer.appendChild(programmerName);
+
+ this.devices.render(devices)
+ programmer.append(devices);
+
+ div.appendChild(programmer);
+ }
+}
+
+/**
+ * List of Programmers, used for rendering to DOM.
+ */
+class ProgrammerList {
+ constructor(list) {
+ this.list = [];
+ for (const l of list) {
+ this.list.push(l);
+ }
+ this.status = {};
+ }
+ async addProgrammer(programmer) {
+ let existing = this.list.filter(d => d.equal(programmer));
+ if (existing.length == 0) {
+ this.list.push(programmer);
+ await programmer.i2c.open();
+ }
+ }
+ removeProgrammer(programmer) {
+ this.list = this.list.filter(d => !d.equal(programmer));
+ }
+ render() {
+ let div = document.querySelector("#programmers");
+ div.innerText = "";
+ for (const programmer of this.list) {
+ programmer.render(div);
+ }
+ }
+}
+
+if (navigator.usb === undefined || navigator.usb.requestDevice === undefined) {
+ alert("No WebUSB support! Please use a Chromium-based browser.");
+}
+
+// 'global' ProgrammerList, modified by document/USB events.
+let list = null;
+
+document.addEventListener('DOMContentLoaded', async () => {
+ let programmers = (await navigator.usb.getDevices()).map(d => new Programmer(d));
+ for (const programmer of programmers) {
+ await programmer.i2c.open();
+ }
+ list = new ProgrammerList(programmers);
+ list.render();
+});
+
+navigator.usb.addEventListener('connect', async event => {
+ await list.addProgrammer(new Programmer(event.device));
+ list.render();
+});
+
+navigator.usb.addEventListener('disconnect', event => {
+ list.removeProgrammer(new Programmer(event.device));
+ list.render();
+});
+
+document.getElementById("connect").onclick = async () => {
+ let device;
+ try {
+ device = await navigator.usb.requestDevice({
+ filters: [{
+ vendorId: 0x16c0,
+ productId: 0x27d8,
+ }]
+ });
+ } catch (err) {
+ return;
+ };
+ if (device !== undefined) {
+ await list.addProgrammer(new Programmer(device));
+ list.render();
+ }
+};
diff --git a/games/valheim/OWNERS b/games/valheim/OWNERS
new file mode 100644
index 0000000..7b3f74b
--- /dev/null
+++ b/games/valheim/OWNERS
@@ -0,0 +1,4 @@
+owners:
+- q3k
+- palid
+- patryk
diff --git a/games/valheim/prod.jsonnet b/games/valheim/prod.jsonnet
index 6c10b8b..9f0f421 100644
--- a/games/valheim/prod.jsonnet
+++ b/games/valheim/prod.jsonnet
@@ -124,6 +124,8 @@
PUBLIC: "1",
PASSWORD: kube.SecretKeyRef(game.secret, "public"),
NAME: cfg.displayName,
+ # Always attempt to update valheim on startup.
+ FORCE_INSTALL: "1",
},
resources: {
requests: {
@@ -155,7 +157,20 @@
},
},
- ns: kube.Namespace("valheim") {
+ # Make namespace for valheim.
+ ns: kube.Namespace("valheim"),
+
+ # Allow patryk and palid to administer this namespace via the namespace-admin clusterrole.
+ adminRB: top.ns.Contain(kube.RoleBinding("sso:admins")) {
+ subjects: [
+ { apiGroup: "rbac.authorization.k8s.io", kind: "User", name: "%s@hackerspace.pl" % [u] }
+ for u in ["patryk", "palid"]
+ ],
+ roleRef: {
+ apiGroup: "rbac.authorization.k8s.io",
+ kind: "ClusterRole",
+ name: "system:admin-namespace",
+ },
},
q3k: top.env(top.ns, "q3k") {
