limen: extract udp into its own static library

limen: extract igmp into its own static library
limen: extract icmp; convert constructor-based self-registration to explicit init()
2026-05-01 13:52:30 -07:00 · 2026-05-01 13:47:41 -07:00 · 2026-05-01 13:44:54 -07:00 · 2026-05-01 13:35:42 -07:00 · 2026-05-01 13:23:12 -07:00 · 2026-05-01 11:03:17 -07:00
35 changed files with 594 additions and 3109 deletions
@@ -0,0 +1,7 @@
+---
+name: info
+description: Query device info from connected Picos. Use when the user says "info", "check devices", or wants to verify devices are responding.
+user-invocable: true
+---
+
+Run `go run ./cmd/picomap/ info` from the project root. This queries all connected devices and prints board ID, MAC, IP, and firmware name.
@@ -0,0 +1,10 @@
+---
+name: test
+description: Run device tests on connected Picos. Use when the user says "test", "run tests", or wants to verify firmware behavior.
+user-invocable: true
+---
+
+Run `go run ./cmd/picomap/ test all` from the project root. This runs all registered tests on the test device.
+
+To list available tests: `go run ./cmd/picomap/ test list`
+To run a specific test: `go run ./cmd/picomap/ test run <name>`
@@ -0,0 +1,3 @@
+[submodule "firmware/limen"]
+	path = firmware/limen
+	url = git@g.fc.run:embed/limen.git
@@ -9,16 +9,83 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"sync"
 	"time"

 	"github.com/theater/picomap/lib/client"
-	"github.com/theater/picomap/lib/picotool"
+	"github.com/theater/picomap/lib/uf2"
 )

+type target struct {
+	name   string
+	client *client.Client
+}
+
+type targetFlags struct {
+	udp   string
+	iface string
+}
+
+func addTargetFlags(fs *flag.FlagSet) *targetFlags {
+	tf := &targetFlags{}
+	fs.StringVar(&tf.udp, "udp", "", "comma-separated UDP IP addresses")
+	fs.StringVar(&tf.iface, "iface", "", "network interface for multicast discovery")
+	return tf
+}
+
+func (tf *targetFlags) connect(timeout time.Duration) ([]target, error) {
+	var targets []target
+
+	if tf.udp != "" {
+		for _, addr := range strings.Split(tf.udp, ",") {
+			addr = strings.TrimSpace(addr)
+			c, err := client.NewUDP(addr, tf.iface, timeout)
+			if err != nil {
+				return nil, fmt.Errorf("udp %s: %w", addr, err)
+			}
+			targets = append(targets, target{addr, c})
+		}
+	}
+
+	if tf.iface != "" && tf.udp == "" {
+		bcast, err := client.InterfaceBroadcast(tf.iface)
+		if err != nil {
+			return nil, err
+		}
+		c, err := client.NewUDP(bcast, tf.iface, timeout)
+		if err != nil {
+			return nil, err
+		}
+		infos, err := c.InfoAll()
+		c.Close()
+		if err != nil {
+			return nil, fmt.Errorf("discovery: %w", err)
+		}
+		for _, r := range infos {
+			uc, err := client.NewUDP(r.From, tf.iface, timeout)
+			if err != nil {
+				return nil, fmt.Errorf("udp %s: %w", r.From, err)
+			}
+			targets = append(targets, target{r.From, uc})
+		}
+	}
+
+	if len(targets) == 0 {
+		return nil, fmt.Errorf("no devices found")
+	}
+	return targets, nil
+}
+
+func closeTargets(targets []target) {
+	for _, t := range targets {
+		t.client.Close()
+	}
+}
+
 func main() {
 	if len(os.Args) < 2 {
-		slog.Error("usage: picomap <info|load|test> [args...]")
+		fmt.Fprintf(os.Stderr, "usage: picomap <command> [args...]\n\ncommands:\n  info\n  flash-status\n  load\n  log\n  reboot\n  test\n")
 		os.Exit(1)
 	}
 	cmd := os.Args[1]
@@ -28,14 +95,18 @@ func main() {
 	switch cmd {
 	case "info":
 		err = cmdInfo(args)
+	case "flash-status":
+		err = cmdFlashStatus(args)
 	case "load":
 		err = cmdLoad(args)
 	case "log":
 		err = cmdLog(args)
+	case "reboot":
+		err = cmdReboot(args)
 	case "test":
-		err = cmdTest(args)
+		err = cmdTestGroup(args)
 	default:
-		slog.Error("usage: picomap <info|load|log|test> [args...]")
+		fmt.Fprintf(os.Stderr, "usage: picomap <command> [args...]\n\ncommands:\n  info\n  flash-status\n  load\n  log\n  reboot\n  test\n")
 		os.Exit(1)
 	}
 	if err != nil {
@@ -44,143 +115,53 @@ func main() {
 	}
 }

-type deviceResult struct {
-	dev  string
-	info *client.ResponseInfo
-	err  error
-}
-
-func printInfo(via string, from string, info *client.ResponseInfo) {
+func printInfo(via string, info *client.ResponseInfo) {
 	slog.Info("device",
 		"via", via,
-		"from", from,
 		"board_id", hex.EncodeToString(info.BoardID[:]),
 		"mac", net.HardwareAddr(info.MAC[:]).String(),
 		"ip", net.IP(info.IP[:]).String(),
-		"firmware", info.FirmwareName)
+		"firmware", info.FirmwareName,
+		"boot", info.Boot.String(),
+		"build_epoch", info.BuildEpoch)
 }

 func cmdInfo(args []string) error {
 	fs := flag.NewFlagSet("info", flag.ExitOnError)
-	udpAddr := fs.String("udp", "", "connect via UDP to this IP address")
-	iface := fs.String("iface", "", "bind to this network interface (for broadcast)")
+	tf := addTargetFlags(fs)
 	fs.Parse(args)

-	if *udpAddr == "" && *iface != "" {
-		bcast, err := client.InterfaceBroadcast(*iface)
-		if err != nil {
-			return err
-		}
-		*udpAddr = bcast
-	}
-
-	if *udpAddr != "" {
-		c, err := client.NewUDP(*udpAddr, *iface, 500*time.Millisecond)
-		if err != nil {
-			return err
-		}
-		defer c.Close()
-		infos, err := c.InfoAll()
-		if err != nil {
-			return err
-		}
-		if len(infos) == 0 {
-			return fmt.Errorf("no devices responded")
-		}
-		for _, r := range infos {
-			printInfo(*udpAddr, r.From, r.Value)
-		}
-		return nil
-	}
-
-	devs, err := client.ListSerial()
+	targets, err := tf.connect(500*time.Millisecond)
 	if err != nil {
 		return err
 	}
-	if len(devs) == 0 {
-		return fmt.Errorf("no devices found")
-	}
+	defer closeTargets(targets)

-	results := make([]deviceResult, len(devs))
-	var wg sync.WaitGroup
-	for i, dev := range devs {
-		results[i].dev = dev
-		wg.Go(func() {
-			c, err := client.NewSerial(dev, 500*time.Millisecond)
-			if err != nil {
-				results[i].err = err
-				return
-			}
-			info, err := c.Info()
-			c.Close()
-			if err != nil {
-				results[i].err = err
-				return
-			}
-			results[i].info = info
-		})
-	}
-	wg.Wait()
-
-	for _, r := range results {
-		if r.err != nil {
-			slog.Error("device error", "dev", r.dev, "err", r.err)
+	for _, t := range targets {
+		info, err := t.client.Info()
+		if err != nil {
+			slog.Error("info error", "via", t.name, "err", err)
 			continue
 		}
-		printInfo(r.dev, r.dev, r.info)
-	}
-
-	return nil
-}
-
-func boardSerial(id [8]byte) string {
-	return fmt.Sprintf("%02X%02X%02X%02X%02X%02X%02X%02X",
-		id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7])
-}
-
-type deviceInfo struct {
-	dev    string
-	serial string
-	uf2    string
-	name   string
-}
-
-func buildFirmware(buildDir string) error {
-	slog.Info("configuring")
-	cmake := exec.Command("cmake", "-S", filepath.Join(filepath.Dir(buildDir)), "-B", buildDir)
-	cmake.Stdout = os.Stdout
-	cmake.Stderr = os.Stderr
-	if err := cmake.Run(); err != nil {
-		return fmt.Errorf("cmake failed: %w", err)
-	}
-
-	slog.Info("building")
-	cmd := exec.Command("make", "-C", buildDir)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	if err := cmd.Run(); err != nil {
-		return fmt.Errorf("build failed: %w", err)
+		printInfo(t.name, info)
 	}
 	return nil
 }

-func cmdLog(_ []string) error {
-	devs, err := client.ListSerial()
+func cmdLog(args []string) error {
+	fs := flag.NewFlagSet("log", flag.ExitOnError)
+	tf := addTargetFlags(fs)
+	fs.Parse(args)
+
+	targets, err := tf.connect(500*time.Millisecond)
 	if err != nil {
 		return err
 	}
-	if len(devs) == 0 {
-		return fmt.Errorf("no devices found")
-	}
-	for _, dev := range devs {
-		log := slog.With("dev", dev)
-		c, err := client.NewSerial(dev, 500*time.Millisecond)
-		if err != nil {
-			log.Error("connect error", "err", err)
-			continue
-		}
-		resp, err := c.Log()
-		c.Close()
+	defer closeTargets(targets)
+
+	for _, t := range targets {
+		log := slog.With("dev", t.name)
+		resp, err := t.client.Log()
 		if err != nil {
 			log.Error("log error", "err", err)
 			continue
@@ -196,10 +177,87 @@ func cmdLog(_ []string) error {
 	return nil
 }

+func cmdFlashStatus(args []string) error {
+	fs := flag.NewFlagSet("flash-status", flag.ExitOnError)
+	tf := addTargetFlags(fs)
+	fs.Parse(args)
+
+	targets, err := tf.connect(500 * time.Millisecond)
+	if err != nil {
+		return err
+	}
+	defer closeTargets(targets)
+
+	for _, t := range targets {
+		status, err := t.client.FlashStatus()
+		if err != nil {
+			slog.Error("flash-status error", "via", t.name, "err", err)
+			continue
+		}
+		log := slog.With("via", t.name)
+		log.Info("flash-status", "boot_partition", status.BootPartition)
+		log.Info("slot-a", "valid", status.SlotA.Valid, "version", status.SlotA.Version, "hash_ok", status.SlotA.HashOK)
+		log.Info("slot-b", "valid", status.SlotB.Valid, "version", status.SlotB.Version, "hash_ok", status.SlotB.HashOK)
+	}
+	return nil
+}
+
+func cmdReboot(args []string) error {
+	fs := flag.NewFlagSet("reboot", flag.ExitOnError)
+	tf := addTargetFlags(fs)
+	fs.Parse(args)
+
+	targets, err := tf.connect(500 * time.Millisecond)
+	if err != nil {
+		return err
+	}
+	defer closeTargets(targets)
+
+	for _, t := range targets {
+		if err := t.client.Reboot(); err != nil {
+			slog.Error("reboot error", "via", t.name, "err", err)
+			continue
+		}
+		slog.Info("rebooted", "via", t.name)
+	}
+	return nil
+}
+
+func boardSerial(id [8]byte) string {
+	return fmt.Sprintf("%02X%02X%02X%02X%02X%02X%02X%02X",
+		id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7])
+}
+
+func runCmd(name string, args ...string) error {
+	cmd := exec.Command(name, args...)
+	out, err := cmd.CombinedOutput()
+	if len(out) > 0 {
+		for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
+			slog.Info(name, "msg", line)
+		}
+	}
+	if err != nil {
+		return fmt.Errorf("%s failed: %w", name, err)
+	}
+	return nil
+}
+
+func buildFirmware(buildDir string) error {
+	srcDir := filepath.Dir(buildDir)
+	if err := runCmd("cmake", "-S", srcDir, "-B", buildDir); err != nil {
+		return err
+	}
+	return runCmd("cmake", "--build", buildDir)
+}
+
 func cmdLoad(args []string) error {
-	target := "all"
-	if len(args) > 0 {
-		target = args[0]
+	fs := flag.NewFlagSet("load", flag.ExitOnError)
+	tf := addTargetFlags(fs)
+	dryRun := fs.Bool("dry-run", false, "parse UF2 and log operations without flashing")
+	fs.Parse(args)
+	loadTarget := "all"
+	if fs.NArg() > 0 {
+		loadTarget = fs.Arg(0)
 	}

 	wd, err := os.Getwd()
@@ -212,116 +270,73 @@ func cmdLoad(args []string) error {
 		return err
 	}

-	devs, err := client.ListSerial()
-	if err != nil {
-		return err
-	}
-
-	allTargets := []struct {
+	type firmwareTarget struct {
 		name string
 		uf2  string
-	}{
+	}
+	allTargets := []firmwareTarget{
 		{"picomap", filepath.Join(buildDir, "picomap.uf2")},
 		{"picomap_test", filepath.Join(buildDir, "picomap_test.uf2")},
 	}

-	var targets []struct {
-		name string
-		uf2  string
-	}
-	switch target {
+	var fwTargets []firmwareTarget
+	switch loadTarget {
 	case "all":
-		targets = allTargets
+		fwTargets = allTargets
 	case "picomap":
-		targets = allTargets[:1]
+		fwTargets = allTargets[:1]
 	case "picomap_test":
-		targets = allTargets[1:]
+		fwTargets = allTargets[1:]
 	default:
-		return fmt.Errorf("unknown target %q", target)
+		return fmt.Errorf("unknown target %q", loadTarget)
 	}

-	if len(devs) < len(targets) {
-		return fmt.Errorf("need %d device(s), found %d", len(targets), len(devs))
+	targets, err := tf.connect(5*time.Second)
+	if err != nil {
+		return err
+	}
+	defer closeTargets(targets)
+
+	if len(targets) < len(fwTargets) {
+		return fmt.Errorf("need %d device(s), found %d", len(fwTargets), len(targets))
 	}

-	devices := make([]deviceInfo, len(targets))
-	errs := make([]error, len(targets))
+	type deviceInfo struct {
+		target target
+		serial string
+		fw     firmwareTarget
+	}

+	devices := make([]deviceInfo, len(fwTargets))
+	for i, t := range targets[:len(fwTargets)] {
+		info, err := t.client.Info()
+		if err != nil {
+			return fmt.Errorf("[%s] info: %w", t.name, err)
+		}
+		devices[i] = deviceInfo{
+			target: t,
+			serial: boardSerial(info.BoardID),
+			fw:     fwTargets[i],
+		}
+		slog.Info("got info", "dev", t.name, "serial", devices[i].serial, "firmware", info.FirmwareName)
+	}
+
+	errs := make([]error, len(devices))
 	var wg sync.WaitGroup
-	for i := range targets {
-		log := slog.With("dev", devs[i])
-		wg.Go(func() {
-			c, err := client.NewSerial(devs[i], 500*time.Millisecond)
-			if err != nil {
-				errs[i] = err
-				return
-			}
-			info, err := c.Info()
-			c.Close()
-			if err != nil {
-				errs[i] = err
-				return
-			}
-			devices[i] = deviceInfo{
-				dev:    devs[i],
-				serial: boardSerial(info.BoardID),
-				uf2:    targets[i].uf2,
-				name:   targets[i].name,
-			}
-			log.Info("got info", "serial", devices[i].serial, "firmware", info.FirmwareName)
-		})
-	}
-	wg.Wait()
-	for i, err := range errs {
-		if err != nil {
-			return fmt.Errorf("[%s] info: %w", devs[i], err)
-		}
-	}
-
 	for i := range devices {
-		log := slog.With("serial", devices[i].serial)
+		log := slog.With("dev", devices[i].target.name, "serial", devices[i].serial)
 		wg.Go(func() {
-			log.Info("sending PICOBOOT")
-			c, err := client.NewSerial(devices[i].dev, 500*time.Millisecond)
-			if err != nil {
-				errs[i] = err
-				return
-			}
-			err = c.PICOBOOT()
-			c.Close()
-			if err != nil {
-				errs[i] = fmt.Errorf("PICOBOOT %s: %w", devices[i].serial, err)
-				return
-			}
-			log.Info("PICOBOOT sent")
-		})
-	}
-	wg.Wait()
-	for i, err := range errs {
-		if err != nil {
-			return fmt.Errorf("[%s] %w", devices[i].serial, err)
-		}
-	}
-
-	uf2s := make([]string, len(targets))
-	for i := range targets {
-		uf2s[i] = targets[i].uf2
-	}
-
-	for i := range devices {
-		log := slog.With("serial", devices[i].serial)
-		wg.Go(func() {
-			log.Info("loading", "uf2", devices[i].name)
-			errs[i] = picotool.Load(devices[i].uf2, devices[i].serial, 10*time.Second)
+			log.Info("flashing", "uf2", devices[i].fw.name)
+			errs[i] = flashDevice(devices[i].target.client, devices[i].fw.uf2, *dryRun, log)
 			if errs[i] == nil {
-				log.Info("loaded", "uf2", devices[i].name)
+				log.Info("flashed", "uf2", devices[i].fw.name)
 			}
 		})
 	}
 	wg.Wait()
 	for i, err := range errs {
 		if err != nil {
-			return fmt.Errorf("[%s] load: %w", devices[i].serial, err)
+			return fmt.Errorf("[%s] flash: %w", devices[i].serial, err)
 		}
 	}

@@ -329,51 +344,166 @@ func cmdLoad(args []string) error {
 	return nil
 }

-func cmdTest(args []string) error {
+func flashDevice(c *client.Client, uf2Path string, dryRun bool, log *slog.Logger) error {
+	blocks, err := uf2.Parse(uf2Path)
+	if err != nil {
+		return fmt.Errorf("parse uf2: %w", err)
+	}
+
+	log.Info("parsed uf2", "blocks", len(blocks))
+
+	const sectorSize = 4096
+
+	if dryRun {
+		erased := make(map[uint32]bool)
+		for _, b := range blocks {
+			sector := b.Addr &^ (sectorSize - 1)
+			if !erased[sector] {
+				log.Info("erasing", "addr", fmt.Sprintf("%08x", sector))
+				erased[sector] = true
+			}
+			log.Info("writing", "addr", fmt.Sprintf("%08x", b.Addr), "len", len(b.Data))
+		}
+		return nil
+	}
+
+	erased := make(map[uint32]bool)
+	for _, b := range blocks {
+		sector := b.Addr &^ (sectorSize - 1)
+		if !erased[sector] {
+			if err := c.FlashErase(sector, sectorSize); err != nil {
+				return fmt.Errorf("erase %08x: %w", sector, err)
+			}
+			erased[sector] = true
+		}
+		if err := c.FlashWrite(b.Addr, b.Data); err != nil {
+			return fmt.Errorf("write %08x: %w", b.Addr, err)
+		}
+	}
+
+	log.Info("rebooting")
+	c.Reboot()
+	return nil
+}
+
+func findTestDevice(args []string) (target, error) {
+	fs := flag.NewFlagSet("test", flag.ExitOnError)
+	tf := addTargetFlags(fs)
+	fs.Parse(args)
+
+	targets, err := tf.connect(10*time.Second)
+	if err != nil {
+		return target{}, err
+	}
+
+	for _, t := range targets {
+		info, err := t.client.Info()
+		if err != nil {
+			t.client.Close()
+			continue
+		}
+		if info.FirmwareName == "picomap_test" {
+			for _, other := range targets {
+				if other.name != t.name {
+					other.client.Close()
+				}
+			}
+			return t, nil
+		}
+		t.client.Close()
+	}
+	return target{}, fmt.Errorf("no picomap_test device found")
+}
+
+func cmdTestGroup(args []string) error {
 	if len(args) < 1 {
-		return fmt.Errorf("usage: picomap test <name>")
+		return fmt.Errorf("usage: picomap test <list|run|all> [args...]")
+	}
+	switch args[0] {
+	case "list":
+		return cmdTestList(args[1:])
+	case "run":
+		return cmdTestRun(args[1:])
+	case "all":
+		return cmdTestAll(args[1:])
+	default:
+		return fmt.Errorf("usage: picomap test <list|run|all> [args...]")
+	}
+}
+
+func cmdTestList(args []string) error {
+	t, err := findTestDevice(args)
+	if err != nil {
+		return err
+	}
+	defer t.client.Close()
+
+	result, err := t.client.ListTests()
+	if err != nil {
+		return fmt.Errorf("remote: %w", err)
+	}
+	for _, name := range result.Names {
+		slog.Info("test", "dev", t.name, "name", name)
+	}
+	return nil
+}
+
+func cmdTestAll(args []string) error {
+	t, err := findTestDevice(args)
+	if err != nil {
+		return err
+	}
+	defer t.client.Close()
+
+	list, err := t.client.ListTests()
+	if err != nil {
+		return fmt.Errorf("remote: %w", err)
+	}
+
+	log := slog.With("dev", t.name)
+	failed := 0
+	for _, name := range list.Names {
+		log.Info("running test", "name", name)
+		result, err := t.client.Test(name)
+		if err != nil {
+			log.Error("error", "name", name, "err", err)
+			failed++
+			continue
+		}
+		for _, msg := range result.Messages {
+			log.Info("remote", "name", name, "msg", msg)
+		}
+		if result.Pass {
+			log.Info("PASS", "name", name)
+		} else {
+			log.Error("FAIL", "name", name)
+			failed++
+		}
+	}
+	if failed > 0 {
+		log.Error("tests failed", "count", failed)
+		os.Exit(1)
+	}
+	log.Info("all tests passed", "count", len(list.Names))
+	return nil
+}
+
+func cmdTestRun(args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: picomap test run <name>")
 	}
 	name := args[0]

-	devs, err := client.ListSerial()
+	t, err := findTestDevice(args[1:])
 	if err != nil {
 		return err
 	}
+	defer t.client.Close()

-	var testDev string
-	for _, dev := range devs {
-		log := slog.With("dev", dev)
-		c, err := client.NewSerial(dev, 500*time.Millisecond)
-		if err != nil {
-			log.Warn("connect error", "err", err)
-			continue
-		}
-		info, err := c.Info()
-		c.Close()
-		if err != nil {
-			log.Warn("info error", "err", err)
-			continue
-		}
-		log.Info("got info", "firmware", info.FirmwareName)
-		if info.FirmwareName == "picomap_test" {
-			testDev = dev
-			break
-		}
-	}
-	if testDev == "" {
-		return fmt.Errorf("no picomap_test device found")
-	}
-
-	log := slog.With("dev", testDev)
+	log := slog.With("dev", t.name)
 	log.Info("running test", "name", name)

-	c, err := client.NewSerial(testDev, 10*time.Second)
-	if err != nil {
-		return err
-	}
-	defer c.Close()
-
-	result, err := c.Test(name)
+	result, err := t.client.Test(name)
 	if err != nil {
 		return fmt.Errorf("remote: %w", err)
 	}
@@ -9,32 +9,20 @@ set(CMAKE_C_STANDARD 11)
 set(CMAKE_CXX_STANDARD 23)
 pico_sdk_init()

-set(LIB_SOURCES
-	lib/dispatch.cpp
-	lib/handlers.cpp
-	lib/net.cpp
-	lib/tusb_config.cpp
-	w6300/w6300.cpp
-)
+add_subdirectory(limen)

-set(LIB_DEPS pico_stdlib tinyusb_device tinyusb_board hardware_pio hardware_spi hardware_dma hardware_clocks)
+string(TIMESTAMP BUILD_EPOCH "%s" UTC)
+math(EXPR VERSION_MAJOR "${BUILD_EPOCH} >> 16")
+math(EXPR VERSION_MINOR "${BUILD_EPOCH} & 65535")

-add_executable(picomap firmware.cpp ${LIB_SOURCES})
-target_include_directories(picomap PRIVATE include w6300)
-target_compile_options(picomap PRIVATE -Wall -Wextra -Wno-unused-parameter)
-pico_generate_pio_header(picomap ${CMAKE_CURRENT_LIST_DIR}/w6300/qspi.pio)
-pico_enable_stdio_usb(picomap 0)
-pico_enable_stdio_uart(picomap 0)
-pico_set_binary_type(picomap copy_to_ram)
-pico_add_extra_outputs(picomap)
-target_link_libraries(picomap ${LIB_DEPS})
+add_executable(picomap firmware.cpp)
+target_link_libraries(picomap PRIVATE limen)
+pico_set_binary_version(picomap MAJOR ${VERSION_MAJOR} MINOR ${VERSION_MINOR})
+target_compile_definitions(picomap PRIVATE BUILD_EPOCH=${BUILD_EPOCH})
+limen_configure_executable(picomap)

-add_executable(picomap_test test.cpp ${LIB_SOURCES})
-target_include_directories(picomap_test PRIVATE include w6300)
-target_compile_options(picomap_test PRIVATE -Wall -Wextra -Wno-unused-parameter)
-pico_generate_pio_header(picomap_test ${CMAKE_CURRENT_LIST_DIR}/w6300/qspi.pio)
-pico_enable_stdio_usb(picomap_test 0)
-pico_enable_stdio_uart(picomap_test 0)
-pico_set_binary_type(picomap_test copy_to_ram)
-pico_add_extra_outputs(picomap_test)
-target_link_libraries(picomap_test ${LIB_DEPS})
+add_executable(picomap_test test.cpp)
+target_link_libraries(picomap_test PRIVATE limen)
+pico_set_binary_version(picomap_test MAJOR ${VERSION_MAJOR} MINOR ${VERSION_MINOR})
+target_compile_definitions(picomap_test PRIVATE BUILD_EPOCH=${BUILD_EPOCH})
+limen_configure_executable(picomap_test)
@@ -1,15 +1,23 @@
 #include "dispatch.h"
 #include "handlers.h"
+#include "igmp.h"

 std::string_view firmware_name = "picomap";
+uint32_t firmware_build_epoch = BUILD_EPOCH;

 static constexpr handler_entry handlers[] = {
-    {RequestPICOBOOT::ext_id, handle_picoboot},
-    {RequestInfo::ext_id, handle_info},
-    {RequestLog::ext_id, handle_log},
+    {RequestInfo::ext_id, typed_handler<RequestInfo, handle_info>},
+    {RequestLog::ext_id, typed_handler<RequestLog, handle_log>},
+    {RequestFlashErase::ext_id, typed_handler<RequestFlashErase, handle_flash_erase>},
+    {RequestFlashWrite::ext_id, typed_handler<RequestFlashWrite, handle_flash_write>},
+    {RequestReboot::ext_id, typed_handler<RequestReboot, handle_reboot>},
+    {RequestFlashStatus::ext_id, typed_handler<RequestFlashStatus, handle_flash_status>},
 };

 int main() {
-    dispatch_init();
+    handlers_init();
+    dispatch_init(PICOMAP_PORT_BE);
+    igmp::join(PICOMAP_DISCOVERY_GROUP);
+    handlers_start();
    dispatch_run(handlers);
 }
@@ -1,39 +0,0 @@
-#pragma once
-#include <functional>
-#include <string>
-#include <string_view>
-#include <vector>
-#include "pico/time.h"
-#include "ring_buffer.h"
-
-struct log_entry {
-    uint32_t timestamp_us;
-    std::string message;
-};
-
-inline ring_buffer<log_entry, 32> g_debug_log;
-
-inline void dlog(std::string_view msg) {
-    g_debug_log.push_overwrite(log_entry{static_cast<uint32_t>(time_us_32()), std::string(msg)});
-}
-
-inline void dlog_if_slow(std::string_view label, uint32_t threshold_us, std::function<void()> fn) {
-    uint32_t t0 = time_us_32();
-    fn();
-    uint32_t elapsed = time_us_32() - t0;
-    if (elapsed > threshold_us)
-        dlog(std::string(label) + " " + std::to_string(elapsed) + "us");
-}
-
-inline std::vector<log_entry> dlog_drain() {
-    std::vector<log_entry> result;
-    uint16_t n = g_debug_log.used();
-    result.reserve(n);
-    for (uint16_t i = 0; i < n; i++) {
-        log_entry e;
-        g_debug_log.peek(std::span{&e, 1});
-        result.push_back(std::move(e));
-        g_debug_log.consume(1);
-    }
-    return result;
-}
@@ -1,30 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <functional>
-#include <span>
-#include <vector>
-#include "wire.h"
-
-using handler_fn = std::vector<std::vector<uint8_t>> (*)(uint32_t message_id, std::span<const uint8_t> payload);
-
-struct handler_entry {
-    int8_t type_id;
-    handler_fn handle;
-};
-
-template <typename Req, auto Fn>
-std::vector<std::vector<uint8_t>> typed_handler(uint32_t message_id, std::span<const uint8_t> payload) {
-    msgpack::parser p(payload.data(), static_cast<int>(payload.size()));
-    Req req;
-    auto tup = req.as_tuple();
-    auto r = msgpack::unpack(p, tup);
-    if (!r) {
-        return {encode_response(message_id, DeviceError{1, "decode request ext_id=" +
-            std::to_string(Req::ext_id) + ": msgpack error " + std::to_string(static_cast<int>(r.error()))})};
-    }
-    return Fn(message_id, req);
-}
-
-void dispatch_init();
-void dispatch_schedule_ms(uint32_t ms, std::function<void()> fn);
-[[noreturn]] void dispatch_run(std::span<const handler_entry> handlers);
@@ -1,79 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <cstddef>
-
-namespace halfsiphash {
-
-namespace detail {
-
-constexpr uint32_t rotl(uint32_t x, int b) {
-  return (x << b) | (x >> (32 - b));
-}
-
-constexpr uint32_t load_le32(const uint8_t *p) {
-  return static_cast<uint32_t>(p[0])
-       | (static_cast<uint32_t>(p[1]) << 8)
-       | (static_cast<uint32_t>(p[2]) << 16)
-       | (static_cast<uint32_t>(p[3]) << 24);
-}
-
-inline void store_le32(uint8_t *p, uint32_t v) {
-  p[0] = static_cast<uint8_t>(v);
-  p[1] = static_cast<uint8_t>(v >> 8);
-  p[2] = static_cast<uint8_t>(v >> 16);
-  p[3] = static_cast<uint8_t>(v >> 24);
-}
-
-inline void sipround(uint32_t &v0, uint32_t &v1, uint32_t &v2, uint32_t &v3) {
-  v0 += v1; v1 = rotl(v1, 5);  v1 ^= v0; v0 = rotl(v0, 16);
-  v2 += v3; v3 = rotl(v3, 8);  v3 ^= v2;
-  v0 += v3; v3 = rotl(v3, 7);  v3 ^= v0;
-  v2 += v1; v1 = rotl(v1, 13); v1 ^= v2; v2 = rotl(v2, 16);
-}
-
-} // namespace detail
-
-// Compute HalfSipHash-2-4 with an 8-byte key, returning a 32-bit hash.
-inline uint32_t hash32(const uint8_t *data, size_t len, const uint8_t key[8]) {
-  using namespace detail;
-
-  uint32_t k0 = load_le32(key);
-  uint32_t k1 = load_le32(key + 4);
-
-  uint32_t v0 = 0 ^ k0;
-  uint32_t v1 = 0 ^ k1;
-  uint32_t v2 = UINT32_C(0x6c796765) ^ k0;
-  uint32_t v3 = UINT32_C(0x74656462) ^ k1;
-
-  const uint8_t *end = data + len - (len % 4);
-  for (const uint8_t *p = data; p != end; p += 4) {
-    uint32_t m = load_le32(p);
-    v3 ^= m;
-    sipround(v0, v1, v2, v3);
-    sipround(v0, v1, v2, v3);
-    v0 ^= m;
-  }
-
-  uint32_t b = static_cast<uint32_t>(len) << 24;
-  switch (len & 3) {
-  case 3: b |= static_cast<uint32_t>(end[2]) << 16; [[fallthrough]];
-  case 2: b |= static_cast<uint32_t>(end[1]) << 8;  [[fallthrough]];
-  case 1: b |= static_cast<uint32_t>(end[0]);        break;
-  case 0: break;
-  }
-
-  v3 ^= b;
-  sipround(v0, v1, v2, v3);
-  sipround(v0, v1, v2, v3);
-  v0 ^= b;
-
-  v2 ^= 0xff;
-  sipround(v0, v1, v2, v3);
-  sipround(v0, v1, v2, v3);
-  sipround(v0, v1, v2, v3);
-  sipround(v0, v1, v2, v3);
-
-  return v1 ^ v3;
-}
-
-} // namespace halfsiphash
@@ -1,12 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <span>
-#include <string_view>
-#include <vector>
-#include "wire.h"
-
-extern std::string_view firmware_name;
-
-std::vector<std::vector<uint8_t>> handle_picoboot(uint32_t message_id, std::span<const uint8_t> payload);
-std::vector<std::vector<uint8_t>> handle_info(uint32_t message_id, std::span<const uint8_t> payload);
-std::vector<std::vector<uint8_t>> handle_log(uint32_t message_id, std::span<const uint8_t> payload);
@@ -1,819 +0,0 @@
-#pragma once
-#include <algorithm>
-#include <array>
-#include <cassert>
-#include <cstdint>
-#include <expected>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <string_view>
-#include <tuple>
-#include <type_traits>
-#include <vector>
-
-namespace msgpack {
-
-enum class error_code {
-  overflow,
-  empty,
-  lack,
-  invalid,
-  type_error,
-};
-
-namespace format {
-  constexpr uint8_t POSITIVE_FIXINT_MIN = 0x00;
-  constexpr uint8_t POSITIVE_FIXINT_MAX = 0x7F;
-  constexpr uint8_t FIXMAP_MIN          = 0x80;
-  constexpr uint8_t FIXMAP_MAX          = 0x8F;
-  constexpr uint8_t FIXARRAY_MIN        = 0x90;
-  constexpr uint8_t FIXARRAY_MAX        = 0x9F;
-  constexpr uint8_t FIXSTR_MIN          = 0xA0;
-  constexpr uint8_t FIXSTR_MAX          = 0xBF;
-  constexpr uint8_t NEGATIVE_FIXINT_MIN = 0xE0;
-  constexpr uint8_t NEGATIVE_FIXINT_MAX = 0xFF;
-
-  constexpr uint8_t NIL         = 0xC0;
-  constexpr uint8_t NEVER_USED = 0xC1;
-  constexpr uint8_t FALSE       = 0xC2;
-  constexpr uint8_t TRUE        = 0xC3;
-  constexpr uint8_t BIN8        = 0xC4;
-  constexpr uint8_t BIN16       = 0xC5;
-  constexpr uint8_t BIN32       = 0xC6;
-  constexpr uint8_t EXT8        = 0xC7;
-  constexpr uint8_t EXT16       = 0xC8;
-  constexpr uint8_t EXT32       = 0xC9;
-  constexpr uint8_t FLOAT32     = 0xCA;
-  constexpr uint8_t FLOAT64     = 0xCB;
-  constexpr uint8_t UINT8       = 0xCC;
-  constexpr uint8_t UINT16      = 0xCD;
-  constexpr uint8_t UINT32      = 0xCE;
-  constexpr uint8_t UINT64      = 0xCF;
-  constexpr uint8_t INT8        = 0xD0;
-  constexpr uint8_t INT16       = 0xD1;
-  constexpr uint8_t INT32       = 0xD2;
-  constexpr uint8_t INT64       = 0xD3;
-  constexpr uint8_t FIXEXT1     = 0xD4;
-  constexpr uint8_t FIXEXT2     = 0xD5;
-  constexpr uint8_t FIXEXT4     = 0xD6;
-  constexpr uint8_t FIXEXT8     = 0xD7;
-  constexpr uint8_t FIXEXT16    = 0xD8;
-  constexpr uint8_t STR8        = 0xD9;
-  constexpr uint8_t STR16       = 0xDA;
-  constexpr uint8_t STR32       = 0xDB;
-  constexpr uint8_t ARRAY16     = 0xDC;
-  constexpr uint8_t ARRAY32     = 0xDD;
-  constexpr uint8_t MAP16       = 0xDE;
-  constexpr uint8_t MAP32       = 0xDF;
-
-  constexpr bool is_positive_fixint(uint8_t b) { return b <= POSITIVE_FIXINT_MAX; }
-  constexpr bool is_fixmap(uint8_t b)          { return b >= FIXMAP_MIN && b <= FIXMAP_MAX; }
-  constexpr bool is_fixarray(uint8_t b)        { return b >= FIXARRAY_MIN && b <= FIXARRAY_MAX; }
-  constexpr bool is_fixstr(uint8_t b)          { return b >= FIXSTR_MIN && b <= FIXSTR_MAX; }
-  constexpr bool is_negative_fixint(uint8_t b) { return b >= NEGATIVE_FIXINT_MIN; }
-} // namespace format
-
-template <typename T>
-using result = std::expected<T, error_code>;
-
-template <typename T>
-result<T> body_number(const uint8_t *p, int size) {
-  if (size < 1 + static_cast<int>(sizeof(T))) {
-    return std::unexpected(error_code::lack);
-  }
-  if constexpr (sizeof(T) == 1) {
-    return static_cast<T>(p[1]);
-  } else if constexpr (sizeof(T) == 2) {
-    return static_cast<T>((p[1] << 8) | p[2]);
-  } else if constexpr (sizeof(T) == 4) {
-    uint8_t buf[] = {p[4], p[3], p[2], p[1]};
-    T val;
-    __builtin_memcpy(&val, buf, sizeof(T));
-    return val;
-  } else if constexpr (sizeof(T) == 8) {
-    uint8_t buf[] = {p[8], p[7], p[6], p[5], p[4], p[3], p[2], p[1]};
-    T val;
-    __builtin_memcpy(&val, buf, sizeof(T));
-    return val;
-  } else {
-    return std::unexpected(error_code::invalid);
-  }
-}
-
-struct body_info {
-  int header;     // bytes before the body (includes format byte + length fields + ext type byte)
-  uint32_t body;  // body size in bytes (0 for containers, computed for variable-length)
-};
-
-inline result<body_info> get_body_info(const uint8_t *p, int size) {
-  if (size < 1) return std::unexpected(error_code::empty);
-  uint8_t b = p[0];
-
-  using namespace format;
-
-  if (is_positive_fixint(b))  return body_info{1, 0};
-  if (is_negative_fixint(b))  return body_info{1, 0};
-  if (is_fixmap(b))           return body_info{1, 0}; // container
-  if (is_fixarray(b))         return body_info{1, 0}; // container
-  if (is_fixstr(b))           return body_info{1, static_cast<uint32_t>(b & 0x1F)};
-
-  switch (b) {
-  case NIL: case FALSE: case TRUE:
-    return body_info{1, 0};
-  case NEVER_USED:
-    return std::unexpected(error_code::invalid);
-
-  case BIN8:  { auto n = body_number<uint8_t>(p, size);  if (!n) return std::unexpected(n.error()); return body_info{1+1, *n}; }
-  case BIN16: { auto n = body_number<uint16_t>(p, size); if (!n) return std::unexpected(n.error()); return body_info{1+2, *n}; }
-  case BIN32: { auto n = body_number<uint32_t>(p, size); if (!n) return std::unexpected(n.error()); return body_info{1+4, *n}; }
-
-  case EXT8:  { auto n = body_number<uint8_t>(p, size);  if (!n) return std::unexpected(n.error()); return body_info{1+1+1, *n}; }
-  case EXT16: { auto n = body_number<uint16_t>(p, size); if (!n) return std::unexpected(n.error()); return body_info{1+2+1, *n}; }
-  case EXT32: { auto n = body_number<uint32_t>(p, size); if (!n) return std::unexpected(n.error()); return body_info{1+4+1, *n}; }
-
-  case FLOAT32: return body_info{1, 4};
-  case FLOAT64: return body_info{1, 8};
-  case UINT8:   return body_info{1, 1};
-  case UINT16:  return body_info{1, 2};
-  case UINT32:  return body_info{1, 4};
-  case UINT64:  return body_info{1, 8};
-  case INT8:    return body_info{1, 1};
-  case INT16:   return body_info{1, 2};
-  case INT32:   return body_info{1, 4};
-  case INT64:   return body_info{1, 8};
-
-  case FIXEXT1:  return body_info{1+1, 1};
-  case FIXEXT2:  return body_info{1+1, 2};
-  case FIXEXT4:  return body_info{1+1, 4};
-  case FIXEXT8:  return body_info{1+1, 8};
-  case FIXEXT16: return body_info{1+1, 16};
-
-  case STR8:  { auto n = body_number<uint8_t>(p, size);  if (!n) return std::unexpected(n.error()); return body_info{1+1, *n}; }
-  case STR16: { auto n = body_number<uint16_t>(p, size); if (!n) return std::unexpected(n.error()); return body_info{1+2, *n}; }
-  case STR32: { auto n = body_number<uint32_t>(p, size); if (!n) return std::unexpected(n.error()); return body_info{1+4, *n}; }
-
-  case ARRAY16: case ARRAY32:
-  case MAP16: case MAP32:
-    return body_info{1 + (b == ARRAY16 || b == MAP16 ? 2 : 4), 0}; // container
-
-  default:
-    return std::unexpected(error_code::invalid);
-  }
-}
-
-class packer {
-public:
-  using buffer = std::vector<std::uint8_t>;
-
-private:
-  std::shared_ptr<buffer> m_buffer;
-
-  template <typename T> void push_big_endian(T n) {
-    auto p = reinterpret_cast<std::uint8_t *>(&n) + (sizeof(T) - 1);
-    for (size_t i = 0; i < sizeof(T); ++i, --p) {
-      m_buffer->push_back(*p);
-    }
-  }
-
-  template <class Range> void push(const Range &r) {
-    m_buffer->insert(m_buffer->end(), std::begin(r), std::end(r));
-  }
-
-public:
-  packer() : m_buffer(std::make_shared<buffer>()) {}
-  packer(const std::shared_ptr<buffer> &buf) : m_buffer(buf) {}
-
-  packer(const packer &) = delete;
-  packer &operator=(const packer &) = delete;
-
-  using pack_result = result<std::reference_wrapper<packer>>;
-
-  pack_result pack_nil() {
-    m_buffer->push_back(format::NIL);
-    return *this;
-  }
-
-  pack_result pack_bool(bool v) {
-    m_buffer->push_back(v ? format::TRUE : format::FALSE);
-    return *this;
-  }
-
-  template <typename T>
-  pack_result pack_integer(T n) {
-    if constexpr (std::is_signed_v<T>) {
-      if (n >= 0 && n <= 0x7F) {
-        m_buffer->push_back(static_cast<uint8_t>(n));
-      } else if (n >= -32 && n < 0) {
-        m_buffer->push_back(static_cast<uint8_t>(n));  // negative fixint
-      } else if (n >= std::numeric_limits<int8_t>::min() && n <= std::numeric_limits<int8_t>::max()) {
-        m_buffer->push_back(format::INT8);
-        m_buffer->push_back(static_cast<uint8_t>(n));
-      } else if (n >= std::numeric_limits<int16_t>::min() && n <= std::numeric_limits<int16_t>::max()) {
-        m_buffer->push_back(format::INT16);
-        push_big_endian(static_cast<int16_t>(n));
-      } else if (n >= std::numeric_limits<int32_t>::min() && n <= std::numeric_limits<int32_t>::max()) {
-        m_buffer->push_back(format::INT32);
-        push_big_endian(static_cast<int32_t>(n));
-      } else {
-        m_buffer->push_back(format::INT64);
-        push_big_endian(static_cast<int64_t>(n));
-      }
-    } else {
-      if (n <= 0x7F) {
-        m_buffer->push_back(static_cast<uint8_t>(n));
-      } else if (n <= std::numeric_limits<uint8_t>::max()) {
-        m_buffer->push_back(format::UINT8);
-        m_buffer->push_back(static_cast<uint8_t>(n));
-      } else if (n <= std::numeric_limits<uint16_t>::max()) {
-        m_buffer->push_back(format::UINT16);
-        push_big_endian(static_cast<uint16_t>(n));
-      } else if (n <= std::numeric_limits<uint32_t>::max()) {
-        m_buffer->push_back(format::UINT32);
-        push_big_endian(static_cast<uint32_t>(n));
-      } else {
-        m_buffer->push_back(format::UINT64);
-        push_big_endian(static_cast<uint64_t>(n));
-      }
-    }
-    return *this;
-  }
-
-  pack_result pack_float(float n) {
-    m_buffer->push_back(format::FLOAT32);
-    push_big_endian(n);
-    return *this;
-  }
-
-  pack_result pack_double(double n) {
-    m_buffer->push_back(format::FLOAT64);
-    push_big_endian(n);
-    return *this;
-  }
-
-  template <class Range>
-  pack_result pack_str(const Range &r) {
-    auto sz = static_cast<size_t>(std::distance(std::begin(r), std::end(r)));
-    if (sz < 32) {
-      m_buffer->push_back(format::FIXSTR_MIN | static_cast<uint8_t>(sz));
-    } else if (sz <= std::numeric_limits<uint8_t>::max()) {
-      m_buffer->push_back(format::STR8);
-      m_buffer->push_back(static_cast<uint8_t>(sz));
-    } else if (sz <= std::numeric_limits<uint16_t>::max()) {
-      m_buffer->push_back(format::STR16);
-      push_big_endian(static_cast<uint16_t>(sz));
-    } else if (sz <= std::numeric_limits<uint32_t>::max()) {
-      m_buffer->push_back(format::STR32);
-      push_big_endian(static_cast<uint32_t>(sz));
-    } else {
-      return std::unexpected(error_code::overflow);
-    }
-    push(r);
-    return *this;
-  }
-
-  pack_result pack_str(const char *s) {
-    return pack_str(std::string_view(s));
-  }
-
-  template <class Range>
-  pack_result pack_bin(const Range &r) {
-    auto sz = static_cast<size_t>(std::distance(std::begin(r), std::end(r)));
-    if (sz <= std::numeric_limits<uint8_t>::max()) {
-      m_buffer->push_back(format::BIN8);
-      m_buffer->push_back(static_cast<uint8_t>(sz));
-    } else if (sz <= std::numeric_limits<uint16_t>::max()) {
-      m_buffer->push_back(format::BIN16);
-      push_big_endian(static_cast<uint16_t>(sz));
-    } else if (sz <= std::numeric_limits<uint32_t>::max()) {
-      m_buffer->push_back(format::BIN32);
-      push_big_endian(static_cast<uint32_t>(sz));
-    } else {
-      return std::unexpected(error_code::overflow);
-    }
-    push(r);
-    return *this;
-  }
-
-  pack_result pack_array(size_t n) {
-    if (n <= 15) {
-      m_buffer->push_back(format::FIXARRAY_MIN | static_cast<uint8_t>(n));
-    } else if (n <= std::numeric_limits<uint16_t>::max()) {
-      m_buffer->push_back(format::ARRAY16);
-      push_big_endian(static_cast<uint16_t>(n));
-    } else if (n <= std::numeric_limits<uint32_t>::max()) {
-      m_buffer->push_back(format::ARRAY32);
-      push_big_endian(static_cast<uint32_t>(n));
-    } else {
-      return std::unexpected(error_code::overflow);
-    }
-    return *this;
-  }
-
-  pack_result pack_map(size_t n) {
-    if (n <= 15) {
-      m_buffer->push_back(format::FIXMAP_MIN | static_cast<uint8_t>(n));
-    } else if (n <= std::numeric_limits<uint16_t>::max()) {
-      m_buffer->push_back(format::MAP16);
-      push_big_endian(static_cast<uint16_t>(n));
-    } else if (n <= std::numeric_limits<uint32_t>::max()) {
-      m_buffer->push_back(format::MAP32);
-      push_big_endian(static_cast<uint32_t>(n));
-    } else {
-      return std::unexpected(error_code::overflow);
-    }
-    return *this;
-  }
-
-  template <class Range>
-  pack_result pack_ext(char type, const Range &r) {
-    auto sz = static_cast<size_t>(std::distance(std::begin(r), std::end(r)));
-
-    switch (sz) {
-    case 1:  m_buffer->push_back(format::FIXEXT1);  break;
-    case 2:  m_buffer->push_back(format::FIXEXT2);  break;
-    case 4:  m_buffer->push_back(format::FIXEXT4);  break;
-    case 8:  m_buffer->push_back(format::FIXEXT8);  break;
-    case 16: m_buffer->push_back(format::FIXEXT16); break;
-    default:
-      if (sz <= std::numeric_limits<uint8_t>::max()) {
-        m_buffer->push_back(format::EXT8);
-        m_buffer->push_back(static_cast<uint8_t>(sz));
-      } else if (sz <= std::numeric_limits<uint16_t>::max()) {
-        m_buffer->push_back(format::EXT16);
-        push_big_endian(static_cast<uint16_t>(sz));
-      } else if (sz <= std::numeric_limits<uint32_t>::max()) {
-        m_buffer->push_back(format::EXT32);
-        push_big_endian(static_cast<uint32_t>(sz));
-      } else {
-        return std::unexpected(error_code::overflow);
-      }
-    }
-    m_buffer->push_back(static_cast<uint8_t>(type));
-    push(r);
-    return *this;
-  }
-
-  template <typename T>
-    requires std::is_integral_v<T> && (!std::is_same_v<T, bool>)
-  pack_result pack(T n) { return pack_integer(n); }
-
-  pack_result pack(bool v)        { return pack_bool(v); }
-  pack_result pack(float v)       { return pack_float(v); }
-  pack_result pack(double v)      { return pack_double(v); }
-  pack_result pack(const char *v) { return pack_str(v); }
-  pack_result pack(std::string_view v) { return pack_str(v); }
-  pack_result pack(const std::string &v) { return pack_str(v); }
-
-  pack_result pack(const std::vector<uint8_t> &v) { return pack_bin(v); }
-
-  template <typename T>
-    requires (!std::is_same_v<T, uint8_t>)
-  pack_result pack(const std::vector<T> &v) {
-    auto r = pack_array(v.size());
-    if (!r) return r;
-    for (auto& elem : v) {
-      r = r->get().pack(elem);
-      if (!r) return r;
-    }
-    return r;
-  }
-
-  template <size_t N>
-  pack_result pack(const std::array<uint8_t, N> &v) { return pack_bin(v); }
-
-  template <typename... Ts>
-  pack_result pack(const std::tuple<Ts...> &t) {
-    auto r = pack_array(sizeof...(Ts));
-    if (!r) return r;
-    return pack_tuple_elements(t, std::index_sequence_for<Ts...>{});
-  }
-
-  template <typename T>
-    requires requires(const T &v) { { T::ext_id } -> std::convertible_to<int8_t>; v.as_tuple(); }
-  pack_result pack(const T &v) {
-    packer inner;
-    auto r = inner.pack(v.as_tuple());
-    if (!r) return r;
-    return pack_ext(T::ext_id, inner.get_payload());
-  }
-
-  template <typename T>
-    requires (requires(const T &v) { v.as_tuple(); } && !requires { { T::ext_id } -> std::convertible_to<int8_t>; })
-  pack_result pack(const T &v) {
-    return pack(v.as_tuple());
-  }
-
-private:
-  template <typename Tuple, size_t... Is>
-  pack_result pack_tuple_elements(const Tuple &t, std::index_sequence<Is...>) {
-    pack_result r = *this;
-    ((r = r ? r->get().pack(std::get<Is>(t)) : r), ...);
-    return r;
-  }
-
-public:
-  const buffer &get_payload() const { return *m_buffer; }
-};
-
-class parser {
-  const uint8_t *m_p = nullptr;
-  int m_size = 0;
-
-  result<uint8_t> header_byte() const {
-    if (m_size < 1) return std::unexpected(error_code::empty);
-    return m_p[0];
-  }
-
-public:
-  parser() = default;
-
-  parser(const std::vector<uint8_t> &v)
-      : m_p(v.data()), m_size(static_cast<int>(v.size())) {}
-
-  parser(const uint8_t *p, int size)
-      : m_p(p), m_size(size < 0 ? 0 : size) {}
-
-  bool is_empty() const { return m_size == 0; }
-  const uint8_t *data() const { return m_p; }
-  int size() const { return m_size; }
-
-  result<parser> advance(int n) const {
-    if (n > m_size) return std::unexpected(error_code::lack);
-    return parser(m_p + n, m_size - n);
-  }
-
-  result<parser> next() const {
-    auto hdr = header_byte();
-    if (!hdr) return std::unexpected(hdr.error());
-
-    if (is_array()) {
-      auto info = get_body_info(m_p, m_size);
-      if (!info) return std::unexpected(info.error());
-      auto cnt = count();
-      if (!cnt) return std::unexpected(cnt.error());
-      auto cur = advance(info->header);
-      if (!cur) return std::unexpected(cur.error());
-      for (uint32_t i = 0; i < *cnt; ++i) {
-        auto n = cur->next();
-        if (!n) return std::unexpected(n.error());
-        cur = *n;
-      }
-      return *cur;
-    } else if (is_map()) {
-      auto info = get_body_info(m_p, m_size);
-      if (!info) return std::unexpected(info.error());
-      auto cnt = count();
-      if (!cnt) return std::unexpected(cnt.error());
-      auto cur = advance(info->header);
-      if (!cur) return std::unexpected(cur.error());
-      for (uint32_t i = 0; i < *cnt; ++i) {
-        auto k = cur->next();
-        if (!k) return std::unexpected(k.error());
-        cur = *k;
-        auto v = cur->next();
-        if (!v) return std::unexpected(v.error());
-        cur = *v;
-      }
-      return *cur;
-    } else {
-      auto info = get_body_info(m_p, m_size);
-      if (!info) return std::unexpected(info.error());
-      auto total = info->header + static_cast<int>(info->body);
-      return advance(total);
-    }
-  }
-
-  bool is_nil() const {
-    auto h = header_byte();
-    return h && *h == format::NIL;
-  }
-
-  bool is_bool() const {
-    auto h = header_byte();
-    return h && (*h == format::TRUE || *h == format::FALSE);
-  }
-
-  bool is_number() const {
-    auto h = header_byte();
-    if (!h) return false;
-    uint8_t b = *h;
-    if (format::is_positive_fixint(b)) return true;
-    if (format::is_negative_fixint(b)) return true;
-    return b >= format::FLOAT32 && b <= format::INT64;
-  }
-
-  bool is_string() const {
-    auto h = header_byte();
-    if (!h) return false;
-    uint8_t b = *h;
-    if (format::is_fixstr(b)) return true;
-    return b == format::STR8 || b == format::STR16 || b == format::STR32;
-  }
-
-  bool is_binary() const {
-    auto h = header_byte();
-    if (!h) return false;
-    uint8_t b = *h;
-    return b == format::BIN8 || b == format::BIN16 || b == format::BIN32;
-  }
-
-  bool is_ext() const {
-    auto h = header_byte();
-    if (!h) return false;
-    uint8_t b = *h;
-    return (b >= format::FIXEXT1 && b <= format::FIXEXT16) ||
-           b == format::EXT8 || b == format::EXT16 || b == format::EXT32;
-  }
-
-  bool is_array() const {
-    auto h = header_byte();
-    if (!h) return false;
-    uint8_t b = *h;
-    if (format::is_fixarray(b)) return true;
-    return b == format::ARRAY16 || b == format::ARRAY32;
-  }
-
-  bool is_map() const {
-    auto h = header_byte();
-    if (!h) return false;
-    uint8_t b = *h;
-    if (format::is_fixmap(b)) return true;
-    return b == format::MAP16 || b == format::MAP32;
-  }
-
-
-  result<bool> get_bool() const {
-    auto h = header_byte();
-    if (!h) return std::unexpected(h.error());
-    if (*h == format::TRUE) return true;
-    if (*h == format::FALSE) return false;
-    return std::unexpected(error_code::type_error);
-  }
-
-  result<std::string_view> get_string() const {
-    auto h = header_byte();
-    if (!h) return std::unexpected(h.error());
-    uint8_t b = *h;
-    size_t offset, len;
-    if (format::is_fixstr(b)) {
-      len = b & 0x1F;
-      offset = 1;
-    } else if (b == format::STR8) {
-      auto n = body_number<uint8_t>(m_p, m_size);
-      if (!n) return std::unexpected(n.error());
-      len = *n; offset = 1 + 1;
-    } else if (b == format::STR16) {
-      auto n = body_number<uint16_t>(m_p, m_size);
-      if (!n) return std::unexpected(n.error());
-      len = *n; offset = 1 + 2;
-    } else if (b == format::STR32) {
-      auto n = body_number<uint32_t>(m_p, m_size);
-      if (!n) return std::unexpected(n.error());
-      len = *n; offset = 1 + 4;
-    } else {
-      return std::unexpected(error_code::type_error);
-    }
-    if (static_cast<int>(offset + len) > m_size) {
-      return std::unexpected(error_code::lack);
-    }
-    return std::string_view(reinterpret_cast<const char *>(m_p + offset), len);
-  }
-
-  result<std::string_view> get_binary_view() const {
-    auto h = header_byte();
-    if (!h) return std::unexpected(h.error());
-    uint8_t b = *h;
-    size_t offset, len;
-
-    if (b == format::BIN8) {
-      auto n = body_number<uint8_t>(m_p, m_size);
-      if (!n) return std::unexpected(n.error());
-      len = *n; offset = 1 + 1;
-    } else if (b == format::BIN16) {
-      auto n = body_number<uint16_t>(m_p, m_size);
-      if (!n) return std::unexpected(n.error());
-      len = *n; offset = 1 + 2;
-    } else if (b == format::BIN32) {
-      auto n = body_number<uint32_t>(m_p, m_size);
-      if (!n) return std::unexpected(n.error());
-      len = *n; offset = 1 + 4;
-    } else {
-      return std::unexpected(error_code::type_error);
-    }
-    if (static_cast<int>(offset + len) > m_size) {
-      return std::unexpected(error_code::lack);
-    }
-    return std::string_view(reinterpret_cast<const char *>(m_p + offset), len);
-  }
-
-  result<std::tuple<int8_t, std::string_view>> get_ext() const {
-    auto h = header_byte();
-    if (!h) return std::unexpected(h.error());
-    uint8_t b = *h;
-    int8_t ext_type;
-    size_t data_offset, data_len;
-
-    switch (b) {
-    case format::FIXEXT1:  ext_type = m_p[1]; data_offset = 2; data_len = 1;  break;
-    case format::FIXEXT2:  ext_type = m_p[1]; data_offset = 2; data_len = 2;  break;
-    case format::FIXEXT4:  ext_type = m_p[1]; data_offset = 2; data_len = 4;  break;
-    case format::FIXEXT8:  ext_type = m_p[1]; data_offset = 2; data_len = 8;  break;
-    case format::FIXEXT16: ext_type = m_p[1]; data_offset = 2; data_len = 16; break;
-    case format::EXT8: {
-      auto n = body_number<uint8_t>(m_p, m_size);
-      if (!n) return std::unexpected(n.error());
-      ext_type = m_p[2]; data_offset = 3; data_len = *n;
-      break;
-    }
-    case format::EXT16: {
-      auto n = body_number<uint16_t>(m_p, m_size);
-      if (!n) return std::unexpected(n.error());
-      ext_type = m_p[3]; data_offset = 4; data_len = *n;
-      break;
-    }
-    case format::EXT32: {
-      auto n = body_number<uint32_t>(m_p, m_size);
-      if (!n) return std::unexpected(n.error());
-      ext_type = m_p[5]; data_offset = 6; data_len = *n;
-      break;
-    }
-    default:
-      return std::unexpected(error_code::type_error);
-    }
-    if (static_cast<int>(data_offset + data_len) > m_size) {
-      return std::unexpected(error_code::lack);
-    }
-    return std::tuple{ext_type,
-                      std::string_view(reinterpret_cast<const char *>(m_p + data_offset), data_len)};
-  }
-
-  template <typename T>
-  result<T> get_number() const {
-    auto h = header_byte();
-    if (!h) return std::unexpected(h.error());
-    uint8_t b = *h;
-
-    if (format::is_positive_fixint(b)) return static_cast<T>(b);
-    if (format::is_negative_fixint(b)) return static_cast<T>(static_cast<int8_t>(b));
-
-    switch (b) {
-    case format::UINT8:   { auto n = body_number<uint8_t>(m_p, m_size);  if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    case format::UINT16:  { auto n = body_number<uint16_t>(m_p, m_size); if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    case format::UINT32:  { auto n = body_number<uint32_t>(m_p, m_size); if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    case format::UINT64:  { auto n = body_number<uint64_t>(m_p, m_size); if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    case format::INT8:    { auto n = body_number<int8_t>(m_p, m_size);   if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    case format::INT16:   { auto n = body_number<int16_t>(m_p, m_size);  if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    case format::INT32:   { auto n = body_number<int32_t>(m_p, m_size);  if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    case format::INT64:   { auto n = body_number<int64_t>(m_p, m_size);  if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    case format::FLOAT32: { auto n = body_number<float>(m_p, m_size);    if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    case format::FLOAT64: { auto n = body_number<double>(m_p, m_size);   if (!n) return std::unexpected(n.error()); return static_cast<T>(*n); }
-    default:
-      return std::unexpected(error_code::type_error);
-    }
-  }
-
-  result<uint32_t> count() const {
-    auto h = header_byte();
-    if (!h) return std::unexpected(h.error());
-    uint8_t b = *h;
-
-    if (format::is_fixarray(b)) return static_cast<uint32_t>(b & 0x0F);
-    if (format::is_fixmap(b))   return static_cast<uint32_t>(b & 0x0F);
-
-    switch (b) {
-    case format::ARRAY16: { auto n = body_number<uint16_t>(m_p, m_size); if (!n) return std::unexpected(n.error()); return static_cast<uint32_t>(*n); }
-    case format::ARRAY32: { auto n = body_number<uint32_t>(m_p, m_size); if (!n) return std::unexpected(n.error()); return *n; }
-    case format::MAP16:   { auto n = body_number<uint16_t>(m_p, m_size); if (!n) return std::unexpected(n.error()); return static_cast<uint32_t>(*n); }
-    case format::MAP32:   { auto n = body_number<uint32_t>(m_p, m_size); if (!n) return std::unexpected(n.error()); return *n; }
-    default:
-      return std::unexpected(error_code::type_error);
-    }
-  }
-
-  result<parser> first_item() const {
-    if (!is_array() && !is_map()) return std::unexpected(error_code::type_error);
-    auto info = get_body_info(m_p, m_size);
-    if (!info) return std::unexpected(info.error());
-    return advance(info->header);
-  }
-
-  parser operator[](int index) const {
-    auto cur = first_item();
-    if (!cur) return {};
-    for (int i = 0; i < index; ++i) {
-      auto n = cur->next();
-      if (!n) return {};
-      cur = *n;
-    }
-    return *cur;
-  }
-};
-
-template <typename T>
-  requires std::is_integral_v<T> && (!std::is_same_v<T, bool>)
-result<parser> unpack(const parser &p, T &out) {
-  auto v = p.get_number<T>();
-  if (!v) return std::unexpected(v.error());
-  out = *v;
-  return p.next();
-}
-
-inline result<parser> unpack(const parser &p, bool &out) {
-  auto v = p.get_bool();
-  if (!v) return std::unexpected(v.error());
-  out = *v;
-  return p.next();
-}
-
-inline result<parser> unpack(const parser &p, std::string_view &out) {
-  auto v = p.get_string();
-  if (!v) return std::unexpected(v.error());
-  out = *v;
-  return p.next();
-}
-
-inline result<parser> unpack(const parser &p, std::string &out) {
-  auto v = p.get_string();
-  if (!v) return std::unexpected(v.error());
-  out = std::string(v->data(), v->size());
-  return p.next();
-}
-
-template <size_t N>
-result<parser> unpack(const parser &p, std::array<uint8_t, N> &out) {
-  auto v = p.get_binary_view();
-  if (!v) return std::unexpected(v.error());
-  if (v->size() != N) return std::unexpected(error_code::type_error);
-  std::copy(v->begin(), v->end(), out.begin());
-  return p.next();
-}
-
-inline result<parser> unpack(const parser &p, std::vector<uint8_t> &out) {
-  auto v = p.get_binary_view();
-  if (!v) return std::unexpected(v.error());
-  out.assign(v->begin(), v->end());
-  return p.next();
-}
-
-template <typename T>
-  requires (!std::is_same_v<T, uint8_t>)
-result<parser> unpack(const parser &p, std::vector<T> &out) {
-  auto cnt = p.count();
-  if (!cnt) return std::unexpected(cnt.error());
-  out.resize(*cnt);
-  result<parser> cur = p.first_item();
-  for (size_t i = 0; i < *cnt; i++) {
-    if (!cur) return cur;
-    cur = unpack(*cur, out[i]);
-  }
-  if (!cur) return cur;
-  return p.next();
-}
-
-template <typename... Ts, size_t... Is>
-result<parser> unpack_tuple_elements(const parser &p, std::tuple<Ts...> &t, std::index_sequence<Is...>) {
-  result<parser> cur = p.first_item();
-  if (!cur) return cur;
-  ((cur = cur ? unpack(*cur, std::get<Is>(t)) : cur), ...);
-  return cur;
-}
-
-template <typename... Ts>
-result<parser> unpack(const parser &p, std::tuple<Ts...> &t) {
-  auto cnt = p.count();
-  if (!cnt) return std::unexpected(cnt.error());
-  if (*cnt != sizeof...(Ts)) return std::unexpected(error_code::type_error);
-  auto r = unpack_tuple_elements(p, t, std::index_sequence_for<Ts...>{});
-  if (!r) return r;
-  return p.next();
-}
-
-template <typename T>
-  requires (requires(T &v) { v.as_tuple(); } && !requires { { T::ext_id } -> std::convertible_to<int8_t>; })
-result<parser> unpack(const parser &p, T &out) {
-  auto tup = out.as_tuple();
-  auto cnt = p.count();
-  if (!cnt) return std::unexpected(cnt.error());
-  if (*cnt != std::tuple_size_v<decltype(tup)>) return std::unexpected(error_code::type_error);
-  auto r = unpack_tuple_elements(p, tup, std::make_index_sequence<std::tuple_size_v<decltype(tup)>>{});
-  if (!r) return r;
-  return p.next();
-}
-
-template <typename T>
-  requires requires(T &v) { { T::ext_id } -> std::convertible_to<int8_t>; v.as_tuple(); }
-result<parser> unpack(const parser &p, T &out) {
-  auto ext = p.get_ext();
-  if (!ext) return std::unexpected(ext.error());
-  auto [ext_type, ext_data] = *ext;
-  if (ext_type != T::ext_id) return std::unexpected(error_code::type_error);
-  parser inner(reinterpret_cast<const uint8_t *>(ext_data.data()),
-               static_cast<int>(ext_data.size()));
-  auto tup = out.as_tuple();
-  auto r = unpack_tuple_elements(inner, tup, std::make_index_sequence<std::tuple_size_v<decltype(tup)>>{});
-  if (!r) return r;
-  return p.next();
-}
-
-} // namespace msgpack
@@ -1,18 +0,0 @@
-#pragma once
-#include <array>
-#include <cstdint>
-#include <functional>
-#include <span>
-#include <vector>
-
-struct net_state {
-    std::array<uint8_t, 6> mac;
-    std::array<uint8_t, 4> ip;
-};
-
-using net_handler = std::function<std::vector<std::vector<uint8_t>>(std::span<const uint8_t> payload)>;
-
-bool net_init();
-const net_state& net_get_state();
-void net_set_handler(net_handler handler);
-void net_poll();
@@ -1,54 +0,0 @@
-#pragma once
-#include <array>
-#include <cstdint>
-#include <span>
-
-template <typename T, uint16_t N>
-struct ring_buffer {
-    std::array<T, N> data = {};
-    uint16_t head = 0;
-    uint16_t tail = 0;
-
-    uint16_t used() const { return tail - head; }
-    uint16_t free() const { return N - used(); }
-    bool empty() const { return head == tail; }
-
-    void push(std::span<const T> src) {
-        if (src.size() > free()) return;
-        for (auto& v : src)
-            data[(tail++) % N] = v;
-    }
-
-    void push(const T& v) {
-        if (free() == 0) return;
-        data[(tail++) % N] = v;
-    }
-
-    void push_overwrite(const T& v) {
-        if (free() == 0) head++;
-        data[(tail++) % N] = v;
-    }
-
-    uint16_t peek(std::span<T> dst) const {
-        uint16_t len = dst.size() < used() ? dst.size() : used();
-        for (uint16_t i = 0; i < len; i++)
-            dst[i] = data[(head + i) % N];
-        return len;
-    }
-
-    void consume(uint16_t len) {
-        head += len;
-        if (head >= N) {
-            head -= N;
-            tail -= N;
-        }
-    }
-
-    std::span<const T> read_contiguous() const {
-        uint16_t offset = head % N;
-        uint16_t contig = N - offset;
-        uint16_t pending = used();
-        uint16_t len = pending < contig ? pending : contig;
-        return {data.data() + offset, len};
-    }
-};
@@ -1,58 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <new>
-#include <utility>
-
-template <typename T, int N>
-struct sorted_list {
-    struct node {
-        alignas(T) uint8_t storage[sizeof(T)];
-        node* next = nullptr;
-
-        T& value() { return *reinterpret_cast<T*>(storage); }
-        const T& value() const { return *reinterpret_cast<const T*>(storage); }
-    };
-
-    node nodes[N];
-    node* head = nullptr;
-    node* free_head = &nodes[0];
-
-    sorted_list() {
-        for (int i = 0; i < N - 1; i++) nodes[i].next = &nodes[i + 1];
-        nodes[N - 1].next = nullptr;
-    }
-
-    bool empty() const { return head == nullptr; }
-    bool full() const { return free_head == nullptr; }
-
-    T& front() { return head->value(); }
-    const T& front() const { return head->value(); }
-
-    void insert(T value) {
-        if (full()) return;
-        node* n = free_head;
-        free_head = n->next;
-        new (n->storage) T(std::move(value));
-
-        if (!head || n->value() < head->value()) {
-            n->next = head;
-            head = n;
-            return;
-        }
-
-        node* cur = head;
-        while (cur->next && !(n->value() < cur->next->value()))
-            cur = cur->next;
-        n->next = cur->next;
-        cur->next = n;
-    }
-
-    void pop_front() {
-        if (empty()) return;
-        node* n = head;
-        head = n->next;
-        n->value().~T();
-        n->next = free_head;
-        free_head = n;
-    }
-};
@@ -1,33 +0,0 @@
-#pragma once
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-
-template <typename T, size_t Capacity>
-class static_vector {
-    T m_data[Capacity];
-    size_t m_size = 0;
-
-public:
-    void push_back(const T &v) {
-        if (m_size < Capacity) m_data[m_size++] = v;
-    }
-
-    void clear() { m_size = 0; }
-
-    size_t size() const { return m_size; }
-    size_t capacity() const { return Capacity; }
-    bool full() const { return m_size >= Capacity; }
-    bool empty() const { return m_size == 0; }
-
-    T *data() { return m_data; }
-    const T *data() const { return m_data; }
-
-    T &operator[](size_t i) { return m_data[i]; }
-    const T &operator[](size_t i) const { return m_data[i]; }
-
-    T *begin() { return m_data; }
-    T *end() { return m_data + m_size; }
-    const T *begin() const { return m_data; }
-    const T *end() const { return m_data + m_size; }
-};
@@ -1,56 +0,0 @@
-#pragma once
-#include <functional>
-#include "pico/time.h"
-#include "sorted_list.h"
-
-struct timer_entry {
-    absolute_time_t when;
-    std::function<void()> fn;
-};
-
-inline bool operator<(const timer_entry& a, const timer_entry& b) {
-    return absolute_time_diff_us(b.when, a.when) < 0;
-}
-
-struct timer_queue {
-    sorted_list<timer_entry, 16> queue;
-    alarm_id_t alarm = -1;
-    volatile bool irq_pending = false;
-
-    void schedule(absolute_time_t when, std::function<void()> fn) {
-        queue.insert({when, std::move(fn)});
-        arm();
-    }
-
-    void schedule_ms(uint32_t ms, std::function<void()> fn) {
-        schedule(make_timeout_time_ms(ms), std::move(fn));
-    }
-
-    void run() {
-        if (!irq_pending) return;
-        irq_pending = false;
-        while (!queue.empty()) {
-            auto& front = queue.front();
-            if (absolute_time_diff_us(get_absolute_time(), front.when) > 0) break;
-            auto fn = std::move(front.fn);
-            queue.pop_front();
-            fn();
-        }
-        arm();
-    }
-
-    bool empty() const { return queue.empty(); }
-
-private:
-    static int64_t alarm_cb(alarm_id_t, void* user_data) {
-        static_cast<timer_queue*>(user_data)->irq_pending = true;
-        return 0;
-    }
-
-    void arm() {
-        if (alarm >= 0) cancel_alarm(alarm);
-        alarm = -1;
-        if (!queue.empty())
-            alarm = add_alarm_at(queue.front().when, alarm_cb, this, false);
-    }
-};
@@ -1,7 +0,0 @@
-#pragma once
-
-#define CFG_TUSB_RHPORT0_MODE OPT_MODE_DEVICE
-#define CFG_TUD_CDC 1
-#define CFG_TUD_CDC_RX_BUFSIZE 256
-#define CFG_TUD_CDC_TX_BUFSIZE 256
-#define CFG_TUD_CDC_EP_BUFSIZE 64
@@ -1,31 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <span>
-#include <vector>
-#include "tusb.h"
-#include "ring_buffer.h"
-
-struct usb_cdc {
-    ring_buffer<uint8_t, 8192> tx;
-
-    void send(std::span<const uint8_t> data) {
-        tx.push(data);
-        drain();
-    }
-
-    void send(const std::vector<uint8_t>& data) {
-        send(std::span<const uint8_t>{data});
-    }
-
-    void drain() {
-        while (!tx.empty()) {
-            uint32_t avail = tud_cdc_write_available();
-            if (avail == 0) break;
-            auto chunk = tx.read_contiguous();
-            if (chunk.size() > avail) chunk = chunk.first(avail);
-            tud_cdc_write(chunk.data(), chunk.size());
-            tx.consume(chunk.size());
-        }
-        tud_cdc_write_flush();
-    }
-};
@@ -1,161 +0,0 @@
-#pragma once
-#include <array>
-#include <cstdint>
-#include <string>
-#include <tuple>
-#include <vector>
-#include "msgpack.h"
-#include "halfsiphash.h"
-#include "static_vector.h"
-
-struct Envelope {
-    static constexpr int8_t ext_id = 0;
-    uint32_t message_id;
-    uint32_t checksum;
-    std::vector<uint8_t> payload;
-    auto as_tuple() const { return std::tie(message_id, checksum, payload); }
-    auto as_tuple() { return std::tie(message_id, checksum, payload); }
-};
-
-struct DeviceError {
-    static constexpr int8_t ext_id = 1;
-    uint32_t code;
-    std::string message;
-    auto as_tuple() const { return std::tie(code, message); }
-    auto as_tuple() { return std::tie(code, message); }
-};
-
-struct RequestPICOBOOT {
-    static constexpr int8_t ext_id = 2;
-    auto as_tuple() const { return std::tie(); }
-    auto as_tuple() { return std::tie(); }
-};
-
-struct ResponsePICOBOOT {
-    static constexpr int8_t ext_id = 3;
-    auto as_tuple() const { return std::tie(); }
-    auto as_tuple() { return std::tie(); }
-};
-
-struct RequestInfo {
-    static constexpr int8_t ext_id = 4;
-    auto as_tuple() const { return std::tie(); }
-    auto as_tuple() { return std::tie(); }
-};
-
-struct ResponseInfo {
-    static constexpr int8_t ext_id = 5;
-    std::array<uint8_t, 8> board_id;
-    std::array<uint8_t, 6> mac;
-    std::array<uint8_t, 4> ip;
-    std::string firmware_name;
-    auto as_tuple() const { return std::tie(board_id, mac, ip, firmware_name); }
-    auto as_tuple() { return std::tie(board_id, mac, ip, firmware_name); }
-};
-
-struct RequestLog {
-    static constexpr int8_t ext_id = 6;
-    auto as_tuple() const { return std::tie(); }
-    auto as_tuple() { return std::tie(); }
-};
-
-struct LogEntry {
-    uint32_t timestamp_us;
-    std::string message;
-    auto as_tuple() const { return std::tie(timestamp_us, message); }
-    auto as_tuple() { return std::tie(timestamp_us, message); }
-};
-
-struct ResponseLog {
-    static constexpr int8_t ext_id = 7;
-    std::vector<LogEntry> entries;
-    auto as_tuple() const { return std::tie(entries); }
-    auto as_tuple() { return std::tie(entries); }
-};
-
-struct RequestTest {
-    static constexpr int8_t ext_id = 127;
-    std::string name;
-    auto as_tuple() const { return std::tie(name); }
-    auto as_tuple() { return std::tie(name); }
-};
-
-struct ResponseTest {
-    static constexpr int8_t ext_id = 126;
-    bool pass;
-    std::vector<std::string> messages;
-    auto as_tuple() const { return std::tie(pass, messages); }
-    auto as_tuple() { return std::tie(pass, messages); }
-};
-
-static constexpr uint8_t hash_key[8] = {};
-
-struct DecodedMessage {
-    uint32_t message_id;
-    int8_t type_id;
-    std::vector<uint8_t> payload;
-};
-
-inline std::vector<uint8_t> pack_envelope(uint32_t message_id, const std::vector<uint8_t> &payload) {
-    uint32_t checksum = halfsiphash::hash32(payload.data(), payload.size(), hash_key);
-    msgpack::packer p;
-    p.pack(Envelope{message_id, checksum, payload});
-    return p.get_payload();
-}
-
-template <typename T>
-inline std::vector<uint8_t> encode_response(uint32_t message_id, const T &msg) {
-    msgpack::packer inner;
-    inner.pack(msg);
-    return pack_envelope(message_id, inner.get_payload());
-}
-
-inline msgpack::result<DecodedMessage> try_decode(const uint8_t *data, size_t len) {
-    msgpack::parser p(data, static_cast<int>(len));
-
-    Envelope env;
-    auto r = msgpack::unpack(p, env);
-    if (!r) return std::unexpected(r.error());
-
-    uint32_t expected = halfsiphash::hash32(env.payload.data(), env.payload.size(), hash_key);
-    if (env.checksum != expected) return std::unexpected(msgpack::error_code::invalid);
-
-    msgpack::parser inner(env.payload.data(), static_cast<int>(env.payload.size()));
-    if (!inner.is_ext()) return std::unexpected(msgpack::error_code::type_error);
-    auto ext = inner.get_ext();
-    if (!ext) return std::unexpected(ext.error());
-
-    auto& [type_id, ext_data] = *ext;
-    return DecodedMessage{env.message_id, type_id,
-        std::vector<uint8_t>(reinterpret_cast<const uint8_t*>(ext_data.data()),
-                             reinterpret_cast<const uint8_t*>(ext_data.data()) + ext_data.size())};
-}
-
-template <size_t N>
-inline msgpack::result<DecodedMessage> try_decode(const static_vector<uint8_t, N> &buf) {
-    return try_decode(buf.data(), buf.size());
-}
-
-template <typename T>
-inline msgpack::result<T> decode_response(const uint8_t *data, size_t len) {
-    msgpack::parser p(data, static_cast<int>(len));
-
-    Envelope env;
-    auto r = msgpack::unpack(p, env);
-    if (!r) return std::unexpected(r.error());
-
-    uint32_t expected = halfsiphash::hash32(env.payload.data(), env.payload.size(), hash_key);
-    if (env.checksum != expected) return std::unexpected(msgpack::error_code::invalid);
-
-    msgpack::parser inner(env.payload.data(), static_cast<int>(env.payload.size()));
-    T out;
-    auto r2 = msgpack::unpack(inner, out);
-    if (!r2) return std::unexpected(r2.error());
-    return out;
-}
-
-inline std::vector<uint8_t> encode_request(uint32_t message_id, const auto &msg) {
-    msgpack::packer inner;
-    inner.pack(msg);
-    return pack_envelope(message_id, inner.get_payload());
-}
@@ -1,85 +0,0 @@
-#include "dispatch.h"
-#include <unordered_map>
-#include "pico/stdlib.h"
-#include "pico/bootrom.h"
-#include "tusb.h"
-#include "wire.h"
-#include "usb_cdc.h"
-#include "timer_queue.h"
-#include "net.h"
-#include "debug_log.h"
-#include "hardware/sync.h"
-
-static timer_queue timers;
-
-void dispatch_init() {
-    tusb_init();
-    net_init();
-    dlog("dispatch_init complete");
-}
-
-void dispatch_schedule_ms(uint32_t ms, std::function<void()> fn) {
-    timers.schedule_ms(ms, std::move(fn));
-}
-
-[[noreturn]] void dispatch_run(std::span<const handler_entry> handlers) {
-    std::unordered_map<int8_t, std::vector<std::vector<uint8_t>> (*)(uint32_t, std::span<const uint8_t>)> handler_map;
-    for (auto& entry : handlers) {
-        handler_map[entry.type_id] = entry.handle;
-    }
-
-    static usb_cdc usb;
-    static static_vector<uint8_t, 256> usb_rx_buf;
-
-    net_set_handler([&](std::span<const uint8_t> payload) -> std::vector<std::vector<uint8_t>> {
-        auto msg = try_decode(payload.data(), payload.size());
-        if (!msg) return {};
-        auto it = handler_map.find(msg->type_id);
-        if (it == handler_map.end()) return {};
-        return it->second(msg->message_id, msg->payload);
-    });
-
-    while (true) {
-        uint32_t save = save_and_disable_interrupts();
-
-        dlog_if_slow("tud_task", 1000, [&]{ tud_task(); });
-        dlog_if_slow("drain", 1000, [&]{ usb.drain(); });
-        dlog_if_slow("timers", 1000, [&]{ timers.run(); });
-        dlog_if_slow("net_poll", 1000, [&]{ net_poll(); });
-
-        while (tud_cdc_available()) {
-            uint8_t byte;
-            if (tud_cdc_read(&byte, 1) != 1) break;
-
-            usb_rx_buf.push_back(byte);
-
-            auto msg = try_decode(usb_rx_buf);
-            if (!msg) {
-                if (usb_rx_buf.full()) usb_rx_buf.clear();
-                continue;
-            }
-
-            usb_rx_buf.clear();
-
-            auto it = handler_map.find(msg->type_id);
-            if (it != handler_map.end()) {
-                for (auto& response : it->second(msg->message_id, msg->payload)) {
-                    if (response.size() > usb.tx.free()) {
-                        auto err = encode_response(msg->message_id,
-                            DeviceError{2, "response too large: " + std::to_string(response.size())});
-                        usb.send(err);
-                    } else {
-                        usb.send(response);
-                    }
-                }
-                if (msg->type_id == RequestPICOBOOT::ext_id) {
-                    sleep_ms(100);
-                    reset_usb_boot(0, 1);
-                }
-            }
-        }
-
-        __wfi();
-        restore_interrupts(save);
-    }
-}
@@ -1,27 +0,0 @@
-#include "handlers.h"
-#include "pico/unique_id.h"
-#include "net.h"
-#include "debug_log.h"
-
-std::vector<std::vector<uint8_t>> handle_picoboot(uint32_t message_id, std::span<const uint8_t>) {
-    return {encode_response(message_id, ResponsePICOBOOT{})};
-}
-
-std::vector<std::vector<uint8_t>> handle_info(uint32_t message_id, std::span<const uint8_t>) {
-    ResponseInfo resp;
-    pico_unique_board_id_t uid;
-    pico_get_unique_board_id(&uid);
-    std::copy(uid.id, uid.id + 8, resp.board_id.begin());
-    auto& ns = net_get_state();
-    resp.mac = ns.mac;
-    resp.ip = ns.ip;
-    resp.firmware_name = firmware_name;
-    return {encode_response(message_id, resp)};
-}
-
-std::vector<std::vector<uint8_t>> handle_log(uint32_t message_id, std::span<const uint8_t>) {
-    ResponseLog resp;
-    for (auto& e : dlog_drain())
-        resp.entries.push_back(LogEntry{e.timestamp_us, std::move(e.message)});
-    return {encode_response(message_id, resp)};
-}
@@ -1,304 +0,0 @@
-#include "net.h"
-#include <cstring>
-#include "pico/unique_id.h"
-#include "pico/time.h"
-#include "w6300.h"
-#include "debug_log.h"
-
-using mac_addr = std::array<uint8_t, 6>;
-using ip4_addr = std::array<uint8_t, 4>;
-
-struct __attribute__((packed)) eth_header {
-    mac_addr dst;
-    mac_addr src;
-    uint16_t ethertype;
-};
-static_assert(sizeof(eth_header) == 14);
-
-struct __attribute__((packed)) arp_packet {
-    eth_header eth;
-    uint16_t htype;
-    uint16_t ptype;
-    uint8_t hlen;
-    uint8_t plen;
-    uint16_t oper;
-    mac_addr sha;
-    ip4_addr spa;
-    mac_addr tha;
-    ip4_addr tpa;
-};
-static_assert(sizeof(arp_packet) == 42);
-
-struct __attribute__((packed)) ipv4_header {
-    eth_header eth;
-    uint8_t ver_ihl;
-    uint8_t dscp_ecn;
-    uint16_t total_len;
-    uint16_t identification;
-    uint16_t flags_frag;
-    uint8_t ttl;
-    uint8_t protocol;
-    uint16_t checksum;
-    ip4_addr src;
-    ip4_addr dst;
-
-    size_t ip_header_len() const { return (ver_ihl & 0x0F) * 4; }
-    size_t ip_total_len() const { return __builtin_bswap16(total_len); }
-    const uint8_t* ip_start() const { return reinterpret_cast<const uint8_t*>(&ver_ihl); }
-    uint8_t* ip_start() { return reinterpret_cast<uint8_t*>(&ver_ihl); }
-};
-static_assert(sizeof(ipv4_header) == 34);
-
-struct __attribute__((packed)) udp_header {
-    ipv4_header ip;
-    uint16_t src_port;
-    uint16_t dst_port;
-    uint16_t length;
-    uint16_t checksum;
-};
-static_assert(sizeof(udp_header) == 42);
-
-struct __attribute__((packed)) icmp_echo {
-    uint8_t type;
-    uint8_t code;
-    uint16_t checksum;
-    uint16_t id;
-    uint16_t seq;
-};
-static_assert(sizeof(icmp_echo) == 8);
-
-static constexpr uint16_t ETH_ARP = __builtin_bswap16(0x0806);
-static constexpr uint16_t ETH_IPV4 = __builtin_bswap16(0x0800);
-static constexpr uint16_t ARP_HTYPE_ETH = __builtin_bswap16(1);
-static constexpr uint16_t ARP_PTYPE_IPV4 = __builtin_bswap16(0x0800);
-static constexpr uint16_t ARP_OP_REQUEST = __builtin_bswap16(1);
-static constexpr uint16_t ARP_OP_REPLY = __builtin_bswap16(2);
-static constexpr uint16_t PICOMAP_PORT = __builtin_bswap16(28781);
-static constexpr mac_addr MAC_BROADCAST = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
-static constexpr ip4_addr IP_BROADCAST_ALL = {255, 255, 255, 255};
-static constexpr ip4_addr IP_BROADCAST_SUBNET = {169, 254, 255, 255};
-
-static net_state state;
-static w6300::socket_id raw_socket{0};
-static net_handler msg_handler;
-
-static uint16_t ip_checksum(const void* data, size_t len) {
-    auto p = static_cast<const uint8_t*>(data);
-    uint32_t sum = 0;
-    for (size_t i = 0; i < len - 1; i += 2)
-        sum += (p[i] << 8) | p[i + 1];
-    if (len & 1)
-        sum += p[len - 1] << 8;
-    while (sum >> 16)
-        sum = (sum & 0xFFFF) + (sum >> 16);
-    return __builtin_bswap16(~sum);
-}
-
-static bool mac_match(const mac_addr& dst) {
-    return dst == state.mac || dst == MAC_BROADCAST;
-}
-
-static bool ip_match(const ip4_addr& dst) {
-    return dst == state.ip;
-}
-
-static bool ip_match_or_broadcast(const ip4_addr& dst) {
-    return ip_match(dst) || dst == IP_BROADCAST_ALL || dst == IP_BROADCAST_SUBNET;
-}
-
-static void send_raw(const void* data, size_t len) {
-    dlog_if_slow("send_raw", 1000, [&]{
-        w6300::send(raw_socket, std::span<const uint8_t>{static_cast<const uint8_t*>(data), len});
-    });
-}
-
-static void handle_arp(const uint8_t* frame, size_t len) {
-    if (len < sizeof(arp_packet)) return;
-    auto& pkt = *reinterpret_cast<const arp_packet*>(frame);
-
-    if (pkt.htype != ARP_HTYPE_ETH) return;
-    if (pkt.ptype != ARP_PTYPE_IPV4) return;
-    if (pkt.hlen != 6 || pkt.plen != 4) return;
-    if (pkt.oper != ARP_OP_REQUEST) return;
-    if (!ip_match(pkt.tpa)) return;
-
-    arp_packet reply = {};
-    reply.eth.dst = pkt.eth.src;
-    reply.eth.src = state.mac;
-    reply.eth.ethertype = ETH_ARP;
-    reply.htype = ARP_HTYPE_ETH;
-    reply.ptype = ARP_PTYPE_IPV4;
-    reply.hlen = 6;
-    reply.plen = 4;
-    reply.oper = ARP_OP_REPLY;
-    reply.sha = state.mac;
-    reply.spa = state.ip;
-    reply.tha = pkt.sha;
-    reply.tpa = pkt.spa;
-
-    send_raw(&reply, sizeof(reply));
-}
-
-static void handle_udp(const uint8_t* frame, size_t len) {
-    if (len < sizeof(udp_header)) return;
-    auto& pkt = *reinterpret_cast<const udp_header*>(frame);
-
-    if (pkt.dst_port != PICOMAP_PORT) return;
-    if (!ip_match_or_broadcast(pkt.ip.dst)) return;
-    if (!msg_handler) return;
-
-    size_t udp_len = __builtin_bswap16(pkt.length);
-    if (udp_len < 8) return;
-    if (sizeof(eth_header) + pkt.ip.ip_total_len() < sizeof(udp_header) + udp_len - 8) return;
-
-    auto* payload = frame + sizeof(udp_header);
-    size_t payload_len = udp_len - 8;
-
-    auto responses = msg_handler(std::span<const uint8_t>{payload, payload_len});
-
-    for (auto& resp : responses) {
-        uint8_t reply_buf[1514];
-        size_t udp_data_len = resp.size();
-        size_t ip_total = 20 + 8 + udp_data_len;
-        size_t reply_len = sizeof(eth_header) + ip_total;
-        if (reply_len > sizeof(reply_buf)) continue;
-
-        auto& rip = *reinterpret_cast<ipv4_header*>(reply_buf);
-        rip.eth.dst = pkt.ip.eth.src;
-        rip.eth.src = state.mac;
-        rip.eth.ethertype = ETH_IPV4;
-        rip.ver_ihl = 0x45;
-        rip.dscp_ecn = 0;
-        rip.total_len = __builtin_bswap16(ip_total);
-        rip.identification = 0;
-        rip.flags_frag = 0;
-        rip.ttl = 64;
-        rip.protocol = 17;
-        rip.checksum = 0;
-        rip.src = state.ip;
-        rip.dst = pkt.ip.src;
-        rip.checksum = ip_checksum(rip.ip_start(), 20);
-
-        auto& rudp = *reinterpret_cast<udp_header*>(reply_buf);
-        rudp.src_port = PICOMAP_PORT;
-        rudp.dst_port = pkt.src_port;
-        rudp.length = __builtin_bswap16(8 + udp_data_len);
-        rudp.checksum = 0;
-
-        memcpy(reply_buf + sizeof(udp_header), resp.data(), udp_data_len);
-
-        send_raw(reply_buf, reply_len);
-    }
-}
-
-static void handle_icmp(const uint8_t* frame, size_t len) {
-    auto& ip = *reinterpret_cast<const ipv4_header*>(frame);
-    size_t ip_hdr_len = ip.ip_header_len();
-    size_t ip_total = ip.ip_total_len();
-
-    if (sizeof(eth_header) + ip_total > len) return;
-    if (ip.protocol != 1) return;
-    if (!ip_match_or_broadcast(ip.dst)) return;
-
-    auto& icmp = *reinterpret_cast<const icmp_echo*>(frame + sizeof(eth_header) + ip_hdr_len);
-    size_t icmp_len = ip_total - ip_hdr_len;
-    if (icmp_len < sizeof(icmp_echo)) return;
-    if (icmp.type != 8) return;
-
-    uint8_t reply_buf[1514];
-    size_t reply_len = sizeof(eth_header) + ip_total;
-    if (reply_len > sizeof(reply_buf)) return;
-
-    memcpy(reply_buf, frame, reply_len);
-    auto& rip = *reinterpret_cast<ipv4_header*>(reply_buf);
-    rip.eth.dst = ip.eth.src;
-    rip.eth.src = state.mac;
-    rip.src = state.ip;
-    rip.dst = ip.src;
-    rip.ttl = 64;
-    rip.checksum = 0;
-    rip.checksum = ip_checksum(rip.ip_start(), ip_hdr_len);
-
-    auto& ricmp = *reinterpret_cast<icmp_echo*>(reply_buf + sizeof(eth_header) + ip_hdr_len);
-    ricmp.type = 0;
-    ricmp.checksum = 0;
-    ricmp.checksum = ip_checksum(&ricmp, icmp_len);
-
-    send_raw(reply_buf, reply_len);
-}
-
-static void handle_ipv4(const uint8_t* frame, size_t len) {
-    if (len < sizeof(ipv4_header)) return;
-    auto& ip = *reinterpret_cast<const ipv4_header*>(frame);
-    if ((ip.ver_ihl >> 4) != 4) return;
-
-    switch (ip.protocol) {
-    case 1:
-        handle_icmp(frame, len);
-        break;
-    case 17:
-        handle_udp(frame, len);
-        break;
-    }
-}
-
-static void process_frame(const uint8_t* frame, size_t len) {
-    if (len < sizeof(eth_header)) return;
-    auto& eth = *reinterpret_cast<const eth_header*>(frame);
-
-    if (!mac_match(eth.dst)) return;
-
-    switch (eth.ethertype) {
-    case ETH_ARP:
-        handle_arp(frame, len);
-        break;
-    case ETH_IPV4:
-        handle_ipv4(frame, len);
-        break;
-    }
-}
-
-bool net_init() {
-    w6300::init_spi();
-    w6300::reset();
-    w6300::init();
-    if (!w6300::check()) return false;
-
-    pico_unique_board_id_t uid;
-    pico_get_unique_board_id(&uid);
-    state.mac[0] = (uid.id[0] & 0xFC) | 0x02;
-    state.mac[1] = uid.id[1];
-    state.mac[2] = uid.id[2];
-    state.mac[3] = uid.id[3];
-    state.mac[4] = uid.id[4];
-    state.mac[5] = uid.id[5];
-
-    state.ip[0] = 169;
-    state.ip[1] = 254;
-    state.ip[2] = state.mac[4];
-    state.ip[3] = state.mac[5];
-
-    w6300::open_socket(raw_socket, w6300::protocol::macraw, w6300::sock_flag::none);
-    w6300::set_interrupt_mask(w6300::ik_sock_0);
-
-    return true;
-}
-
-const net_state& net_get_state() {
-    return state;
-}
-
-void net_set_handler(net_handler handler) {
-    msg_handler = std::move(handler);
-}
-
-void net_poll() {
-    if (!w6300::irq_pending) return;
-    w6300::irq_pending = false;
-    w6300::clear_interrupt(w6300::ik_int_all);
-    if (w6300::get_socket_recv_buf(raw_socket) == 0) return;
-    static uint8_t rx_buf[1518];
-    auto result = w6300::recv(raw_socket, std::span{rx_buf});
-    if (!result) return;
-    process_frame(rx_buf, *result);
-}
@@ -1,82 +0,0 @@
-#include <cstring>
-#include "pico/unique_id.h"
-#include "tusb.h"
-
-constexpr uint16_t USB_VID = 0x2E8A;
-constexpr uint16_t USB_PID = 0x000A;
-
-static constexpr tusb_desc_device_t desc_device = {
-    sizeof(tusb_desc_device_t),
-    TUSB_DESC_DEVICE,
-    0x0200,
-    TUSB_CLASS_MISC,
-    MISC_SUBCLASS_COMMON,
-    MISC_PROTOCOL_IAD,
-    CFG_TUD_ENDPOINT0_SIZE,
-    USB_VID,
-    USB_PID,
-    0x0100,
-    1, 2, 3,
-    1,
-};
-
-enum { ITF_NUM_CDC, ITF_NUM_CDC_DATA, ITF_NUM_TOTAL };
-
-constexpr uint8_t EPNUM_CDC_NOTIF = 0x81;
-constexpr uint8_t EPNUM_CDC_OUT   = 0x02;
-constexpr uint8_t EPNUM_CDC_IN    = 0x82;
-constexpr uint16_t CONFIG_TOTAL_LEN = TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN;
-
-static uint8_t const desc_configuration[] = {
-    TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, 0x00, 100),
-    TUD_CDC_DESCRIPTOR(ITF_NUM_CDC, 0, EPNUM_CDC_NOTIF, 8, EPNUM_CDC_OUT, EPNUM_CDC_IN, 64),
-};
-
-static constexpr const char* string_desc[] = {
-    "\x09\x04",
-    "picomap",
-    "picomap",
-    nullptr,
-};
-
-static uint16_t desc_str_buf[33];
-
-extern "C" {
-
-uint8_t const* tud_descriptor_device_cb(void) {
-    return reinterpret_cast<uint8_t const*>(&desc_device);
-}
-
-uint8_t const* tud_descriptor_configuration_cb(uint8_t index) {
-    return desc_configuration;
-}
-
-uint16_t const* tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
-    uint8_t chr_count;
-
-    if (index == 0) {
-        memcpy(&desc_str_buf[1], string_desc[0], 2);
-        chr_count = 1;
-    } else if (index == 3) {
-        pico_unique_board_id_t uid;
-        pico_get_unique_board_id(&uid);
-        chr_count = 0;
-        for (int i = 0; i < 8; i++) {
-            desc_str_buf[1 + chr_count++] = "0123456789ABCDEF"[uid.id[i] >> 4];
-            desc_str_buf[1 + chr_count++] = "0123456789ABCDEF"[uid.id[i] & 0xF];
-        }
-    } else {
-        if (index >= sizeof(string_desc) / sizeof(string_desc[0])) return nullptr;
-        const char* str = string_desc[index];
-        if (!str) return nullptr;
-        chr_count = strlen(str);
-        if (chr_count > 31) chr_count = 31;
-        for (uint8_t i = 0; i < chr_count; i++)
-            desc_str_buf[1 + i] = str[i];
-    }
-
-    desc_str_buf[0] = static_cast<uint16_t>((TUSB_DESC_STRING << 8) | (2 * chr_count + 2));
-    return desc_str_buf;
-}
-
-} // extern "C"
@@ -1,10 +1,9 @@
-#include <unordered_map>
 #include "pico/stdlib.h"
-#include "pico/time.h"
 #include "hardware/gpio.h"
 #include "dispatch.h"
 #include "handlers.h"
-#include "w6300.h"
+#include "igmp.h"
+#include "test_handlers.h"

 static constexpr uint8_t LED_PIN = 25;

@@ -14,105 +13,24 @@ static void led_toggle() {
 }

 std::string_view firmware_name = "picomap_test";
-
-static constexpr uint16_t PICOMAP_DISCOVERY_PORT = 28777;
-
-static constexpr std::array<uint8_t, 4> picomap_discovery_ip = {239, 0, 112, 109};
-
-static constexpr std::array<uint8_t, 6> picomap_discovery_mac = {
-    0x01, 0x00, 0x5e, 0x00, 0x70, 0x6d,
-};
-
-static w6300::socket_id test_socket{1};
-
-static ResponseTest test_discovery() {
-    ResponseTest resp;
-    resp.pass = true;
-
-    auto req = encode_request(0, RequestInfo{});
-    auto send_result = w6300::send(test_socket, std::span<const uint8_t>{req});
-    if (!send_result) {
-        resp.pass = false;
-        resp.messages.push_back("send: error " + std::to_string(static_cast<int>(send_result.error())));
-        return resp;
-    }
-
-    uint8_t rx_buf[512];
-
-    auto deadline = make_timeout_time_ms(5000);
-    std::expected<uint16_t, w6300::sock_error> recv_result = std::unexpected(w6300::sock_error::busy);
-    while (get_absolute_time() < deadline) {
-        recv_result = w6300::recv(test_socket, std::span{rx_buf});
-        if (recv_result || recv_result.error() != w6300::sock_error::busy) break;
-    }
-
-    if (!recv_result) {
-        resp.pass = false;
-        if (recv_result.error() == w6300::sock_error::busy) {
-            resp.messages.push_back("recv: timed out after 5s");
-        } else {
-            resp.messages.push_back("recv: error " + std::to_string(static_cast<int>(recv_result.error())));
-        }
-        return resp;
-    }
-
-    resp.messages.push_back("received " + std::to_string(*recv_result) + " bytes");
-
-    auto info = decode_response<ResponseInfo>(rx_buf, *recv_result);
-    if (!info) {
-        resp.pass = false;
-        resp.messages.push_back("decode: msgpack error " + std::to_string(static_cast<int>(info.error())));
-        return resp;
-    }
-
-    if (info->firmware_name.empty()) {
-        resp.pass = false;
-        resp.messages.push_back("firmware_name is empty");
-    } else {
-        resp.messages.push_back("firmware_name: " + info->firmware_name);
-    }
-
-    bool mac_zero = true;
-    for (auto b : info->mac) { if (b != 0) { mac_zero = false; break; } }
-    if (mac_zero) {
-        resp.pass = false;
-        resp.messages.push_back("mac is all zeros");
-    }
-
-    bool ip_zero = true;
-    for (auto b : info->ip) { if (b != 0) { ip_zero = false; break; } }
-    if (ip_zero) {
-        resp.pass = false;
-        resp.messages.push_back("ip is all zeros");
-    }
-
-    return resp;
-}
-
-using test_fn = ResponseTest (*)();
-
-static const std::unordered_map<std::string_view, test_fn> tests = {
-    {"discovery", test_discovery},
-};
-
-static std::vector<std::vector<uint8_t>> handle_test(uint32_t message_id, const RequestTest& req) {
-    auto it = tests.find(req.name);
-    if (it == tests.end()) {
-        return {encode_response(message_id, ResponseTest{false, {"unknown test: " + req.name}})};
-    }
-
-    return {encode_response(message_id, it->second())};
-}
+uint32_t firmware_build_epoch = BUILD_EPOCH;

 static constexpr handler_entry handlers[] = {
-    {RequestPICOBOOT::ext_id, handle_picoboot},
-    {RequestInfo::ext_id, handle_info},
-    {RequestLog::ext_id, handle_log},
+    {RequestInfo::ext_id, typed_handler<RequestInfo, handle_info>},
+    {RequestLog::ext_id, typed_handler<RequestLog, handle_log>},
+    {RequestFlashErase::ext_id, typed_handler<RequestFlashErase, handle_flash_erase>},
+    {RequestFlashWrite::ext_id, typed_handler<RequestFlashWrite, handle_flash_write>},
+    {RequestReboot::ext_id, typed_handler<RequestReboot, handle_reboot>},
+    {RequestFlashStatus::ext_id, typed_handler<RequestFlashStatus, handle_flash_status>},
+    {RequestListTests::ext_id, typed_handler<RequestListTests, handle_list_tests>},
    {RequestTest::ext_id, typed_handler<RequestTest, handle_test>},
 };

 int main() {
-    dispatch_init();
+    handlers_init();
+    dispatch_init(PICOMAP_PORT_BE);
+    igmp::join(PICOMAP_DISCOVERY_GROUP);
+    handlers_start();

    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
@@ -1,18 +0,0 @@
-.program qspi
-.side_set 1
-
-write_bits:
-    out pins, 4             side 0
-    jmp x-- write_bits      side 1
-    set pins 0              side 0
-public write_bits_end:
-read_byte_delay:
-    set pindirs 0           side 0
-read_byte:
-    set x 0                 side 1
-read_bits:
-    in pins, 4              side 0
-    jmp x-- read_bits       side 1
-    in pins, 4              side 0
-    jmp y-- read_byte       side 0
-public read_bits_end:
@@ -1,643 +0,0 @@
-#include <cstring>
-#include <initializer_list>
-#include "pico/stdlib.h"
-#include "pico/error.h"
-#include "hardware/dma.h"
-#include "hardware/clocks.h"
-#include "w6300.h"
-#include "qspi.pio.h"
-
-namespace w6300 {
-
-constexpr int sock_count = 8;
-
-namespace {
-
-#define PIO_PROGRAM_NAME qspi
-#define PIO_PROGRAM_FUNC __CONCAT(PIO_PROGRAM_NAME, _program)
-#define PIO_PROGRAM_GET_DEFAULT_CONFIG_FUNC __CONCAT(PIO_PROGRAM_NAME, _program_get_default_config)
-#define PIO_OFFSET_WRITE_BITS_END __CONCAT(PIO_PROGRAM_NAME, _offset_write_bits_end)
-#define PIO_OFFSET_READ_BITS_END __CONCAT(PIO_PROGRAM_NAME, _offset_read_bits_end)
-
-constexpr uint8_t PIN_INT              = 15;
-constexpr uint8_t PIN_CS               = 16;
-constexpr uint8_t PIO_SPI_SCK_PIN      = 17;
-constexpr uint8_t PIO_SPI_DATA_IO0_PIN = 18;
-constexpr uint8_t PIO_SPI_DATA_IO1_PIN = 19;
-constexpr uint8_t PIO_SPI_DATA_IO2_PIN = 20;
-constexpr uint8_t PIO_SPI_DATA_IO3_PIN = 21;
-constexpr uint8_t PIN_RST              = 22;
-
-constexpr uint16_t SPI_CLKDIV_MAJOR = 2;
-constexpr uint8_t  SPI_CLKDIV_MINOR = 0;
-
-constexpr uint32_t PADS_DRIVE = PADS_BANK0_GPIO0_DRIVE_VALUE_12MA;
-constexpr uint32_t IRQ_DELAY_NS = 100;
-constexpr uint32_t QSPI_LOOP_CNT = 2;
-
-struct {
-    pio_hw_t *pio;
-    uint8_t pio_func_sel;
-    int8_t pio_offset;
-    int8_t pio_sm;
-    int8_t dma_out;
-    int8_t dma_in;
-} state;
-
-uint16_t mk_cmd_buf(uint8_t *pdst, uint8_t opcode, uint16_t addr) {
-    pdst[0] = ((opcode >> 7 & 0x01) << 4) | ((opcode >> 6 & 0x01) << 0);
-    pdst[1] = ((opcode >> 5 & 0x01) << 4) | ((opcode >> 4 & 0x01) << 0);
-    pdst[2] = ((opcode >> 3 & 0x01) << 4) | ((opcode >> 2 & 0x01) << 0);
-    pdst[3] = ((opcode >> 1 & 0x01) << 4) | ((opcode >> 0 & 0x01) << 0);
-    pdst[4] = (uint8_t)(addr >> 8);
-    pdst[5] = (uint8_t)(addr);
-    pdst[6] = 0;
-    return 7;
-}
-
-uint32_t data_pin_mask() {
-    return (1u << PIO_SPI_DATA_IO0_PIN) | (1u << PIO_SPI_DATA_IO1_PIN) |
-           (1u << PIO_SPI_DATA_IO2_PIN) | (1u << PIO_SPI_DATA_IO3_PIN);
-}
-
-__noinline void ns_delay(uint32_t ns) {
-    uint32_t cycles = ns * (clock_get_hz(clk_sys) >> 16u) / (1000000000u >> 16u);
-    busy_wait_at_least_cycles(cycles);
-}
-
-void pio_init() {
-    for (auto pin : {PIO_SPI_DATA_IO0_PIN, PIO_SPI_DATA_IO1_PIN, PIO_SPI_DATA_IO2_PIN, PIO_SPI_DATA_IO3_PIN}) {
-        gpio_init(pin);
-        gpio_set_dir(pin, GPIO_OUT);
-        gpio_put(pin, false);
-    }
-    gpio_init(PIN_CS);
-    gpio_set_dir(PIN_CS, GPIO_OUT);
-    gpio_put(PIN_CS, true);
-    gpio_init(PIN_INT);
-    gpio_set_dir(PIN_INT, GPIO_IN);
-    gpio_pull_up(PIN_INT);
-    gpio_set_irq_enabled_with_callback(PIN_INT, GPIO_IRQ_EDGE_FALL, true,
-        [](uint, uint32_t){ irq_pending = true; });
-
-    pio_hw_t *pios[2] = {pio0, pio1};
-    uint pio_index = 1;
-    if (!pio_can_add_program(pios[pio_index], &PIO_PROGRAM_FUNC)) {
-        pio_index ^= 1;
-        assert(pio_can_add_program(pios[pio_index], &PIO_PROGRAM_FUNC));
-    }
-
-    state.pio = pios[pio_index];
-    state.dma_in = -1;
-    state.dma_out = -1;
-
-    static_assert(GPIO_FUNC_PIO1 == GPIO_FUNC_PIO0 + 1);
-    state.pio_func_sel = GPIO_FUNC_PIO0 + pio_index;
-    state.pio_sm = (int8_t)pio_claim_unused_sm(state.pio, true);
-    state.pio_offset = pio_add_program(state.pio, &PIO_PROGRAM_FUNC);
-
-    pio_sm_config sm_config = PIO_PROGRAM_GET_DEFAULT_CONFIG_FUNC(state.pio_offset);
-    sm_config_set_clkdiv_int_frac(&sm_config, SPI_CLKDIV_MAJOR, SPI_CLKDIV_MINOR);
-
-    hw_write_masked(&pads_bank0_hw->io[PIO_SPI_SCK_PIN],
-                    (uint)PADS_DRIVE << PADS_BANK0_GPIO0_DRIVE_LSB,
-                    PADS_BANK0_GPIO0_DRIVE_BITS);
-    hw_write_masked(&pads_bank0_hw->io[PIO_SPI_SCK_PIN],
-                    1u << PADS_BANK0_GPIO0_SLEWFAST_LSB,
-                    PADS_BANK0_GPIO0_SLEWFAST_BITS);
-
-    sm_config_set_out_pins(&sm_config, PIO_SPI_DATA_IO0_PIN, 4);
-    sm_config_set_in_pins(&sm_config, PIO_SPI_DATA_IO0_PIN);
-    sm_config_set_set_pins(&sm_config, PIO_SPI_DATA_IO0_PIN, 4);
-    sm_config_set_sideset(&sm_config, 1, false, false);
-    sm_config_set_sideset_pins(&sm_config, PIO_SPI_SCK_PIN);
-    sm_config_set_in_shift(&sm_config, false, true, 8);
-    sm_config_set_out_shift(&sm_config, false, true, 8);
-    hw_set_bits(&state.pio->input_sync_bypass, data_pin_mask());
-    pio_sm_set_config(state.pio, state.pio_sm, &sm_config);
-    pio_sm_set_consecutive_pindirs(state.pio, state.pio_sm, PIO_SPI_SCK_PIN, 1, true);
-
-    for (auto pin : {PIO_SPI_DATA_IO0_PIN, PIO_SPI_DATA_IO1_PIN, PIO_SPI_DATA_IO2_PIN, PIO_SPI_DATA_IO3_PIN}) {
-        gpio_set_function(pin, (gpio_function_t)state.pio_func_sel);
-        gpio_set_pulls(pin, false, true);
-        gpio_set_input_hysteresis_enabled(pin, true);
-    }
-
-    pio_sm_exec(state.pio, state.pio_sm, pio_encode_set(pio_pins, 1));
-
-    state.dma_out = (int8_t)dma_claim_unused_channel(true);
-    state.dma_in = (int8_t)dma_claim_unused_channel(true);
-}
-
-
-void pio_frame_start() {
-    for (auto pin : {PIO_SPI_DATA_IO0_PIN, PIO_SPI_DATA_IO1_PIN, PIO_SPI_DATA_IO2_PIN, PIO_SPI_DATA_IO3_PIN})
-        gpio_set_function(pin, (gpio_function_t)state.pio_func_sel);
-    gpio_set_function(PIO_SPI_SCK_PIN, (gpio_function_t)state.pio_func_sel);
-    gpio_pull_down(PIO_SPI_SCK_PIN);
-    gpio_put(PIN_CS, false);
-}
-
-void pio_frame_end() {
-    gpio_put(PIN_CS, true);
-    ns_delay(IRQ_DELAY_NS);
-}
-
-void pio_read(uint8_t opcode, uint16_t addr, uint8_t* buf, uint16_t len) {
-    uint8_t cmd[8] = {};
-    uint16_t cmd_len = mk_cmd_buf(cmd, opcode, addr);
-
-    pio_sm_set_enabled(state.pio, state.pio_sm, false);
-    pio_sm_set_wrap(state.pio, state.pio_sm, state.pio_offset, state.pio_offset + PIO_OFFSET_READ_BITS_END - 1);
-    pio_sm_clear_fifos(state.pio, state.pio_sm);
-    pio_sm_set_pindirs_with_mask(state.pio, state.pio_sm, data_pin_mask(), data_pin_mask());
-    pio_sm_restart(state.pio, state.pio_sm);
-    pio_sm_clkdiv_restart(state.pio, state.pio_sm);
-
-    pio_sm_put(state.pio, state.pio_sm, cmd_len * QSPI_LOOP_CNT - 1);
-    pio_sm_exec(state.pio, state.pio_sm, pio_encode_out(pio_x, 32));
-    pio_sm_put(state.pio, state.pio_sm, len - 1);
-    pio_sm_exec(state.pio, state.pio_sm, pio_encode_out(pio_y, 32));
-    pio_sm_exec(state.pio, state.pio_sm, pio_encode_jmp(state.pio_offset));
-
-    dma_channel_abort(state.dma_out);
-    dma_channel_abort(state.dma_in);
-
-    dma_channel_config out_cfg = dma_channel_get_default_config(state.dma_out);
-    channel_config_set_transfer_data_size(&out_cfg, DMA_SIZE_8);
-    channel_config_set_bswap(&out_cfg, true);
-    channel_config_set_dreq(&out_cfg, pio_get_dreq(state.pio, state.pio_sm, true));
-    dma_channel_configure(state.dma_out, &out_cfg, &state.pio->txf[state.pio_sm], cmd, cmd_len, true);
-
-    dma_channel_config in_cfg = dma_channel_get_default_config(state.dma_in);
-    channel_config_set_transfer_data_size(&in_cfg, DMA_SIZE_8);
-    channel_config_set_bswap(&in_cfg, true);
-    channel_config_set_dreq(&in_cfg, pio_get_dreq(state.pio, state.pio_sm, false));
-    channel_config_set_write_increment(&in_cfg, true);
-    channel_config_set_read_increment(&in_cfg, false);
-    dma_channel_configure(state.dma_in, &in_cfg, buf, &state.pio->rxf[state.pio_sm], len, true);
-
-    pio_sm_set_enabled(state.pio, state.pio_sm, true);
-    __compiler_memory_barrier();
-    dma_channel_wait_for_finish_blocking(state.dma_out);
-    dma_channel_wait_for_finish_blocking(state.dma_in);
-    __compiler_memory_barrier();
-    pio_sm_set_enabled(state.pio, state.pio_sm, false);
-    pio_sm_exec(state.pio, state.pio_sm, pio_encode_mov(pio_pins, pio_null));
-}
-
-void pio_write(uint8_t opcode, uint16_t addr, uint8_t* buf, uint16_t len) {
-    uint8_t cmd[8] = {};
-    uint16_t cmd_len = mk_cmd_buf(cmd, opcode, addr);
-    uint16_t total = len + cmd_len;
-
-    pio_sm_set_enabled(state.pio, state.pio_sm, false);
-    pio_sm_set_wrap(state.pio, state.pio_sm, state.pio_offset, state.pio_offset + PIO_OFFSET_WRITE_BITS_END - 1);
-    pio_sm_clear_fifos(state.pio, state.pio_sm);
-    pio_sm_set_pindirs_with_mask(state.pio, state.pio_sm, data_pin_mask(), data_pin_mask());
-    pio_sm_restart(state.pio, state.pio_sm);
-    pio_sm_clkdiv_restart(state.pio, state.pio_sm);
-
-    pio_sm_put(state.pio, state.pio_sm, total * QSPI_LOOP_CNT - 1);
-    pio_sm_exec(state.pio, state.pio_sm, pio_encode_out(pio_x, 32));
-    pio_sm_put(state.pio, state.pio_sm, 0);
-    pio_sm_exec(state.pio, state.pio_sm, pio_encode_out(pio_y, 32));
-    pio_sm_exec(state.pio, state.pio_sm, pio_encode_jmp(state.pio_offset));
-
-    dma_channel_abort(state.dma_out);
-
-    dma_channel_config out_cfg = dma_channel_get_default_config(state.dma_out);
-    channel_config_set_transfer_data_size(&out_cfg, DMA_SIZE_8);
-    channel_config_set_bswap(&out_cfg, true);
-    channel_config_set_dreq(&out_cfg, pio_get_dreq(state.pio, state.pio_sm, true));
-
-    pio_sm_set_enabled(state.pio, state.pio_sm, true);
-    dma_channel_configure(state.dma_out, &out_cfg, &state.pio->txf[state.pio_sm], cmd, cmd_len, true);
-    dma_channel_wait_for_finish_blocking(state.dma_out);
-    dma_channel_configure(state.dma_out, &out_cfg, &state.pio->txf[state.pio_sm], buf, len, true);
-    dma_channel_wait_for_finish_blocking(state.dma_out);
-
-    const uint32_t stall = 1u << (PIO_FDEBUG_TXSTALL_LSB + state.pio_sm);
-    state.pio->fdebug = stall;
-    while (!(state.pio->fdebug & stall)) tight_loop_contents();
-
-    __compiler_memory_barrier();
-    pio_sm_set_consecutive_pindirs(state.pio, state.pio_sm, PIO_SPI_DATA_IO0_PIN, 4, false);
-    pio_sm_exec(state.pio, state.pio_sm, pio_encode_mov(pio_pins, pio_null));
-    pio_sm_set_enabled(state.pio, state.pio_sm, false);
-}
-
-using datasize_t = int16_t;
-
-
-constexpr uint8_t QSPI_MODE = 0x02 << 6;
-
-
-constexpr uint8_t PACK_NONE      = 0x00;
-constexpr uint8_t PACK_FIRST     = 1 << 1;
-constexpr uint8_t PACK_REMAINED  = 1 << 2;
-constexpr uint8_t PACK_COMPLETED = 1 << 3;
-
-constexpr uint8_t SPI_READ  = (0x00 << 5);
-constexpr uint8_t SPI_WRITE = (0x01 << 5);
-
-constexpr uint32_t CREG_BLOCK           = 0x00;
-constexpr uint32_t SREG_BLOCK(uint8_t n) { return 1 + 4 * n; }
-constexpr uint32_t TXBUF_BLOCK(uint8_t n) { return 2 + 4 * n; }
-constexpr uint32_t RXBUF_BLOCK(uint8_t n) { return 3 + 4 * n; }
-
-constexpr uint32_t offset_inc(uint32_t addr, uint32_t n) { return addr + (n << 8); }
-
-constexpr uint32_t REG_CIDR      = (0x0000 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_RTL       = (0x0004 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_SYSR      = (0x2000 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_SYCR0     = (0x2004 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_IMR       = (0x2104 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_IRCLR     = (0x2108 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_SIMR      = (0x2114 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_SLIMR     = (0x2124 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_SLIRCLR   = (0x2128 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_SHAR      = (0x4120 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_GAR       = (0x4130 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_SUBR      = (0x4134 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_SIPR      = (0x4138 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_LLAR      = (0x4140 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_GUAR      = (0x4150 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_SUB6R     = (0x4160 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_GA6R      = (0x4170 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_CHPLCKR   = (0x41F4 << 8) + CREG_BLOCK;
-constexpr uint32_t REG_NETLCKR   = (0x41F5 << 8) + CREG_BLOCK;
-
-constexpr uint32_t REG_SN_MR(uint8_t n)      { return (0x0000 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_CR(uint8_t n)      { return (0x0010 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_IR(uint8_t n)      { return (0x0020 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_IRCLR(uint8_t n)   { return (0x0028 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_SR(uint8_t n)      { return (0x0030 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_MR2(uint8_t n)     { return (0x0144 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_TX_BSR(uint8_t n)  { return (0x0200 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_TX_FSR(uint8_t n)  { return (0x0204 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_TX_WR(uint8_t n)   { return (0x020C << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_RX_BSR(uint8_t n)  { return (0x0220 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_RX_RSR(uint8_t n)  { return (0x0224 << 8) + SREG_BLOCK(n); }
-constexpr uint32_t REG_SN_RX_RD(uint8_t n)   { return (0x0228 << 8) + SREG_BLOCK(n); }
-
-constexpr uint8_t SYSR_CHPL            = 1 << 7;
-constexpr uint8_t SYSR_NETL            = 1 << 6;
-constexpr uint8_t SYCR0_RST            = 0x00;
-constexpr uint8_t SN_MR_MACRAW         = 0x07;
-constexpr uint8_t SN_CR_OPEN           = 0x01;
-constexpr uint8_t SN_CR_CLOSE          = 0x10;
-constexpr uint8_t SN_CR_SEND           = 0x20;
-constexpr uint8_t SN_CR_RECV           = 0x40;
-constexpr uint8_t SN_IR_SENDOK         = 0x10;
-constexpr uint8_t SN_IR_TIMEOUT        = 0x08;
-constexpr uint8_t SOCK_CLOSED          = 0x00;
-
-uint8_t reg_read(uint32_t addr_sel);
-void reg_write(uint32_t addr_sel, uint8_t wb);
-void reg_read_buf(uint32_t addr_sel, uint8_t* buf, datasize_t len);
-void reg_write_buf(uint32_t addr_sel, uint8_t* buf, datasize_t len);
-uint16_t get_sn_tx_fsr(uint8_t sn);
-uint16_t get_sn_rx_rsr(uint8_t sn);
-
-uint16_t get_cidr() { return (((uint16_t)reg_read(REG_CIDR) | (((reg_read(REG_RTL)) & 0x0F) << 1)) << 8) + reg_read(offset_inc(REG_CIDR, 1)); }
-uint8_t get_sysr() { return reg_read(REG_SYSR); }
-uint8_t get_sycr0() { return reg_read(REG_SYCR0); }
-void set_sycr0(uint8_t v) { reg_write(REG_SYCR0, v); }
-void set_imr(uint8_t v) { reg_write(REG_IMR, v); }
-void set_irclr(uint8_t v) { reg_write(REG_IRCLR, v); }
-void set_simr(uint8_t v) { reg_write(REG_SIMR, v); }
-void set_slimr(uint8_t v) { reg_write(REG_SLIMR, v); }
-void set_slirclr(uint8_t v) { reg_write(REG_SLIRCLR, v); }
-void set_shar(uint8_t* v) { reg_write_buf(REG_SHAR, v, 6); }
-void get_shar(uint8_t* v) { reg_read_buf(REG_SHAR, v, 6); }
-void set_gar(uint8_t* v) { reg_write_buf(REG_GAR, v, 4); }
-void get_gar(uint8_t* v) { reg_read_buf(REG_GAR, v, 4); }
-void set_subr(uint8_t* v) { reg_write_buf(REG_SUBR, v, 4); }
-void get_subr(uint8_t* v) { reg_read_buf(REG_SUBR, v, 4); }
-void set_sipr(uint8_t* v) { reg_write_buf(REG_SIPR, v, 4); }
-void get_sipr(uint8_t* v) { reg_read_buf(REG_SIPR, v, 4); }
-void set_llar(uint8_t* v) { reg_write_buf(REG_LLAR, v, 16); }
-void get_llar(uint8_t* v) { reg_read_buf(REG_LLAR, v, 16); }
-void set_guar(uint8_t* v) { reg_write_buf(REG_GUAR, v, 16); }
-void get_guar(uint8_t* v) { reg_read_buf(REG_GUAR, v, 16); }
-void set_sub6r(uint8_t* v) { reg_write_buf(REG_SUB6R, v, 16); }
-void get_sub6r(uint8_t* v) { reg_read_buf(REG_SUB6R, v, 16); }
-void set_ga6r(uint8_t* v) { reg_write_buf(REG_GA6R, v, 16); }
-void get_ga6r(uint8_t* v) { reg_read_buf(REG_GA6R, v, 16); }
-void set_chplckr(uint8_t v) { reg_write(REG_CHPLCKR, v); }
-void chip_lock() { set_chplckr(0xFF); }
-void chip_unlock() { set_chplckr(0xCE); }
-void set_netlckr(uint8_t v) { reg_write(REG_NETLCKR, v); }
-void net_lock() { set_netlckr(0xC5); }
-void net_unlock() { set_netlckr(0x3A); }
-
-void set_sn_mr(uint8_t sn, uint8_t v) { reg_write(REG_SN_MR(sn), v); }
-void set_sn_cr(uint8_t sn, uint8_t v) { reg_write(REG_SN_CR(sn), v); }
-uint8_t get_sn_cr(uint8_t sn) { return reg_read(REG_SN_CR(sn)); }
-uint8_t get_sn_ir(uint8_t sn) { return reg_read(REG_SN_IR(sn)); }
-void set_sn_irclr(uint8_t sn, uint8_t v) { reg_write(REG_SN_IRCLR(sn), v); }
-void set_sn_ir(uint8_t sn, uint8_t v) { set_sn_irclr(sn, v); }
-uint8_t get_sn_sr(uint8_t sn) { return reg_read(REG_SN_SR(sn)); }
-void set_sn_mr2(uint8_t sn, uint8_t v) { reg_write(REG_SN_MR2(sn), v); }
-void set_sn_tx_bsr(uint8_t sn, uint8_t v) { reg_write(REG_SN_TX_BSR(sn), v); }
-void set_sn_txbuf_size(uint8_t sn, uint8_t v) { set_sn_tx_bsr(sn, v); }
-uint8_t get_sn_tx_bsr(uint8_t sn) { return reg_read(REG_SN_TX_BSR(sn)); }
-uint16_t get_sn_tx_max(uint8_t sn) { return get_sn_tx_bsr(sn) << 10; }
-uint16_t get_sn_tx_wr(uint8_t sn) { return ((uint16_t)reg_read(REG_SN_TX_WR(sn)) << 8) + reg_read(offset_inc(REG_SN_TX_WR(sn), 1)); }
-void set_sn_tx_wr(uint8_t sn, uint16_t v) {
-    reg_write(REG_SN_TX_WR(sn), (uint8_t)(v >> 8));
-    reg_write(offset_inc(REG_SN_TX_WR(sn), 1), (uint8_t)v);
-}
-void set_sn_rx_bsr(uint8_t sn, uint8_t v) { reg_write(REG_SN_RX_BSR(sn), v); }
-void set_sn_rxbuf_size(uint8_t sn, uint8_t v) { set_sn_rx_bsr(sn, v); }
-void set_sn_rx_rd(uint8_t sn, uint16_t v) {
-    reg_write(REG_SN_RX_RD(sn), (uint8_t)(v >> 8));
-    reg_write(offset_inc(REG_SN_RX_RD(sn), 1), (uint8_t)v);
-}
-uint16_t get_sn_rx_rd(uint8_t sn) { return ((uint16_t)reg_read(REG_SN_RX_RD(sn)) << 8) + reg_read(offset_inc(REG_SN_RX_RD(sn), 1)); }
-static uint8_t make_opcode(uint32_t addr, uint8_t rw) {
-    return static_cast<uint8_t>((addr & 0xFF) | rw | QSPI_MODE);
-}
-
-static uint16_t make_addr(uint32_t addr) {
-    return static_cast<uint16_t>((addr & 0x00FFFF00) >> 8);
-}
-
-void reg_write(uint32_t addr_sel, uint8_t wb) {
-    pio_frame_start();
-    pio_write(make_opcode(addr_sel, SPI_WRITE), make_addr(addr_sel), &wb, 1);
-    pio_frame_end();
-}
-
-uint8_t reg_read(uint32_t addr_sel) {
-    uint8_t ret[2] = {0};
-    pio_frame_start();
-    pio_read(make_opcode(addr_sel, SPI_READ), make_addr(addr_sel), ret, 1);
-    pio_frame_end();
-    return ret[0];
-}
-
-void reg_write_buf(uint32_t addr_sel, uint8_t* buf, datasize_t len) {
-    pio_frame_start();
-    pio_write(make_opcode(addr_sel, SPI_WRITE), make_addr(addr_sel), buf, len);
-    pio_frame_end();
-}
-
-void reg_read_buf(uint32_t addr_sel, uint8_t* buf, datasize_t len) {
-    pio_frame_start();
-    pio_read(make_opcode(addr_sel, SPI_READ), make_addr(addr_sel), buf, len);
-    pio_frame_end();
-}
-
-uint16_t get_sn_tx_fsr(uint8_t sn) {
-    uint16_t prev_val = -1, val = 0;
-    do {
-        prev_val = val;
-        val = reg_read(REG_SN_TX_FSR(sn));
-        val = (val << 8) + reg_read(offset_inc(REG_SN_TX_FSR(sn), 1));
-    } while (val != prev_val);
-    return val;
-}
-
-uint16_t get_sn_rx_rsr(uint8_t sn) {
-    uint16_t prev_val = -1, val = 0;
-    do {
-        prev_val = val;
-        val = reg_read(REG_SN_RX_RSR(sn));
-        val = (val << 8) + reg_read(offset_inc(REG_SN_RX_RSR(sn), 1));
-    } while (val != prev_val);
-    return val;
-}
-
-void send_data(uint8_t sn, uint8_t *data, uint16_t len) {
-    uint16_t ptr = get_sn_tx_wr(sn);
-    uint32_t addrsel = ((uint32_t)ptr << 8) + TXBUF_BLOCK(sn);
-    reg_write_buf(addrsel, data, len);
-    ptr += len;
-    set_sn_tx_wr(sn, ptr);
-}
-
-void recv_data(uint8_t sn, uint8_t *data, uint16_t len) {
-    if (len == 0) return;
-    uint16_t ptr = get_sn_rx_rd(sn);
-    uint32_t addrsel = ((uint32_t)ptr << 8) + RXBUF_BLOCK(sn);
-    reg_read_buf(addrsel, data, len);
-    ptr += len;
-    set_sn_rx_rd(sn, ptr);
-}
-
-void soft_reset() {
-    uint8_t gw[4], sn[4], sip[4], mac[6];
-    uint8_t gw6[16], sn6[16], lla[16], gua[16];
-    uint8_t islock = get_sysr();
-
-    chip_unlock();
-    get_shar(mac); get_gar(gw); get_subr(sn); get_sipr(sip);
-    get_ga6r(gw6); get_sub6r(sn6); get_llar(lla); get_guar(gua);
-    set_sycr0(SYCR0_RST);
-    get_sycr0();
-
-    net_unlock();
-    set_shar(mac); set_gar(gw); set_subr(sn); set_sipr(sip);
-    set_ga6r(gw6); set_sub6r(sn6); set_llar(lla); set_guar(gua);
-
-    if (islock & SYSR_CHPL) chip_lock();
-    if (islock & SYSR_NETL) net_lock();
-}
-
-int8_t init_buffers(std::span<const uint8_t> txsize, std::span<const uint8_t> rxsize) {
-    soft_reset();
-    if (!txsize.empty()) {
-        int8_t tmp = 0;
-        for (int i = 0; i < sock_count; i++) {
-            tmp += txsize[i];
-            if (tmp > 32) return -1;
-        }
-        for (int i = 0; i < sock_count; i++) set_sn_txbuf_size(i, txsize[i]);
-    }
-    if (!rxsize.empty()) {
-        int8_t tmp = 0;
-        for (int i = 0; i < sock_count; i++) {
-            tmp += rxsize[i];
-            if (tmp > 32) return -1;
-        }
-        for (int i = 0; i < sock_count; i++) set_sn_rxbuf_size(i, rxsize[i]);
-    }
-    return 0;
-}
-
-uint16_t sock_is_sending = 0;
-uint16_t sock_remained_size[sock_count] = {0,};
-uint8_t sock_pack_info[sock_count] = {0,};
-
-#define FAIL(e) return std::unexpected(sock_error::e)
-#define CHECK_SOCKNUM()   do { if(sn >= sock_count) FAIL(sock_num); } while(0)
-#define CHECK_SOCKDATA()  do { if(len == 0) FAIL(data_len); } while(0)
-
-std::expected<void, sock_error> close(socket_id sid) {
-    uint8_t sn = static_cast<uint8_t>(sid);
-    CHECK_SOCKNUM();
-    set_sn_cr(sn, SN_CR_CLOSE);
-    while (get_sn_cr(sn));
-    set_sn_ir(sn, 0xFF);
-    sock_is_sending &= ~(1 << sn);
-    sock_remained_size[sn] = 0;
-    sock_pack_info[sn] = PACK_NONE;
-    while (get_sn_sr(sn) != SOCK_CLOSED);
-    return {};
-}
-
-} // namespace
-
-volatile bool irq_pending = false;
-
-void clear_interrupt(intr_kind intr) {
-    set_irclr((uint8_t)intr);
-    uint8_t sir = (uint8_t)((uint16_t)intr >> 8);
-    for (int i = 0; i < sock_count; i++)
-        if (sir & (1 << i)) set_sn_irclr(i, 0xFF);
-    set_slirclr((uint8_t)((uint32_t)intr >> 16));
-}
-
-void set_interrupt_mask(intr_kind intr) {
-    set_imr((uint8_t)intr);
-    set_simr((uint8_t)((uint16_t)intr >> 8));
-    set_slimr((uint8_t)((uint32_t)intr >> 16));
-}
-
-
-std::expected<socket_id, sock_error> open_socket(socket_id sid, protocol proto, sock_flag flag) {
-    uint8_t sn = static_cast<uint8_t>(sid);
-    uint8_t pr = static_cast<uint8_t>(proto);
-    uint8_t fl = static_cast<uint8_t>(flag);
-    CHECK_SOCKNUM();
-    if ((pr & 0x0F) != SN_MR_MACRAW) FAIL(sock_mode);
-    close(sid);
-    set_sn_mr(sn, (pr | (fl & 0xF0)));
-    set_sn_mr2(sn, fl & 0x03);
-    set_sn_cr(sn, SN_CR_OPEN);
-    while (get_sn_cr(sn));
-    sock_is_sending &= ~(1 << sn);
-    sock_remained_size[sn] = 0;
-    sock_pack_info[sn] = PACK_COMPLETED;
-    while (get_sn_sr(sn) == SOCK_CLOSED);
-    return sid;
-}
-
-std::expected<uint16_t, sock_error> send(socket_id sid, std::span<const uint8_t> buf) {
-    uint8_t sn = static_cast<uint8_t>(sid);
-    uint16_t len = buf.size();
-    uint8_t tmp = 0;
-    uint16_t freesize = 0;
-
-    CHECK_SOCKNUM();
-
-    freesize = get_sn_tx_max(sn);
-    if (len > freesize) len = freesize;
-    while (1) {
-        freesize = get_sn_tx_fsr(sn);
-        if (get_sn_sr(sn) == SOCK_CLOSED) FAIL(sock_closed);
-        if (len <= freesize) break;
-    };
-    send_data(sn, const_cast<uint8_t*>(buf.data()), len);
-    set_sn_cr(sn, SN_CR_SEND);
-    while (get_sn_cr(sn));
-    while (1) {
-        tmp = get_sn_ir(sn);
-        if (tmp & SN_IR_SENDOK) {
-            set_sn_ir(sn, SN_IR_SENDOK);
-            break;
-        } else if (tmp & SN_IR_TIMEOUT) {
-            set_sn_ir(sn, SN_IR_TIMEOUT);
-            FAIL(timeout);
-        }
-    }
-    return len;
-}
-
-std::expected<uint16_t, sock_error> recv(socket_id sid, std::span<uint8_t> buf) {
-    uint8_t sn = static_cast<uint8_t>(sid);
-    uint16_t len = buf.size();
-    uint8_t head[2];
-    uint16_t pack_len = 0;
-
-    CHECK_SOCKNUM();
-    CHECK_SOCKDATA();
-
-    if (sock_remained_size[sn] == 0) {
-        while (1) {
-            pack_len = get_sn_rx_rsr(sn);
-            if (get_sn_sr(sn) == SOCK_CLOSED) FAIL(sock_closed);
-            if (pack_len != 0) {
-                sock_pack_info[sn] = PACK_NONE;
-                break;
-            }
-        };
-    }
-
-    recv_data(sn, head, 2);
-    set_sn_cr(sn, SN_CR_RECV);
-    while (get_sn_cr(sn));
-
-    if (sock_remained_size[sn] == 0) {
-        sock_remained_size[sn] = head[0];
-        sock_remained_size[sn] = (sock_remained_size[sn] << 8) + head[1] - 2;
-        if (sock_remained_size[sn] > 1514) {
-            close(sid);
-            FAIL(fatal_packlen);
-        }
-        sock_pack_info[sn] = PACK_FIRST;
-    }
-    if (len < sock_remained_size[sn]) pack_len = len;
-    else pack_len = sock_remained_size[sn];
-    recv_data(sn, buf.data(), pack_len);
-
-    sock_remained_size[sn] = pack_len;
-    sock_pack_info[sn] |= PACK_FIRST;
-
-    if (len < sock_remained_size[sn]) pack_len = len;
-    else pack_len = sock_remained_size[sn];
-    recv_data(sn, buf.data(), pack_len);
-    set_sn_cr(sn, SN_CR_RECV);
-    while (get_sn_cr(sn));
-
-    sock_remained_size[sn] -= pack_len;
-    if (sock_remained_size[sn] != 0) sock_pack_info[sn] |= PACK_REMAINED;
-    else sock_pack_info[sn] |= PACK_COMPLETED;
-
-    return pack_len;
-}
-
-
-void reset() {
-    gpio_init(PIN_RST);
-    gpio_set_dir(PIN_RST, GPIO_OUT);
-    gpio_put(PIN_RST, 0);
-    sleep_ms(100);
-    gpio_put(PIN_RST, 1);
-    sleep_ms(100);
-}
-
-void init_spi() {
-    pio_init();
-}
-
-void init() {
-    pio_frame_end();
-    std::array<uint8_t, 8> txsize = {4, 4, 4, 4, 4, 4, 4, 4};
-    std::array<uint8_t, 8> rxsize = {4, 4, 4, 4, 4, 4, 4, 4};
-    init_buffers(txsize, rxsize);
-}
-
-bool check() {
-    return get_cidr() == 0x6300;
-}
-
-
-
-uint16_t get_socket_recv_buf(socket_id sid) {
-    return get_sn_rx_rsr(static_cast<uint8_t>(sid));
-}
-
-} // namespace w6300
@@ -1,51 +0,0 @@
-#pragma once
-#include <array>
-#include <cstdint>
-#include <expected>
-#include <span>
-
-namespace w6300 {
-
-enum class socket_id : uint8_t {};
-
-enum class sock_error : int16_t {
-    busy           =     0,
-    sock_num       =    -1,
-    sock_closed    =    -4,
-    sock_mode      =    -5,
-    arg            =   -10,
-    timeout        =   -13,
-    data_len       =   -14,
-    fatal_packlen  = -1001,
-};
-
-enum class protocol : uint8_t {
-    macraw    = 0x07,
-};
-
-enum class sock_flag : uint8_t {
-    none            = 0,
-};
-
-enum intr_kind : uint32_t {
-    ik_sock_0 = (1 << 8),
-    ik_int_all = 0x00FFFF97
-};
-
-void init_spi();
-void reset();
-void init();
-bool check();
-
-extern volatile bool irq_pending;
-
-void clear_interrupt(intr_kind intr);
-void set_interrupt_mask(intr_kind intr);
-
-std::expected<socket_id, sock_error> open_socket(socket_id sn, protocol proto, sock_flag flag);
-std::expected<uint16_t, sock_error> send(socket_id sn, std::span<const uint8_t> buf);
-std::expected<uint16_t, sock_error> recv(socket_id sn, std::span<uint8_t> buf);
-
-uint16_t get_socket_recv_buf(socket_id sn);
-
-} // namespace w6300
@@ -2,9 +2,4 @@ module github.com/theater/picomap

 go 1.25.0

-require go.bug.st/serial v1.6.4
-
-require (
-	github.com/creack/goselect v0.1.2 // indirect
-	golang.org/x/sys v0.19.0 // indirect
-)
+require golang.org/x/sys v0.19.0
@@ -1,14 +1,2 @@
-github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0=
-github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-go.bug.st/serial v1.6.4 h1:7FmqNPgVp3pu2Jz5PoPtbZ9jJO5gnEnZIvnI1lzve8A=
-go.bug.st/serial v1.6.4/go.mod h1:nofMJxTeNVny/m6+KaafC6vJGj3miwQZ6vW4BZUGJPI=
 golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
 golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -75,7 +75,7 @@ func roundTrip[T any](c *Client, req any) ([]Response[T], error) {
 		}
 		var inner any
 		if err := msgpack.Unmarshal(env.Payload, &inner); err != nil {
-			continue
+			return nil, fmt.Errorf("decode response: %w", err)
 		}
 		if devErr, ok := inner.(*DeviceError); ok {
 			return nil, devErr
@@ -100,11 +100,6 @@ func first[T any](results []Response[T], err error) (*T, error) {
 	return results[0].Value, nil
 }

-func (c *Client) PICOBOOT() error {
-	_, err := first(roundTrip[ResponsePICOBOOT](c, &RequestPICOBOOT{}))
-	return err
-}
-
 func (c *Client) Info() (*ResponseInfo, error) {
 	return first(roundTrip[ResponseInfo](c, &RequestInfo{}))
 }
@@ -117,6 +112,29 @@ func (c *Client) Log() (*ResponseLog, error) {
 	return first(roundTrip[ResponseLog](c, &RequestLog{}))
 }

+func (c *Client) FlashErase(addr, length uint32) error {
+	_, err := first(roundTrip[ResponseFlashErase](c, &RequestFlashErase{Addr: addr, Len: length}))
+	return err
+}
+
+func (c *Client) FlashWrite(addr uint32, data []byte) error {
+	_, err := first(roundTrip[ResponseFlashWrite](c, &RequestFlashWrite{Addr: addr, Data: data}))
+	return err
+}
+
+func (c *Client) Reboot() error {
+	_, err := first(roundTrip[ResponseReboot](c, &RequestReboot{}))
+	return err
+}
+
+func (c *Client) FlashStatus() (*ResponseFlashStatus, error) {
+	return first(roundTrip[ResponseFlashStatus](c, &RequestFlashStatus{}))
+}
+
+func (c *Client) ListTests() (*ResponseListTests, error) {
+	return first(roundTrip[ResponseListTests](c, &RequestListTests{}))
+}
+
 func (c *Client) Test(name string) (*ResponseTest, error) {
 	return first(roundTrip[ResponseTest](c, &RequestTest{Name: name}))
 }
@@ -1,75 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"slices"
-	"strings"
-	"time"
-
-	"github.com/theater/picomap/lib/msgpack"
-	"go.bug.st/serial"
-	"go.bug.st/serial/enumerator"
-)
-
-func ListSerial() ([]string, error) {
-	ports, err := enumerator.GetDetailedPortsList()
-	if err != nil {
-		return nil, fmt.Errorf("enumerating ports: %w", err)
-	}
-	type entry struct {
-		name   string
-		serial string
-	}
-	var entries []entry
-	for _, p := range ports {
-		if p.IsUSB && p.VID == "2E8A" && strings.HasPrefix(p.Name, "/dev/cu.") {
-			entries = append(entries, entry{p.Name, p.SerialNumber})
-		}
-	}
-	slices.SortFunc(entries, func(a, b entry) int {
-		return strings.Compare(a.serial, b.serial)
-	})
-	var result []string
-	for _, e := range entries {
-		result = append(result, e.name)
-	}
-	return result, nil
-}
-
-type serialTransport struct {
-	port     serial.Port
-	portName string
-	dec      *msgpack.Decoder
-}
-
-func NewSerial(portName string, timeout time.Duration) (*Client, error) {
-	port, err := serial.Open(portName, &serial.Mode{BaudRate: 115200})
-	if err != nil {
-		return nil, fmt.Errorf("opening %s: %w", portName, err)
-	}
-	t := &serialTransport{port: port, portName: portName, dec: msgpack.NewDecoder(port)}
-	return &Client{transport: t, timeout: timeout}, nil
-}
-
-func (t *serialTransport) Send(data []byte) error {
-	_, err := t.port.Write(data)
-	return err
-}
-
-func (t *serialTransport) SetReadTimeout(timeout time.Duration) {
-	t.port.SetReadTimeout(timeout)
-}
-
-func (t *serialTransport) Recv() ([]byte, string, error) {
-	var raw msgpack.RawMessage
-	if err := t.dec.Decode(&raw); err != nil {
-		return nil, "", err
-	}
-	return []byte(raw), t.portName, nil
-}
-
-func (t *serialTransport) Broadcast() bool { return false }
-
-func (t *serialTransport) Close() error {
-	return t.port.Close()
-}
@@ -2,15 +2,35 @@ package client

 import "github.com/theater/picomap/lib/msgpack"

-type RequestPICOBOOT struct{}
-type ResponsePICOBOOT struct{}
-
 type RequestInfo struct{}
+type BootReason uint8
+
+const (
+	BootCold     BootReason = 0
+	BootReboot   BootReason = 1
+	BootWatchdog BootReason = 2
+)
+
+func (b BootReason) String() string {
+	switch b {
+	case BootCold:
+		return "cold"
+	case BootReboot:
+		return "reboot"
+	case BootWatchdog:
+		return "watchdog"
+	default:
+		return "unknown"
+	}
+}
+
 type ResponseInfo struct {
 	BoardID      [8]byte
 	MAC          [6]byte
 	IP           [4]byte
 	FirmwareName string
+	Boot         BootReason
+	BuildEpoch   uint32
 }

 type RequestLog struct{}
@@ -24,6 +44,40 @@ type ResponseLog struct {
 	Entries []LogEntry
 }

+type RequestFlashErase struct {
+	Addr uint32
+	Len  uint32
+}
+type ResponseFlashErase struct{}
+
+type RequestFlashWrite struct {
+	Addr uint32
+	Data []byte
+}
+type ResponseFlashWrite struct{}
+
+type RequestReboot struct{}
+type ResponseReboot struct{}
+
+type RequestFlashStatus struct{}
+
+type SlotInfo struct {
+	Valid   bool
+	Version uint32
+	HashOK  bool
+}
+
+type ResponseFlashStatus struct {
+	BootPartition int8
+	SlotA         SlotInfo
+	SlotB         SlotInfo
+}
+
+type RequestListTests struct{}
+type ResponseListTests struct {
+	Names []string
+}
+
 type RequestTest struct {
 	Name string
 }
@@ -51,12 +105,20 @@ type Envelope struct {
 func init() {
 	msgpack.RegisterExt(0, (*Envelope)(nil))
 	msgpack.RegisterExt(1, (*DeviceError)(nil))
-	msgpack.RegisterExt(2, (*RequestPICOBOOT)(nil))
-	msgpack.RegisterExt(3, (*ResponsePICOBOOT)(nil))
 	msgpack.RegisterExt(4, (*RequestInfo)(nil))
 	msgpack.RegisterExt(5, (*ResponseInfo)(nil))
 	msgpack.RegisterExt(6, (*RequestLog)(nil))
 	msgpack.RegisterExt(7, (*ResponseLog)(nil))
+	msgpack.RegisterExt(8, (*RequestFlashErase)(nil))
+	msgpack.RegisterExt(9, (*ResponseFlashErase)(nil))
+	msgpack.RegisterExt(10, (*RequestFlashWrite)(nil))
+	msgpack.RegisterExt(11, (*ResponseFlashWrite)(nil))
+	msgpack.RegisterExt(12, (*RequestReboot)(nil))
+	msgpack.RegisterExt(13, (*ResponseReboot)(nil))
+	msgpack.RegisterExt(14, (*RequestFlashStatus)(nil))
+	msgpack.RegisterExt(15, (*ResponseFlashStatus)(nil))
+	msgpack.RegisterExt(125, (*RequestListTests)(nil))
+	msgpack.RegisterExt(124, (*ResponseListTests)(nil))
 	msgpack.RegisterExt(127, (*RequestTest)(nil))
 	msgpack.RegisterExt(126, (*ResponseTest)(nil))
 }
@@ -1,32 +0,0 @@
-package picotool
-
-import (
-	"fmt"
-	"os/exec"
-	"time"
-)
-
-func Load(uf2Path string, serial string, timeout time.Duration) error {
-	deadline := time.Now().Add(timeout)
-	var out []byte
-	var err error
-	for {
-		cmd := exec.Command("picotool", "load", uf2Path, "-x", "--ser", serial)
-		out, err = cmd.CombinedOutput()
-		if err == nil {
-			return nil
-		}
-		if time.Now().After(deadline) {
-			return fmt.Errorf("picotool load: %w\n%s", err, out)
-		}
-	}
-}
-
-func Reboot(serial string) error {
-	cmd := exec.Command("picotool", "reboot", "--ser", serial)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("picotool reboot: %w\n%s", err, out)
-	}
-	return nil
-}
@@ -0,0 +1,71 @@
+package uf2
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"sort"
+)
+
+const (
+	blockSize = 512
+	magic0    = 0x0A324655
+	magic1    = 0x9E5D5157
+	magicEnd  = 0x0AB16F30
+
+	flagNotMainFlash       = 0x00000001
+	flagFamilyIDPresent    = 0x00002000
+	absoluteFamilyID       = 0xe48bff57
+)
+
+type Block struct {
+	Addr uint32
+	Data []byte
+}
+
+func Parse(path string) ([]Block, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	if len(data)%blockSize != 0 {
+		return nil, fmt.Errorf("file size %d not multiple of %d", len(data), blockSize)
+	}
+
+	var blocks []Block
+	for i := 0; i < len(data); i += blockSize {
+		b := data[i : i+blockSize]
+		m0 := binary.LittleEndian.Uint32(b[0:4])
+		m1 := binary.LittleEndian.Uint32(b[4:8])
+		me := binary.LittleEndian.Uint32(b[508:512])
+		if m0 != magic0 || m1 != magic1 || me != magicEnd {
+			return nil, fmt.Errorf("block %d: bad magic", i/blockSize)
+		}
+		flags := binary.LittleEndian.Uint32(b[8:12])
+		if flags&flagNotMainFlash != 0 {
+			continue
+		}
+		if flags&flagFamilyIDPresent != 0 {
+			familyID := binary.LittleEndian.Uint32(b[28:32])
+			if familyID == absoluteFamilyID {
+				continue
+			}
+		}
+		addr := binary.LittleEndian.Uint32(b[12:16])
+		size := binary.LittleEndian.Uint32(b[16:20])
+		if size > 256 {
+			return nil, fmt.Errorf("block %d: data size %d > 256", i/blockSize, size)
+		}
+		blocks = append(blocks, Block{
+			Addr: addr,
+			Data: make([]byte, size),
+		})
+		copy(blocks[len(blocks)-1].Data, b[32:32+size])
+	}
+
+	sort.Slice(blocks, func(i, j int) bool {
+		return blocks[i].Addr < blocks[j].Addr
+	})
+
+	return blocks, nil
+}
Author	SHA1	Message	Date
Ian Gulliver	5bad374129	limen: extract udp into its own static library	2026-05-01 13:52:30 -07:00
Ian Gulliver	f1bc6381db	limen: extract igmp into its own static library	2026-05-01 13:47:41 -07:00
Ian Gulliver	22ead50a00	limen: extract icmp; convert constructor-based self-registration to explicit init()	2026-05-01 13:44:54 -07:00
Ian Gulliver	f8b258f92e	limen: extract arp into its own static library	2026-05-01 13:35:42 -07:00
Ian Gulliver	b29dd149e3	limen: extract ipv4 into its own static library	2026-05-01 13:23:12 -07:00
Ian Gulliver	fc0c948b23	limen: merge net+eth into eth lib; ipv4 owns its IP	2026-05-01 11:03:17 -07:00
Ian Gulliver	6505aec466	limen: move remaining util headers into util/	2026-05-01 10:50:16 -07:00
Ian Gulliver	2eb11398c6	limen: move ring_buffer into util	2026-05-01 10:48:18 -07:00
Ian Gulliver	b6ac9dce59	limen: header doc comments on util data structures	2026-05-01 10:47:09 -07:00
Ian Gulliver	57313f836c	limen: extract msgpack and util libs; split msgpack header/cpp	2026-05-01 10:43:38 -07:00
Ian Gulliver	94afcf39e7	limen: extract debug_log into its own static library	2026-05-01 10:33:48 -07:00
Ian Gulliver	e89e72ca59	limen: net::/ipv4:: namespace, mac/addr filter framework, registry overflow logging	2026-05-01 10:16:07 -07:00
Ian Gulliver	c4335a0737	limen: split w6300 into its own static library to enforce layer isolation	2026-04-30 23:14:50 -07:00
Ian Gulliver	7b8dd66185	move w6300/dispatch/net stack to limen submodule	2026-04-19 17:38:29 -07:00
Ian Gulliver	4db5c36931	Self-registering IP-protocol and UDP-port dispatch; move picomap-specific constants out of generic net/dispatch layers	2026-04-19 08:39:13 -07:00
Ian Gulliver	7e493b7d70	Ethertype handler registry: arp/ipv4 self-register via __attribute__((constructor)), drop threaded mac/ip/subnet params	2026-04-19 08:26:57 -07:00
Ian Gulliver	59829b569e	Strip over-commenting in test_handlers.cpp	2026-04-19 08:13:16 -07:00
Ian Gulliver	32044a5cbd	Eliminate std::function: fn-pointer callbacks, per-test test_state structs, udp.cpp with link-time udp::client::handler, udp::address	2026-04-19 00:32:13 -07:00
Ian Gulliver	40f7fb5941	Drop handle_udp parameter threading: ipv4::handle calls net_handle_udp directly	2026-04-17 14:55:09 -07:00
Ian Gulliver	e2daf04bed	Drop send_raw parameter threading: arp/icmp/igmp/ipv4 call net_send_raw directly	2026-04-17 14:35:10 -07:00
Ian Gulliver	cdc113285a	Remove USB/serial support: network-only protocol, drop tinyusb and PICOBOOT	2026-04-17 11:20:57 -07:00
Ian Gulliver	23587c41e2	SHA-256 hash verification of flash slots, pico_hash_binary, flash:: namespace, ring_buffer iterator, non-destructive log	2026-04-12 23:47:00 +09:00
Ian Gulliver	cc37b711a4	Return error on inner decode failure instead of hanging, split flash-status output	2026-04-12 22:27:21 +09:00
Ian Gulliver	11c101c235	Flash status: scan PICOBIN blocks for per-slot validity and version	2026-04-12 22:22:54 +09:00
Ian Gulliver	819632a7ea	Fix A/B partition link: B partition declares its A partner, not vice versa	2026-04-12 21:54:57 +09:00
Ian Gulliver	8da5ff9886	A/B partition table, embed in both firmware targets	2026-04-12 21:47:12 +09:00
Ian Gulliver	a41ee70a3c	Build epoch in info, flash-status command, cmake version embedding	2026-04-12 09:02:31 +09:00
Ian Gulliver	21c7900444	Watchdog timer, boot reason tracking, net_poll frame limit, reboot/picoboot CLI commands	2026-04-12 08:27:21 +09:00
Ian Gulliver	6c3e0757f9	Boot reason via watchdog scratch register, reboot/picoboot CLI commands, enum msgpack support	2026-04-12 08:17:22 +09:00
Ian Gulliver	9b7362c460	Rename ping_rate/ping_rate_1k to packet_rate/byte_rate, use 1400-byte payloads	2026-04-12 07:55:30 +09:00
Ian Gulliver	761b740c10	Zero-copy ethernet TX: encode directly into prepend_buffer, add info/test skills	2026-04-12 07:50:20 +09:00
Ian Gulliver	846d6bb201	Clean up load logging, capture build output via slog, use cmake --build	2026-04-11 22:38:16 +09:00
Ian Gulliver	5f2268f5e1	Unified --usb/--udp/--iface target flags for all CLI commands	2026-04-11 22:33:55 +09:00
Ian Gulliver	e3d97f4946	In-app flash write, UF2 parser, remove picotool dependency, reboot command	2026-04-11 22:26:54 +09:00
Ian Gulliver	a635aa04e0	Level-triggered w6300 interrupt, drain until empty, rearm after drain	2026-04-11 21:51:22 +09:00
Ian Gulliver	8b69917e1d	Biffer buffers, more aggressive tests	2026-04-11 21:32:50 +09:00
Ian Gulliver	59d67c740c	Replace net_poll budget with snapshot-based drain: read available bytes once, stop when consumed	2026-04-11 20:51:42 +09:00
Ian Gulliver	ecc8271648	Remove unused sorted_list	2026-04-11 20:45:04 +09:00
Ian Gulliver	1c8c645878	Clean up callback_list, remove sentinel/active/tail, callbacks return bool for removal, register before send	2026-04-11 15:01:37 +09:00
Ian Gulliver	938b4b8a4c	Limit net_poll to 2 frames per iteration, pipeline=2 for both rate tests	2026-04-11 14:36:40 +09:00
Ian Gulliver	fec0a0f765	Replace sorted_list/vector with callback_list doubly-linked list for timers and frame callbacks	2026-04-11 14:26:53 +09:00
Ian Gulliver	aa349e1a36	Add debug logging to overflow/error paths, fix pipeline=2 drop	2026-04-11 09:48:25 +09:00
Ian Gulliver	f7baf60249	Pipeline ping rate tests, small=1 large=2 in-flight	2026-04-11 09:29:34 +09:00
Ian Gulliver	1843660e6f	Add ping rate tests, discover_peer helper, standardize prepend_buffer to 4096	2026-04-11 09:17:46 +09:00
Ian Gulliver	a6225faa2b	Add IGMP, prepend_buffer/parse_buffer, split UDP header, discovery tests, test all	2026-04-11 09:04:55 +09:00
Ian Gulliver	e486f6501a	Cancellable timers: sorted_list::remove, timer cancel, replace done flag with timer cancellation	2026-04-11 08:28:32 +09:00
Ian Gulliver	3a3c5873c3	Add dlogf printf formatting, ipv4::to_string helper, clean up string building	2026-04-11 08:21:59 +09:00
Ian Gulliver	c35c1de76a	Split net stack into eth/arp/ipv4/icmp, deferred handler responses, ping tests	2026-04-11 08:15:41 +09:00
Ian Gulliver	34efaeefd5	Add list-tests protocol message, test subcommands, extract test handlers	2026-04-11 07:25:16 +09:00
Ian Gulliver	f6d8847bcf	Fix packer: store span_writer by reference, not copy	2026-04-10 23:23:58 +09:00
Ian Gulliver	7264611f99	Zero-copy decode: span-based Envelope and DecodedMessage, defer usb_rx_buf clear	2026-04-10 23:08:51 +09:00
Ian Gulliver	76c519c17a	Overflow detection, span-based signatures, flatten control flow	2026-04-10 23:02:07 +09:00
Ian Gulliver	8408603390	Zero-copy encode: pack response body in place, single shared tx_buf, drain rx loop	2026-04-10 22:48:28 +09:00
Ian Gulliver	58db392bf3	Simplify handler signatures: return response struct, typed_handler does encoding	2026-04-10 22:21:31 +09:00
Ian Gulliver	e2a5d97dae	Zero-copy TX: span_writer packer, static buffers, no vector returns	2026-04-10 22:18:44 +09:00
Ian Gulliver	94895fd2fe	Move picoboot reboot into handler via dispatch_schedule_ms	2026-04-10 22:04:38 +09:00