Research
What was looked at before acting: the question, what was found, and what it rests on.
Where does orchestration's work stand, for a fresh orchestration session to take it up without this session's long context?
ROLE: orchestrator (brief ideal-agent-linux-phone-oco/orchestration.md). This session (orchestration-lpoco-roof) ran 2026-11-17 evening to 2026-11-18 morning; it hands over at its size. DONE, each landed and read back from main: - The lpoco roof (decision 2026-11-17-bringup-in-lab-tools): dispatcher (lab-tools #83), bringup image v0 (#85), rename to lpoco-lab/lpoco-tone with the old names kept as second [[bin]] (#86), one MCP door (#87), pin and hooks (#88), install from tag (#90). - lpoco host (decision 2026-11-17-lpoco-host, amended: 51-android.rules kept): #91, --help (#93), script tools by rev stamp (#95), reads device.toml from origin/main (#108). lab.toml in grenudi/lab-machine (#36, pins in #37-#43). - Then: lpoco-lab argenv (#98) and env through the contract (#103); tone argenv (#101); names sweep (lab-tools #99, #100, #104; docs #400; device-template #12; surya-lab #166; google-walleye-lab #100); suspend-irq-quiet check (#106, the surya lane's item); bringup image swap (#110), initramfs (#114), bisect (#123). - Releases: the family is one version. Changelog-only releases and the release loop are fixed (#112, #116, #119), and one release PR writes every changelog (#121). Proven live: v0.3.8 #122 and v0.4.0 #124, main green, no follow-up. - The lab: lpoco host prepare now installed the family at 0.3.8, land at 66a3144 and agent-env with rev stamps; devlab-watch@surya-lab was restarted in surya's window; lpoco host check has no FAIL. Rollback copies: ~/.local/bin/devlab-0.1.0, devlab-0.2.1, devlab-0.2.2, land-7e740e2. - land (lab-machine): refuses to run traced (#35), and every stop says why, with a rebased change branch pushed with a lease (#41). - docs: lane queries retired (decision 2026-11-17-docs-serves-no-lane); waits naming items became blocked_by; backlog-status and backlog-needs refuse a write that matches no item (sign status-write-matched-no-row); briefs in head form (patrol.md, builder.md, phone-keeper.md with walleye folded in, feature-research.md; #389); surya's watchdog in phone-keeper.md; the patrol's stored prompt rewritten (no ocoeco, read-only, signs to the owning base, reports to the Top Coordinator). HOW THE LINE RUNS: the coordinator's stored task lab-tools-builder takes the open lab-tools row with needs=build, its blocked_by done, lowest rank then oldest; it builds test-first, lands, records and reports. Rank the rows, run_scheduled_task, read each landing back from main, then land --release in a lab-tools worktree of your own and watch main's CI. A lanes-waker every 30 minutes nudges when the queue has work and nothing runs. A run often ends without a report: read main and the row yourself. The lab host is orchestration's to keep (the coordinator, 2026-11-18): change it only by bumping lab.toml's pins and running lpoco host prepare now (plan first; stop on any root command) in a surya idle window that the surya coordinator names, then restart devlab-watch@surya-lab. OPEN: lpoco-host waits on its tty half (walleye's pk5l, then the keeper opens /dev/ttyACM0 as the lab user; the block half passed, walleye lab #70). The lab-tools build queue is empty. Walleye's bisect series and retiring build-bisect.sh/check-bisect.sh are the walleye lane's; I offered a 0.4.0 move in a walleye window. The lab is at 0.3.8, release v0.4.0 is out. oco-work has no living repository to pin. The older owed items of orchestration-2026-11-17-late (derive-parts-in-base, about-across-bases, device-template-follow, docs-phone-items-to-lanes) still stand. SIGNS: a launcher run's status write once never reached main (fixed in the record); a launcher run counted as running while it waited on lanes (tell it to end); cargo warns that devlab and tone main.rs are in two bin targets (gone with the aliases); two sessions answer to "orchestration", so a builder could not message it; the lab host has a stray ~/.local/.crates.toml from cargo --root ~/.local, which is expected. DO NOT UNDO: release-plz.toml's release_commits and changelog_include (one release PR per version, no loop); the devlab and tone aliases while the lanes' scripts call them; 51-android.rules.
2026-11-18
What does the dmesg of our own mainline kernel (y2) show works and what fails?
y2 booted from fastboot on slot b (nothing flashed), tty read by tests/host/mainline-shell-read.sh: dmesg 336 lines, kernel 7.3.0-dirty. Present: a800000.usb (udc), 3400000.pinctrl, 800f000.spmi, rpm regulators/clocks, ramoops, watchdog, qfprom, remoteproc nodes, event0 input, ~12 regulators. Absent: /sys/class/drm, power_supply (no charger/fuel gauge), debugfs devices_deferred (debugfs not mounted). Faults: psci PC mode -3 (firmware bug msg); spmi pm8998@0 and pmi8998@3 'does not have reg property' (-22), so PMIC children (charger, gpio, rtc) probably not bound; arm-smmu 5040000 deferred probe timeout -110; c16f000.serial waits on supplier /vendor-overlay-stubs/clock_gcc; OF: i2c@c179000 phandle not found. Next parts: PMIC reg/spmi nodes, then charger, display, UFS. Raw material in ~/lab-material/walleye/mainline-shell-20261118-082300 (redacted, not in git). Phone back via reboot -f, left in fastboot, slot b current, a and b successful.
2026-11-18
Which node of OUR dtb stops boot with a kernel that reaches init with porthole's dtb?
Diff of our dtb against porthole's taimen dtb (dtc -I dtb, symbols and the vendor stubs left out): ours is the smaller (4148 vs 7206 lines). Nodes only in ours: watchdog@17817000 (porthole has the same address, compatible apss-wdt-msm8998 plus kpss-wdt and timeout-sec 30), reserved-memory ramoops@a1100000 (theirs 0xb0000000, no-map) and memory@94b00000 slpi 0x700000 (theirs 0x95800000, 0xf00000), RPM regulators-0/-1 (porthole has pm8998-regulators and pmi8998-regulators), qusb2 phy c012000 and the sleep-state pinctrl nodes. Present only in porthole's: aliases, gpio-keys, sound, fingerprint, camera/panel regulators, cpu/cpr opp tables, battery, skin thermal, zap shader region. Our gpu_mem lacks compatible shared-dma-pool. build/build-dtb-bisect.sh removes with fdtput -r from our dtb in pk4's bytes: d1 watchdog; d2 ramoops; d3 slpi carve-out; d4 RPM regulators; d5 usb@a8f8800 + phy@c012000; d6 = d1+d2+d3. spmi is not a group (the dtbo overlay needs it: it would not merge). Per image: header, command line (no earlycon), ramdisk, Image.gz equal pk4's, dtb differs and is the one written, 32 MiB, AVB footer verifies, dtb reads and has __symbols__, stock dtbo entry 3 merges. 90 checks ok, rebuild identical. sha256 in SHA256SUMS: boot-d1 b446afcc, d2 c1b89833, d3 a74f9f4d, d4 9defe73d, d5 d61531c8, d6 8da77454. Expected: init ran = Android back at about 40-65 s, no init about 75 s.
2026-11-18
Which node group of our dtb stops init (d1 watchdog, d2 ramoops, d3 slpi, d4 RPM regulators, d5 usb+qusb2, d6 = d1+d2+d3)?
13 boots from fastboot, each left fastboot after 12 s and came back as Android after 75 s (the no-init time; init would be 40-65 s). No image differed, d6 included. So none of the removed groups alone or d1+d2+d3 together is the cause. pstore not read (needs root). Slots unchanged after: b current, a and b successful. Next: diff our dtb against porthole's taimen dtb for other nodes and build d7+.
2026-11-18
Which group of the differences between the alive dtb and ours makes init die?
build/build-fdt-bisect.sh builds boot-x1..x7 and boot-xa from boot-wpa.img and our dtb: x1 gpio-reserved-ranges, x2 chosen+reserved-memory, x3 cpu scaling, x4 restart+watchdog+imem+pmu, x5 interconnects, x6 statuses, x7 what x1..x6 leave, xa all. Only the dtb differs from wpa's image; the stock dtbo overlay still merges in each (overlay targets are emptied, not removed); the groups change disjoint lines (checked pairwise); xa differs from ours in exactly 82 pinned lines (ours-only regulators, stubs, phandle renumbering). Reviewed by the programmer subagent; its findings (x7 overlap, a hiding skip list, stale output on abort, phandle constants) fixed. Expected returns alive <= 66 s, dead >= 69 s; try order x4 x1 x2 x6 x5 x3 x7 xa, twice each.
2026-11-18
Which disjoint group of dtb differences from the alive wpa to ours makes init die?
Returns (s), try 1/2: x4 61/64, x1 79/78, x2 43/43, x6 37/37, x5 64/64, x3 64/64, x7 64/49, xa 78/76. Alive <=66, dead >=69. x1 dead twice alone, so pinctrl@3400000 missing gpio-reserved-ranges <0 4>,<81 4> is a cause. xa dead as expected; other groups alone alive. Slot b, flags a and b successful before each; nothing flashed.
2026-11-18
What does the phone's running fdt add to or need from a tree, and what do the alive taimen dtb and the running fdt have that our dtb lacks?
Three trees compared (ours 581 nodes, alive 953, running vendor tree 2284). The bootloader adds chosen bootargs/initrd, fills /memory, and rewrites reserved-memory (pil regions at other addresses than their names, bootloader log 0xa1300000, rtel 0xa1800000+32 MiB, ramoops 0xa1100000). Ours lacks restart@10ac000 qcom,pshold and the apps watchdog (in both alive trees and the running fdt), gpio-reserved-ranges <0 4>,<81 4> (both alive trees), has ramoops inside the bootloader's rtel region, and leaves display, gpu, ufshc, remoteprocs, serial and wifi disabled. 288 nodes only wpa has, 22 only ours, 45 differing and 126 only-wpa properties. The USB nodes of the running fdt equal what ours already carries; no new node is proposed.
2026-11-18
Does pk5g's first stage (gadget dir+strings) keep init alive and show a USB gadget?
Start state read first: fastboot, current slot b, both slots successful, none unbootable; the earlier keeper left no record but the state was clean. g1 try 1: left USB at ~15 s, back as adb at ~108 s (alive class), pstore empty, bootreason reboot. g1 try 2: left at 14 s, back at 64 s (neither 108 alive nor 75 dead). Neither showed a 1d6b:0104 device. Slot flags unchanged.
2026-11-18
Does pk5g's second stage show a USB gadget?
g2 try 1: fastboot boot accepted, left USB at 15 s, no 1d6b:0104 in the per-second lsusb log (g2-try1-usb.log), back as adb at 138 s: later than the 108 s alive and 75 s dead classes. Slot flags unchanged (b current, a and b successful). Second g2 try and g3 still to run.
2026-11-18
What does the stock dtbo overlay (entry 3) switch on in OUR dtb that it does not in porthole's taimen dtb?
fdtoverlay merges entry 3 into pk5's taimen dtb and into ours; the merged dtbs were flattened and diffed. Of the 137 labels the overlay names, 7 are real nodes in ours (mdss_dsi0, mdss_dsi1, mdss_mdp, pcie0, soc, spmi_bus, tlmm), 130 land on empty stubs the kernel ignores; the taimen dtb has all 137 real. On existing nodes the overlay changes in ours: i2c@c179000 (disabled to okay, compatible qcom,i2c-msm-v2, no mainline driver: inert), pcie and dsi properties (nodes stay disabled: inert), one display-controller property. Everything it adds under real parents (gpio_keys, serial@0c16f000, bt_wcn3990, tps61099, panel nodes, pmic nodes) it adds to the taimen dtb too: ours' added node set is a subset of pk5's (232 against 269). The overlay hypothesis is falsified; a label-neutralizing bisect would test almost nothing. What differs between the alive taimen dtb and the dead walleye dtbs (porthole's pk2 too, same kernel) is the base: the walleye dtbs leave 15 nodes disabled that taimen enables (camss, cci, dma-controller@17184000, iommu@5100000, video-codec, slim-ngd, five i2c masters, pcie and its phy, pon resin, pmic@3 led-controller) and lack ~100 nodes taimen has (fingerprint, gpio-keys, cam regulators, sound, skin thermal, i2c children, pin states). Ranked suspects: dma/iommu group, pcie, i2c, camera, removed nodes. Next: images w1..w5, wr, wa from pk5 (research walleye-taimen-walleye-built).
2026-11-18
Can pk1 and ml5a be built without earlycon on the (possibly gated) debug UART, everything else byte-equal?
build/build-nocon.sh unpacks pk1 and ml5a, drops earlycon=msm_serial_dm,0xc1b0000 (the only earlycon/console= word; androidboot.console=ttyMSM0 is stock and stays), repacks with mkbootimg and the source's AVB footer props and salt. Checks per image: kernel blob (Image.gz+dtb), ramdisk and every header word but the command line equal the source's; the cmdline differs, has no earlycon or console=, keeps clk_ignore_unused ignore_loglevel panic=5 and all androidboot.* words; size 32 MiB as the source; AVB footer verifies. Rebuild byte-identical. Now: clk_ignore_unused ignore_loglevel panic=5 androidboot.hardware=walleye androidboot.console=ttyMSM0 androidboot.dtbo_idx=3. sha256: boot-pk3.img 7f92abee656bbf3ed3637df8c7b08a7b047db21caa70c341675bf8e631f4f523; boot-ml6a.img aceb7e7a47abcf0713f2708a8f1b6a4dfa2828acb78e7ef618922437022aa02f. Images in ~/Projects/walleye-build/images-nocon. Expected: init ran = Android back at ~36-45 s; ~70-78 s = earlycon was not the hang.
2026-11-18
Which gadget step on pk5 (dir+strings; +mass_storage; +UDC bind) first kills init, and does g3 enumerate?
Each of g1,g2,g3 booted twice from fastboot (slot b, nothing flashed), lsusb polled each second for 100 s, pstore read after each via adb root. Left fastboot at 15 s every time. Back as Android: g1 43 s,42 s; g2 138 s,138 s; g3 48 s,42 s. USB showed only fastboot then Android's 18d1:4ee7: no 1d6b device ever, so g3 (UDC bind) did not enumerate as the item expected (~25 s). pstore empty in the tries read (g1 try 1 not read). g2 returns at 138 s, outside the 42-63 alive and 75 dead classes. Battery 4377 mV read after the tries (the battery rule landed during the run).
2026-11-18
Can the mainline gadget be staged on the alive base so each image adds one step and alive and dead are 30+ s apart?
g1, g2, g3 are pk5's kernel, dtb, cmdline, header and size byte for byte; only the ramdisk differs, and the three ramdisks differ in /stage alone (one init, init-pk5g). Each pets the watchdog every second, holds 60 s, then reboot -f. No ACM, no shell loop. 58 checks ok (kernel config has the gadget, configfs, dwc3, qusb2, wdt options; AVB footer verifies), rebuild byte-identical. Not run on the phone.
2026-11-18
Can pk5 carry a first mainline userspace with a console and a log window, all else byte-equal?
build/build-pk5l.sh repacks pk5 with only the ramdisk changed (init-pk5l, busybox arm64 static). Checks: kernel+dtb bytes, header, no earlycon/console=, 32 MiB, AVB footer verifies, init in ramdisk equals source and has no bashisms, the busybox config has every applet it uses, our kernel config has USB_GADGET, CONFIGFS_ACM, CONFIGFS_MASS_STORAGE, DWC3 (+QCOM, DUAL_ROLE), QUSB2 phy, QCOM_WDT, CONFIGFS_FS, DEVTMPFS, PSTORE_RAM; porthole's dtb carries dwc3 peripheral high-speed with the qusb2 phy. The init binds one gadget with acm.GS0 and mass_storage.0, a respawned ash on /dev/ttyGS0, a 5 s log window, and pets the watchdog for 180 s (longer while /tmp/hold), then reboot -f. sha256: boot-pk5l.img a313a0c3fe927a4c6980cc320800baeb99b48ec3bd8f593de99394289e74469c; initramfs-pk5l.cpio.xz 9ab2f0945ccb9e288da45ee63f185934a4f2047d8dcd583facad62550c23cc5f. Host test tests/host/mainline-acm-up.sh. Not run on the phone.
2026-11-18
Does pk5l (our kernel, porthole's dtb, gadget init) bring up the ACM console and the mass_storage window?
Two tries from the first state (slot b current, a and b successful). Each: left fastboot after 15 s; ACM_WAIT 60 and 40 s: no walleye-first-boot gadget, no ttyACM, no 18d1 device but fastboot; then Android adb gadget at 57 s / 42 s (the bootloader fell back to slot b's Android, i.e. the init never held 180 s nor showed a gadget). Window not read. Slot flags unchanged after (b current, both successful, retry 0). Return to fastboot by adb reboot bootloader. Suite latest not run: no devlab password (fastboot-only phone). Next: the dtb diff/bisect (walleye-try-dtb-bisect).
2026-11-18
Can pk5l's early end be read from Android's pstore: an image that differs from pk5l only in the ramoops node?
boot-pk5l2.img (sha256 222c6196...b5fd): fdtput on porthole's dtb in the kernel blob, reg 0xa1100000/2 MiB, record 0x80000, console 0x20000, pmsg 0; same dtb size, only that node differs, no overlap, kernel config has PSTORE_CONSOLE and PSTORE_RAM; kernel, ramdisk, header, cmdline, footer are pk5l's.
2026-11-18
Does pk5l2 (ramoops in the phone's own region 0xa1100000) leave a mainline panic or console text in Android's pstore?
Both tries: fastboot boot, phone back as Android after 60 s and 42 s, adb root. Try 1: pstore held only the stock 4.4.302 Android kernel's boot; it itself oopsed at 17.9 s in init (persistent_ram_save_old -> __memcpy_fromio, paging fault at ffffff8009c60000, Kernel panic - not syncing: Fatal exception), rebooted, bootreason kernel_panic; no Linux version 5-9 anywhere. Try 2: pstore empty, no panic, stable 3+ min. So the mainline kernel wrote nothing Android can read at 0xa1100000: it dies before ramoops probes, or the region differs. The Android oops suggests its mapping of the old region is itself fragile (excerpt in material).
2026-11-18
Images for the property-level bisect between wa (alive) and pk2 (dead)
build/build-property-bisect.sh: six boot images, all of wa's header, command line, ramdisk, Image.gz and AVB footer, only the dtb changed by fdtput; each image changes exactly its group's property lines (checked on the normalized diff); wpa equals pk2's properties; the stock dtbo overlay merges in all; hashes in the material folder. Plan for the phone: wpa twice first (alive <=66 s means the cause is not a property: stop, look at phandle order/size); dead: wp1..wp5 twice each, the dead ones hold it, halve inside. Expected: wp4 and wp3 likeliest.
2026-11-18
Which properties differ between wa (alive taimen-based dtb with the walleye node set and statuses) and pk2 (porthole's walleye dtb, dead)?
Decompiled both (dtc -I dtb -O dts -s), phandles resolved to node paths (build/dts-norm.awk): 31 changed property lines (12 in wa only, 13 in pk2 only, 6 raw renumbered). Groups: root compatible+model; battery capacity (0x35b600 vs 0x2932e0, two properties); panel@0 has no compatible in pk2 (wa lg,sw43402); qcom,protection-domain avs/audio + msm/adsp/audio_pd on seven apr services only in pk2; leftovers in nodes disabled in both (camss supplies, pcie reg/ranges/supply, resin linux,code). Nothing in /memory, reserved-memory, chosen, cpus, timer, psci. Not property-level: phandle numbering, node order, dtb size (wa 132369 B, pk2 128809 B) - if the all-groups image wpa lives, the cause is there, not in a property.
2026-11-18
Why does our mainline kernel's console never survive in pstore, and how does an MSM8998 kernel ask for a warm reset so ramoops at 0xa1100000 keeps its text?
READ FROM SOURCE. (1) Vendor wahoo 4.4 msm_restart_prepare: the PMIC reset type is set explicitly before every restart; WARM only if download mode is on (in_panic turns it on) or the reboot command is non-empty ('reboot recovery'); a plain reboot is a PMIC HARD reset ('unless memory contents must be maintained'). It then de-asserts PS_HOLD through TZ. So on the phone, only panics and 'reboot <arg>' keep DDR; this is why stock Android's console-ramoops survives a panic but not a plain reboot. (2) Mainline: reboot=w sets REBOOT_WARM, but psci_sys_reset uses SYSTEM_RESET2 only if PSCI is 1.1+; otherwise plain SYSTEM_RESET (notifier priority 129, before qcom-wdt's 128, so the watchdog restart is never reached). The pm8998-pon driver only registers reboot-mode (soft spare reason) and never programs the PS_HOLD warm/hard reset type. Nothing in mainline does what msm_restart_prepare does; panic=5 and sysrq c therefore end in the same plain reset, whatever the PMIC default is (set by SBL/XBL: not known yet). (3) The lab's tries (ml1-ml5, pk*) never showed a kernel alive (no USB, no earlycon on the host), so an empty pstore says nothing yet about warm or cold: ramoops registers at postcore, so a kernel that dies earlier, or never starts, leaves nothing. RANKED CAUSES: (A) no kernel code ran far enough to write (most likely for ml*; test: any sign of life first, e.g. the m1 mass-storage log); (B) plain reset = PMIC hard reset, DDR lost (certain to matter once A is cleared; mainline sets no reset type); (C) the reader: stock 4.4 ramoops layout/ECC/zone count differs from the 7.x writer's, or Android init consumes the files (read with adb root right after boot; compare the 4.4 and 7.x zone maths before trusting an empty read; the clean control is the SAME kernel reading its own region after a warm reset); (D) bootloader zeroes the region on a path other than a warm reset (not shown by anything; Pixel stock Android relies on survival after panic, so XBL/ABL keep DDR on the warm path). NOT TESTED: all of it; nothing here ran on the phone. CHEAP IMAGE CHANGES, each one image, expected pstore: (T1) init marker to /dev/kmsg, 20 s wait, 'echo c > /proc/sysrq-trigger' with panic=5: console/dmesg-ramoops present only if the reset kept DDR; expected ABSENT (cause B). (T2) same, cmdline reboot=w added: expected the same, because PSCI on MSM8998 TZ is 1.0 as far as known (dmesg 'PSCIv' line to confirm) so no RESET2. (T3) init opens /dev/watchdog (kpss-wdt, already in the dts) with a short timeout and never pets it: a bite is a SoC watchdog reset which the vendor treats as a dump-capable warm path; expected console-ramoops PRESENT; this is the one image change with real hope and needs no kernel patch. (T4) kernel patch: a reboot notifier writing the PON PS_HOLD reset-type register to WARM (SPMI regmap of the pm8998 pon node; register and values to be read from the vendor qpnp-power-on source and header before writing) and arming it in the notifier; a patch worth sending upstream if T3 does not hold. READ-BACK WITHOUT PSTORE: after any return the PMIC's own record (PON_ON_REASON 0x40 = warm sequence, PON_WARM_RESET_REASON) tells which reset ran; stock Android exposes it in bootreason and in /sys/class/power_supply or qpnp pon sysfs; the live mass-storage log of init-pk5l (rewritten every 5 s) already gives the console without any pstore once a kernel is alive.
2026-11-18
Can the sysrq-c try be one image that differs from pk5 only in the ramoops node and the ramdisk?
boot-t1.img sha256 435ec18473e74a95cfcb64ef6e9990400e1b073500373e60ca7bfe684d0f078d (initramfs-t1.cpio.xz f75c8c02...7720): pk5's Image.gz, header and size; only the ramoops node differs in the dtb (reg 0xa1100000/2 MiB, console 0x20000, same size, no overlap); command line has panic=5, no earlycon/console=; config has MAGIC_SYSRQ, PSTORE_CONSOLE, PSTORE_RAM, QCOM_WDT; AVB footer verifies; checks ok, rebuild identical; the init and reader share one marker (checked). Reader tests/host/pstore-t1-read.sh exits 2 (not measured) without a rooted adb, so an unrooted read is not taken for cause B. Reviewed by the programmer subagent (5 findings fixed). Not run on the phone.
2026-11-18
Can the unpetted-watchdog bite try be one image that differs from T1 only in the init?
boot-t3.img sha256 9ccc6e2787f8a7bcc7ba9cf54ce0ab3423dd18bfc9061ea49fff636a9ff88993 (initramfs-t3.cpio.xz 991cc9cd75c4a395...): same kernel, header, size and dtb edit as T1; the init writes marker walleye-t3-marker-5c1e to /dev/kmsg, then runs busybox 'watchdog -T 10 -t 3600 -F /dev/watchdog' (one ping, timeout 10 s, next ping an hour away), logs ticks for 45 s, and has no sysrq c, so a return before 45 s can only be the bite. pk5's dtb already carries watchdog@17817000 (apss-wdt-msm8998, kpss-wdt, timeout-sec 30), so the node needs no measuring to be tried: the try itself measures it (no node response = no bite = return at the 45 s reboot -f). 43 checks ok (ramoops node, no overlap, dtb differs only there, wdt node present, panic=5, config has QCOM_WDT and PSTORE_RAM, busybox has the watchdog applet, AVB footer verifies), rebuild identical. Reader tests/host/pstore-t3-read.sh passes only with the marker, a last tick under 15 and no no-bite line (a marker without a bite fails); exits 2 (not measured) without a rooted adb. Not run on the phone.
2026-11-18
Does a hardware watchdog bite leave our console in ramoops?
boot-t3.img (sha 9ccc6e27...) from fastboot on slot b; left fastboot 15 s, adb back at 42 s, same as other alive-class images; pstore-t3-read: fail, 0 console-ramoops in /sys/fs/pstore and vendor_ce, bootreason reboot. Dtb carries watchdog@17817000 and QCOM_WDT=y. Not separated: bite never happened vs bite without surviving ramoops vs init never ran; no UART/serial console.
2026-11-18
Which difference between the alive taimen dtb and the dead walleye dtbs stops init?
build-taimen-walleye.sh builds seven images from pk5 (our kernel + porthole's taimen dtb, init 42 s): w1 camera, w2 dma/iommu/codec/slim, w3 i2c, w4 pcie, w5 pmic key/led (each: status disabled, children removed), wr nodes only taimen has removed (dangling references left on purpose), wa all of them: node set and every status equal pk2's. Header, command line, ramdisk (reboot at once), Image.gz, AVB props are pk5's; the stock overlay still merges in all. Bisect plan: wa twice first (~42 s init ran, ~75 s dead): wa alive means the cause is a property, stop; wa dead then w1..w5 and wr twice each, the dead ones hold it, halve inside.
2026-11-18
Does vf2 repeat, and does vf4 behave like vf2 when watched the same way (no poller, no lsusb -v, LUN read only at 70 s)?
Four tries from slot b (a and b successful), no poller, plain lsusb 1 s, one LUN read at >=70 s. vf2 try1: gadget 1d6b:0104 at 20 s (counted from the boot command), gone before 70 s (read: no device), Android at 125 s. vf2 try2: gadget at 20 s, LUN /dev/sda readable at 70 s, header empty (no WALLEYE-LOG), gone at 72 s, Android at 127 s. vf4 tries 1 and 2: no gadget at all, Android back at 78-80 s (the dead path), nothing readable. So vf2 repeats (alive, gadget up ~50 s, window empty again); vf4 is dead unwatched too, though its init equals vf2's byte for byte up to the bind: the poller is cleared; what differs is vf4's later part (the progressive dump after the bind) or the image's size/layout. Note: tries 1 (vf2) and the vf2 try 1 first run (read missed by a loop timing slip, re-run as try 1b) began from fastboot after an earlier tool slip, not from Android; slot flags unchanged all along, phone back as Android on b.
2026-11-18
Can the vendor kernel be made to hand the running hardware's facts to the host through the m1 window?
boot-vf1.img (sha256 af1ca884...fffe in images-vf1/SHA256SUMS-vf1): header, kernel, footer as m1's; ramdisk init-vf1 mounts proc/sys/configfs/debugfs, binds m1's mass_storage gadget with an 8 MiB LUN, and every 10 s for 90 s rebuilds a gzipped tar (device tree per property, clk/regulator/pinctrl/gpio/usb/dwc3 debugfs, interrupts, iomem, ioports, udc, dmesg) written as 64-byte header then body, then reboot -f. Redaction in the init (no mac-address/bdaddr/serial-number/imei properties, no raw fdt, no /sys/class/net, serialno/IMEI/MAC blanked) and again in the host reader, which deletes a dump that fails. Programmer review found 1 build-failing check, the raw fdt leak, a 64-byte O_DIRECT read, a leftover raw copy and an over-broad name filter; all fixed. Not yet run on the phone.
2026-11-18
Does vf1 write the vendor-facts blob into its mass_storage window, readable on the host?
Host now on 7.3.4 with usb_storage, so the earlier module block is gone. Two tries (battery 4378 mV, slots a and b successful, boot from fastboot on b, nothing flashed): left fastboot at 12 s, enumerated 1d6b:0104 with our strings at 18 s, /dev/sda read by the reader, but the 64-byte header was empty (not WALLEYE-VF1) over 12 reads in try 1 and the full LUN_WAIT=60 VF_TRIES=60 run in try 2. Phone then left USB and came back as Android on b, flags unchanged, fastboot reachable. Not told apart: init never wrote a blob (dump step failing), host read of the LUN cached or empty, or the vendor kernel dying before the first round. Next, by the coordinator: read the vf1 init's dump step for what it writes before the first round, or add a marker round written at once; a UART remains the sure witness.
2026-11-18
How can the window tell an empty header from a dead init?
boot-vf2.img = the control's kernel with init-vf2: the window file and the WALLEYE-VF2 BEAT marker are written before any mount and before the gadget; a beat repaints every 2 s under flock; every step goes through stp (start line before, rc=X and stderr after; a step with failed grabs gets a non-zero rc); applet list written at start; blob at offset 65536 with its own magic. The reader prints the step lines first, retries while the beat lives, and says ALIVE or DEAD/hung. sha256 boot-vf2.img 75723a23acf85e18... (full in images-vf2/SHA256SUMS-vf2 on the lab). Programmer review found 5 issues (stale overwrite between painters, marker order, rc=0 on failed grabs, reader retries, selftest beat); all fixed. Not tried on the phone.
2026-11-18
Does the vf2 init run, and how far does it get?
Try 1: gadget 1d6b:0104 at 18 s, reader found no marker/empty text on its re-reads (phone gone from USB before any manual read). Try 2: polling the LUN every 2 s from 15 s showed WALLEYE-VF2 BEAT=2..22 (UP 3.4..43.5 s), 'start 0 init (kernel 4.4.302-...)', 21 applets ok, steps mount-sysfs/configfs/debugfs/g-mkdir rc=0, 'start 5 g-idVendor' at 43 s; my capture cut at 600 bytes so later steps and any blob header unseen; then the phone left USB. Back as Android on b both tries, left in fastboot, slots a and b successful. So the earlier empty header meant the first dump round had not been written yet, not a dead init. The init runs the VENDOR kernel 4.4.302 inside (the instrument). Reader: reads of the 64 KiB text region came back empty at times (O_DIRECT while the init rewrites every 2 s?); a plain dd poll worked.
2026-11-18
How does the window keep what the phone shows before it leaves USB at ~45-60 s?
boot-vf3.img = the control's kernel with init-vf3: window file + WALLEYE-VF3 beat block 0 (2 s), proc/sysfs/configfs, gadget bound, THEN one source at a time (cmdline, version, udc, iomem, interrupts, clk/regulator/gpio/pinctrl, usb/dwc3, ioports, devices, applets, dmesg head/tail, device tree one node per block) framed BEGIN/END rc=N, appended from the last 4096-byte boundary and synced, ending in DONE; nothing to the console; stream budget 3.8 MB. tests/host/vendor-facts-poll.sh (start BEFORE the boot, own job): finds the LUN by our strings, copies the used part every 2 s (numbered copies, last-complete), fetches each finished block once as a flat file, stops at DONE or 150 s, refuses and deletes on a MAC/15-digit/serialno. Programmer review: nested names aborted the fetch (fixed: flat dt%a%b names), torn reads could glue across a hole (fixed: contiguous prefix, torn last line dropped), leak check now on the whole copy before any save, budget line once. sha256 boot-vf3.img cb5c7ad9bad50d80... (full in images-vf3/SHA256SUMS-vf3 on the lab). Selftest poll 25 ok, reader 25 ok.
2026-11-18
Does vf3 (gadget bound first, dump appended after) show its window and facts?
Both tries: poller (150 s, own job) saw no USB device with our strings; usb log of try 2 (1 s): fastboot until left at 12 s, then nothing on USB for ~64 s, then Android adb (18d1:4ee7) at 78 s. vf2 had the gadget up at 18 s on the same host. So vf3's reordered init did not reach the gadget (or crashed before it): the 78 s return is the dead-init class, not alive. Nothing flashed; phone left in fastboot on b, flags a and b successful, battery 4376 mV.
2026-11-18
Which change between vf2 (alive) and vf3 (dead before the bind, twice) killed vf3, and what is the smallest step from vf2 toward a readable dump?
Diff vf2->vf3 BEFORE the bind (what vf3 did that vf2 did not, or not as vf2 did): (1) no 'say' to /dev/console and /dev/kmsg per step - vf2 wrote the console twice per step, and its gadget bind came only at 43 s; vf3 bound within seconds of boot; (2) no debugfs mount before the bind (vf2 mounted debugfs before); (3) no applet loop, no flock'd 64 KiB text region, no per-step start/step lines; (4) window 4 MiB with a 4096-byte beat block instead of 8 MiB with a 64 KiB text region. Likely cause (a hypothesis, not measured): the bind itself came too EARLY - vf2's slow console writes put it after the kernel's late unused clock/regulator cleanup (~30 s), vf3's bind ran before it, and the UDC/PHY went down or the phone reset; vf4 keeps vf2's timing so a dead vf4 would speak against this, an alive one for it. Not excluded: the missing debugfs mount or the window size. vf4 = vf2's init lines 1-86 unchanged (up to and including the 'gadget' call = UDC bind; diff vf2->vf4 first hunk at line 87, md5 of the 86 lines equal, checked by the build), then vf3's stream appended from byte 65536 of vf2's 8 MiB window (framed BEGIN/END blocks, flushed from the last 4096-byte boundary and synced, a 'chunk NAME' step line first so a hang shows in the text region, timeout 5 on debugfs reads, 3.8 MB budget, DONE, hold to 90 s then reboot -f). Poller of vf3 reused with VF_MARK=WALLEYE-VF2 VF_HEAD=16 VF_BLOCKS=1040 (reads 4259840 bytes; also keeps the 64 KiB text region as steps.txt, leak-checked). sha256 (first 16) 6184dbdc240ead5c 681b5d0858cde6e1 full in ~/Projects/walleye-build/images-vf4/SHA256SUMS-vf4 on the lab. Selftests: poll 25 ok (vf3 layout unchanged), vf4 13 ok. Programmer review (no defect on the first read) led to: POLL_MAX=400 (the dump needs more than 150 s after a 43 s bind), the gadget step lines copied into the stream as block gadget-steps, dmesg and udc before the clk/regulator/gpio reads (a wedged read cannot hide them), dbg-usb no longer a duplicate of usb. Not measured yet: the phone.
2026-11-18
Does vf4 (vf2's init to the gadget bind, then the progressive dump) show the gadget, and what facts stream?
Both tries: battery 4377 mV, poller (POLL_MAX=400) started first, boot-vf4.img by devlab fastboot boot; left fastboot after 12 s, back as Android (adb) after 78 s. Poller fetched 0 blocks, no DONE, beat.log empty (0 bytes), no win copies, no steps.txt: no walleye-first-boot / Pixel 2 walleye (mainline) device ever on the host. Same as vf3 (78 s, no gadget), unlike vf2 (gadget at ~43 s). Flags not re-read after (phone left in Android on b; fastboot state was a/b successful before both). The 78 s return is the dead-kernel class. vf4 differs from vf2 only after the bind, yet no gadget: vf2's gadget may have depended on something other than the init (timing, or a first-boot-after-flash state) - not shown by these tries.
2026-11-18
Which hardware source, read alone on m1's proven structure, works and which kills the vendor kernel (vf3/vf4's progressive dump died)?
build/initramfs-vendor5/init-vfx is m1's init line for line from the first command to the gadget bind (checked by the build), plus one block before the bind: the payload named by /etc/walleye-vf. vfa = /sys/firmware/fdt (binary, merged running tree) + /proc/iomem + /proc/interrupts + /proc/cmdline (redacted); vfb = debugfs clk_summary; vfc = debugfs regulator_summary; vfd = debugfs usb/ and the dwc3 directories. Each source is read by timeout 5 cat into the ramdisk, then put in the window file m1 makes (2 MiB): bytes 0-511 a plain header 'WALLEYE-VFx LEN= PARTS= TRUNC=' and a PART line per source (name, length, rc), the plain bytes from 512 (no tar, no gzip), a payload over the room cut with TRUNC=1; a first header with no part is written before the first read, so a kernel killed in a read shows as a header with PARTS=0. After the bind no payload write: only a 4 KiB beat block at the window's end every 5 s (m1 wrote 64 KiB every 5 s), 180 s then reboot -f. The four ramdisks differ in /etc/walleye-vf alone; header, kernel, busybox, file list and AVB footer equal m1's. Reader tests/host/window-payload-read.sh: one dd of the LUN by the header's length, parts cut out (fdt as fdt.dtb and fdt.dts through dtc), refuses an identifying string; selftest tests/host/window-payload-selftest.sh 18 ok (all four letters, truncation, missing source, killed first read, foreign window, redaction). sha256 (first 16) boot-vfa 2bb9f7214f2eef89, vfb fd90dd4d57665103, vfc dabf900a7f3bd962, vfd e8d4badc52e47908; full in ~/Projects/walleye-build/images-vfx/SHA256SUMS-vfx on the lab. Programmer review (no defect that stops a build or a good read) led to: a 200 s reboot watchdog started before anything is read (a hang before the bind used to end in no reboot), the usb dump to three levels and 64 KiB per file, the reader no longer lets one redacted MAC hide a leftover serial, a bounded LEN, stale files ignored, the fdt.dts (the serial sits in /chosen/bootargs) kept in the lab material directory and not judged. Not measured yet: the phone.
2026-11-18
Which single hardware source can the vendor-kernel init read into the window, and which kills it?
From the first state (slot b, a and b successful, battery 4.38 V), no poller, read at ~68 s and again near the end. vfa: gadget up at 18 s, header ours, 4 parts rc=0 (fdt 466569 B, iomem, interrupts, cmdline), both tries; the live fdt differs between tries only in 7 bytes of bootargs boottime; Android back at ~165-220 s. vfb: init alive (beat 11 at 52 s, 24 at 117 s), part clk_summary LEN=0 rc=1 - read failed, did not kill; one try. vfc: pass, regulator_summary 22515 B rc=0; one try. vfd (usb/dwc3 debugfs): no gadget ever, Android back at 87 s (try 1) and by ~136 s (try 2) - the dead path; killed twice. Flags and slot unchanged: b active, a and b successful. Material (never in git): ~/Projects/walleye-build/material/vf/2026-11-18-vfx-vf{a,b,c,d}-try*. Side finding: the fdt bootargs hold the phone's own serial unredacted, so the fdt stays in the material path only. Also: tests/host/battery-ok.sh hangs while the phone is in Android (fastboot getvar waits for a device); wrap it in timeout.
2026-11-18
Which walleye dtb difference group, put into the alive taimen dtb, stops init?
Return times (s): w1 48,63; w2 42,63; w3 42,42; w4 63,42; w5 42,42; wr 42,42. Slot b, nothing flashed, flags unchanged. Rule from the coordinator: up to ~66 s alive, 69+ dead (all earlier dead images 69-78). With wa (42,63,63) also alive, every taimen-based image is alive, though pk2 (same nodes/statuses, porthole's walleye dtb) is dead: the cause is a property, not a node or group.
2026-11-18
Does wa (taimen dtb with every walleye difference) run init (~42 s) or die (~75 s)?
Three tries of boot-wa.img from fastboot on slot b, nothing flashed: back as Android after 42 s, 63 s, 63 s (devlab's measure, includes the 15 s in fastboot). Slots' flags unchanged (a and b successful, none unbootable). The plan's rule (alive ~42 means a property) is not met cleanly: one alive-looking, two between. 63 s twice may be a third path (kernel ran longer before reset) or timing noise; unresolved. w1..w5 and wr not tried yet. Note devlab phone needs the missing password file; plain adb used to return to fastboot.
2026-11-18
Does adding all walleye property groups to the taimen dtb (wpa) make the boot die (>=69 s) or stay alive (<=66 s)?
wpa returned at 60 s both times (alive class, <=66 s). So no property group causes the dead boot; wp1..wp5 were not tried, being unneeded. Remaining suspects: phandle order or dtb size. Nothing flashed; slot b current, a and b successful, phone in fastboot.
2026-11-18
Does our own dtb, given the property whose absence killed every dtb of ours, boot to init (y1) and to a USB gadget (y2)?
build/build-y.sh compiles dt/msm8998-google-walleye.dts (with the new &tlmm gpio-reserved-ranges = <0 4>, <81 4>) and puts it under ml6a's Image.gz with ml6a's header and command line (no earlycon). y1 carries ml5a's ramdisk (reboot at once); y2 pk5l's gadget init (ACM shell + mass_storage window). The dtb differs from ml6a's in that one property line only; the stock dtbo overlay merges into it; AVB footers verify; sizes are ml6a's. Expected: y1 alive (<= 66 s), y2 shows 1d6b:0104 on the host within ~25 s. Not measured yet: the phone; the cheap extra items of the fdt compare (restart@10ac000, the apps watchdog) are left out on purpose, the finding does not say they matter (x4 was alive), and one change keeps the effect attributable.
2026-11-18
Does our own dtb with gpio-reserved-ranges <0 4>,<81 4> boot to init (y1) and to a USB gadget (y2)?
From slot b (a and b successful), battery 4379 mV. y1: left fastboot at 15 s, back as Android 36 s after the jump, both tries (alive class, <=66 s). y2: left fastboot at 15 s, 1d6b:0104 (serial walleye-first-boot, 'Pixel 2 walleye (mainline)') enumerated 18 s after the jump on both tries, /dev/ttyACM0 appeared on the host; back as Android after the init's 180 s reboot. tests/host/gadget-up.sh fails only at its ping step: y2 is ACM + mass_storage, no network function, so no ping is expected. Our own dtb now gives the first mainline USB gadget on walleye: the missing gpio-reserved-ranges property was the cause of every dead dtb of ours (x1/xa, d1..d6). Not read: ACM shell content, mass_storage window. Phone left Android on slot b, stock kernel, nothing flashed.
2026-11-18
How do other mainline Qualcomm phones with QCA UART Bluetooth survive s2idle, and what is surya missing?
Read 2026-11-18. (1) Surya's device tree already is the mainline pattern: the live /sys/firmware/devicetree node serial@88c000 has interrupts-extended (GIC 604 + tlmm 41 edge falling), pinctrl default+sleep, bluetooth compatible qcom,wcn3998-bt. Its sleep state: CTS gpio38 bias-bus-hold, RTS gpio39 pull-down, TX gpio40 pull-up, RX gpio41 pull-up. The only mainline QCA UART Bluetooth built to sleep in s2idle, sc7180-trogdor (same GPIO 38-41, same qup03), has the same wiring; its sleep state differs in one pin: CTS gets bias-pull-down 'to match the pull of the Bluetooth module' (surya: bus-hold). So the DT is not what is missing; one pin bias is the only measured-nowhere difference. (2) Mechanism of the failures, from the code: qca_suspend waits only 200 ms for the chip's own HCI_IBS_SLEEP_IND and returns -ETIMEDOUT (suspend then refuses, as in r4 'qca_suspend returned -110'); during SSR it waits up to memdump+3 s then times out. qcom_geni_serial_isr returns IRQ_NONE while uport->suspended, and irq 157 is a level irq: any RX/CTS activity from the chip after the port is suspended, or while a crashed controller keeps talking, is the 'nobody cared' storm. Not measured: whether the storm comes before or after the controller crash (r4 shows both within 8 s, order unread). (3) What others do: mainline gives no hook - Chromebooks (trogdor) rely on in-band sleep plus the RX wake; every desktop/distro remedy found is user space: bluetoothctl power off before sleep (ArchWiki), rfkill block in a sleep hook (pop-os, which breaks BT peripherals and needs a power cycle), and for a QCA UART controller that loses state, unbinding only the serdev from hci_uart_qca before sleep and binding it after (SteamOS 2845, worked across S4). No postmarketOS/Mobian/Droidian rule for qca UART Bluetooth across s2idle was found in two searches (only our earlier note of a pmOS hook stopping Bluetooth for the Pixel 3a FastRPC crash); not found is not absent. (4) Local facts that bound the choice: wakeup off + BT up passed 4 of 4 15 s cycles (irq157-quiet-with-wakeup-off) yet r4 failed at its first long off-USB run; BT blocked (rfkill) hung suspend entry hard twice (surya-s2idle-bt-blocked-hang, sh0-bt-blocked-cycle-resets) - so closing the port is not safe; unbind and power-off by serdev remove were never tried; the r4 wedge was sxmo calling rtcwake in a 1-20 s loop while the controller sat in SSR, with three rfkill processes on the misc_open mutex, not a kernel panic. Ways it could go: A mirror trogdor exactly (CTS pull-down in sleep) and run with the wakeup switch on; B unbind hci_uart_qca (serdev) before suspend, bind after - a clean controller power-off and a full re-setup, never rfkill; C gate sxmo's autosleep on a healthy hci0 (no suspend while SSR or rfkill busy), which cannot fix the storm but removes the wedge; D take Bluetooth off the standby profile (bluetoothctl power off) - the ArchWiki remedy, loses BT peripherals; E patch hci_qca (longer sleep wait, reset on timeout) - upstream-shaped but needs the cause first.
2026-11-18
Score r4 and find why surya hung after the run
r4 (log /var/tmp/standby-r4): USB gone 22:28:35Z (sensorspd stopped), settle 600 s, measure began mono 1319 s. Run stopped itself 22:40:48Z: Bluetooth failed (irq 157 'nobody cared' at 22:40:40 inside the 15 s cycle, hci0 cmd 0x0c01 timeout, controller crash). So the plan's 'no noirqdebug' did not stop irq 157 firing in a bt-on cycle. SCORE: aborted/partial, NOT scorable: only 4 post-settle samples (charger_online 0): current_now 125.9/114.1/60.0/142.4 mA, median 120, mean 111; gauge current_avg 29.4 mA; suspended 51 s of 81 s (63%) in the measure window, 442 s of ~702 s since USB left; instantaneous reads taken awake so biased high; vs 15/9 mA targets: unknown; Android reference not measured; sensorspd restore: never ran (run ended aborted; reboot restored it). HANG: after the stop, sxmo's own autosleep kept calling 'rtcwake -m mem -s 99999999' every 1-20 s while the QCA Bluetooth was in SSR/retry (setting up wcn399x, 'SSR or FW download time out', qca_suspend returned -110 at 22:41:05). Three 'rfkill' processes sat in D state on the misc_open mutex (26697, 26727, 26892; trace repeated every 21 s) until the journal ends at 22:45:01; no pstore, no panic, no hung-task panic: the phone wedged with the USB gadget gone, until the author's forced reboot at 23:56. Cause: a Bluetooth SSR stuck in hci_uart_qca holding the misc/rfkill path while sxmo kept suspending. Not shown: which exact lock holder; why USB died (journal shows no panic).
2026-11-18
Does stopping hexagonrpcd-adsp-sensorspd around a suspend (what its Conflicts=suspend.target does) stop the ADSP crash on every suspend?
way-back.sh cycle 15 bt-on stop-sensors x3, watchdog armed, USB attached: no sensor_process/ADSP crash in dmesg (4 of 4 crashed before, with the daemon running); after each restart the daemon was active and iio-sensor-proxy still gave Accelerometer, AmbientLight, Proximity; hci0 present. Suite after: no-processor-crashes, motion-and-light, proximity-reads pass; soc-sleeps still fails (cxsd/aosd 0, adsp never asleep). The unit already carries Conflicts/Before=suspend.target, so a real systemd suspend does this by itself; rtcwake bypasses it, hence the new stop-sensors flag. Not done: a real systemctl suspend path (sxmo) and the sensors-across-suspend streaming read.
2026-11-18
Does a real systemctl suspend (RTC wake) keep the sensors working, as the manual stop/start did?
Try 1 (no hook): suspend returned at once (serial wakeup write 'echo 0' was invalid; fixed to 'disabled'), sensorspd stayed inactive after return: Conflicts=suspend.target stops it and Restart=always does not apply, so sensors are lost until a manual start. Try 2 (hook starting it in post): systemctl start refused 'destructive: suspend.target has start job queued'; an earlier suspend entry (09.33) still saw the daemon running and ADSP crashed (sensor_process); sensors gone until daemon started by hand, then restored. Try 3 (hook starts via systemd-run --on-active=3, lab/devlab-sensors-resume): phone stopped answering on USB for 10+ min after the try; fuse defuse ran only on return, so cause unknown (hang or wedge). Not proven; the hook is not landed as a fix.
2026-11-18
Why was surya unreachable on USB after the third systemctl-suspend try?
Phone came back (up 1 min, same kept kernel) after the author's power-cycle. /sys/fs/pstore is empty: no oops was stored. The previous boot's last journal line is 'kernel: PM: suspend entry (s2idle)' at 00:10:19, right after a systemctl suspend finished at 00:10:18 and sxmo autosleep ran 'rtcwake -m mem -s 99999999' (a second, nested suspend with no near wake). So: the phone went into a second s2idle straight after resume, because sxmo autosleep was still on, and did not wake on USB; the journal alone does not say whether that is a hang or a missing wake source. Not shown: a FastRPC/ADSP crash. Unproven.
2026-11-18
How is clean-room reverse engineering best done with AI agents, and how should walleye's bring-up apply it?
Agents are now near-human at reading binaries (arXiv 2610.14960; 2608.11469 SRE-Bench: best agents solve ~27-32% of realistic ones), but no paper yet covers clean-room hardware bring-up; the practice does. AI "clean rooms" (ArtCraft: a rule on inputs; chardet 7.0: disputed) cannot prove the wall by the model's mind, only by what it was shown - so use an INPUT wall: observer (traces on the stock system, GPL vendor kernel source, public specs) writes spec rows with evidence kind + hash; a separate scrubber checks them for expression; the implementer sees only accepted rows, public specs and mainline; commits cite spec ids; per-session input log and taint register. Tools: mmiotrace/ftrace/dynamic debug/regmap/QMI logs/debugfs on the running stock system (Nouveau, Asahi m1n1 tracing, freedreno), never disassembly or vendor binaries (Asahi: 'without looking at the code'). Walleye: most MSM8998 parts are upstream and need no clean room; likely only panel init, sensor hub, audio calibration/topology, camera, vendor protocols. GPL vendor kernel (android-msm-wahoo, kcxt/linux-wahoo) is read and ported with licence kept - no clean room. EFF: clean room is good practice, not a legal requirement; no court has ruled on AI clean rooms. Not legal advice. Full proposal, table of parts and record design in the material.
- EFF Coders' Rights: Reverse Engineering FAQ - research-cleanroom-agents Clean room is good practice, not a legal requirement; least intrusive technique first; EULAs can bind
- Asahi Linux progress report, August 2021 (m1n1 hypervisor tracing) - research-cleanroom-agents Trace hardware accesses on the real system without looking at the vendor code; disassembly would endanger copyright status
- Nouveau: Memory Mapped I/O Trace - research-cleanroom-agents mmiotrace plus envytools register database; one person documents, another implements
- Clean-room reverse engineering process manual v1 (Kyvero-Vexus) - research-cleanroom-agents A/B/C team roles, access matrix, taint register, spec-to-test traceability, evidence bundle (not peer reviewed)
- storytold/wordcraft AGENTS.md (ArtCraft clean-room house rules) - research-cleanroom-agents Clean room as a rule on inputs: black-box observation plus public specs; never read the app bundle
- Reversa: reverse documentation engineering for AI agents (arXiv 2605.18684) - research-cleanroom-agents Spec shape: claims with confidence, gaps, traceability, parity scenarios; no clean-room discussion
- When Binaries Talk Back: Representation-Confusion Attacks on LLM-assisted RE (arXiv 2607.12507) - research-cleanroom-agents Captured data is data, never instructions; count evidence by origin
- Humans vs. Machines: AI agents in software reverse engineering (arXiv 2610.14960) - research-cleanroom-agents Agents competitive but need persistent analysis state
- Chardet dispute shows how AI will kill software licensing (The Register, 2026-03-06) - research-cleanroom-agents An AI clean room is not yet a defence; the wall cannot be shown by the model's mind
- postmarketOS: Qualcomm mainline porting - research-cleanroom-agents Downstream vendor kernel is the reference; device tree plus mainline drivers
2026-11-17
How do SM6150/SM7150 'bolero' boards and their siblings (SM7125 atoll, SM6115 bengal, QCS615 talos) record their microphones on mainline and open stacks, and what does the vendor's own model say?
Working on mainline, legacy q6afe firmware: SM7150 davinci (sm7150-mainline PR 60, open, -62 dBFS floor) and surya (pulpoff/linux-surya; and linux-phone-oco since 2026-11-17), both through analog mics on the WCD9375 -> TX SoundWire -> TX macro DEC (SWR_MIC) -> TX_CODEC_DMA_TX_3. The SM7150-specific trap: its TX SoundWire controller has one dout port, which shifts both the master port numbers (inputs from port 2) and the controller's DAIs (capture is DAI 1); SM7125, the template, has none, so its <&swr2 0> is right there. Nobody streams the VA port on SM6150/SM7150; both trees declare a VA link and leave out the DCODEC vote this ADSP refuses. The vendor (sm6150 bolero, qcom,va-without-decimation) uses the VA block only for MCLK, the fs counter and DMIC clocks, clocked from the TX macro's MCLK through bolero's mclk mux, and routes every TX and RX path to VA_MCLK; mainline gives the same through the VA macro's fsgen clock on the TX macro. No open implementation of va-without-decimation exists - only a board with real DMICs on this family would need it. SM6115/QRB4210 (Linaro RB2 v3) records DMICs through VA_CODEC_DMA_TX_0 with the DCODEC vote: not a template here. QCS615 upstream (2026-05) is AudioReach with an external DA7212, headset mic only. postmarketOS ships no microphone support for SM7150 (wiki: N, UCM speaker-only).
- sm7150-mainline/linux PR 60: working WCD9375 microphone capture on davinci (open) - , 2026 The four faults of SM7150 WCD capture: swr_tx_data mux 3, the TX bus wakeup IRQ, port numbering shifted by the TX controller's one dout port, and the capture link's DAI 1; plus MultiMedia2 for capture. The place to contribute surya's fixes upstream, beside it rather than in a parallel series
- pulpoff/linux-surya: mainline 7.2.15 for the POCO X3 NFC on Mobian, both microphones and call audio - , 2026 surya's microphones are analog on the WCD9375 (bottom AMIC1 on ADC1, top AMIC3 on ADC2); capture link on <&swr2 1>; qcom,tx-port-mapping <2 3 4 5> gives ADC2 its own master port 3; LPI gpio7-11 NC (no DMIC pins in use); q6voice call uplink needs a running mono capture on TX_CODEC_DMA_TX_3
- LineageOS sm6150 kernel: the vendor bolero codec (tx-macro, va-macro, bolero-cdc) and sm6150 machine driver - , 2019 sm6150/sdmmagpie use qcom,va-without-decimation: the VA block gives only MCLK, the fs counter and DMIC clocks, clocked from the TX macro's MCLK through bolero's mclk mux; TX decimators record everything; TX AIF1 is TX_CDC_DMA_TX_3 (AFE 45111 = 0xB037)
- sm7125-mainline/alsa-ucm-conf: miatoll HiFi (TX macro, TX_CODEC_DMA_TX_3 mic entries) - , 2025 SM7125 records through the TX macro on TX_CODEC_DMA_TX_3 with q6afe and WCD937x; its TX controller has no dout port, so <&swr2 0> is right there - the template sm7150 copied. Whether miatoll's mic records is unverified
- [PATCH v3 00/12] qrb4210-rb2: wsa audio playback and capture (Alexey Klimov, Linaro) - , 2025 SM6115/QRB4210 records its DMIC through the VA macro on VA_CODEC_DMA_TX_0 with the DCODEC vote on q6afe - both refused by surya's ADSP, so not a template for SM7150
- [PATCH v5 0/2] QCS615 Talos EVK audio support (Le Qi) - , 2026 Upstream QCS615 audio (merged 2026-05) is AudioReach with an external DA7212 over MI2S, headset mic only: no LPASS macro, WCD or DMIC work for talos yet
- postmarketOS wiki: Qualcomm Snapdragon 730/730G/732G (SM7150) - Microphones marked not working on SM7150 devices; the shipped alsa-ucm-conf-qcom-sm7150 is speaker-only
2026-11-17
How should docs split general knowledge from per-device work, and how does it learn each device's progress?
Read and summarised in grenudi/ideal-knowledge-base (research commons-and-unit-bases-world, material research/commons-bases/2026-11-17/): Linux MAINTAINERS, devicetree bindings vs board dts, Debian ports wiki, Renovate, GitHub templates and Copier agree on a commons with schema and process and units that declare their own status; the commons pulls and derives, a status typed twice drifts. Measured here: test_results 1.3 MB of 2.0 MB; 40 of 81 docs backlog items, 34 of 49 research rows and 14 of 28 decisions name a device. Not read: postmarketOS, Fedora ARM.
2026-11-17
Where does the coordinator's work stand, for a fresh coordinator to take it up without the old session's 840k tokens?
ROLE: the author's one session for linux-phone-oco - relays his words to the working sessions, keeps docs' records true through tad, routes work by the weakest link; does not build. SESSIONS (list_sessions linked): orchestration local_325ef65d (devlab, the queue, the face, the agent folder, the patrol and the waker); the phone keeper, started by the waker (surya dispatcher) - the one holder of the phone; ideal-agent-ikb local_05818060 (general agent know-how: practices, skills, hooks, housekeeping); idealkb build local_b8ca2fb5 (ideal-knowledge-base; docs and ideal-agent follow it, 0.5.0); phone lover local_f93a213b (bring-up, retired to the upstream queue). IN FLIGHT: deep sleep - after a timed s2idle test surya showed the initramfs gadget (18d1:d001); the author force-rebooted it and the keeper was to check health and record it; the wake IRQ 157 is the Bluetooth UART. Next on the queue: the sensor hub (sensors-and-the-mask, sensors-without-crash), off-state charging; gps-measurable waits on a research session; telegram-at-provisioning waits on Alpine v3.24; upstream-alpine-tqftpserv is a request in the author's name. Ask: tad q phone-queue, tad q next. WAITING ON THE AUTHOR: hands for any phone reboot or physical test; his word before anything goes upstream in his name; whether to start a GPS or sensors research session. STANDING WORDS: nothing depends on ocoeco; everything through tad in docs, idealkb the layer on top; deep sleep first, hard features researched first; a small look around before any change, with sources; summaries kept current; Gmail and Claude Docs off by default; quiet test sounds; fewer, longer-lived roles renewed by hand-over; sign as grenudi upstream; patches by git send-email. DON'T: widen ocoeco for another project; send HTML mail to lists.sr.ht; let a session re-read history to start; devlab kernel remove on entries sharing a release; treat idealkb as tad. Read from the old coordinator's transcript (7007ce97, 12.9 MB, 1,222 turns) by a subagent that returned 2.5 KB; corrected against main: docs follows idealkb 0.4.0 and the bring-up brief is folded into the keeper's.
2026-11-17
Which public number can an automated call reach from a German mobile, that plays back what it hears, free or at the national rate?
Only one German public echo line is attested across sources and years: blueSIP's echo test, +49 89 721010 99701, a Munich landline number (landline rate: inside any German allnet flat, about 9 ct/min on plain prepaid), named in forums in 2005 and 2013, recommended in 2021, and still on Placetel's list (which gives no warranty). It plays back what it hears at once (an echo, not record-then-playback); no length limit is stated. The same provider's +49 89 721010 99702 plays a signal tone: a downlink-only control that needs no working uplink. sipgate's echo (10005) and test (10000) are SIP-internal short codes, not dialable from a mobile, and sipgate serves only business customers since 2025-06. Other European lines (portunity's 0211 237099929 from 2005, sip2sip's +31 20 8005161, a Dutch C*NET echo) are old and unconfirmed, and abroad costs more. No source confirms any line works from a mobile today, so the first supervised call settles it. Fallback that is certain to exist and free on German tariffs: the SIM's own mailbox (record a message, play it back by DTMF; slower and operator-specific).
- Testrufnummer gesucht? Vollständige Liste für alle Zwecke - Placetel blueSIP's echo test +49 89 721010 99701 and its signal-tone line 99702; no warranty given for the list
- Testrufnummern gesucht (IP Phone Forum) - , 2005 blueSIP 99701 echo, 99702 tone, 99703 song; portunity's 0211 237099929 echo
- Telefonnummer für Testanrufe (IP Phone Forum) - , 2013 089 72101099701 still given as the BlueSIP echo test in 2013
- BlueSIP Echotest, +49 89 721010 99701 (Festnetztarif) - , 2021 the echo still recommended in 2021, at the landline rate
- Sipgate (prepaid-wiki) - , 2025 sipgate's echo 10005 and test 10000 are SIP-internal; sipgate serves only business customers since 2025-06
- SipTesting - SIP2SIP (AG Projects) - an EU PSTN test number +31 20 8005161; echo only on SIP (4444)
2026-11-17
How can the phone itself decide that a call carried sound both ways?
Acoustically, through the paths a person uses, with the analysis in Rust: during the call the uplink capture that the call needs anyway (1 channel on TX_CODEC_DMA_TX_3, the bottom mic) is written to a file instead of thrown away. The phone plays a pattern of three short tones (e.g. 800, 1300, 1900 Hz, 200 ms each, 300 ms apart - inside the 300-3400 Hz every voice codec keeps) on the loudspeaker at the manifest's quiet level; the bottom mic hears it at once (proves the injection) and sends it up the call; the echo comes back down and plays on the earpiece, and the same mic hears it again 150-1500 ms later (the network's round trip; acoustic reflections are under 20 ms). A Goertzel envelope per frequency finds the pattern twice; the echo counts when the same order of tones recurs at one delay, 15 dB above the noise, and the delay is reported. Before the echo call, a call to the tone line (99702) proves the downlink alone, so a missing echo says uplink (or the line) rather than everything. Cost: one call of at most 25 s (dial, about 8 s to answer, 5 s of pattern, hang up; a hard timeout), at most once a day, a landline-rate number: inside a flat, or under 10 ct per day on prepaid. Skips cleanly, as unknown: no modem, no SIM, not registered, no voice interface, no call path (call-audio-path failing), the daily call already made, or the number unset in the manifest. A pass proves works for modem-calls. If q6voice exposes in-call record/playback ports (downstream's VOICE_RECORD_RX, incall music), a digital loop could replace the acoustic one later; unknown on this driver.
- pulpoff/linux-surya: mainline 7.2.15 for the POCO X3 NFC on Mobian, both microphones and call audio - , 2026 surya's microphones are analog on the WCD9375 (bottom AMIC1 on ADC1, top AMIC3 on ADC2); capture link on <&swr2 1>; qcom,tx-port-mapping <2 3 4 5> gives ADC2 its own master port 3; LPI gpio7-11 NC (no DMIC pins in use); q6voice call uplink needs a running mono capture on TX_CODEC_DMA_TX_3
- Testrufnummer gesucht? Vollständige Liste für alle Zwecke - Placetel blueSIP's echo test +49 89 721010 99701 and its signal-tone line 99702; no warranty given for the list
2026-11-17
Should linux-phone-oco keep standing expert sessions, one per hard domain (audio, modem, sleep...), with the orchestrator routing questions to them - or keep expertise somewhere else?
The world has tried it under several names - specialised workers under a supervisor, hierarchical teams, blackboard systems, stateful agents - and converges on one split: the expert is a role and a body of written knowledge; a session is a disposable worker that takes the role up. Gas Town says it outright (an agent is a persistent identity, sessions are cattle; any session can hand off and restart from its hook). Anthropic's long-running harness found compaction alone not enough and had every fresh session get up to speed from a progress file, git and a feature list; its context-engineering guide names notes outside the window as the tool for iterative work with milestones. Claude Code itself moved this way: subagents may keep a per-role MEMORY.md, and agent teams start each teammate from project context and a spawn prompt, never the lead's history, and do not restore teammates on resume. Against expertise held in a long context: models recall worse as input grows (Chroma, context rot; Anthropic's attention budget), repeated summarising erodes detail (ACE: context collapse, brevity bias), and a session of 1000-1800 messages re-reads all of it each turn - after an idle hour without the cache, at full price - so a standing expert answering an occasional question is the costliest and not the most reliable way to answer it. Against a central router: a supervisor that relays every message plays telephone - lower scores and more tokens than agents handing off directly (LangChain); misalignment between agents (lost context, withheld information) is one of the three failure groups in 1600 traces (MAST). What works (Cognition, 2026): one writer per thing, other agents adding intelligence not actions; a consult works best given a fork of the asker's full context. Blackboard systems route by a shared record agents read, not by a relay. For us: most of the audio expertise is already rows in docs (5 research, 2 decisions, 27 backlog items name the microphone); what is not written is the tacit part - dead ends, where the experiment patches are, what hung the phone - and it now lives in hand-over notes outside any repository.
- Effective context engineering for AI agents - , 2025 Context rot and an attention budget: more tokens, worse recall. Three tools for long work - compaction (risks losing what matters later), structured notes outside the window (NOTES.md), sub-agents that return 1-2 thousand token summaries; load knowledge just in time by reference.
- Effective harnesses for long-running agents - , 2025 Compaction alone was not enough: each fresh session gets up to speed from a progress file, the git log and a feature list, works one item, commits and writes its progress. Whether specialised agents beat one general agent is left open.
- Orchestrate teams of Claude Code sessions - , 2026 Teammates message each other directly, not only through the lead; 3-5 teammates; each starts from project context and a spawn prompt, never the lead's history; in-process teammates are not restored on resume; for routine or sequential work one session is cheaper.
- Claude Code agent memory frontmatter - , 2026 Since v2.1.33 a subagent can keep its own MEMORY.md (project scope in .claude/agent-memory/NAME/), its first 200 lines put in its prompt each time: the field writes expertise down per role rather than keeping it in a session; each role's memory is siloed from the others.
- Multi-Agents: What's Actually Working - , 2026 A narrower class works: writes stay single-threaded and extra agents contribute intelligence, not actions. Consulting a 'smart friend' works best by sharing a fork of the asker's full context; unstructured swarms of negotiating agents are a distraction.
- Benchmarking Multi-Agent Architectures - , 2025 A supervisor that relays every message plays telephone: it scored lower and spent more tokens than agents handing off directly; removing routing chatter from the workers' context closed much of the gap.
- Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models - , 2025 Knowledge kept by rewriting one summary erodes (context collapse) and drifts toward the terse (brevity bias); itemised, incremental additions to a playbook keep the detail. ICLR 2026.
- Why Do Multi-Agent LLM Systems Fail? - , 2025 1600+ traces, 14 failure modes in three groups: system design, misalignment between agents (lost context, ignored input, withheld information), task verification. Gains from multi-agent systems are often minimal. NeurIPS 2025.
- Context Rot: How Increasing Input Tokens Impacts LLM Performance - , 2025 Models do worse as input grows, even on simple tasks and well below the window's size; focused inputs beat full ones.
- Exploring Advanced LLM Multi-Agent Systems Based on Blackboard Architecture - , 2025 Agents share one blackboard instead of private memories; a control unit picks who acts from what is on it. With 2510.01285 (agents volunteer for requests posted to the board): routing by a shared record, not by a central relay.
- Sleep-time Compute - , 2025 Stateful agents keep editable memory blocks; a separate agent rewrites them between tasks into clean, concise learned context, so the working agent need not re-derive it.
2026-11-17
How does the Pixel 2 XL (taimen) stand?
Far from surya. Nothing is measured here. By community report it boots mainline 5.10-rc2 on a basic device tree from an out-of-tree fork (kcxt/linux-wahoo, last push 2022-02-27), USB networking and flashing work, there is no display, the battery does not work. No mainline device tree, no pmaports package, no one has reported touch, audio, modem, wifi or the rest. Worth a lab test one day only as the cheap member of the pair, after surya's list: it is the one with a documented boot.
- Nura (postmarketOS) wiki: Google Pixel 2 XL (google-taimen) - Mainline boots with a basic DT (5.10-rc2), USB networking and flashing work, no display; the only wiki page of either phone (walleye has none). Revised 2026-09-05 and 2026-09-27 (bot); status by Casey/kcxt.
- kcxt/linux-wahoo: Mainline Linux for the Google Pixel 2XL (And 2?) - Out-of-tree mainline port, created 2020-07-20, last pushed 2022-02-27: msm8998-google-taimen.dts, -walleye.dts and wahoo.dtsi (branch wahoo/5.17), panel and DPU/DSC work, a 5.11 submission branch.
- Linux mainline: arch/arm64/boot/dts/qcom (MSM8998 device trees) - No Pixel 2 / 2 XL device tree in mainline (checked 2026-11-17); MSM8998 boards there: OnePlus 5/5T, Xiaomi Mi 6, Sony yoshino, F(x)tec Pro1, HP Envy x2, Lenovo Miix 630, Asus NovaGo; msm8998.dtsi still edited (2026-09-17).
- Nura pmaports: device packages of Google phones (device/community, device/testing) - device-google-walleye and device-google-taimen are absent from device/main, community and testing (listed 2026-11-17); Google packages there are sargo/bonito (community), blueline, flame, oriole, raven (testing).
2026-11-17
What does Android on the Pixel 2 give, by public specifications, that a Linux phone is measured against (sensors, sleep, audio, battery)?
Public sources only (table in research/google-walleye/2026-11-17/android-reference-public-specs.md). Android reference: 5.0 in AMOLED 1080x1920, 2700 mAh, two front stereo speakers about 89 dB(A), no 3.5 mm jack (USB-C audio, Bluetooth 5 with aptX HD), 12.2 MP rear with OIS and laser focus, 8 MP front, LTE Cat. 15, NFC, eSIM plus nano-SIM, rear fingerprint, Active Edge squeeze. Sensor set to count: accelerometer, gyro, magnetometer, barometer, proximity, light, Hall, squeeze, step counter and detector, behind a sensor hub. Chips (only from the Pixel 2 XL teardown, so likely not stated for walleye): LSM6DSM IMU, AK09915C magnetometer, BMP280 barometer, AK8789 Hall, TMD4903 light, VL53L0X ranger, TAS2557 amp, DRV2624 haptics; the vendor kernel confirms TAS2557, DRV2624 and a ranger for walleye. Android battery runs (Notebookcheck): idle Wi-Fi off 24 h 17 min, web 9 h 35 min, video 9 h 24 min; field 15 to 17 h unplugged a day. Doze (when unplugged, still, screen off): network suspended, wake locks ignored, alarms and jobs deferred, maintenance windows spread out. Last software Android 11, build RP1A.201005.004.A1, support ended October 2020. Not known yet: standby current per hour (none published), real sensor list and rates on walleye, charger wattage, speaker level under a test tone. Only Android booted on our phone can give these (backlog google-walleye-lab/android-reference-walleye; needs the author).
- Wikipedia: Pixel 2 - walleye-research-vendor Cameras (rear IMX362 12.2 MP, front IMX179 8 MP), Pixel Visual Core, eSIM, software versions (Android 8.0 to 11).
- Notebookcheck: Google Pixel 2 review - walleye-research-vendor, 2017 Measured display (426 cd/m2 peak, PWM about 245 Hz), speaker level, battery runtimes on Android (idle Wi-Fi off 24 h 17 min), GPS walk test.
- iFixit: Google Pixel 2 XL teardown - iFixit, 2017 Chip names (IMU LSM6DSM, magnetometer AK09915C, barometer BMP280, Hall AK8789, light TMD4903, ToF VL53L0X, amp TAS2557, haptics DRV2624, charger SMB1381, NFC PN81A, Pixel Visual Core). Pixel 2 XL only: likely, not stated, for walleye.
- LineageOS wiki data file for walleye (devices/walleye.yml) - walleye-research-vendor Public spec as LineageOS lists it: SoC, 4 GB, 2700 mAh, stereo front speakers, Bluetooth 5, branches 16.0 to 22.2, kernel repo, fastboot install.
- 9to5Google: Pixel 2 final update (December 2020) - walleye-research-vendor, 2020 End of Pixel 2 support: last build RP1A.201005.004.A1, Android 11.
- Droid Life: Pixel 2 battery life - walleye-research-vendor, 2017 Field figures: 4 to 5+ h screen-on, 15 to 17 h unplugged a day.
- Android developers: Optimize for Doze and App Standby - walleye-research-vendor What Android does when idle: network suspended, wake locks ignored, alarms deferred, maintenance windows; the sleep behaviour a Linux phone is measured against.
2026-11-17
How does the Pixel 2 (walleye) stand?
Nothing reported on mainline: no wiki page, no pmaports package, no mainline device tree. Only the out-of-tree fork kcxt/linux-wahoo has a walleye device tree (wahoo/5.17), and nobody says it boots. Android (LineageOS 22.2) and an old Ubuntu Touch 16.04 port exist. Everything is unknown; test it only after taimen has shown the way, since both share the SoC and the kernel fork.
- kcxt/linux-wahoo: Mainline Linux for the Google Pixel 2XL (And 2?) - Out-of-tree mainline port, created 2020-07-20, last pushed 2022-02-27: msm8998-google-taimen.dts, -walleye.dts and wahoo.dtsi (branch wahoo/5.17), panel and DPU/DSC work, a 5.11 submission branch.
- Ubuntu Touch: Google Pixel 2 (walleye), old releases - Only the 16.04 (xenial) release exists; the current release does not support the phone. A Halium/Android-kernel port, not mainline.
- LineageOS wiki: Google Pixel 2 (walleye) - Android, current LineageOS 22.2 (Android 15) on kernel 4.4 for walleye; taimen has the same page shape. Shows the phones stay alive on Android, not on mainline.
- Nura pmaports: device packages of Google phones (device/community, device/testing) - device-google-walleye and device-google-taimen are absent from device/main, community and testing (listed 2026-11-17); Google packages there are sargo/bonito (community), blueline, flame, oriole, raven (testing).
2026-11-17
How did others boot Linux on the Pixel 2 family (boot image, A/B, fastboot boot, dtbo), what boots, and how did they reach a phone with no display?
Only the Pixel 2 XL (taimen) is reported to have booted mainline, by kcxt (Caleb Connolly) on an out-of-tree 5.10 to 5.17 fork, 2020 to 2022: black screen, USB networking to a shell, flashing works; a March 2021 mainline submission shows no sign of being merged. Walleye has a 13-line tree in the same fork and no report that it boots; neither phone is in pmaports (Pixel 3, 3 XL, 3a are). Ubuntu Touch (Halium 9, Android 4.4 kernel) has only an abandoned 16.04 port for walleye, with boot loops and no USB networking in the forum threads read. How the no-display phone was reached: USB peripheral mode only (SuperSpeed dropped), kernel console on a USB serial gadget ttyGS0 plus ttyMSM1 earlycon, clk_ignore_unused; a UART through the USB-C sideband pins ('Android Debug Cable', 115200 baud) which the pmOS wiki lists as tested with walleye - enabled with `fastboot oem uart enable`; pstore only partly worked. What the bootloader wants (XL only, read): a dtbo partition holding an overlay with id 2704 (0xa90) or the bootloader refuses to boot; pmaports' Pixel 3 packages append the dtb to the kernel (4096-byte pages, kernel offset 0x8000, ramdisk 0x1000000), LineageOS uses Image.lz4-dtb with recovery in the boot partition and A/B, 8 MB dtbo. Detail and URLs in research/google-walleye/2026-11-17/how-others-booted-wahoo.md. Not known yet: whether this phone's bootloader accepts `fastboot boot` of our image; the dtbo id walleye needs (the README is XL only; changing dtbo writes to the phone); whether `fastboot oem uart enable` only sets a RAM flag or writes something (until known, it is a change to the phone); the boot header version; slot handling for a Linux boot; any report for the small Pixel 2 booting mainline. Ways forward: (1) read walleye's dtbo overlay ids without writing (from Android if it boots, or Google's factory image, a proprietary download - decision needed); (2) try a first `fastboot boot` of a kernel with appended dtb and a USB-gadget serial console once devlab's fastboot mode exists; (3) build the USB-C debug cable and enable the UART only after a decision on the oem command.
- Nura (postmarketOS) wiki: Google Pixel 2 XL (google-taimen) - Mainline boots with a basic DT (5.10-rc2), USB networking and flashing work, no display; the only wiki page of either phone (walleye has none). Revised 2026-09-05 and 2026-09-27 (bot); status by Casey/kcxt.
- kcxt/linux-wahoo: Mainline Linux for the Google Pixel 2XL (And 2?) - Out-of-tree mainline port, created 2020-07-20, last pushed 2022-02-27: msm8998-google-taimen.dts, -walleye.dts and wahoo.dtsi (branch wahoo/5.17), panel and DPU/DSC work, a 5.11 submission branch.
- kcxt/linux-wahoo branch wahoo/5.17: msm8998-google-walleye.dts and the shared wahoo dtsi - walleye-research-vendor, 2022 What mainline can already express for wahoo: UFS, USB peripheral, one DSI, GPU, Wi-Fi, SLPI/ADSP, regulators; walleye file is 13 lines and sets no panel; boots with console on ttyMSM1 and USB-gadget ttyGS0, ramoops at 0xa1810000.
- kcxt/dtbo-google-wahoo-mainline: minimal dtbo for the Pixel 2 XL - walleye-research-vendor, 2020 The Pixel 2 XL bootloader refuses a kernel unless dtbo holds an overlay with id 2704 (0xa90); stock cmdline has androidboot.dtbo_idx=12. XL only; walleye's id not known.
- LKML March 2021: [PATCH] arm64: dts: add support for the Pixel 2 XL, with review - walleye-research-vendor, 2021 Boots with USB networking, panel needs DSC, dtbo overlay id required, clk_ignore_unused, Wi-Fi needs diag-router; no sign it was merged.
- postmarketOS (Nura) wiki: Serial debugging / Cable schematics, Google Pixel Android Debug Cable - walleye-research-vendor USB-C sideband UART cable tested with Pixel 2 (walleye), 2 XL, 3 and later; fastboot oem uart enable; Suzy-Q is the wrong cable.
- Peter-Easton/android-debug-cable-howto - walleye-research-vendor How to build the Pixel USB-C debug UART cable (A1 GND, SBU1 RX, SBU2 TX, 115200 baud).
- Nura pmaports: device packages of Google phones (device/community, device/testing) - device-google-walleye and device-google-taimen are absent from device/main, community and testing (listed 2026-11-17); Google packages there are sargo/bonito (community), blueline, flame, oriole, raven (testing).
- LineageOS wiki: Install LineageOS on walleye - walleye-research-vendor Latest Android 11 firmware first; OEM unlock then fastboot flashing unlock; recovery flashed into boot; no set_active step, no fastboot boot step.
- Ubuntu Touch: Google Pixel 2 (walleye), old releases - Only the 16.04 (xenial) release exists; the current release does not support the phone. A Halium/Android-kernel port, not mainline.
- UBports forum: walleye install threads (topics 5639, 6251, 12600) - walleye-research-vendor Halium 9 on walleye: boot loops, Slot Unbootable, no RNDIS after flashing halium-boot; Pixel 2 XL Ubuntu 24.04 claim Sept 2026, unverified.
- Halium docs: debug build over USB networking - walleye-research-vendor Telnet at 192.168.2.15 from the initrd, host 192.168.2.1; useless when the kernel does not start.
2026-11-17
Which chip is each part of the Pixel 2 (walleye) and how is it wired, by Google's GPL wahoo kernel device tree and the mainline port's tree?
Read from the LineageOS copy of Google's wahoo kernel (4.4, branch lineage-22.2) and kcxt/linux-wahoo wahoo/5.17; observed facts only, nothing copied; table in research/google-walleye/2026-11-17/vendor-kernel-hardware-inventory.md. Walleye is the HTC-built half of the pair: its files are under dts/htc/ and called "muskie"; one base plus one of two overlays by board revision (xa/xb/xc or xd/xe/a; our MP1 maps to one of them - not known yet). SoC MSM8998 v2.1 with PM8998, PMI8998 and PM8005. Parts: panel Samsung S6E3FA5 5.0 in 1080x1920 command mode, 4 DSI lanes, reset GPIO94, TE GPIO10, rails PM8998 L14 1.8 V and L22 3.0 V, backlight by DCS (no WLED), always-on modes. Touch Synaptics DSX at I2C 0x20 on the BLSP1 QUP5 bus (GPIO87/88), IRQ GPIO125, reset GPIO89. Audio: WCD934x "Tavil" codec on SLIMbus, TI TAS2557 stereo speaker amp at I2C 0x4d, no jack; NXP TFA98xx amps are in the tree but disabled. Haptics TI DRV2624 (LRA 155 Hz, I2C 0x5a, reset GPIO95). LED: TI LP5562 on early revisions, PMI8998 RGB on later. Charger: PMI8998 SMB2 with Type-C PD, TPS61099 for USB host power, NXP PTN36241G redriver. Fuel gauge: PMI8998 FG gen3 with HTC battery module, 2700 mAh, 4.4 V. NFC: NXP NQ-class at 0x28 plus PN81A secure element on SPI. Fingerprint FPC1020 family (IRQ GPIO86, reset GPIO128). Wi-Fi and Bluetooth: Qualcomm WCN3990 (Bluetooth HCI on BLSP1 UART3). Cameras: two CCI sensors, rear with autofocus, OIS, EEPROM and flash, laser ranger at I2C 0x29; the sensor chips are not named in the tree (public specs: Sony IMX362 rear, IMX179 front). Pixel Visual Core ("Easel") on PCIe 0 with a BCM15602 PMIC and SPI. Storage UFS. Sensors (IMU, magnetometer, barometer, light, Hall) are not in the application processor's tree: the SLPI sensor-hub DSP owns them, firmware proprietary. For a phone with no display: stock describes a RAM console (ramoops) at 0xa1100000, 2 MiB, plus an alternate at 0xa3800000; the mainline port uses 0xa1810000 instead and boots with console on ttyMSM1 (BLSP2 UART1) and a USB-gadget serial ttyGS0 - which address survives a reset on this phone is not known yet. The mainline port's walleye file is 13 lines and sets no panel (the shared file's panel is taimen's LG one), and enables UFS, USB peripheral, one DSI, GPU, Wi-Fi, SLPI and ADSP, regulators - nothing for touch, audio, haptics, NFC, gauge, charger, cameras, sensors. Not known yet: camera and sensor chips on walleye itself, touch controller model, codec exact part, fingerprint wiring, Active Edge sensing, UART test pads, which overlay MP1 uses.
- LineageOS android_kernel_google_wahoo (lineage-22.2): device-tree sources of walleye and taimen - Google, HTC, LG, Qualcomm; kept by LineageOS, 2025 GPL-2.0 Linux 4.4 kernel of both wahoo phones. Walleye (HTC-built, project name muskie) is under arch/arm64/boot/dts/htc: panel, touch, audio amp, haptics, NFC, camera, battery, memory map. Read as facts for a hardware table; ports of code keep copyright and licence.
- kcxt/linux-wahoo branch wahoo/5.17: msm8998-google-walleye.dts and the shared wahoo dtsi - walleye-research-vendor, 2022 What mainline can already express for wahoo: UFS, USB peripheral, one DSI, GPU, Wi-Fi, SLPI/ADSP, regulators; walleye file is 13 lines and sets no panel; boots with console on ttyMSM1 and USB-gadget ttyGS0, ramoops at 0xa1810000.
- iFixit: Google Pixel 2 XL teardown - iFixit, 2017 Chip names (IMU LSM6DSM, magnetometer AK09915C, barometer BMP280, Hall AK8789, light TMD4903, ToF VL53L0X, amp TAS2557, haptics DRV2624, charger SMB1381, NFC PN81A, Pixel Visual Core). Pixel 2 XL only: likely, not stated, for walleye.
- AOSP: Build Pixel kernels (legacy branches) - Pixel 2 and 2 XL share one kernel, device/google/wahoo-kernel, branch android-msm-wahoo-4.4-android10-qpr3.
2026-11-17
How should hardware for debugging and bring-up (cables, adapters, meters) be kept for every phone, claimed versus confirmed, and read by the lanes?
Read: Snipe-IT (model vs asset; status labels deployable/pending/archived; purchase_cost with purchase_date), Part-DB (part vs lot by location; supplier price details with quantity breaks; a needs-review flag), KiCad (custom fields MPN/Manufacturer by convention; no status or price date), OpenBOM (item vs usage), the kernel's serial-console doc (software contract only), and for the Pixel UART cable bacon.dev (2020, updated 2022), Peter-Easton's howto (title says Pixel 2/3/4, body details the 3), xairy's pixel-kgdb (FT232R supports break, CP2102N does not), google/usb-cereal (DIP 1.8/3.3 V, archived 2023-01-10). Not read: postmarketOS Serial_debugging (301 to nura.eco, then Anubis denial), iFixit (404), LineageOS device pages (403), Part-DB parts page (503).
2026-11-17
How should the phones' health suites be organised to cover every part and feature, stay quick to change and dependable, and avoid Python?
What is: devlab-health, a static Rust runner (lab-tools/health), runs shell checks on the phone after every boot in two layers (base, shell): 11 generic in lab-tools and 5 of surya's own in surya-lab; each prints 'pass|fail|skip TEST COMPONENT detail' and docs' tests table says what each pass proves. The weak spot is computation in shell: three of surya's checks carry a Goertzel filter written in awk and a tone made byte by byte with printf, because lab-tools' tested tone crate never reaches the phone. The phone has no Rust toolchain (it has python3, which the lab refuses), so rust-script (stable, 0.36 on the lab) cannot run there and would need a toolchain and network on the phone; Cargo's own single-file scripts (frontmatter, cargo PR 16569) are still nightly-only in Cargo 1.99. KTAP is the kernel's test output (ok/not ok, SKIP, nested suites) - a format our lines map onto if LAVA-style tools are ever wanted. Shape that fits: shell stays for what is a reading (sysfs, a command's output; ten readable lines), and anything with numbers, timing or a state machine (tones, echoes, calls, sleep counters) is a subcommand of one static multi-call Rust binary shipped with devlab-health (e.g. devlab-health tone find, devlab-health call echo), built with its unit tests and recorded fixtures on the lab and cross-built by health/build.sh; rust-script is the lab's prototyping and one-off analysis tool against recordings fetched from the phone, a prototype becoming a subcommand once it is kept. Coverage is read off the data: a query of every device's components with no test that proves works, and a layer per cost - base, shell, then telephony (calls and data, gated by budget and once a day) and witnessed (needs a person).
- rust-script: run Rust files and expressions as scripts - stable today on the lab (0.36): a single .rs file with its dependencies, compiled and cached on first run
- Rust project goal 2026: cargo-script - Rust project, 2026 single-file Cargo packages with frontmatter, unstable for years, stabilisation in progress (cargo PR 16569); Cargo 1.99 on the lab still asks for -Zscript
- The Kernel Test Anything Protocol (KTAP), version 1 - Linux kernel the kernel's test output: ok/not ok with SKIP, nested suites; a format our one-line reports could be converted to
2026-11-17
What in the commons already does part of an ideal knowledge base, and would idealkb be one nature under a second name?
tad (creation-guidelines/tad-engine) is the engine: tables declared as data after Frictionless Table Schema, checked rows, canonical files, SQL, named queries and records with their header line as their description (tad statements is already an index of every question and record a base keeps). text-as-data-template is the template for a base kept as tad data - the same nature as idealkb - and has drifted: last changed 2026-11-04, still the vendored Python engine on a DuckDB schema that every base left on 2026-11-11 (as the vendored engines had drifted, three of four behind). ideal-project-playbook is how to run a software project - the loop, guards, CI, honesty - whose own docs/ is a tad base; its kit/templates for backlog, development log and idea page are records a base keeps as tables, and its findability test (real questions, the answer within the first three) is the measure a base needs. software-engineering-canon is a base itself (the spike the template came from). ideal-agent (grenudi/ideal-agent, 2026-11-17) is how agents work: practices, skills, hooks, and its own tad base; it keeps only what is general and leaves a project's domain in the project's data. ocoeco's marks (oco.toml exports, holds) and lenses say how a base fits the observatory's picture - its face, not its organisation. linux-phone-oco/docs is one tad base for every linux-phone place (2026-11-17-one-database), with prompts/ (role briefs), research/ (long prose), and rendered docs/ the face reads. Overlap: idealkb would be text-as-data-template under a second name; nothing else holds how knowledge is organised. Gap: no base links a record to what it is about, and no base has an entry that routes questions to queries.
- text-as-data-template - , 2026 The commons' template for a knowledge base kept as data; last changed 2026-11-04 and still describing the vendored Python engine on a DuckDB schema (bin/adopt-engine.sh, .tad/), which every base left for tad on 2026-11-11.
2026-11-17
How do open practice and agent makers organise a knowledge base so that people and agents reach what they need without reading all of it?
They agree. (1) One small entry that is always read and routes onward, saying what each target is for: llms.txt, the root AGENTS.md (nearest wins), PhotoCraft's Read/Why orientation table, Johnny.Decimal's index, datapackage.json. (2) What is always loaded is kept small: CLAUDE.md under 200 lines, no more than ten per level, llms.txt's skippable Optional. (3) Detail in stages: Skills' name and line, then body, then linked files; Claude Code loads nested CLAUDE.md only when its subtree is touched; context engineering keeps lightweight identifiers - paths, stored queries - and loads content just in time. (4) Small units with stable addresses: evergreen notes whose titles work like APIs, numbered ADRs, Wikidata's Q and P ids. (5) Facts apart from explanation: Diátaxis' reference against explanation, Wikidata statements and infoboxes beside prose. (6) One decision per record, superseded rather than deleted (Nygard, MADR). (7) Every statement is about an item by its id and cites who says so (Wikidata). (8) Views are generated from the source data (PhotoCraft's scorecard, Mintlify's llms.txt). Tensions: hierarchy against association (fixed buckets vs dense links - a small fixed index with free links beneath answers both); one file against many (concatenation does not save context; loading on demand does). No source measured how much any of it speeds an agent - the measure here is docs' own (kb-navigation-measured).
- Diátaxis: a systematic approach to technical documentation - , 2021 Four kinds by the reader's need - tutorial, how-to, reference, explanation - never mixed on one page. Reference is neutral and looked up: in a tad base, the tables; how-to is the named records and briefs; explanation is decisions, concepts and the occasional essay.
- The /llms.txt file - , 2024 One Markdown file at a fixed path: a title, a one-line summary, then sections of links with a note each, and an Optional section an agent may skip when short of context. A router, not the content.
- AGENTS.md - , 2025 A README for agents; the nearest AGENTS.md to the file being edited wins. The one file every agent already looks for - the place for a base's single entry.
- Documenting Architecture Decisions - , 2011 One significant decision per record, numbered and never reused; a reversed decision is kept, marked superseded, pointing at what replaced it. docs' decisions table is this, with rejected beside it.
- MADR: Markdown Architectural Decision Records 4.0 - , 2024 Adds considered options with pros and cons and a status that says superseded by which. What docs' decisions already keep as decision, why, rejected.
- Data Package (Frictionless Data) - , 2017 datapackage.json at the top is the descriptor and index of the data's resources, each with a stable name and a schema. tables.toml follows its Table Schema; tad statements is the same kind of index for questions.
- Docs as Code - , 2024 Documentation in plain text, in git, reviewed and tested like code. What every tad base already is.
- Evergreen notes - , 2020 Atomic, concept-oriented, densely linked notes whose titles work like APIs; outline notes link many notes. One row is one such note; a checked link is the dense link; a query is the outline note.
- Johnny.Decimal - , 2024 A fixed small index - no more than ten at each level - kept as a first-class record of every id. A base's entry should be that small.
- The PARA Method - , 2023 Organise by actionability: projects, areas, resources, archives. In a base, what is actionable is read off status (open backlog), not filed by folder.
- Help:Statements (Wikidata) - , 2024 Every statement is about an item, by its id, with references saying who says so. The missing piece in docs: records say which place they are of, but not checked which thing they are about.
- Help:Infobox (Wikipedia) - , 2024 A fixed-format summary of facts beside the prose that explains them; the facts must stand in the prose with citations too. Tables for facts, prose for reasons.
- Effective context engineering for AI agents - , 2025 Context rot and an attention budget: more tokens, worse recall. Three tools for long work - compaction (risks losing what matters later), structured notes outside the window (NOTES.md), sub-agents that return 1-2 thousand token summaries; load knowledge just in time by reference.
- Equipping agents for the real world with Agent Skills - , 2025 Three levels: a name and one line always loaded, the body when relevant, linked files only when needed; scripts run without being read. The shape of a base's entry: AGENTS.md, tad statements, a query's rows, one row.
- Manage Claude's memory (Claude Code) - , 2026 CLAUDE.md up the tree loads at start, nested ones when their subtree is touched; under 200 lines; imports organise but do not save context; procedures go into skills. CLAUDE.md is @AGENTS.md, one source.
- PhotoCraft AGENTS.md - , 2026 Root AGENTS.md: who it is, then an Orientation table (Read / Why) of about 14 docs pages, the workspace map, golden rules, how to pick work, and where each thing is tracked and which pages are generated from which data. ArtCraft (storytold/artcraft) routes by nested AGENTS.md and .claude/rules instead.
- Simplifying docs for AI with /llms.txt - , 2024 llms.txt as the slim index and llms-full.txt as the whole site in one file, both generated. For a base's published site, generated from the data - not the agent's entry.
2026-11-17
Which microphones does surya have, and on which inputs?
Two built-in analog microphones on the WCD9375: the bottom one on AMIC1 (mic bias 1) into ADC1, the top one on AMIC3 (mic bias 3) into ADC2 with its input mux at INP3; the headset mic is AMIC2 (bias 2) on the same ADC2 at INP2. ADC1 comes back over the TX SoundWire bus on master port 2, ADC2 needs its own master port 3 (qcom,tx-port-mapping <2 3 4 5>): sharing port 2 with ADC1 lost the top mic and turned the bottom one to full-scale noise (pulpoff). No digital mics: pulpoff names LPI gpio7-11 NC, among them gpio8-11, the DMIC clock and data pins (vendor gpio26-29), and records both mics through ADC1/ADC2 on mainline. The TX DMIC1-3 routes read on 2026-11-17 come from sdmmagpie-qrd-overlay.dts, Qualcomm's QRD reference board kept in Xiaomi's tree, which declares the SWR_ADC0/ADC2 routes beside them. Measured on the phone (bring-up, 2026-11-17 04:37 UTC, test/surya-mic with <&swr2 1>): mic-records pass and mic-hears-speaker pass, a 1 kHz tone at -19.4 dBFS against -76.3 dBFS of noise through ADC1. The DMIC experiment (pins at mux 1, VA DMIC clocks on a switch) answered a question surya does not ask and is to be dropped.
- pulpoff/linux-surya: mainline 7.2.15 for the POCO X3 NFC on Mobian, both microphones and call audio - , 2026 surya's microphones are analog on the WCD9375 (bottom AMIC1 on ADC1, top AMIC3 on ADC2); capture link on <&swr2 1>; qcom,tx-port-mapping <2 3 4 5> gives ADC2 its own master port 3; LPI gpio7-11 NC (no DMIC pins in use); q6voice call uplink needs a running mono capture on TX_CODEC_DMA_TX_3
- sm7150-mainline/linux PR 60: working WCD9375 microphone capture on davinci (open) - , 2026 The four faults of SM7150 WCD capture: swr_tx_data mux 3, the TX bus wakeup IRQ, port numbering shifted by the TX controller's one dout port, and the capture link's DAI 1; plus MultiMedia2 for capture. The place to contribute surya's fixes upstream, beside it rather than in a parallel series
- Xiaomi's GPL kernel (surya-q-oss): sdmmagpie-qrd-overlay.dts, the sound card routing Xiaomi kept from Qualcomm's QRD board - , 2020 Declares TX DMIC1-3 (bias 1/3) and AMIC2 together with TX SWR_ADC0/ADC2 from ADC1/ADC2: a reference board's routing, not proof of DMICs on surya; every TX/RX path is routed to VA_MCLK
2026-11-17
How can mobile data be checked after every boot within about 3 GB?
Per run: the modem registered and its bearer connected (mmcli), the bearer's interface found from ModemManager, then over that interface only (curl --interface, so Wi-Fi cannot pass for it): a DNS lookup, five pings to a fixed address (round trip, loss), and a 100 kB HTTPS download timed (speed.cloudflare.com/__down?bytes=100000 or a file the project hosts), about 150 kB with overheads. Boots run up to ~45 a day in bring-up, so about 7 MB on a heavy day; once a week a 5 MB download measures throughput. That is under 0.3 GB a month even on busy months: the 3 GB lasts most of a year at the worst rate and years at an ordinary one. A check also reads the bearer's own byte counters (the interface's /sys/class/net/IFACE/statistics before and after) so each run states what it used, and skips when the month's total passes a budget set in the manifest. Skips without a SIM, as the modem checks already do.
2026-11-17
Where does orchestration's work stand, for a fresh orchestration session to take it up without this session's long context?
ROLE: orchestrator (ideal-agent card; brief ideal-agent-linux-phone-oco/orchestration.md, which now opens with Role/Name). Owns the conveyor - lab-tools (devlab; lpoco-health's packaging and the Alpine path are the conveyor's, its code is lpoco-health's), device-template, docs' face and its queries - and tends the agents. Notes: side-session-notes/local_325ef65d-55c6-44bd-85b9-53de24869d6e/orchestration-3.md. LIVE: surya lane - waker scheduled task linux-phone-keeper-waker (hourly) only nudges the surya coordinator (local_0ecf107e), reading tad q phone-next; the coordinator starts keepers, which take tad q phone-next (one row). Walleye lane - walleye coordinator (local_7fb92f70); google-walleye (FA81N1A00790) sits in fastboot; devlab fastboot state|getvar|boot now|reboot now, by serial. devlab-watch@surya-lab runs ~/.local/bin/devlab built from ~/Projects/linux-phone-oco/lab-tools at main (1b35fc6); suite put --runner builds in that tree, so build devlab only from it. lpoco-health 0.1.7 published by the conveyor (lpoco-health-v tags); #78's provides + old-name links ship with the next release. LANDED THIS TURN OF THE ROLE (2026-11-17): lab-tools 71 (kernel try reads the booted entry off cmdline initrd=initramfs-NAME), 72 (suite put --runner builds the runner), 79 (fastboot by serial; flash only with [fastboot] writes = true; guard refuses raw fastboot but devices/getvar/help); device-template 3; docs 202 (queries/phone-next.sql, 603 B vs 14.9 KB), 224 (decision 2026-11-17-fastboot-by-serial-writes-by-manifest). OWED: (1) the read-weight of the first keeper the surya coordinator starts with Role: keeper / Name: lines (it was asked to send the session id) -> ideal-agent-roles local_dd7369b2, backlog measure-a-role-start; the 12:33 scheduled keeper read 75,649 tok / 39 KB, not comparable (route, connectors). (2) trim the briefs of what the role cards now say (renew thresholds, the read-only-when shape, recording rules said three times); start-weight after docs 230: phone-keeper 25.6 KB, surya lane 21.1, coordinator 22.4, orchestration 27.5. (3) lab-tools backlog by the weakest link: kernel-orphan-modules next (health-*, hear-* are lpoco-health's). WAITS ON OTHERS: surya-lab surya-fastboot-serial (phone queue: devlab flash refuses surya until its manifest says [fastboot] serial, likely dc21014b unread, and writes = true); google-walleye-lab [fastboot] serial line (walleye coordinator's). The author's: dispatcher permission mode/model, gather.yml in five repos, archiving linux-phone-oco/lens, cards for charging, GPS, programs on argenv. DO NOT UNDO: suite put takes the Alpine package and reads the lab at main; gather lands only after 15 quiet minutes; a kept kernel sorts 1-kept-* after tries; remove keeps shared modules; every fastboot call names its serial and nothing is written over fastboot without writes = true; kernel try trusts LoaderEntrySelected, then the running initramfs, then the release name. SIGNS: land is killed (143) when its wait outlives the caller's timeout - run it in the background; make verify refreshes docs/ and IKB.md, run it twice or render first; a hook from before 0.3.2 re-roles a running session on any quoted Role: line - do not quote Role lines to older sessions.
2026-11-17
Where does orchestration's work stand, for a fresh orchestration session to take it up without this session's long context?
ROLE: orchestrator (brief ideal-agent-linux-phone-oco/orchestration.md). Notes and the move scripts (move-lane.sh, replay.sh, select.sh): side-session-notes/local_7d95b264-ad32-49ad-932a-7f19e9f9806d/move/. DONE 2026-11-17 (decision 2026-11-17-commons-and-device-bases, all landed and read back from main): google-walleye-lab #14 and surya-lab #134 got their own tad bases from device-template; walleye's rows moved (google-walleye-lab #15, docs #353) and surya's (surya-lab #136 with all 143 runs identical row for row, docs #360), each under the lease orchestration-move, by the rule of decision 2026-11-17-moving-a-lane; the lane briefs (walleye-coordinator, surya-coordinator, phone-keeper), the five launchers and the waker read the lab's own base (phone-next, lane-next --needs, phone-stands) and record with ikb; device-template got lane-next and phone-stands; lab-tools #82 (gather files into the base; devlab-watch@surya-lab restarted on it); tad 0.7.1 (references by a table's key; pins bumped in the template and both labs); feed-device-bases (#355, #356) pulls each base's parts daily and devices.base names both labs (#361); the face rendered from the pulled parts. move-device-rows, gather-into-device-base, launchers-per-device done. OPEN (commons-only): derive-parts-in-base (a base derives parts.measured from its own runs; until then surya's measured fields stay as seeded at the move), about-across-bases (abouts naming the device, a milestone or another base's subject were left empty in the move), device-template-follow; the older owed items of orchestration-2026-11-17-night (keeper read-weight, trimming briefs, kernel-orphan-modules) still stand. WAITS ON OTHERS: the walleye coordinator closes docs PRs 335, 337, 310 and settles 316 (two unlanded s0n-try rows contradicting main; to be recorded in the lab if they hold). SIGNS: a shared ~/.local/bin/tad was overwritten by another project's make setup (0.5.0) - install-tad.sh defaults to ~/.local/bin on a shared lab; jq's index(.) inside a pipe evaluates . against the array (bind $x first); the ideal-agent guard now refuses writing tad sql (TAD_SQL_WRITE_OK=1 for a recorded one-time migration); a refused command skips its git checkout too - read the branch before committing; land refuses a branch that puts back lines main changed; a pages build is not triggered by the feeds bot's push (the 3-hourly schedule catches up). DO NOT UNDO: the previous hand-overs' lists; no walleye or surya rows land in docs any more - a lane records in its lab.
2026-11-17
Where does orchestration's work stand, for a fresh orchestration session to take it up without this session's long context?
ROLE: orchestrator (brief ideal-agent-linux-phone-oco/orchestration.md, which opens with its Role/Name lines). Owns the conveyor - lab-tools/devlab, device-template, the Alpine path, docs' face and queries - and tends the agents. Notes: side-session-notes/local_325ef65d-55c6-44bd-85b9-53de24869d6e/orchestration-3.md (state, signs, every landing of 2026-11-17). LIVE: surya lane - surya coordinator (local_0ecf107e) starts keepers with Role: keeper / Name: surya-keeper-N / Also practices: 42 and phone-keeper.md by path; waker linux-phone-keeper-waker only nudges it, reading tad q phone-next --device xiaomi-surya. Walleye lane - walleye coordinator (local_7fb92f70); google-walleye in fastboot on slot b with slot a unbootable (its bootloader's doing in a RAM boot try); slot_switch stays false until its decision and the author's word. ~/.local/bin/devlab is built from ~/Projects/linux-phone-oco/lab-tools at main (d510232); devlab-watch@surya-lab restarted on it. LANDED SINCE THE EVENING HAND-OVER: lab-tools 80 (fastboot boot reads the slots' flags before/after and says where the phone went; set-active gated by [fastboot] slot_switch); docs 242 (the eight briefs restored after 226 reverted 230's role start), the slots item closed, gather-into-device-base recorded; reviewed: device-template 4 (each device's own tad base: parts contract, phone-next/phone-queue/next without --device), docs 260 (backlog.device, lane-next; kept until the split moves rows). DECIDED (the author, via the Top Coordinator): docs holds only what helps every device; each device has its own base from device-template; docs pulls parts and derives support_status (decision 2026-11-17-commons-and-device-bases; backlog tad q next --about commons-only). Next links: feed-device-bases (docs), move-device-rows (with each keeper), then lab-tools/gather-into-device-base (orchestration's, waits on the move) and launchers-per-device (roles). OWED: the clean 'after' read-weight - the first keeper started with Role lines on ideal-agent 0.3.6+ (keeper-6: 80,864 tok/30 KB; keeper-7: 79,870 tok but every practice, the hook then skipped started sessions) -> ideal-agent-roles local_dd7369b2; trimming the briefs of what the role cards say; tad-engine sign: a conditional rule (needs requires device), after the split; lab-tools kernel-orphan-modules. lab-agent's future is the Top Coordinator's research (research-lab-agent); devlab's root-exec/board uses move only on its word. WAITS ON OTHERS: surya-lab surya-fastboot-serial (devlab flash refuses surya until its manifest has [fastboot] serial, likely dc21014b unread, and writes = true); walleye's slot decision. DO NOT UNDO: the previous hand-over's list; every fastboot call names its serial; no partition write without writes = true, no slot switch without slot_switch = true; a boot's verdict is where the phone went and the flags, not fastboot's exit. SIGNS: rebase and read diff --stat origin/main...HEAD before land (226 reverted 230); land's commit title is at most 100 characters and a research brief at most 200; a hold sent after a yes may arrive after the landing - say hold before yes when a direction is open.
2026-11-17
Where does orchestration's work stand, for a fresh orchestration session to take it up without the old session's long context?
ROLE: owns the conveyor - lab-tools (devlab: phone, kernel try/keep/--dtb/remove, suite put from the Alpine package and the lab's main, gather once quiet, watch, guard for the phone, hazards, keeper lease), device-template, the package conveyor's Alpine path (alpine.yml, v1), docs' face (bin/face-data + engine, no ocoeco) and derive/queries - and tends the agents. Brief: ideal-agent-linux-phone-oco/orchestration.md; method: ideal-agent orchestrate-agents. LIVE: phone keeper flow (phone-keeper.md; lease devlab keeper; queue tad q phone-queue in the author's rank order, deep sleep first; waker = scheduled task linux-phone-keeper-waker titled surya dispatcher, hourly; patrol every 6 h). surya-keeper-2 held the lease at 12:49 UTC. OPEN, the author's: the dispatcher task's permission mode/model (its runs stall on the first prompt; Sonnet 5.5 medium proposed); whether dispatcher runs start from orchestration instead (visible in the left pane); gather.yml in five repos and land's observatory pings (passive ocoeco links, his call); archiving linux-phone-oco/lens; cards waiting: research charging, research GPS, programs on argenv. OPEN, orchestration's: run read-weight on surya-keeper-2's transcript and send ideal-agent its read and first-turn tokens (where read-weight lives was asked of ideal-agent); add read-weight to the patrol round; backlog start-weight-on-the-face, kernel-orphan-modules, health-carry-old-checks, guard items moved to ideal-agent. DO NOT UNDO: suite put reads the lab at main (a stale clone once regressed the phone); gather lands only after 15 quiet minutes; the face's data sorts like observe did and maps a non-linux-phone project field to docs; a kept kernel sorts 1-kept-* after tries; remove keeps shared modules. Notes: side-session-notes/local_12b18c70-.../orchestration-2026-11-17.md.
2026-11-17
What works on the Google Pixel 2 (walleye) and Pixel 2 XL (taimen) on Linux today, by published sources, and how does their SoC (MSM8998) relate to surya's SM7150?
A survey from published sources only (nothing touched, nothing measured here; every part of both phones is unknown, the reports sit in support_status notes and wiki_claims). (1) Nura (postmarketOS) wiki: only the Pixel 2 XL has a page (kernel field 5.10-rc2; 'Boots but no display output'; usbnet Y, flashing Y, screen N, battery N; page by Casey/kcxt, edited 2026-09-05, bot edit 2026-09-27); the Pixel 2 has none. (2) pmaports: neither device-google-walleye nor device-google-taimen exists in device/main, community or testing (listed 2026-11-17). (3) Mainline Linux: no Pixel 2 device tree; arm64/qcom has MSM8998 boards (OnePlus 5/5T, Xiaomi Mi 6, Sony yoshino, F(x)tec Pro1, HP Envy x2, Lenovo Miix 630, Asus NovaGo) and msm8998.dtsi was still edited on 2026-09-17. (4) The port lives out of tree: kcxt/linux-wahoo, created 2020-07-20, last pushed 2022-02-27; branch wahoo/5.17 has msm8998-google-taimen.dts, -walleye.dts and wahoo.dtsi, plus panel and DPU/DSC work (unfinished), and a taimen-5.11-submit branch whose mainline submission is not found upstream. (5) Other distributions: Ubuntu Touch has only a 16.04 (Halium, Android kernel) release for walleye, the current release does not support it (taimen page exists, not read); LineageOS 22.2 runs both on Android (kernel 4.4, AOSP branch android-msm-wahoo-4.4-android10-qpr3 shared by both). Not found for either: Mobian, Droidian, Sailfish, a pmOS issue or MR (search only; absence is not a report). SoC and surya: MSM8998 (Snapdragon 835, 2017) vs SM7150 (Snapdragon 732G). Per mainline msm8998.dtsi it has Adreno 540, DPU/MDSS with 10 nm DSI PHY, UFS 2.0, DWC3 USB with QMP PHYs, ADSP/SLPI/modem remoteprocs, Venus and the older RPM (rpm-msm8998, glink-smd-rpm), so what surya's SM7150 shares is the kind of block (UFS, DWC3/QMP USB, DSI/DPU display, remoteproc DSPs, SPMI PMIC) but not the drivers or tables: SM7150 itself is not in mainline Linux (surya runs the sm7150-mainline fork; the nearest mainline Qualcomm sibling is sdm670, the Pixel 3a), and MSM8998 has Adreno 5xx and RPM where SM7150 has Adreno 6xx and RPMh (our reading of the trees, not a source's claim). Sibling evidence for the SoC: the wiki's OnePlus 5 (archived, kernel field 6.0) reports touch, screen, wifi, Bluetooth, 3D, GPS Y and audio, mobile data, calls, SMS, sensors N: a different phone, stale, context only. Distance: surya has 12 of 20 parts working by its own tests; the Pixel 2 XL has 1 community 'works' (flashing), 1 'broken' (screen) and 19 unknown; the Pixel 2 has nothing reported.
- Nura (postmarketOS) wiki: Google Pixel 2 XL (google-taimen) - Mainline boots with a basic DT (5.10-rc2), USB networking and flashing work, no display; the only wiki page of either phone (walleye has none). Revised 2026-09-05 and 2026-09-27 (bot); status by Casey/kcxt.
- kcxt/linux-wahoo: Mainline Linux for the Google Pixel 2XL (And 2?) - Out-of-tree mainline port, created 2020-07-20, last pushed 2022-02-27: msm8998-google-taimen.dts, -walleye.dts and wahoo.dtsi (branch wahoo/5.17), panel and DPU/DSC work, a 5.11 submission branch.
- Linux mainline: arch/arm64/boot/dts/qcom (MSM8998 device trees) - No Pixel 2 / 2 XL device tree in mainline (checked 2026-11-17); MSM8998 boards there: OnePlus 5/5T, Xiaomi Mi 6, Sony yoshino, F(x)tec Pro1, HP Envy x2, Lenovo Miix 630, Asus NovaGo; msm8998.dtsi still edited (2026-09-17).
- Nura pmaports: device packages of Google phones (device/community, device/testing) - device-google-walleye and device-google-taimen are absent from device/main, community and testing (listed 2026-11-17); Google packages there are sargo/bonito (community), blueline, flame, oriole, raven (testing).
- Ubuntu Touch: Google Pixel 2 (walleye), old releases - Only the 16.04 (xenial) release exists; the current release does not support the phone. A Halium/Android-kernel port, not mainline.
- LineageOS wiki: Google Pixel 2 (walleye) - Android, current LineageOS 22.2 (Android 15) on kernel 4.4 for walleye; taimen has the same page shape. Shows the phones stay alive on Android, not on mainline.
- AOSP: Build Pixel kernels (legacy branches) - Pixel 2 and 2 XL share one kernel, device/google/wahoo-kernel, branch android-msm-wahoo-4.4-android10-qpr3.
- Nura wiki: OnePlus 5 (oneplus-cheeseburger), the MSM8998 phone best supported in mainline - Same SoC family; category archived, kernel field 6.0; touch, screen, wifi, bluetooth, 3D, GPS Y; audio, mobile data, calls, SMS, sensors N. A claim about a different phone: context for the SoC, not a status of the Pixels.
2026-11-17
Where do linux-phone-oco's founding principles live, and how do briefs and guides cite them without restating?
Read: Debian Social Contract and DFSG (5 and 10 numbered points, versioned 1.0-1.2, cited as DFSG #n), Mozilla Manifesto (10 principles, anchors principles-01..10), Wikipedia five pillars (shortcuts WP:5P1..5, redirects keep citations after renames), Rust API guidelines (54 items with ids such as C-CASE that are the anchors), RFC 7282 and PEP 20 (cited by section or wording), the kernel's Developer's Certificate of Origin 1.1 (the version is part of the name), MADR decision drivers (local to one record). Not read: Arch principles (blocked), PEP 1, Nygard's ADR post, the Rust RFC process. Locally: the idea table holds the story (as good as Android, counted), conveyor concepts are five rows, restating lines sat in phone-keeper and device AGENTS.md; overlay-check (ideal-agent) flags a brief that restates ideal-agent's words by 6-word runs, 15 percent limit.
2026-11-17
What keeps a Qualcomm SoC out of its lowest state on mainline?
Any processor or bus vote left up: on a QCS8550 handheld, aosd, cxsd and ddr stayed at 0 until the USB controller's interconnect vote and the PCIe and LPASS (audio) votes were released, then it reached the floor at about 23 mA (2026-10). A DSP that never sleeps holds CX up; on surya the audio DSP has not slept once. FastRPC helpers attached across suspend crash the audio DSP: postmarketOS stops hexagonrpcd's helper before suspend on the Pixel 3a, as we saw on surya (24 of 24 attempts with rootpd attached). Wi-Fi (ath10k) floods the modem's IPC interrupt and blocks or breaks suspend on SDM845; surya is reported to wake at random while asleep, cause unknown.
- PortareOS issue 62: aosd/cxsd/ddr stuck at 0 on QCS8550 until the USB, PCIe and LPASS votes were released (2026-10) -
- pmaports, google-sargo: hexagonrpcd's sensors helper stopped before suspend, the DSP crashing otherwise -
- pmaports 4783: with the modem wakeup on, every modem event wakes the phone; Wi-Fi blocks suspend -
- pmaports 4823: surya wakes at random while asleep (open) -
2026-11-17
How does a Qualcomm phone reach its lowest power state on mainline?
Through s2idle and CPU idle, not suspend to RAM: the firmware offers no PSCI system suspend, so with userspace frozen the CPUs enter their idle states, the last one down takes the cluster power domain to its deepest state (PSCI OS-initiated mode, hierarchical CPU idle), and as the cluster powers off the application processor's RPMh sleep votes are flushed to the always-on subsystem (rpmh-rsc attached to the cluster domain). The always-on subsystem then lowers CX and DDR when no processor votes for them: CX collapse (cxsd), then AOSS sleep (aosd), the floor. The SoC counts each in its own memory (rpmh-stats, read through qcom_stats), so reaching the floor is measured, not inferred. Without OS-initiated mode the cluster domain would stay always on and the votes would never flush; surya's firmware has it.
- LWN: hierarchical CPU idle and PSCI OS-initiated mode (Ulf Hansson's series) -
- rpmh-rsc: attach RSC to the cluster PM domain - sleep votes flushed when the cluster powers off (Ulf Hansson, 2022) -
- The qcom-stats binding: the SoC's sleep counters (aosd, cxsd, ddr, per subsystem) -
- Qualcomm: SoC power-saving states (CXSD, AOSD) on QCS6490 -
- Nura (postmarketOS) wiki, SDM845: s2idle only; waking for calls through the modem's IPCRTR glink wakeup -
2026-11-17
How does a Qualcomm phone on mainline wake for a call or a message?
The modem's messages (QMI over QRTR on glink) are handled even in s2idle (IRQF_NO_SUSPEND), but userspace is frozen, so nothing rings. The kernel cannot tell a call from a signal-strength update: there is one switch, the IPCRTR glink device's wakeup (/sys/bus/rpmsg/devices/4080000.remoteproc:glink-edge.IPCRTR.-1.-1/power/wakeup), which wakes for every modem message. postmarketOS (now Nura) pairs it on the OnePlus 6 with ModemManager's quick suspend/resume, which quiets the modem's notifications before suspend and resyncs after; that fixed calls signalled late or lost. It is still not dependable: on OnePlus 6/6T and the Pixel 3a waking for calls is reported not working (with the switch on the phone wakes at once; open since 2026-10), and with it on every modem event wakes the phone. surya's modem sits at the same address (remoteproc 4080000), so the same path applies; a SIM card is needed to prove it.
- Nura (postmarketOS) wiki, SDM845: s2idle only; waking for calls through the modem's IPCRTR glink wakeup -
- Nura (postmarketOS) wiki, OnePlus 6: ModemManager's quick suspend/resume and the IPCRTR wakeup -
- pmaports 4194: calls signalled late or lost across suspend - fixed by ModemManager's quick suspend/resume -
- pmaports 4989: waking from suspend for calls does not work (OnePlus 6/6T, Pixel 3a; open) -
- pmaports 4783: with the modem wakeup on, every modem event wakes the phone; Wi-Fi blocks suspend -
2026-11-17
How else have phones got deep sleep that still rings?
Android's own kernel: Ubuntu Touch runs officially on surya through Halium with the vendor's 4.14 kernel and Android's opportunistic suspend (wakeup sources and autosleep, which mainline also has), claiming a day and more - deep sleep that works, at the price of the vendor's kernel and blobs and nothing upstream. A separate power-management core: Crust on the PinePhone sleeps the whole Allwinner SoC (about 80% less power) and the separate modem wakes it through its RI line; Qualcomm's always-on subsystem runs signed firmware, so nothing like Crust can be written for it, and its modem is inside the SoC. Push through sleep: only partly solved anywhere (PinePhone: WoWLAN pattern matching plus an RTC wake as a safety net). The postmarketOS SM7150 page lists suspend as working with no measurement behind it; we found no published standby current for mainline Qualcomm phones.
- Ubuntu Touch on surya: Halium 10 with the vendor's 4.14 kernel -
- LWN: Android's opportunistic suspend in mainline - wakeup sources and autosleep -
- Crust on the PinePhone: deep sleep on a separate power-management core -
- Push notifications through suspend on the PinePhone: WoWLAN and an RTC safety net (2023) -
- Nura (postmarketOS) wiki, SM7150: suspend listed as working, no detail -
2026-11-17
What must a fresh linux-phone session read before its first useful action, per role, and is it within ideal-agent's budget (practice 45-keep-the-start-light: 32 KB a role, 3 KB a front file, 8 KB a brief)?
Measured 2026-11-17 on docs' main (495bbc6) with ideal-agent 0.2.1's scripts/start-weight, in bytes. Every role reads: the session start 14,353 (the practices without their reasons, and the inbox - 22.5 KB before ideal-agent #13 put the reasons a command away), skill and agent descriptions 4,057, lab-session-start 2,012, AGENTS.md 2,141, ideal-agent-linux-phone-oco/README.md 2,306 - 24,869 in all. Then the brief: bring-up 13,313 (38,182 in all: over the 32 KB budget, and the brief over 8 KB), orchestration 6,248 (31,117), phone-keeper 4,559 (29,428), feature-research 2,417 (27,286). Before #13 the same roles read 35-46 KB. The front files are within 3 KB. Whether summaries are due cannot be read yet: docs pins idealkb 0.1.0, whose about query has no summaries (0.3.0 comes with the weekly pin).
2026-11-17
What does a first mainline boot of the Pixel 2 need, and what can and cannot fastboot boot do on this bootloader?
Image: boot header v0, base 0x0, kernel offset 0x8000, ramdisk 0x1000000, tags 0x100, page 4096 - verified by porthole against the stock TAIMEN boot.img; LineageOS's wahoo board config says tags 0x01E00000 / ramdisk 0x02000000 instead: two sets are reported, walleye's own stock boot.img header decides (not read yet). Boot partition is 32 MiB (getvar boot_a 0x2000000), max-download-size 0x20000000: size is no limit. The DTB is appended to the kernel; it must carry qcom,msm-id = <0x124 0x20001> (taimen has it, kcxt's walleye does not). Cmdline (porthole): clk_ignore_unused ignore_loglevel panic=10 earlycon=msm_serial_dm,0xc1b0000 qcom_wdt.arm_on_probe=1 watchdog.open_timeout=300 reboot=w; kcxt adds console=ttyGS0,115200. No bootargs/stdout-path in the DTS: ABL appends the boot.img cmdline with fdt_appendprop_string, and a pre-existing bootargs hides it. Display: command-mode panels, so no scanned-out framebuffer for simple-framebuffer; the first sign of life must be USB. Path: dwc3 peripheral, high-speed only, SuperSpeed PHY dropped, qcom,select-utmi-as-pipe-clk, assigned-clock-rates 19.2/60 MHz (works on taimen); initramfs with a configfs gadget (ACM console + RNDIS/ECM) and telnet/ssh on 172.16.42.1 (devlab's address). pstore: ramoops 0xa1810000/0x200000; a cold reset scrambles it, so the warm-reset/watchdog parameters matter. UART: the Pixel debug cable (see google-walleye-how-others-booted; fastboot oem uart enable is a change to the phone, undecided). Bootloader (keeper's read-only getvar, google-walleye-bootloader-first-look): mw8998-003.0085.00, hw-revision MP1, unlocked, A/B both slots successful, avb_version 1.0.0, kernel:uefi, no fastbootd. fastboot boot: TWRP's own instructions for walleye use it (xdaforums), but another report could not boot TWRP that way, and nobody reports a mainline kernel booted from RAM on any Pixel 2: NOT known. Also not known: whether ABL applies the stock dtbo of the active slot to a mainline DTB (taimen's bootloader refuses a kernel unless dtbo holds overlay id 2704 - kcxt's README, taimen only; porthole flashes its own stub into slot b), and what vbmeta/AVB does to an unsigned image on an unlocked phone. One try through devlab (walleye-first-fastboot-boot) answers all three; a refusal is an answer, and the stub dtbo is a write (the author's decision; backlog walleye-dtbo-overlay-id).
- porthole-dev/pmaports (branch taimen-bringup): mainline 7.2.2 + 263 patches, device-google-taimen, walleye board patch 0029 - porthole-dev, 2026 The one maintained mainline Pixel 2 family kernel: taimen proven, walleye board file untested. deviceinfo gives the boot image header (v0, offsets, appended dtb); the dtbo stub (id 2704) and cmdline are the first-boot facts.
- Nura (postmarketOS) wiki: Google Pixel 2 XL (google-taimen) - Mainline boots with a basic DT (5.10-rc2), USB networking and flashing work, no display; the only wiki page of either phone (walleye has none). Revised 2026-09-05 and 2026-09-27 (bot); status by Casey/kcxt.
- kcxt/linux-wahoo wahoo/5.17: msm8998-google-wahoo.dtsi, taimen and walleye dts, 2022 - kcxt, 2022 The first Pixel 2 family device tree; walleye dts is a 13-line stub on the taimen base; USB 2.0 peripheral, regulators, ramoops, UART facts.
- kcxt/dtbo-google-wahoo-mainline: minimal dtbo for the Pixel 2 XL - walleye-research-vendor, 2020 The Pixel 2 XL bootloader refuses a kernel unless dtbo holds an overlay with id 2704 (0xa90); stock cmdline has androidboot.dtbo_idx=12. XL only; walleye's id not known.
- LineageOS android_kernel_google_wahoo (lineage-22.2): device-tree sources of walleye and taimen - Google, HTC, LG, Qualcomm; kept by LineageOS, 2025 GPL-2.0 Linux 4.4 kernel of both wahoo phones. Walleye (HTC-built, project name muskie) is under arch/arm64/boot/dts/htc: panel, touch, audio amp, haptics, NFC, camera, battery, memory map. Read as facts for a hardware table; ports of code keep copyright and licence.
- TWRP 3.2.3-1 for Pixel 2 (xdaforums): temporary boot with fastboot boot - TWRP / XDA community, 2018 fastboot boot of a recovery image works on the unlocked walleye, so a boot image can be held in memory without a flash.
- kerneltoast/android_kernel_google_wahoo (11.0.0-sultan): Google's GPL wahoo kernel, device-tree sources under htc/ (Pixel 2) and lge/ (Pixel 2 XL) - Google, HTC, LG (GPL-2.0), 2020 Walleye's parts from GPL device-tree sources: Samsung S6E3FA5 command-mode panel, Synaptics RMI touch on i2c5, DRV2624 haptics, TFA98xx/TAS2557 amps, keys, battery; read for facts, not copied.
- LKML March 2021: [PATCH] arm64: dts: add support for the Pixel 2 XL, with review - walleye-research-vendor, 2021 Boots with USB networking, panel needs DSC, dtbo overlay id required, clk_ignore_unused, Wi-Fi needs diag-router; no sign it was merged.
2026-11-17
What does the Pixel 2 bootloader dislike in our boot images (Load Error), from public sources, and which variants should be tried next?
What is: four images, one kernel/dtb/initramfs, all v0 with the dtb appended to a gzipped Image (Image.gz+dtb). a (taimen offsets, os word 0) got "Booting OKAY" then silence; b (LineageOS offsets) first left fastboot (Android came back on slot b), later Load Error; c and d (a, b plus os_version 8.1.0 / patch 2020-01) both Load Error. The only difference between a and c is that header word. What others show (not the Pixel 2 itself - nobody reports a mainline fastboot boot there): 1. The format is the accepted one. Stock ABL on the same line (Pixel 3) takes a gzipped kernel with the dtb appended in a v0 boot image (U-Boot's board doc), and postmarketOS boots blueline with exactly base 0 / kernel 0x8000 / ramdisk 0x1000000 / tags 0x100 / page 4096 / dtb appended (pmaports deviceinfo). Two differences from our images: pmaports sets second offset 0 (we use 0xf00000; second is empty, so it should not matter) and no os_version/patch level at all. So "header v0 vs what ABL expects" and "Image.gz-dtb vs Image+dtb" are not the likely cause; the os word is, if anything, the one thing we added that pmaports does not have. 2. ABL, not the kernel, picks and patches the dtb (Inoki, MSM8998 Nokia 8): DeviceTreeAppended scans the appended blobs and DeviceTreeCompatible matches qcom,msm-id, qcom,board-id and qcom,pmic-id. Our dts carries only msm-id (0x124 0x20001, as kcxt's taimen, which boots with msm-id alone); it has no board-id or pmic-id. Whether walleye's ABL accepts that is not known; the stock walleye dtb's ids are not read yet (not in the public sources reached today). 3. The bootloader merges a dtbo overlay into the dtb before the kernel starts (AOSP DTO). kcxt found the taimen bootloader refuses a mainline kernel unless the dtbo partition holds an overlay with id 2704, and flashes a stub. Stock overlays patch downstream nodes a mainline base does not have, so a failed merge is the best-fitting reading of an immediate "Load Error" that comes from the bootloader after the transfer. Not proven for walleye: the dtbo of slot b is an older LineageOS build's, its overlay table not read. 4. "Load Error" is not proof the image is bad. Known-good TWRP for walleye got the same words from fastboot boot (Android SE), and one XDA report says it appeared randomly and went away on restart. Our slot flags (a unbootable, current b) were left by the first try; whether they feed the refusal is not known. 5. "Booting OKAY" then silence (a) means the bootloader sent its OK and a later step failed or the kernel died before any sign of life; it is a different outcome from Load Error, and a is the only image that got it. The os word turning OKAY into Load Error says the refusal is sensitive to the header word - the likeliest reason is the bootloader comparing the os_version/patch level with the active slot's recorded one (not read anywhere; unknown). Ranked causes (each has a try that tells it apart): (H1) overlay merge fails against a mainline base, so a stub dtbo or a dtb that survives the stock overlay is needed - only fixable by a write (dtbo_b stub) or by finding that slot b's dtbo is not the cause; (H2) dtb ids: msm-id only, no board-id/pmic-id; free to test on the host; (H3) state: slot flags or random Load Error; test with a control image; (H4) header word: only os word 0 passes, so keep 0. Control first: a stock-format image known to boot on walleye (LineageOS or TWRP recovery for walleye, public) through the same fastboot boot path. If the control also gets Load Error, the cause is the phone's state and no image change helps; if it boots, the cause is in our image and the variants below tell which part. The control is a try, not a write. Not read yet and worth reading without writing: walleye's stock boot.img header and dtb ids from a public LineageOS wahoo build (host only), slot b's dtbo overlay ids (pstore/Android adb read - keeper only).
- U-Boot doc: Qualcomm generic boards (booting through ABL on Pixel 3) - walleye-research, 2024 Stock ABL (Pixel 3 family, same ABL line as walleye) expects a gzipped kernel with the dtb appended, packed as an Android boot image; U-Boot mimics Linux to satisfy it.
- pmaports device-google-blueline deviceinfo (Pixel 3, booted on stock ABL) - walleye-research, 2025 A working recipe on a sibling Pixel ABL: base 0, kernel 0x8000, ramdisk 0x1000000, second 0x0, tags 0x100, page 4096, dtb appended, cmdline console=ttyMSM0,115200 only, no os_version.
- Android Bootloader and Linux Internal based on Nokia 8 (NB1): DT loading in ABL - walleye-research, 2022 On an MSM8998 phone ABL's DeviceTreeAppended scans every dtb appended to the kernel and DeviceTreeCompatible picks the best by qcom,msm-id, qcom,board-id, qcom,pmic-id; the ABL, not the kernel, chooses and patches the dt.
- Android: Use multiple DTs (device tree overlays in the bootloader) - walleye-research, 2026 The bootloader loads the SoC dtb, identifies the board, loads the matching dtbo overlay from the dtbo partition and merges them before starting the kernel: a failed merge is a bootloader refusal.
- Android SE: Pixel 2 bootloader loop, fastboot boot of TWRP walleye gives Load Error - walleye-research, 2019 A known-good walleye TWRP image also gets 'Failed to load/authenticate boot image: Load Error' from fastboot boot when the phone's slot state is odd: the message is not proof the image is bad.
- XDA: Troubles reinstalling TWRP [Failed to load/authenticate boot image: Load Error] - walleye-research, 2020 One report fixed Load Error by restarting the device: it appears randomly when flashing - state, not content, can cause it (excerpt read in search results only).
- kcxt/dtbo-google-wahoo-mainline: minimal dtbo for the Pixel 2 XL - walleye-research-vendor, 2020 The Pixel 2 XL bootloader refuses a kernel unless dtbo holds an overlay with id 2704 (0xa90); stock cmdline has androidboot.dtbo_idx=12. XL only; walleye's id not known.
- porthole-dev/pmaports (branch taimen-bringup): mainline 7.2.2 + 263 patches, device-google-taimen, walleye board patch 0029 - porthole-dev, 2026 The one maintained mainline Pixel 2 family kernel: taimen proven, walleye board file untested. deviceinfo gives the boot image header (v0, offsets, appended dtb); the dtbo stub (id 2704) and cmdline are the first-boot facts.
- kcxt/linux-wahoo branch wahoo/5.17: msm8998-google-walleye.dts and the shared wahoo dtsi - walleye-research-vendor, 2022 What mainline can already express for wahoo: UFS, USB peripheral, one DSI, GPU, Wi-Fi, SLPI/ADSP, regulators; walleye file is 13 lines and sets no panel; boots with console on ttyMSM1 and USB-gadget ttyGS0, ramoops at 0xa1810000.
2026-11-17
What exists for the Pixel 2 (walleye) on mainline: kcxt/linux-wahoo, the other trees, which nodes work, what is missing?
Mainline (v7.3, v7.4-rc3 out) has no msm8998-google-* file and nothing was submitted to the lists that a search finds. kcxt/linux-wahoo (last push 2022-02-27, branch wahoo/5.17 = 5.17 fork of the MSM8998 community tree): msm8998-google-wahoo.dtsi (shared) + taimen.dts (LG SW43402 panel, qcom,msm-id 0x124 0x20001) + walleye.dts, which is 13 lines: model and compatible only, no qcom,msm-id, no panel or battery. The shared dtsi enables: UART (blsp2_uart1 earlycon), Bluetooth, pm8998/pm8005/pmi8998 regulators, qusb2phy + dwc3 as USB 2.0 peripheral only (SuperSpeed does not work), UFS + PHY, Wi-Fi, adsp/slpi/mss remoteprocs with wahoo firmware names, mdss/dsi0/DSC panel, Adreno 540 (GPU voltage raised as a hack), ramoops at 0xa1810000. Its bootargs in the dts is wrong with this bootloader (see walleye-first-boot-recipe). Per the Nura wiki (taimen, kernel 5.10-rc2): boots, USB networking works enough for a shell, needs clk_ignore_unused; display broken, battery broken, everything else untested. porthole-dev/pmaports taimen-bringup (2026-10): kernel = kernel.org v7.2.2 + 263 numbered patches; taimen is a daily-driver port (display, GPU, touch, haptics, amps, wifi, modem, sensors, camera, suspend). For walleye only patch 0029: a 33-line board dts with a 2700 mAh battery taken from the published spec, "nobody has run this branch on an actual walleye device yet"; "no dedicated display or camera overrides" - walleye's panel and touch are not in it. pmaports/Nura masters: no walleye or taimen package. Missing for walleye (all unknown on the phone): display (S6E3FA5 command-mode panel: no mainline driver), touch (Synaptics RMI: driver in mainline, node missing), USB (taimen only), UFS (taimen only), Wi-Fi, modem, sound (amps differ from taimen), haptics (DRV2624, no mainline driver), fuel gauge (out of tree).
- kcxt/linux-wahoo wahoo/5.17: msm8998-google-wahoo.dtsi, taimen and walleye dts, 2022 - kcxt, 2022 The first Pixel 2 family device tree; walleye dts is a 13-line stub on the taimen base; USB 2.0 peripheral, regulators, ramoops, UART facts.
- kcxt/linux-wahoo: Mainline Linux for the Google Pixel 2XL (And 2?) - Out-of-tree mainline port, created 2020-07-20, last pushed 2022-02-27: msm8998-google-taimen.dts, -walleye.dts and wahoo.dtsi (branch wahoo/5.17), panel and DPU/DSC work, a 5.11 submission branch.
- porthole-dev/pmaports (branch taimen-bringup): mainline 7.2.2 + 263 patches, device-google-taimen, walleye board patch 0029 - porthole-dev, 2026 The one maintained mainline Pixel 2 family kernel: taimen proven, walleye board file untested. deviceinfo gives the boot image header (v0, offsets, appended dtb); the dtbo stub (id 2704) and cmdline are the first-boot facts.
- Nura (postmarketOS) wiki: Google Pixel 2 XL (google-taimen) - Mainline boots with a basic DT (5.10-rc2), USB networking and flashing work, no display; the only wiki page of either phone (walleye has none). Revised 2026-09-05 and 2026-09-27 (bot); status by Casey/kcxt.
- Linux v7.3 (mainline): arch/arm64/boot/dts/qcom msm8998 boards, drm/panel, input/rmi4, power/supply - kernel.org mainline, 2026 What mainline already has for MSM8998 (DPU, DSI PHY, Adreno 540, UFS, dwc3, qusb2, wifi, charger, rmi4) and what it lacks for the Pixel 2 (no Google board, no S6E3FA5, no fuel gauge, no DRV2624, no TAS2557).
- Nura pmaports: device packages of Google phones (device/community, device/testing) - device-google-walleye and device-google-taimen are absent from device/main, community and testing (listed 2026-11-17); Google packages there are sargo/bonito (community), blueline, flame, oriole, raven (testing).
2026-11-17
Which MSM8998 boards are in mainline, and which nodes and drivers can walleye reuse; what do its parts need?
Boards in v7.3: msm8998-mtp, OnePlus 5/5T (cheeseburger/dumpling, common dtsi), Xiaomi Mi 6 (sagit), Sony Xperia XZ Premium/XZ1/XZ1 Compact (yoshino lilac/maple/poplar), F(x)tec Pro1, HP Envy x2, Asus Novago, Lenovo Miix 630. Best templates: OnePlus common dtsi (blsp1_i2c5 touch, gpio-keys, ufs, usb3 peripheral, wifi, ramoops, zap shader region, qcom,msm-id 292 0x20001 "required for bootloader to select correct board") and the Mi 6 (same i2c5 touch bus). SoC pieces already in msm8998.dtsi: ufshc+ufsphy, dwc3+qusb2, mdss/dpu/dsi0+10nm PHY, adreno-540.1, gpucc, wcn3990 wifi, smmus, mss/adsp pas remoteprocs, pinctrl; pmi8998 charger + rradc + wled + lpg + flash; drivers rmi_i2c, rmi_f1a, qcom_smbx, stmfts. Walleye parts (GPL downstream dtsi): Samsung S6E3FA5 5.0" 1080x1920 DSI command mode (TE on, reset gpio94, rails PM8998 L14 1.8 V and L22 3.0 V, DCS backlight: no WLED and no LAB/IBB, which taimen needs) - mainline has s6e3fa7/fc2x01/ha2/ha8 but no fa5, an out-of-tree fa5 driver exists (OnePlus 5, Jami Kettunen) and porthole's sw43402 shows the command-mode + DPU work that is needed; touch Synaptics RMI on i2c5@0x20, irq gpio125, reset gpio89, l6/l28 rails -> node only; haptics DRV2624 (driver out of tree, porthole 0018); speaker amp TI TAS2557 as on taimen (TFA98xx is in the tree but disabled, an older revision); codec WCD934x on SLIMbus; keys gpios 40/126/121; battery 2700 mAh/4.4 V; NFC PN81A, fingerprint FPC1020 later. Fuel gauge qcom_fg out of tree (porthole 0022). Reuse rule: take the board file from the GPL wahoo dtsi (Caleb Connolly, Giuseppe Maggio; licence kept), patches from porthole one at a time when a part needs one.
- Linux v7.3 (mainline): arch/arm64/boot/dts/qcom msm8998 boards, drm/panel, input/rmi4, power/supply - kernel.org mainline, 2026 What mainline already has for MSM8998 (DPU, DSI PHY, Adreno 540, UFS, dwc3, qusb2, wifi, charger, rmi4) and what it lacks for the Pixel 2 (no Google board, no S6E3FA5, no fuel gauge, no DRV2624, no TAS2557).
- kerneltoast/android_kernel_google_wahoo (11.0.0-sultan): Google's GPL wahoo kernel, device-tree sources under htc/ (Pixel 2) and lge/ (Pixel 2 XL) - Google, HTC, LG (GPL-2.0), 2020 Walleye's parts from GPL device-tree sources: Samsung S6E3FA5 command-mode panel, Synaptics RMI touch on i2c5, DRV2624 haptics, TFA98xx/TAS2557 amps, keys, battery; read for facts, not copied.
- LineageOS android_kernel_google_wahoo (lineage-22.2): device-tree sources of walleye and taimen - Google, HTC, LG, Qualcomm; kept by LineageOS, 2025 GPL-2.0 Linux 4.4 kernel of both wahoo phones. Walleye (HTC-built, project name muskie) is under arch/arm64/boot/dts/htc: panel, touch, audio amp, haptics, NFC, camera, battery, memory map. Read as facts for a hardware table; ports of code keep copyright and licence.
- kcxt/linux-wahoo wahoo/5.17: msm8998-google-wahoo.dtsi, taimen and walleye dts, 2022 - kcxt, 2022 The first Pixel 2 family device tree; walleye dts is a 13-line stub on the taimen base; USB 2.0 peripheral, regulators, ramoops, UART facts.
- porthole-dev/pmaports (branch taimen-bringup): mainline 7.2.2 + 263 patches, device-google-taimen, walleye board patch 0029 - porthole-dev, 2026 The one maintained mainline Pixel 2 family kernel: taimen proven, walleye board file untested. deviceinfo gives the boot image header (v0, offsets, appended dtb); the dtbo stub (id 2704) and cmdline are the first-boot facts.
2026-11-17
What is the shortest honest path to a mainline fastboot boot of the Pixel 2, and which kernel is built first?
Path: (1) kernel.org v7.3 + a new msm8998-google-walleye.dts (own file, GPL, from the wahoo dtsi, carrying qcom,msm-id) with only what a USB-reachable initramfs needs: reserved memory, pm8998/pm8005/pmi8998 RPM regulators, qusb2phy + dwc3 peripheral, ramoops, UART; UFS, display, GPU, wifi, remoteprocs disabled (no firmware, no storage touched). (2) v0 boot.img with the dtb appended. (3) initramfs with a USB gadget. (4) one fastboot boot through devlab; proof = host sees the gadget and answers on 172.16.42.1. Display, touch, UFS, charger follow, each by the bring-up method. Rejected: starting from porthole's 263-patch kernel (taimen-shaped, hard to tell what a walleye failure comes from; kept as the fallback and the patch source); kcxt's 5.17 (old, bootargs in the dts, no msm-id, unmaintained); a display-first or simple-framebuffer start (command-mode panel: no framebuffer to reuse); flashing dtbo/boot first (breaks decision walleye-fastboot-first; only if the one try shows ABL needs the stub dtbo, and then the author decides). Unknown: see walleye-first-boot-recipe (walleye boot.img header, dtbo/ABL with a mainline dtb, vbmeta, whether a mainline kernel boots from RAM on a Pixel 2 at all).
- porthole-dev/pmaports (branch taimen-bringup): mainline 7.2.2 + 263 patches, device-google-taimen, walleye board patch 0029 - porthole-dev, 2026 The one maintained mainline Pixel 2 family kernel: taimen proven, walleye board file untested. deviceinfo gives the boot image header (v0, offsets, appended dtb); the dtbo stub (id 2704) and cmdline are the first-boot facts.
- kcxt/linux-wahoo wahoo/5.17: msm8998-google-wahoo.dtsi, taimen and walleye dts, 2022 - kcxt, 2022 The first Pixel 2 family device tree; walleye dts is a 13-line stub on the taimen base; USB 2.0 peripheral, regulators, ramoops, UART facts.
- Linux v7.3 (mainline): arch/arm64/boot/dts/qcom msm8998 boards, drm/panel, input/rmi4, power/supply - kernel.org mainline, 2026 What mainline already has for MSM8998 (DPU, DSI PHY, Adreno 540, UFS, dwc3, qusb2, wifi, charger, rmi4) and what it lacks for the Pixel 2 (no Google board, no S6E3FA5, no fuel gauge, no DRV2624, no TAS2557).
- TWRP 3.2.3-1 for Pixel 2 (xdaforums): temporary boot with fastboot boot - TWRP / XDA community, 2018 fastboot boot of a recovery image works on the unlocked walleye, so a boot image can be held in memory without a flash.
2026-11-17
Why does the host not bind cdc_acm to the FunctionFS single-interface console of n3r?
n3r tried once on slot b (set-active b, fastboot boot): the gadget came up as 1d6b:0104 'Pixel 2 walleye (mainline)' serial walleye-first-boot, one class-2 interface. Host dmesg: 'cdc_acm 3-2:1.0: Zero length descriptor references; probe failed with error -22'. In acm_probe the interface extra bytes (and the first endpoint's extra) are empty, so it returns -EINVAL before the union-descriptor fallback ('castrated device') is reached; that fallback only works when some extra descriptor exists. Fix to try: write a CDC header functional descriptor (plus call-management and ACM, no union required) after the interface descriptor in the FunctionFS descriptors. Contradicts the wording of decision walleye-ffs-acm-single-interface (no CDC functional descriptors), so it goes to the coordinator.
2026-11-17
Does the panic of gadget2/3 happen without our gadget code (idle init only)?
From the first state, fastboot boot of vendor-gadget4.img: left fastboot after 15 s, back on Android a (adb) after 156 s; ro.boot.bootreason=reboot (gadget3 gave kernel_panic at ~75 s), sys.boot_completed=1, slot a active/successful, b unbootable retry 1 as before (flags unchanged). So the vendor kernel boots and our init runs to its own reboot at ~120 s; the gadget bring-up of gadget2/3 is what panics. Our init's /dev/kmsg marker is not readable from Android.
2026-11-17
With usb_storage and the uaccess rule in place, what does the phone's first written text show?
Fastboot booted vendor-gadget-m1 (sha a3cf08d3...) from slot a (a active+successful, b unbootable retry 1): left fastboot 12 s, enumerated 1d6b:0104 after 18 s. tests/host/massstorage-read.sh (LUN_WAIT=60 LUN_WATCH=20) PASSED as the lab user, no sudo: /dev/sda read O_DIRECT, 'WALLEYE-LOG m1 beat=0..4 up=1.3..21.3s', the heartbeat grows every 5 s. Window: uname Linux 4.4.302-gddfd598aee10 (the vendor kernel, our init as pid 1); cmdline is the control's (androidboot.*, verifiedbootstate=orange, dtbo_idx=3, root=PARTUUID, lpm_levels.sleep_disabled=1); mounts rootfs/proc/sys/configfs; udc a800000.dwc3; dmesg tail shows our init steps through 'gadget bound to a800000.dwc3' and configfs-gadget high-speed config #1 CONFIGURED at 3.4 s. No panic in the mass_storage path. Phone returned by itself to Android on a, then adb reboot bootloader: fastboot, flags as before (a active+successful, b unbootable retry 1); nothing flashed. lpoco-host acceptance: pass (70-lpoco-google-walleye.rules uaccess, usb_storage loaded). Full window in the material folder.
2026-11-17
Does boot-ml4.img's init run its checklist and reset itself at a score-dependent time?
boot-ml4.img (sha256 105364591ce1...ea84) fastboot-booted twice on slot b, nothing flashed: fastboot left after 15 s, adb back after 75 s (t0 23:42:58) and 76 s (t0 23:44:40). ml4-bin-table.sh reads 75 s and 76 s as delay 33/34 s = score 7 (all six checks held, including the UFS host device the dts was expected not to give). BUT the safety-watchdog return is not clearly separate: ml1/ml2/ml3 (no timing init) came back at 69-72 s, ml4 only 3-4 s later, inside one 5 s bin; so 75/76 s may equally be the watchdog firing (init not run or hung) - the two readings are not told apart. Android bootreason 'reboot'; /sys/fs/pstore empty and /data/vendor_ce/0/ramoops absent after both, no kernel log of ours survived. Slots after both: current b, a and b successful, not unbootable. Next to tell them apart: an ml5 whose init sleeps a score-independent long time (e.g. a fixed 20 s, and a score 0 variant), so a return near 72 s plus the sleep cannot be the watchdog; not decided here.
2026-11-17
Which step of the ncm function bring-up panics the vendor msm-4.4.302 kernel (b1..b4 from the first state, stop at the first panic)?
From the first state (Android booted on a, slot a active+successful, b unbootable retry 1) by devlab fastboot boot now: vendor-gadget5b1 left fastboot after 12 s, Android back at 156 s, ro.boot.bootreason=reboot. vendor-gadget5b2 left fastboot after 12 s, back at 75 s, bootreason kernel_panic. b2 differs from b1 only by the dev_addr and host_addr writes into functions/ncm.usb0, so creating the ncm function is safe and the attribute writes panic - as predicted (walleye-ncm-panic-why). b3, b4 not tried (stop rule). Flags unchanged afterwards; phone in fastboot on a, nothing flashed.
2026-11-17
Which step of the gadget bring-up panics the vendor kernel: configfs+gadget dir (5a), +ncm function and config (5b), +UDC bind/network (5c)?
From the first state (Android on a successful, b unbootable retry 1), fastboot boot of each image, nothing flashed. 5a: left fastboot 12 s, Android on a at 156 s, bootreason reboot, boot_completed 1 (init ran to its own reboot at ~120 s). 5b: left fastboot 12 s, Android on a at 75 s, bootreason kernel_panic. Stopped at the first panic, so 5c not tried. Culprit: the step 5b adds over 5a: creating the ncm function and/or the config with its symlink (f_ncm in the vendor 4.4 kernel, or configfs usb_gadget function handling). UDC bind is not the cause. Slot flags before and after each try identical: a current/successful, b unbootable retry 1; phone left in fastboot. gadget-up.sh not run: it is only for a 5c that does not panic. Next: split 5b (function dir only; ncm without config; other function type such as rndis/acm) - builder.
2026-11-17
What does Android do on the Pixel 2 as the author left it - build, sensors, battery, boot time, audio - measured read-only, with nothing installed or changed?
Measured with plain adb reads, then back to fastboot with the slot flags unchanged: LineageOS 15 (Android 15, userdebug, built 2025-12-05, patch 2025-11-01) on a stock Android 11 Pixel 2 vendor image, kernel 4.4.302, MSM8998 (8 cores), 3.7 GB RAM, 51 GB data, 1080x1920. Sensorservice lists 37 sensors (LSM6DSM, AK09915, TMx490x, BMP280, AK8789, Elmyra, camera sync). Battery learned 2709 mAh of 2805 mAh design (96.6 %), 922 cycles. Boot, from the phone's own event log: system server at 8.3 s, package manager ready 10.1 s, ams_ready 12.0 s, boot animation done 17.8 s (kernel start to there; the bootloader stage is not counted). Audio config: stereo speaker output at 48 kHz. Not known yet: sleep current (the phone was charging on USB, Wi-Fi was on, no meter; batterystats' long-run counters contradict themselves so no figure is given), audio levels (no tone source, no microphone), boot time from power-on, thermal limits, the real partition table. Needs next: a USB power meter or the battery path to measure standby with radios as stated, and a tone source plus a lab microphone. Lesson for the keeper: adb authorization on this phone was lost at reboot until the author tapped Allow again, and the lab's adb server had to be restarted to see it; no reboot should be planned before "Always allow" is confirmed.
2026-11-17
What does the Pixel 2's bootloader say about the phone, and does Android still sit on it, judged from read-only variables only?
Measured with `fastboot getvar all` (nothing flashed, booted or set): product walleye, hw-revision MP1, boot-mode FASTBOOT, unlocked yes, secure yes, kernel uefi, bootloader mw8998-003.0085.00, baseband g8998-00034-2006052136, slot-count 2, current-slot a, both slots successful=yes unbootable=no retry-count 0, max-download-size 512 MiB, avb 1.0.0 with user-settable key set, battery 4344 mV. Partitions listed with a size: boot_a/b 32 MiB raw, system_a/b 2560 MiB ext4, vendor_a/b 500 MiB ext4, userdata about 53 GiB ext4. is-userspace, slot-suffixes, snapshot-update-status and the sizes of vbmeta, dtbo and modem are not offered: an old bootloader, no fastbootd. Inference: both slots carry the flags Android's boot control leaves after a good boot, and the partition table is the stock A/B layout, so an Android has run on each slot; userdata of 53 GiB fits the 64 GB model. Which Android, whether it still boots and whether userdata holds data is not known yet - the bootloader cannot say. Not known yet: whether `fastboot boot` accepts a kernel built by us, and what it does afterwards; every Android reference measurement (sleep current, audio levels, sensors, boot time), backlog google-walleye-lab/android-reference-walleye - it needs the author to boot slot a, enable USB debugging and say when the phone is at the home screen; the paragraph is in the material README. Next: a first `fastboot boot` try needs a kernel from the research sessions and devlab's fastboot mode (backlog lab-tools/devlab-fastboot-mode). The IMEI the bootloader prints was left out of the kept output.
2026-11-17
Why does the Pixel 2's bootloader refuse even LineageOS's official boot.img by fastboot boot (Load Error), and what makes fastboot boot work on it?
What is: the control (LineageOS 22.2 20261113 boot.img, stock header, AVB footer, own dtb) is refused with "Failed to load/authenticate boot image: Load Error" on slot b and, per walleye-control-on-slot-a-try, on slot a too; so are our b-f. Seen to be accepted: our boot-b on the very first try (slot a active, phone entered fastboot from healthy Android): the phone left USB, Android came up on b, a flagged unbootable; and boot-a, "Booting OKAY" with nothing starting, on slot b. The same image was refused later. So the refusal is not the image's format and, after the slot-a try, not the active slot or the unbootable flag alone. The same string and A/B flip are reported for walleye since 2017 (XDA PSA); on other Qualcomm ABL phones it comes "randomly" and goes with a restart, another port or cable, set_active or a stock reflash. Ranked causes now (each by what it predicts): 1. State left by the first tries that set_active does not undo. The one accepted try came from a phone booted into Android on a, with a successful=yes (Android marks it when boot completes). Now a is successful=no, retry 1, and b's flag was reset by our set-active (b successful no). Predicts: after Android boots on a to completion (marks it successful) and the phone is put into the bootloader from that Android, the control is accepted again. Cheapest and reversible; it is the exact first state. Not tested. 2. A bootloader that has stayed up since a failed boot (the 'restart cures it' reports). Predicts: a cold power-off and start into the bootloader, then the same try, is accepted. Not tested; also covered by 1, which reboots the phone. 3. dtbo (or vbmeta) of the active slot. The bootloader picks overlays from dtbo by id and rev and refuses if none fits (AOSP DTO; the taimen bootloader wants id 2704, kcxt). Slot b's is an older Lineage build's and a's is current, yet both refuse, so a mismatch with the new dtb is unlikely; a cause only if 1 and 2 fail. A write; stays named, with no way back for the stock dtbo (fastboot cannot read it back). 4. Host: old fastboot, USB port, cable. The transfer succeeds and the refusal comes back at "booting", so least likely; recorded with each try (fastboot --version). 5. AVB and lock state: the phone reports unlocked yes, where verification errors are warnings; not measured. Not known yet: the bootloader's own reason. Google's ABL is not public (the CAF Qualcomm ABL only shows the shape) and fastboot has no read-only oem command that prints it. The way to see it is the serial log over the Pixel 2's Android Debug Cable (Nura wiki), which needs the author's hardware. Vector chosen: restore the first state, since it is the only state in which an image was accepted: set-active a, boot Android on a normally to completion (a's own Android, nothing written), adb reboot bootloader, the control once; then, if still refused, cold power-off start and host checks; then UART; a write last.
- PSA: fastboot booting a bad image can confuse the A/B bootloader (Pixel 2 walleye) - walleye-research, 2017 On walleye, fastboot boot of MSM8998 TWRP images was refused before any kernel ran and flipped slots; set_active a restores; later posters got Load Error for every image after it, even after stock flashes, until both slots were reflashed; use a current fastboot
- Troubles reinstalling TWRP [Load Error] (Mi 8 SE thread, another Qualcomm ABL phone) - walleye-research, 2019 Same ABL string on another phone: reported cures are restart, another USB port or cable, set_active, reflashing stock; the string is generic with several unrelated causes
- dtbo-google-wahoo-mainline README (Casey Connolly) - walleye-research, 2021 Taimen bootloader refuses to boot unless the dtbo partition holds an overlay with id 2704 (androidboot.dtbo_idx=12); a minimal dtbo makes mainline boot
- Google Pixel 2 XL (google-taimen) mainline status - walleye-research, 2026 Mainline boots on taimen through pmbootstrap flasher with basic dts and clk_ignore_unused; pstore is unreliable after cold reboot; a serial Android Debug Cable is the way to see early boot
- AOSP: Compile and verify device tree overlays - walleye-research, 2026 The bootloader picks overlays from dtbo by id and rev, applies them to the base dtb and passes androidboot.dtbo_idx; an overlay that fails to apply is a bootloader-side boot failure
2026-11-17
What do LineageOS's wahoo build and porthole's mkbootimg inputs say about header version, page size, base and os_version, and does a v0 header fit walleye?
LineageOS wahoo (lineage-15.1 BoardConfig.mk): BOARD_KERNEL_BASE 0, PAGESIZE 4096, default kernel offset, tags 0x01E00000 and ramdisk 0x02000000 for walleye and muskie (0x80000/0x02500000/0x02700000 only for the kasan builds), no header-version, dtb or recovery_dtbo argument: header v0; BOARD_USES_RECOVERY_AS_BOOT and system-as-root, dtbo in its own partition. Porthole's taimen deviceinfo: header v0, base 0, kernel 0x8000, ramdisk 0x1000000, tags 0x100, pagesize 4096 'verified against the stock taimen boot.img', kernel with the dtb appended, dtbo flashed to its own partition, no os_version set. A v0 header has no dt size or recovery_dtbo field (those arrive with v1/v2), so v0 fits walleye as far as public sources say; walleye's own stock header is still not read. The two offset sets are the two publics': taimen's stock (a) and LineageOS's (b), and try a, with the stock offsets, did not leave fastboot while b did. os_version/patch level: the AOSP build writes them into every boot.img (PLATFORM_VERSION, PLATFORM_SECURITY_PATCH); no public source for walleye gives the value, so variants c and d use 8.1.0 / 2020-01 (a pick). Not known: whether ABL reads them, and whether the dtbo overlay id (backlog walleye-dtbo-overlay-id) or the signature/AVB footer decides instead; porthole flashes a stub dtbo, which we have not.
- LineageOS android_kernel_google_wahoo (lineage-22.2): device-tree sources of walleye and taimen - Google, HTC, LG, Qualcomm; kept by LineageOS, 2025 GPL-2.0 Linux 4.4 kernel of both wahoo phones. Walleye (HTC-built, project name muskie) is under arch/arm64/boot/dts/htc: panel, touch, audio amp, haptics, NFC, camera, battery, memory map. Read as facts for a hardware table; ports of code keep copyright and licence.
- porthole-dev/pmaports (branch taimen-bringup): mainline 7.2.2 + 263 patches, device-google-taimen, walleye board patch 0029 - porthole-dev, 2026 The one maintained mainline Pixel 2 family kernel: taimen proven, walleye board file untested. deviceinfo gives the boot image header (v0, offsets, appended dtb); the dtbo stub (id 2704) and cmdline are the first-boot facts.
2026-11-17
What is the best-known way to bootstrap an Android phone to mainline almost from zero (pmOS, Mobian/Halium, sdm845/sm8150 communities, MSM8998 siblings), and how does the walleye lane's work compare?
THE METHOD, in order (pmOS Porting/Mainlining guides, Qualcomm mainline porting, Halium early-init, MSM8998 pages): 1 unlock, keep the stock boot.img and a way back to Android; read offsets/ids from it. 2 Get a feedback channel BEFORE mainline: UART first, then simple-framebuffer, ramoops last (pmOS order); for a no-display phone the USB gadget shell is the channel. 3 Vendor kernel first as a known-good: Halium/UBports/Droidian boot the vendor kernel with their own initramfs (telnet 192.168.2.15, break= levels) - it proves image format, offsets, cmdline, gadget, and shows ids, rails, reserved memory. pmOS recommends a downstream port as the base but no MSM8998 sibling did it; they went straight to mainline. 4 Board dts from msm8998-mtp: fix model/compatible/board-id, delete CoreSight nodes, match regulators, clk_ignore_unused (still the normal first flag, Dybcio 2025). 5 Image.gz + dtb appended, mkbootimg base 0 page 4096, initramfs with debug-shell and USB gadget; fastboot boot (OnePlus 5, Mi 6, Pixel 3 XL with a stub dtbo; OnePlus 5T OxygenOS 9 cannot fastboot boot - flash instead). 6 First shell over USB peripheral (QMP + QUSB2 PHY, dr_mode peripheral); Pixel 2 XL reached exactly this, black screen. 7 Then UFS (not on Sony), display, touch, radios; upstream with b4. LK2ND: not a route. Its device list stops at msm8996, msm8998 is '?' in targets.md, no Pixel, and it is an LK fork loaded by LK-based aboot; Pixel 2 runs a Qualcomm ABL/UEFI-derived bootloader. Pixel 3/sdm845 recipe is plain fastboot boot plus a stub dtbo, not lk2nd. U-Boot as second stage under ABL exists for sdm845 (FOSDEM 2024), not known for msm8998. Whether an LK image could run under ABL is not known yet. WALLEYE LANE vs THE METHOD: done - stock ids and header read from the public LineageOS image, boot images a-f (17 checks), gadget initramfs proven in QEMU, minimal dts, control test, and the finding that Load Error follows the slot's successful flag (control accepted only from the first state). Gaps: (a) step 3 never done - no image has run a kernel on this phone, so cmdline, ids, rails, ramoops address, and the gadget on real hardware are unseen; (b) step 2 - no feedback channel chosen: UART needs a cable and an oem decision, ramoops address unverified, simplefb unlikely (command-mode DSC panel); (c) the order: the lane went to its own mainline image before any known-good boot. The control (LineageOS boot.img, vendor 4.4 kernel) is accepted from the first state but then left USB with no sign for 6+ min, so even a stock image gives no feedback on this phone yet. NOT KNOWN YET: whether the vendor kernel in the control reaches a configfs gadget (LineageOS kernels normally do for adb); whether fastboot oem uart enable persists; walleye's dtbo overlay id; first-shell method on taimen (flash vs fastboot boot); sm8150 practice and the FOSDEM 2024 slides were not read. pmOS wiki now at wiki.nura.eco behind a bot wall; read as raw wikitext.
- postmarketOS: Porting to a new device - walleye-research Steps: unlock, pmbootstrap, device+kernel package, build, test; read offsets from the stock boot.img
- postmarketOS: Mainlining Guide - walleye-research Assumes a downstream port and a USB shell; serial recommended; start from a similar dts; second stage only if TrustZone/bootloader needs it
- postmarketOS: Qualcomm mainline porting - walleye-research First feedback order: UART, then simple framebuffer, then ramoops as last resort
- postmarketOS: Snapdragon 835 (MSM8998) - walleye-research MTP-derived dts boots only after CoreSight nodes are removed; clk_ignore_unused; simplefb from XBL strings; DSC panels (Pixel 2 XL) likely no simplefb; USB peripheral PHYs
- Jami Kettunen: linux-mainline-oneplus5 (branch history) - walleye-research MSM8998 first-boot order: dts from mtp, drop CoreSight, simplefb, then touch/UFS; cat Image.gz dtb, mkbootimg base 0 page 4096
- postmarketOS: Xiaomi Mi 6 (sagit) - walleye-research Mainline first shell by fastboot boot of Image.gz-dtb in the stock boot.img; UART pads; edk2 for OTG
- lk2nd Documentation/devices.md and targets.md - walleye-research Platforms to msm8996 only; msm8998 row '?'; no Pixel; LK-based stock bootloaders only
- pmaports issue 153: crosshatch mainlining attempt - walleye-research Pixel 3 XL: fastboot boot of a mainline image with a stub dtbo; no UART, pstore planned
- Halium docs: Early Init (debug build) - walleye-research Vendor kernel + halium-boot initramfs gives a telnet shell on 192.168.2.15; break= levels; serial-number string reports debug state
- Linux kernel: ramoops - walleye-research Log survives a warm/watchdog reset usually; address must be reserved and stable
- Peter-Easton/android-debug-cable-howto - walleye-research-vendor How to build the Pixel USB-C debug UART cable (A1 GND, SBU1 RX, SBU2 TX, 115200 baud).
- Dybcio: clk/pd ignore_unused warning thread - walleye-research clk_ignore_unused is still the normal first-boot flag, hiding an incomplete platform description
- dtbo-google-wahoo-mainline README (Casey Connolly) - walleye-research, 2021 Taimen bootloader refuses to boot unless the dtbo partition holds an overlay with id 2704 (androidboot.dtbo_idx=12); a minimal dtbo makes mainline boot
- PSA: fastboot booting a bad image can confuse the A/B bootloader (Pixel 2 walleye) - walleye-research, 2017 On walleye, fastboot boot of MSM8998 TWRP images was refused before any kernel ran and flipped slots; set_active a restores; later posters got Load Error for every image after it, even after stock flashes, until both slots were reflashed; use a current fastboot
2026-11-17
Does a real stock-format walleye image boot by fastboot boot where ours is refused?
No. The LineageOS 22.2 boot.img, boot-e and boot-f each got Load Error ('Failed to load/authenticate boot image') within a second of the transfer; the phone stayed in fastboot (18d1:4ee0 in all 90 polls each); slot flags unchanged. Files: research/walleye-first-fastboot-boot/2026-11-17-control-e-f. So our images are not the (only) cause; open: dtbo/vbmeta/slot a flags, all writes or the author's.
2026-11-17
Does the LineageOS control boot.img boot by fastboot boot with slot a active (the state of the very first tries)?
No. Per decision walleye-slot-set-active-a-once: devlab fastboot set-active now a (before: current b, a unbootable yes/successful yes/retry 0, b unbootable no/successful yes/retry 0; after: current a, a unbootable no/successful no/retry 1). devlab fastboot boot now control/boot.img (sha256 48dbc55c..., LineageOS 22.2 20261113): 'Sending boot.img OKAY', then 'Booting FAILED (remote: Failed to load/authenticate boot image: Load Error)'; still in fastboot after a minute; the try changed no flags. So the refusal is not caused by slot b being active or by a being flagged unbootable: the same stock image is refused on a too. Open causes: dtbo/vbmeta state (a write, the author's or coordinator's call), or fastboot boot on this bootloader never takes an image of this kind. Restored with set-active now b: current b, a unbootable no/successful no/retry 1, b unbootable no/successful no/retry 1 (set-active resets b's successful flag; both slots bootable, retry counts 1); fastboot reachable, nothing written.
2026-11-17
Does the bootloader's dtbo overlay merge need __symbols__ and the nodes the overlays patch, and is that why our dtb is never started?
What is: androidboot.dtbo_idx=3 (set by the bootloader) = dtbo.img entry 3 (id 0x1bc rev 3), 147 fragments, label-targeted, __fixups__ naming 137 labels of the base dtb (cci, tlmm, soc, mdss_mdp, pm8998_gpios...). No msm-id/board-id in the overlays; the entry is picked by id/rev, then merged into the dtb of the boot image. Measured on the host (material: dtbo-measurements.md): fdtoverlay merges entry 3 into the stock dtb (986 symbols, all 137 present) and FAILS on ours: no /__symbols__ node. AOSP's libufdt, the reference for Android's overlay merge, treats that as an error (aosp-libufdt-overlay). Even compiled with -@, our dtb would carry about 14 of the 137 labels (mainline names), and its soc is soc@0, so the fixups would still not resolve. Fits the bisect: s0n/s0 (stock dtb) start; s2 (our kernel, stock dtb) starts the kernel and falls back; s3 (our dtb, stock kernel) alone reaches 'Booting OKAY' then stays in fastboot - the only variant whose dtb cannot take the overlay. So the dtbo merge is the likeliest cause of s3, and one that outlives every later fix: the vendor ABL will overlay any dtb we hand it. Not known yet: what Google's ABL does on a failed merge (its source is not public; libufdt returns an error, ABL may refuse or continue) - the one cheap image tells. Does not explain the Load Error of the control (stock dtb merges fine): that stays on research walleye-boot-refused-why-how-it-stands. Ways: (a) give our dtb the symbols: a compatibility dtsi with stub nodes for the ~123 missing labels, built with -@ - host-testable by fdtoverlay, but adds vendor stubs the mainline kernel ignores; (b) boot the stock dtb for first light and move to ours later - the kernel then runs on the vendor dtb, wrong for mainline drivers; (c) patch the stock dtb: replace its nodes with ours - same merge-safety, much larger; (d) remove the overlay from the path: only by writing dtbo (a write, not proposed); (e) ask the bootloader to skip it: no known way (androidboot.dtbo_idx is its output, not input). Chosen: (a), narrowed: generate the stub label set from the overlay's own __fixups__ (the 137 names, each with the path it has in the stock dtb's __symbols__), build with -@, prove with tests/host/dtbo-overlay-merges.sh on the host first, then one image on the phone.
- AOSP: Compile and verify device tree overlays - walleye-research, 2026 The bootloader picks overlays from dtbo by id and rev, applies them to the base dtb and passes androidboot.dtbo_idx; an overlay that fails to apply is a bootloader-side boot failure
- dtbo-google-wahoo-mainline README (Casey Connolly) - walleye-research, 2021 Taimen bootloader refuses to boot unless the dtbo partition holds an overlay with id 2704 (androidboot.dtbo_idx=12); a minimal dtbo makes mainline boot
2026-11-17
How can FunctionFS give the host a /dev/ttyACM0 with a shell, on the vendor 4.4.302 kernel (ACM/SERIAL/ECM/RNDIS off, F_FS on, no devtmpfs), from a tiny static aarch64 C helper?
What is: the running kernel is the stock 4.4.302 with our ramdisk (research walleye-vendor-kernel-facts-s1-panic): USB_CONFIGFS and F_FS =y, ACM/SERIAL/ECM/RNDIS not set, no devtmpfs, UDC a800000.dwc3. Android itself uses ffs.adb in configfs group g1 on this phone (src-wahoo-init-hardware-usb-rc), so F_FS is exercised by the stock stack. Finding 1 (the trap): f_fs's descriptor parser (v4.4.302 and v7.3 alike) rejects any descriptor type outside interface, endpoint, HID, OTG, interface-association and SS-companion; CS_INTERFACE (0x24, the CDC header/call-management/ACM/union descriptors) falls to default -> -EINVAL. The queued idea of declaring the full CDC functional descriptors would make the write to ep0 fail. Finding 2 (the way): cdc_acm's probe, with no union descriptor and a class 2 / subclass 2 / protocol 1 interface with exactly three endpoints, assumes a single combined interface and picks interrupt-in, bulk-in, bulk-out with usb_find_common_endpoints. So ONE interface (class 0x02, sub 0x02, proto 0x01) with interrupt-in (10 bytes, interval 9), bulk-out and bulk-in (512 HS/SS, 64 FS) plus SS companion descriptors is enough; the host gives /dev/ttyACM0. Line coding / control-line-state are best-effort for the host. Design: (1) init: mount configfs; gadget with ids and strings as n2; functions/ffs.acm, configs/c.1 symlink; mkdir /dev/ffs; mount -t functionfs acm /dev/ffs (no devtmpfs: nodes by cpio; ep0 appears in the ffs mount, ep1..3 after the descriptors are written; /dev/ptmx a cpio node, mount devpts). (2) helper (C, static aarch64, clang, GPL base ffs-test.c, libc only): open /dev/ffs/ep0; write the V2 descriptors blob (flags FS|HS|SS), then the strings blob (lang 0x0409); only then write the UDC name (before that the configfs bind returns -ENODEV: f_fs desc_ready). (3) ep0 loop: on ENABLE open ep1..ep3 (names follow descriptor order) and fork a pty shell (posix_openpt, /bin/sh as session leader); on DISABLE/UNBIND close and kill; answer class SETUP events (SET_LINE_CODING 0x20, GET_LINE_CODING 0x21, SET_CONTROL_LINE_STATE 0x22) with a zero-length ack or canned 115200 8N1 so cdc_acm sees no stall; any other setup gets a stall. (4) bridge: poll pty master and ep2 (bulk-out) -> ep3 (bulk-in); ep1 opened and idle. A bulk-in write blocks until the host reads, so use a thread or timeout so a missing host never hangs the shell; log to /dev/kmsg only on state changes. (5) the mass-storage log window stays the second channel. Failure modes and how each looks: UDC write ENODEV (descriptors not written first, or parse -EINVAL: helper reports errno on /dev/kmsg and the mass-storage window); enumerates but no ttyACM (host cdc_acm rejected: host dmesg); enumerates then drops (ep0 events unanswered: host reset); panic (as 5b, an unwritten function attribute: this design writes no function attribute, only ep0 data) - the bootloader falls back to slot a as before. Not measured yet: whether the vendor's f_fs (Android common 4.4 plus patches) behaves like stock 4.4.302 here (read, not run); the host side of the ACM bind.
2026-11-17
What did the Pixel 2 do when given the builder's first boot images with fastboot boot, and what did it leave behind?
Try a (boot-a.img, taimen offsets): sent, the phone stayed in fastboot, no USB event on the host for 60 s. Try b (boot-b.img, LineageOS offsets): image accepted, "Booting" then the phone left USB at once; 20 s later it was Android's adb gadget (18d1:4ee7), Android on slot b (an older LineageOS build than slot a's), boot reason reboot,ota. Nothing of ours answered: no serial port, no RNDIS/ECM, 172.16.42.1 silent, pstore empty. Whether our kernel ran is not known yet. The bootloader's A/B logic changed the state, with no write command from us: after try b the phone reports current-slot b and slot a unbootable = yes (first look: slot a current, unbootable no). Slot a's Android is presumably intact; restoring the flags is `set_active a`, a write that needs a recorded decision and the author's word. devlab called try b "refused", though the host log shows the phone left fastboot; it should read slot flags before and after a try and say what changed. Until the author decides about the slot flags no further try should be made.
2026-11-17
Does setting os_version and patch level in the header make the bootloader start our boot image?
Try c (boot-a plus the header os word) and try d (boot-b plus it), on slot b with devlab's before/after report: both fastboot "Booting FAILED (remote: 'Failed to load/authenticate boot image: Load Error')" after the 0.368 s transfer. The phone stayed in fastboot: 18d1:4ee0 in all 90 one-second lsusb polls after each, nothing new on USB (no Linux gadget, no serial port), host kernel log empty. Slot flags identical before and after (current b, a unbootable). No write, no set-active. So the os_version/patch level word does not make the bootloader accept our images, and it turned boot-a's silent "Booting OKAY" into a Load Error. No image has started our kernel; what the loader dislikes (header, kernel format, dtb, missing dtbo) is not known yet. Open: a dtbo stub is a write and stays the author's decision; the builder may try other header fields or a kernel with the dtb as Android expects.
2026-11-17
What do boot-a.img and boot-b.img do with slot b active, with devlab's before/after slot report?
With b active (a unbootable, as left): try a - fastboot "Booting OKAY [0.052s]", the phone stays in fastboot, no USB event, nothing answers. Try b - "Booting FAILED (remote: 'Failed to load/authenticate boot image: Load Error')", stays in fastboot. Slot flags before and after were identical both times (current b; a unbootable yes, successful yes; b unbootable no, successful yes; retry-counts 0), so set-active was not needed and was not used; nothing written. The first try b (17:37, slot a active) behaved differently: the phone left USB and Android came up on b with a flagged unbootable. Same image, so what decided is not known yet (the active slot, or something that changed in between). Our kernel has not been seen to start at all. Next: the builder's variant with os_version and patch level set; a dtbo stub stays the author's decision.
2026-11-17
Does restoring the first state (Android completed on slot a, adb reboot bootloader) make the bootloader accept the control boot.img?
Yes. set-active a, fastboot reboot, Android up on a (sys.boot_completed 1, slot _a). After adb reboot bootloader: current-slot a, a unbootable no/successful yes/retry 0, b unbootable no/successful no/retry 1. devlab fastboot boot now control/boot.img: left fastboot after 12 s. devlab's 'came back as Linux, USB network answering' is a false match: the 18d1:d001 gadget (Qualcomm SM7150, serial postmarketOS) on the bus is the surya phone; walleye FA81N1A00790 was on no USB, no adb, no fastboot for 6+ min. So cause 1 (state left by the first tries) is confirmed: Load Error follows the slot's successful flag, not the image. Nothing written. The lab has no power control for walleye, so it is not back in fastboot: a hand hold of power 10-30 s is needed (slot a is successful, so it boots Android on a; then adb reboot bootloader). Next: boot-b/e from the same first state; fix devlab's came-back check to match the manifest serial.
2026-11-17
Does vendor-gadget3 enumerate our gadget (serial walleye-first-boot) when the watcher is kept alive for the whole window?
From the first state (a active+successful, b unbootable), fastboot boot of vendor-gadget3.img: left fastboot after 12 s, Android on a after 74 s (Pixel 2 strings at t=68 s). A 1 s watcher over 130 s (its own setsid job) listed every USB device each second: port 3-2 showed only fastboot, then Android; no device with serial walleye-first-boot or product 'Pixel 2 walleye (mainline)'. The 18d1:d001 devices seen all sit on port 3-1 with serial postmarketOS = surya, not ours. ro.boot.bootreason=kernel_panic; no pstore readable without root. So the panic comes before any gadget strings, and the 240 s timer never runs. Next: an init that only writes to /dev/kmsg, to separate ramdisk unpack from gadget bring-up.
2026-11-17
With the host on 7.3.4, does m1's mass-storage LUN show up and can its first text be read?
Fastboot boot of vendor-gadget-m1 (sha a3cf08d3...) from slot a good/b unbootable: left fastboot 12 s, enumerated 1d6b:0104 at 18 s, usb-storage bound without modprobe, /dev/sda size 4096 sectors. massstorage-read.sh gave skip: /dev/sda is root:disk rw-rw----, user mll in wheel only, sudo needs a password. The phone fell back by itself to Android on slot a (adb up, boot completed); adb reboot bootloader returned it to fastboot, flags unchanged (a ok/successful, b unbootable retry 1). m1 is the first walleye image of ours proven to run and reach the host; only the host read is missing.
2026-11-17
Does our mainline kernel start (first light: serial walleye-first-boot, product 'Pixel 2 walleye (mainline)') from boot-ml1.img (Image.gz) and boot-ml2.img (lz4)?
Both images (sha256 41d8efc0..., 63b2977f...) booted once each from the first state (a current+successful, b unbootable, fastboot). ml1: left fastboot after 15 s, Android adb back after 72 s. ml2: left after 12 s, back after 69 s. mainline-light-up.sh watched 150 s per try: fail both, no device with our strings. Return at ~70 s with bootreason reboot (not kernel_panic), the same time as the vendor-kernel panic fallback: either the panic=5/watchdog path or the bootloader fallback; which is not told by what we can read. Slot flags unchanged after both (a current, successful=yes, b unbootable, retry 1); phone left in fastboot on a. Nothing flashed. Reading it needs ramoops (author unlock) or the UART cable, per decision walleye-panic-read-order; the watchdog node address is still the unmeasured downstream value.
2026-11-17
Does the stock Android's pstore hold our mainline kernel's console after ml3 (ramoops at the phone's own region)?
boot-ml3.img (sha256 5c257470...) booted from the first state with fastboot boot: left fastboot after 15 s, USB light never (no walleye-first-boot device), Android on slot a after 72 s, androidboot.bootreason=reboot. adb root works (Lineage-like build). Android's ramoops is at mem_address 2702180352 = 0xa1100000, size 2 MiB, record 524288, console 131072, pmsg 0 - it matches our node. /sys/fs/pstore has 0 files, no 'no valid data' line; /data/vendor_ce/0/ramoops holds only pub/priv pem. So no console record of ours: either our kernel dies before the pstore console registers, or the reset clears DDR (a bootloader/PMIC reset, not a warm one - bootreason is plain reboot, not kernel_panic/watchdog). Together with ml1/ml2 the 7.3 image has never shown a sign of life.
2026-11-17
Is ml4 built so only the ramdisk differs from ml3?
build/build-ml4.sh unpacks ml3, builds the ramdisk from build/initramfs-mainline/init-ml4, repacks with ml3's header fields and AVB footer; 10 checks ok; rebuilt twice with the same hashes. boot-ml4.img sha256 105364591ce1f46a2a828caf1f80c851399487ab4a59bd777210a9a72e13ea84; initramfs-ml4.cpio.xz sha256 da11b5e005dbe541db83ba9c286e91bfbb44db1058df65bc6e920b12c61dfd19; in ~/Projects/walleye-build/images-ml4/ (SHA256SUMS there). Decision of the build: the init pets the watchdog once a second during its bounded sleep (up to 35 s at score 7) so the SoC watchdog (~30 s) does not cut the delay; before the sleep it is open and unpetted, so a hang there still resets by itself. Bin table: tests/host/ml4-bin-table.sh.
2026-11-17
Can timing bins finish before the ~33 s dead-kernel reset?
ml5a and ml5b built from ml3 with only the ramdisk /init changed (build/build-ml5.sh; kernel, dtb and header bytes equal ml3's; AVB footer verifies; 20 checks ok; rebuild byte-identical). ml5a: mount proc/sys, kmsg marker, reboot -f at once (sysrq b fallback), no watchdog. ml5b: ml4's checklist with 3 s per point (max 21 s, under the ~33 s dead-kernel reset), watchdog petting kept. Bin table in tests/host/ml5-bin-table.sh: ml5a returns at BASE (expected ~40 s if init ran, ~70 s if the kernel never reached it); ml5b returns at BASE + 3*score. Images in ~/Projects/walleye-build/images-ml5/. sha256: boot-ml5a.img b937e8fba212c08db3343ada25fcfa6045f7ce903e4a5e44ea3c095e782b461e; boot-ml5b.img a0fe6f0bb02484c08a7eb0f74f095e59f12c03aba6b071c62caac4d1ae3d8ed8; initramfs-ml5a.cpio.xz 56d1f4ce247f903f2f23984b25d743f6acaea2182bb0d495a0ae611938af1ee6; initramfs-ml5b.cpio.xz 3357b2b63cdbf91337573359ca9010d221fcba84f3ba1f4e1d352569e2886b89.
2026-11-17
Does image n3 give a ttyACM and a shell answer on the host (ffs-acm-up.sh)?
devlab fastboot boot now n3 (sha 6672eb84...): left fastboot 12 s, came back as 1d6b:0104 on 3-2 after 18 s; lsusb shows iProduct 'Pixel 2 walleye (mainline)', iSerial walleye-first-boot, bInterfaceClass 2; no panic. ffs-acm-up.sh (ACM_WAIT=30) fails: interface 3-2:1.0 has no driver. The host runs 7.3.3-1-cachyos but /lib/modules holds only 7.3.4 and 6.18 lts, so modinfo cdc_acm finds nothing; cdc_acm cannot load until the host reboots into 7.3.4 (same wait as try-massstorage's usb_storage). The init's self-reboot returned the phone to Android on a after ~4 min; adb reboot bootloader; fastboot state: a current, successful, not unbootable; b unbootable, retry 1, as before the try. Nothing flashed.
2026-11-17
Does the ncm gadget without any attribute write bind without a panic, and does the host get a network device?
From the first state (Android on a, adb reboot bootloader), 2026-11-17: n1 (mkdir function, config, symlink, no bind): left fastboot after 12 s, Android on a at 156 s, bootreason reboot - as predicted. n2 (+ UDC bind): left fastboot after 12 s, host saw USB 1d6b:0104 after 18 s with manufacturer linux-phone-oco, product 'Pixel 2 walleye (mainline)', serial walleye-first-boot - the FIRST time our own kernel strings reach the host; no panic at bind, Android back on a at ~2 min (bootreason reboot via the init's 120 s reboot -f). So the attribute writes were the panic cause (walleye-ncm-panic-why holds). But no network device on the host: dmesg 'cdc_ncm 3-2:1.0: failed to get mac address / bind() failure'; lsusb -v shows the CDC Ethernet descriptor iMacAddress 6 (??): string 6 is not served, so the host cannot read the MAC, usb0 on the phone is unreachable, telnetd 172.16.43.1 not reachable. In the wahoo 4.4 f_ncm.c the MAC string is the static ncm_string_defs[STRING_MAC_IDX].s set in ncm_alloc to the instance's ethaddr (filled at ncm_bind from the net device) - why it is not served is not known yet. After: back in fastboot, slot a active+successful, b unbootable retry 1, nothing flashed.
2026-11-17
Why does the ncm function (or its config symlink) panic the vendor msm-4.4 kernel, and which function is safe and gives a channel?
Ranked causes. 1 (source-proven, not yet counted on the phone): the two `echo > functions/ncm.usb0/{dev_addr,host_addr}` lines in every gadget init (vendor, 3, 5b, 5c). In the wahoo 4.4 tree ncm_alloc_inst leaves opts->net NULL (the net_device is made in ncm_bind at UDC bind) and refcnt is 0 until the symlink, so the attribute store calls gether_set_dev_addr(NULL,...): NULL deref, oops, panic. After the symlink the store returns -EBUSY, so no write is ever valid here. Fits all facts: 5a (no function) and gadget4 return; 5b and gadget2/3 panic; mkdir and symlink alone do not touch net (ncm_alloc only refcnt++). 2: the UDC bind (ncm_bind -> gether_register_netdev, dwc3 endpoints) could panic in 5c; unknowable until 1 is removed (Android never uses ncm: its stack is gsi/ffs, so the vendor never exercised this path). 3: the symlink itself: no code path touches net; unlikely. Safe alternatives, with the image that tells: (a) ncm WITHOUT any attribute write (random MACs; set the device side later with ip link set usb0 address): image ncm-noattr = 5c minus the two echo lines; returns at 120 s with no panic and the host sees our strings = confirmed. (b) ffs with a tiny static aarch64 helper: more work, no gain if (a) works; the fallback. (c) gsi.rndis/rmnet: need IPA driver and firmware at early init, not a first channel. (d) mass_storage read-only image: host sees a disk, no log stream; crude fallback. (e) mtp/ptp/acc: need a userspace daemon; no. Caveat: the source is the public android11 branch of the wahoo 4.4 line; the phone runs 4.4.302, the exact build is not public, so the image is the proof.
2026-11-17
Without earlycon, does init run: pk3 twice, ml6a twice from the first state, return times?
Images images-nocon on slot b via devlab fastboot boot. pk3: left fastboot 12 s, Android adb back after 63 s then 48 s. ml6a: left after 15 s, Android back after 75 s and 75 s (the no-init watchdog pattern of ml5a, pk1, pk2). Flags after each: a and b successful, unbootable no, retry 0. Reading: ml6a still shows no init; pk3 returns faster than 75 s but slower and more varied than stock 36-45 s, so it is unproven that init ran - needs a log channel (ramoops/UART) to settle. No hands used; one pk3 try was lost to adb not ready (rerun).
2026-11-17
Does fastboot boot of our images e and b start from the restored first state?
Both ACCEPTED (Booting OKAY) but not started: 90 s watch by serial, phone stays in fastboot, no new USB device, no 172.16.42.1 (172.16.42.2 is surya's), slot flags unchanged; acceptance is not the cause of silence
2026-11-17
Why does the vendor 4.4.302 kernel panic about 60 s after fastboot boot with our ramdisk, and how can the panic text be read?
WHAT IS (lab base): the vendor 4.4.302 kernel started with our swapped ramdisk (xz, so not the gzip fault) and panics before any gadget: bootreason kernel_panic, USB gone at ~12 s, Android back on a at 68-74 s; the true panic time is NOT measured (the host sees USB only, and the fallback Android boot itself takes tens of seconds, so the panic may be at ~30-60 s, not 60). Stock-kernel pstore is empty from Android (vendor ramoops -D encrypts after unlock). CAUSES, ranked by what the facts support, each with the one cheap try that tells it apart. (1) Our ramdisk is not what runs: Pixel 2 is system-as-root (A/B, recovery in boot; LineageOS flashes recovery into boot), and a system-as-root cmdline is ro root=/dev/dm-0 rootwait skip_initramfs init=/init - the kernel then ignores the boot ramdisk and runs /init from the system partition (src-android-system-as-root); a bootloader can add skip_initramfs itself (src-magisk-skip-initramfs). Then our /init never ran, which fits no gadget ever, and the later panic is Android first-stage failing on a half-set-up boot. Told apart by two READ-ONLY facts: the full /proc/cmdline and /proc/device-tree/chosen/bootargs of the running Android (skip_initramfs, root=, dm=), and the control image header cmdline (host, from the file). Needs no try. If skip_initramfs is there, gadget4 (idle init) is moot for the panic and the way is an image whose cmdline/ABL path honours our ramdisk, or the system partition route; this goes first because it is free. (2) A kernel-side failure independent of userspace: a peripheral (modem/adsp/slpi via PIL) crashing or timing out with restart level SYSTEM prints subsys-restart ... Resetting the SoC and panics (src-qcom-log-analysis); the user-mode firmware fallback waits 60 s by default (src-kernel-firmware-fallback), so a missing userspace ueventd can turn into a panic about a minute in. Told apart by gadget4 (idle init that survives): the same gap with an idle init means kernel-side; the cheaper first step is to measure the panic time (see below). (3) Our init exiting or crashing: ruled out in time by gadget3 (240 s timer, no early exit seen), and gadget4 tests it again. (4) MSM apps watchdog: pet by the kernel, not userspace, so unlikely; reads as watchdog bark/bite in the text. HOW TO READ THE PANIC TEXT, cheapest first: (a) Measure the time instead of reading the text: a 1 s USB watcher over a plain adb reboot gives T_android (USB loss to Android on USB); the panic try gives the gap; panic time = gap - T_android. This needs no write. 60 s plus ~12 s would point at the firmware fallback; ~25-45 s at an early kernel fault. (b) Previous boot text in ramoops: region 0xa1100000 2 MiB is reserved, so the panic text survives the warm reset (src-kernel-ramoops-doc) but the vendor init consumes and encrypts it into /data/vendor_ce/0/ramoops once the user unlocks; so after a panic try, boot Android on a, have the author unlock the phone once (credential is the author, not ours), and read the ramoops files as root - UNKNOWN whether the file appears for a non-user-initiated reboot: one try shows it. The phone must not be rebooted again before reading, or the next boot overwrites the buffer. (c) Our own ramdisk as reader: only if (1) is false - a second try image whose init mounts pstore and only prints to a path we can read; no channel exists, so not first. (d) UART: the Android Debug Cable (USB-C passthrough breakout + FT232 TTL, a purchase of a few euros for the author, src-pixel-uart-cable) works on walleye (src-nura-serial-pixel2); fastboot oem uart enable needs the unlocked bootloader (it is) and is a bootloader setting that persists until fastboot oem uart disable - a write with a way back; the 1.8 V line needs the board to be right. It gives the bootloader log AND the kernel console to the end of the panic, so it answers causes 1-4 at once and also the Load Error question; it is the sure route, kept second only because it costs a purchase and a hand. (e) /proc/last_kmsg: not in 4.4 Android (moved to console-ramoops, Android 6+). (f) Not now: kernel rebuild with the earlycon/pstore console to the cmdline, a dtbo write.
2026-11-17
From slot b, with no earlycon, which swap of kernel/dtb between porthole's (pk3) and ours (ml6a) stops init: return times of pk3 once, pk4/pk5/pk6 twice?
Via devlab fastboot boot, slot b, no writes. Return as Android (adb): pk3 48 s; pk4 75, 69 s; pk5 42, 42 s; pk6 66, 42 s. Bootreason reboot each, /sys/fs/pstore empty after each (shell has no su, so /data/vendor_ce/0/ramoops unread). Reading: pk5 = our Image.gz with porthole's taimen dtb returns at stock speed, so init ran and our kernel is fine; pk4 = porthole kernel with our dtb gives the no-init 70-75 s pattern, so our dtb is what stops boot. pk6 (pk3 + timing init) 66 then 42 s does not show the 3 s per point; noisy, no conclusion from it. Slot flags unchanged at the end (a,b successful, retry 0), phone left in fastboot on slot b. Next: diff our dtb against porthole's taimen/walleye dtb (memory, ramoops, reserved regions, console/uart nodes) and bisect nodes.
2026-11-17
Can porthole's known-good mainline kernel be put in our ml5a image (immediate-reboot init) for the phone?
Built from kernel.org v7.2.2 (sha512 checked) + the 262 numbered patches + config of porthole-dev/pmaports taimen-bringup @ 0d62af2 (every patch and the config checked against the APKBUILD sums; the series has no 0236). clang build of Image.gz (9.9 MB) and the taimen and walleye dtbs with -@. pk1 = taimen dtb; pk2 = walleye dtb (their patch 0029) plus qcom,msm-id <0x124 0x20001> added by us (their walleye file has none). Both dtbs carry the stub nodes for the vendor overlay's labels, and the stock dtbo entry 3 merges into each (fdtoverlay). Images = ml5a with only the kernel blob changed: header, command line (earlycon clk_ignore_unused ignore_loglevel panic=5 androidboot.*), ramdisk (init-ml5a) and AVB footer equal ml5a's, 32 MiB, footer verifies. The porthole cmdline words (qcom_wdt.arm_on_probe, watchdog.open_timeout, reboot=w) are NOT used, so that only kernel and dtb differ from ml5a. Hashes: Image.gz 852f82dc, pk1.dtb b6996001, pk2.dtb fe6bf56b, boot-pk1.img b35aab07, boot-pk2.img 9fab400f (full in SHA256SUMS). Expected: init ran = Android back at ~36-45 s; kernel never reached init = ~70-78 s (ml5a 75/75 s). pk1 back at ~40 s while ml5 was ~75 s would put the cause in our dts/config; pk1 and pk2 both ~75 s would put it in the phone, bootloader path or image.
2026-11-17
Can porthole's kernel and ours be bisected one part at a time, all without earlycon, everything else byte-equal?
build/build-pk456.sh unpacks pk3, ml6a and ml5b and repacks with pk3's header, earlycon-free command line and AVB footer props/salt. pk4 = pk3's Image.gz + ml6a's dtb (ours, -@ with overlay stubs, init-ml5a). pk5 = ml6a's Image.gz + pk3's taimen dtb (init-ml5a). pk6 = pk3 with ml5b's ramdisk (timing init). Checks: header words, no earlycon/console=, 32 MiB size, AVB footer verifies, dtb reads and has __symbols__, each part equals the named source's and differs from the other's, three images differ. sha256: boot-pk4.img 71f199ce9bfa2bf25107a0b1991e11aeb885ac3b5674e34f6fb30d42307a656b; boot-pk5.img 6ad5ff369d0c0bc57be1dd01d2db5b675964934845def22ce1154fc95ee31327; boot-pk6.img 0c1b341e47e9624dcd0aae22bce60a94a79f9dc778e7c336e095ec30248f2c13. Images in ~/Projects/walleye-build/images-pk456. Expected: init ran (reboot at once) = Android back at about 40-65 s, no init = about 75 s; pk6 = pk3's time + 3 s per score if init ran.
2026-11-17
Does the control image with only our dtb swapped (-@, __symbols__, 130 overlay stubs) get past the bootloader's overlay merge, unlike s3?
boot-s3o.img sha256 f61e5e8c... fastboot boot once. Before: slot a active/successful, b unbootable retry 1. Result: left fastboot after 12 s (s3 stayed in fastboot), Android a with adb after 36 s, uptime 0 min, bootreason reboot, current slot a. After: adb reboot bootloader, fastboot, flags identical (a successful, b unbootable retry 1), nothing written. So the bootloader now accepts and starts the image; the s3 hang was the overlay merge. Android on a at 36 s (vs 156 s for a panic return) suggests an early reset of the started kernel with our dtb, cause not yet read; next: bring our kernel with this dtb, or read the reset reason (pstore/last_kmsg after unlock).
2026-11-17
Why did two fastboot boot tries change the A/B state, how do we restore it, how do we keep tries from flipping it, and should tries run on slot b?
Probable, not proven: the Pixel 2's bootloader is Qualcomm-derived ABL (Google's build is not public). In Qualcomm's ABL source (CAF pie mirror, QcomModulePkg FastbootCmds.c, PartitionTableUpdate.c, avb/VerifiedBoot.c), `fastboot boot` runs LoadImageAndAuth on the active slot; when that fails, HandleActiveSlotUnbootable sets slot a's unbootable flag (leaving successful set - the odd pair we saw), makes b active because b is successful, and cold-resets before the reply (our "Status read failed"). So our kernel probably never ran, and panic=10 is not the cause. `fastboot boot` does not decrement retry-count; a kernel crash falls back to a normal boot of the stock boot partition; a slot that is successful=yes is never counted down. set_active X (ABL source): makes the slot active at priority 3, retry 7, clears unbootable and successful; swaps the a/b partition-type GUIDs and switches the UFS boot LUN: metadata only, undone by set_active back. a stays successful=no until Android on a marks itself good. `--slot` is ignored by `boot`. Pixel 2 reports: loops end in "Slot Unbootable: Load Error", fixed by set_active (UBports forum 5639); after 7 unsuccessful boots the bootloader switches slot (pmaports MR 3190); the Pixel 2 XL bootloader refuses a kernel unless dtbo holds overlay id 2704 (kcxt dtbo README) - the likely real cause of the failed authentication, unconfirmed for walleye. Not known yet: the real failure point; why try a stayed in fastboot and whether it changed flags; why b shows retry 0 after the switch; whether Google's ABL matches Qualcomm's. Ways: leave flags and try on b (no write; if b is flagged too, set_active is the way out); set_active a now (a stays successful=no, the next failed try flips again); set_active before each try (a write per try); flash a stub dtbo to the active slot (a write, no known way back: the stock dtbo cannot be read back by fastboot); image changes (os_version 0 in our header untested).
2026-11-17
What do walleye's stock boot header and dtb carry (page size, offsets, cmdline, os word, qcom,msm-id/board-id/pmic-id), and is a dtbo present?
Source: LineageOS official walleye boot.img, build 20261113, https://mirrorbits.lineageos.org/full/walleye/20261113/boot.img, 33554432 bytes, sha256 48dbc55c76ee47840e645707b6bf3ac322099c06358178ad8ddf2c6a53c17468 (equals the site's published value; kept at ~/Projects/walleye-build/control/boot.img, data only, never run on the host). download.lineageos.org publishes no recovery.img for walleye; on A/B the recovery is in boot. unpack_bootimg: header v0; page size 4096; kernel load 0x8000; ramdisk 0x1000000; second size 0 and address 0; tags 0x100 (base 0: taimen/blueline offsets, the same as our image a); os_version 15.0.0, os_patch_level 2026-11 (a nonzero os word; ours are 0, or 8.1.0/2020-01 in c,d); product name empty; cmdline: androidboot.hardware=walleye androidboot.console=ttyMSM0 lpm_levels.sleep_disabled=1 user_debug=31 msm_rtb.filter=0x37 ehci-hcd.park=3 service_locator.enable=1 swiotlb=2048 firmware_class.path=/vendor/firmware loop.max_part=7 raid=noautodetect usbcore.autosuspend=7 androidboot.dtbo_idx=3. Kernel: lz4 (sha256 0256983d1002752214fde5035f78ce07e088d167bad993f3f16e1e9f78162872), Linux 4.4.302 arm64, with ONE dtb appended at byte 17613814 (376259 bytes, sha256 37dd8612cab84bd96025bd5831eac194fcf1f10bc8f8f08ea6ff72717a8f5751): model 'Qualcomm Technologies, Inc. MSM8998 v2.1', compatible qcom,msm8998-mtp / qcom,msm8998 / qcom,mtp, qcom,msm-id <0x124 0x20001>; NO qcom,board-id and NO qcom,pmic-id at the root. Ramdisk is xz (sha256 a0d50bc3063f3fd60e93c067ca9b54d16e670b6171eb498decc294d658f5dcbf). So the stock dtb is matched on msm-id alone, as ours is. The board identity is in the dtbo: dtbo.img of the same build (8388608 bytes, sha256 fb09009b7946bf33d860ee94cadfabdfcf3cf63a872314bc650d9220486bb8f6, equals the site's) holds a DT table of 13 entries, ids 0x1bc (revs 0-4 and 0x80), 0x190, 0x490, 0x590, 0x690 and more; androidboot.dtbo_idx=3 names the one merged; the overlays carry no qcom,board-id. So variant f's premise (stock board-id/pmic-id to copy) does not hold: f adds qcom,board-id <8 0> only (what qcom,mtp means), a guess, no pmic-id.
- Android: Use multiple DTs (device tree overlays in the bootloader) - walleye-research, 2026 The bootloader loads the SoC dtb, identifies the board, loads the matching dtbo overlay from the dtbo partition and merges them before starting the kernel: a failed merge is a bootloader refusal.
- Android Bootloader and Linux Internal based on Nokia 8 (NB1): DT loading in ABL - walleye-research, 2022 On an MSM8998 phone ABL's DeviceTreeAppended scans every dtb appended to the kernel and DeviceTreeCompatible picks the best by qcom,msm-id, qcom,board-id, qcom,pmic-id; the ABL, not the kernel, chooses and patches the dt.
2026-11-17
Is the footer-carrying stock control s0 accepted from the healthy state, and what does it do?
Same state as the s1 panic try. s0: left fastboot after 12 s and then no adb, no fastboot, nothing on its USB port for 3+ min (as the earlier control-accepted try). So s0 differs from s1: the stock image runs (no fallback to Android a, no panic reboot visible) but the phone then sits off USB - a hang or the vendor kernel with no adb (control cmdline and ramdisk are stock, so Android should have come up: more likely it shut off or hung). Needs hands: hold Power 10-30 s; slot a is successful so it then boots Android on a. Nothing written. Contrast: s1 (our ramdisk) panics and falls back in 75 s, s0 does not fall back.
2026-11-17
Does the stock kernel with our gadget initramfs (s1, AVB footer present, size 33554432 checked) start from the first state, and does 172.16.43.1 answer?
Checked: boot-s0/s1/s2/s3 are 33554432 bytes and end in AVBf; s0n is 26472448 without. Then, current-slot a (a successful, b unbootable yes retry 1): devlab fastboot boot now boot-s1.img -> 'Failed to load/authenticate boot image: Load Error', flags unchanged; again with images/vendor-gadget.img (same bytes) while GADGET_WAIT=90 gadget-up.sh (from the builder's worktree wt-walleye-builder-lab, not yet landed in the lab) ran: same Load Error, gadget-up: fail, no USB device with our strings, 2 google devices (the phone in fastboot and surya?). The earlier s1/s2 runs this session (left fastboot after 12 s, Android on a 4.4.302) were therefore fallbacks to stock, not starts; my earlier suggestion to rebuild s1 with the footer was wrong - it has it. Earlier research showed Load Error followed the slot state; b is unbootable now and tries have been run with a active this time, so the open question is whether the state (b unbootable, active a) or the image causes it. No write.
2026-11-17
Which stock part, swapped for ours, makes walleye's bootloader stop starting the image?
From the first state (current-slot a, a successful, b unbootable), no writes. s1: left fastboot after 12 s, Android on slot _a kernel 4.4.302 after 75 s, no 172.16.43.1, no new USB device (only the stock adb): our gadget did NOT come up; stock vendor kernel/dtb/cmdline with our ramdisk did not start (a stock boot of slot a is what ran). s2: same shape (12 s, Android on a, 4.4.302 after 72 s). s3: 'Booting OKAY' then stayed in fastboot, no USB event. Flags unchanged each time (a successful, b unbootable). Together with s0n (no start) and s0 (stock with AVB footer, accepted earlier): every image that differs from the stock footer-carrying boot.img, even ramdisk only, fails to start; s0n shows the footer or padding alone may be enough. Next: rebuild s1 with the AVB footer (algorithm NONE, padded to 32 MiB like s0) and try it.
2026-11-17
Why did s1 / vendor-gadget.img panic the stock kernel?
IKCFG data in the control's Image.raw (offset 19381680): CONFIG_RD_GZIP not set, RD_XZ=y, DEVTMPFS not set, UNIX98_PTYS y, USB_CONFIGFS_NCM y. Our v1 ramdisk was gzip, so the kernel could not unpack it, found no /init and panicked (kernel_panic bootreason). The stock ramdisk is xz CRC32. Also fixed in v2, as it would have failed next: a tmpfs mounted over /dev hid /dev/console (exec to it ends init), ACM/ECM/RNDIS absent (NCM used), init exiting. Not run on arm64 (no qemu-aarch64 installed): checked by unpack, file, sh -n, applets present.
2026-11-17
What did the s1 try do, and what does the running vendor kernel offer our gadget init?
Bootloader first: after the earlier Load Errors both slots ended unbootable (a: unbootable yes, retry 0) and the phone stayed in fastboot after a reboot; one metadata-only 'devlab fastboot set-active now a' cleared a (unbootable no, successful no, retry 1) and Android completed on a (successful yes again). s1 re-run from that healthy first state: left fastboot after 12 s, Android on a after 75 s, ro.boot.bootreason=kernel_panic - so the stock kernel DID start with our ramdisk and panicked, then the bootloader fell back to a. (Load Error appeared only when run from the state after several refusals.) Facts, read-only from the vendor kernel 4.4.302 (adb root, debuggable): UDC a800000.dwc3. Config: USB_CONFIGFS=y, F_FS, NCM, MASS_STORAGE, MTP, PTP, ACC, AUDIO_SRC, MIDI, HID, DIAG, GSI, CDEV, QDSS = y; ACM, SERIAL, OBEX, ECM, RNDIS, EEM are NOT set; DEVTMPFS not set; PSTORE, PSTORE_CONSOLE, PSTORE_PMSG, PSTORE_RAM, ACCESS_RAMOOPS = y. Our gadget init (ACM + RNDIS/ECM) therefore could not bring up a gadget on this kernel even if init ran; it needs NCM (host sees a cdc_ncm interface) and, with no devtmpfs, mounting devtmpfs fails - our init must mknod or use mdev. Ramoops: ramoops_region reg 0xa1100000 size 0x200000; alt_ramoops_region 0xa3800000 size 0x200000; meta region 0xaffff000 size 0x1000; params record 524288, console 262144? (from /sys/module/ramoops: mem_size 2097152, record 524288, console 131072 order as listed). The pstore is encrypted by vendor ramoops (init.ramoops.sh: ramoops -D after the user unlocks, files appear in /data/vendor_ce/0/ramoops, absent here), so the s1 panic text is NOT readable from Android; /sys/fs/pstore empty. Cmdline of the vendor boot: androidboot.hardware=walleye console=ttyMSM0 ... root=PARTUUID, androidboot.dtbo_idx=3, panel mdss_dsi_samsung_s6e3fa5_1080p_cmd, serial redacted. Next: rebuild s1's init for NCM (+ mknod, no devtmpfs), keep the panic hunt by making init print to /dev/kmsg-less console only if needed; or make our init never exit (sleep loop) to see if the panic was init exiting.
2026-11-17
How are tests organised, shipped and provisioned on Linux phones (postmarketOS, bootrr, LAVA, CI-tron, systemd), where do rust-script tests plus a bundle crate fit, and should we build fully on postmarketOS upstream?
postmarketOS (postmarketos-test subpackages, initramfs hook), bootrr, LAVA and CI-tron share one shape: a test is a small executable, a thin runner prints one pass/fail/skip line per case, the lab collects the lines, device facts live as data. Nobody compiles on the device. rust-script compiles on first run and needs rust+cargo on the phone (Alpine aarch64: 72 MiB download, 206 MiB installed plus gcc/musl-dev/llvm-libs, network for crates): fine on the lab, poor on a phone. A bundle crate that depends on tests (nextest discovery, inventory/linkme) is sound as design but unproven on aarch64 musl; one binary per test found by directory gives the same independence. Provisioning: an apk gives versions, uninstall and signatures at the price of a key and a repository (ours is published); a lab push is fast and leaves no version record. UPSTREAM (checked 2026-11-17; their sites now redirect to nura.eco): MRs on their GitLab with Alpine-style commit rules and approval rules; on-device tests are postmarketos-test-* subpackages run by an initramfs hook that halts the boot; only kernel/initramfs tests work today, boot and system tests (modem, Wi-Fi, audio, sleep - what we need) are not built; their farm is a CI-tron gateway with one OnePlus 6T, joining is token-gated and undocumented; Python is host-side only (pipeline generation, pmbootstrap) and costs nothing on the phone. Whether rhizcuts handle a GitLab subfolder is not known. Weighed: fully upstream (A), our runner with upstreamable shell files in their shape (B), a different shape (C). Chosen B. Not known yet: pmaports licence/CLA, fork-sync cost, bootrr contribution policy, rust-script cache path, inventory/linkme on aarch64 musl, the systemd claims (memory only).
- pmaports MR 4420: initial on-device CI support - A test package installing scripts into known directories plus an early-boot hook; seen only through search summaries (page behind a bot wall).
- postmarketOS hardware CI and on-device CI docs (nura.eco) - On-device tests are postmarketos-test subpackages run by an initramfs hook; only kernel tests work; farm is CI-tron with one OnePlus 6T.
- bootrr: sanity checks for boards on LAVA (linux-msm) - Board descriptions as data, generic helpers, board detection, an explicit skip: the shape our shell checks already have.
- LAVA test definitions - One line per test case with pass/fail/skip, a fatal abort; set aside the YAML wrapper and server.
- CI-tron components (freedesktop) - A stored record of what a device should look like, and qualifying by repeated boots.
- rust-script (fornwall) - Compiles on first run and caches the executable; needs a Rust toolchain on the machine that runs it.
- Alpine edge aarch64 package: rust - 71.7 MiB download, 205.5 MiB installed: the cost of a toolchain on a phone.
- cargo-nextest: how it works - List tests per binary, run each in its own process: a runner that depends on the tests, not the tests on it.
- Alpine wiki: abuild and package signing - An apk gives versions, dependencies, uninstall and signatures at the price of a key and a repository.
2026-11-17
Should linux-phone-oco's tools share one prefix (lpoco-bringup, lpoco-health; devlab, tone renamed or not), or none?
What is: lab-tools has devlab (host command, built from the clone, named in about 450 files of linux-phone-oco and in the MCP door's tool names), tone (a library crate and its command, not installed anywhere) and lpoco-health (a package shipped to phones, renamed from devlab-health when it became one, the old name kept as another name). Collisions checked 2026-11-17: crates.io already has a crate named tone (0.0.1); devlab, bringup and lpoco-bringup are not taken as crates, none is on the lab's PATH or in the Arch repositories. How others do it: git-* and cargo-* are discovered by the prefix itself (a subcommand is any git-NAME or cargo-NAME on PATH) and complete at the prompt; pmbootstrap and pmaports carry pm for postmarketOS across the whole family; systemd uses a suffix (*ctl) for the same purpose. In each, the prefix marks the tools others install, and it names whose they are. Finding: share the prefix where the tool is installed or pinned by others (lpoco-health, lpoco-bringup); keep the short names of the lab's own commands (devlab, tone) until they are installed elsewhere - renaming them now costs about 450 references, the installed path and the MCP tool names for no reader's gain, and the alias precedent (devlab-health kept as another name) makes the later rename cheap. A mixed family is acceptable when the rule is one sentence. Not known yet: when devlab is first pinned by a device repository (that triggers its rename).
- rhizoid: fork, own and sync git dependencies - git-rhizoid Cutting (a fork owned and pinned), tracking branch pristine, patch branch merged from it, additive-only metadata: the model for patching a tool before upstream takes the change. CLI boundary typed, add/update/status stubbed.
2026-11-17
How do device repositories use, extend, send back to and update from a tools home, side by side with no rebase, and where does rhizoid fit?
The question: a home for bring-up tools must also let device repositories use them, extend them with device-specific parts, send useful changes back and pull updates in, their own changes side by side with no rebase each time (the author's words, relayed by the coordinator; the problem git-rhizoid was started for). Extends research bringup-tools-landscape. What is: the chain already decided (idealkb decision 2026-11-17-chain-follow-by-slice, research chain-follow-world): one pin-and-follow mechanism for data and briefs - a source names its generic files, a follower pins a release and keeps its own files, a changed generic file ends follow.sh with exit 3 and goes back as an upstream item (ikb upstream-item, form patch), weekly update-pins and a release gate; device bases follow idealkb and device-template that way. It lays a slice of files. Rhizoid (git-rhizoid.github.io, rhizoid repo) is for whole forks: a cutting is a fork owned and pinned, tracking branch pristine, patch branch merged from it, rhizoid's own metadata additive-only, so a diff of patch against tracking is a clean patch back; its CLI is typed but add/update/status are stubbed, its consumption side is open (design-consumption-side) and slice-consumption was added 2026-11-17 by the idealkb chain. devlab and lpoco-health already reach consumers as released packages (release-plz tags, the packaging conveyor), not as copied files. Finding: a tool is not a slice. Compiled logic is followed by a version pin, not by files laid into the follower, so the rebase trouble does not arise for the tool at all as long as a device never edits the tool's tree: its own parts live in its own repository, beside the tool, in three levels. (1) Data: device.toml [boot] and the files it names (initramfs skeleton, dtb variants). (2) Hooks: executables the manifest names for a step (shell where stupid simple), called with the paths in arguments, a nonzero exit stops the job. (3) Logic: a rust-script file (or a small crate) in the device repository whose header depends on bringup's library at the pinned tag (rust-script and cargo take a git tag as a dependency). Only two things then need the follow machinery: the pin (a version line the follower owns) and the slice of files that go with the tool in device-template (the [boot] skeleton, hook examples). Sending back: a generic improvement is a pull request to lab-tools from the device's branch, recorded in the device base as an upstream item (form patch) against a lab-tools upstream row seeded beside idealkb and device-template; an update comes by a pin bump (the weekly job, a pull request per source). Side by side: the device's changes are files of its own, so a pin bump touches none of them; when a device must patch the tool itself before upstream takes it, that is a cutting of lab-tools consumed as a git dependency (Cargo [patch]) - rhizoid's exact case, rare because the three levels cover most. Where rhizoid carries it, and what it lacks (recorded on its own backlog, git-rhizoid.github.io PR 28, not worked around): a cutting consumed by a language manager - writing and bumping the pin where cargo or rust-script reads it (cutting-as-cargo-dependency); one pin file, one bump, one verdict for slices, cuttings and tool versions together (followers-one-pin-bump); sending a patch back as a pull request on the person's word with the follower's own record of it (send-back-writes-the-upstream-item); and slice-consumption (already open) for the template files. Until rhizoid has them: idealkb's follow.sh and update-pins for the slices, a plain fork with a [patch] line for the rare cutting, recorded as a problem. Not known yet: whether bringup's library API can stay stable enough for the third level while it is 0.x (the first builder's test of pin refusal tells); whether a host binary release (asset) or cargo install --git is the simpler install for a device lab (bringup-release settles it).
- rhizoid: fork, own and sync git dependencies - git-rhizoid Cutting (a fork owned and pinned), tracking branch pristine, patch branch merged from it, additive-only metadata: the model for patching a tool before upstream takes the change. CLI boundary typed, add/update/status stubbed.
- git-rhizoid.github.io: design log and backlog of rhizoid (tad-kept) - git-rhizoid Concepts (additive file structure, tracking vs patch branch, clean patch back) and open items: design-consumption-side, slice-consumption (2026-11-17) and the three items this research added.
- ideal-knowledge-base: decision 2026-11-17-chain-follow-by-slice, research chain-follow-world, bin/follow.sh - grenudi One pin-and-follow mechanism: a source names its generic files, a follower pins a release and keeps its own files, a changed generic file exits 3 and goes back as an upstream item; rhizoid is left for whole forks, and its missing slice mode is on rhizoid's backlog.
- rust-script: dependencies in a script's cargo header, run single-file Rust - fornwall A device-specific step can be one file that names bringup as a pinned dependency (git tag) in its own header: logic beside the device, no edit of the tool.
- Cargo: dependencies from git, and overriding dependencies with [patch] - Rust A git dependency pinned by tag or rev is the pin; [patch] is how a patched fork stands in for the source until upstream takes the change, side by side with no vendored copy.
2026-11-17
Does abootimg-oxide write header v0 byte-exact, or must pack wrap mkbootimg?
Measured 2026-11-17 with a scratch program against mkbootimg (android-tools, header v0, base 0, kernel 0x8000, ramdisk 0x1000000, tags 0x100, page 4096): the crate's header write gave bytes identical to mkbootimg for the whole length it wrote. Two gaps, both ours to fill: (1) full_write only seeks to boot_image_size, so the image ends before the last page's padding (15288 of 16384 bytes) - pack pads itself; (2) the header id: mkbootimg's v0 id is SHA-1 over kernel, ramdisk and second, each followed by its u32 size (three parts), while the crate's compute_hash_digest hashes five (adds recovery dtbo and dtb) - so for v0 the id is computed in our code. With both, pack equals mkbootimg for the plain header and with os_version/os_patch_level words (tests/pack_v0.rs, two cases). mkbootimg writes second address 0 when there is no second image, whatever second_offset says. Header::parse reads v0..v2 and v3/v4; this tool reads v0 only for now. Cost: binrw and thiserror come with the crate. Not known yet: v1/v2 write parity, vendor_boot.
2026-11-17
Should all lpoco tools sit under one command, one pin and one release (the author: one roof), and in what form?
Asked by the author after the prefix amendment: the point was to gather all tools of lpoco under one roof. Forms: (a) one lpoco command with subcommands, as git and cargo do - a dispatcher that runs lpoco-NAME found beside it or on PATH; (b) every tool renamed lpoco-* now, released together; (c) the prefix rule with devlab and tone deferred (the first amendment). What a roof buys: one install, one pin in device.toml [tools], one completion and man page, one MCP server, one place agents look. What it costs: ~450 references to devlab and the MCP tool names, softened by keeping the old names as other names (the lpoco-health precedent). Constraint: lpoco-health ships to phones as a small static binary (opt-level s, no tokio, no rmcp), so a single fat binary would grow the phone's program; a dispatcher keeps every tool its own crate and binary, testable and runnable alone. Finding: (a) as a dispatcher over lpoco-* programs, family released together with a version lockstep check, the new tool born as lpoco-bringup under it; devlab becomes lpoco lab (devlab kept as another name), tone lpoco tone, the MCP door becomes lpoco mcp. Not known yet: whether release-plz makes one family tag easily (the builder of lpoco-dispatcher settles it); whether a feature-gated single binary would later be simpler.
- rhizoid: fork, own and sync git dependencies - git-rhizoid Cutting (a fork owned and pinned), tracking branch pristine, patch branch merged from it, additive-only metadata: the model for patching a tool before upstream takes the change. CLI boundary typed, add/update/status stubbed.
2026-11-17
What exists to build, unpack, swap and check Android boot images and initramfs for a phone bring-up, and what does walleye's shell do today?
What is: walleye's bring-up is 8 POSIX shell scripts (~520 lines) in google-walleye-lab/build plus tests/host/gadget-up.sh; they call mkbootimg, unpack_bootimg and avbtool (Python from android-tools), the kernel's gen_init_cpio, lz4, fdtget/fdtdump, with their own checks (check-bootimg, check-bisect count fields and fail). Their knowledge is worth keeping: header v0 offsets by variant, the appended dtb, the lz4 frame shape of the stock kernel, the AVB hash footer (algorithm NONE, padded to the control's size), the NET=43 address rewrite, xz because the 4.4 kernel has no gzip. surya's bring-up had no scripts (by hand). Earlier records already decided the family: backlog rust-toolset (one Rust toolset in lab-tools, rust-script for small scripts, pmbootstrap read as reference) and decision 2026-11-17-health-checks-shell-and-rust (shell for plain readings, Rust for logic, rust-script for prototypes and one-offs). Others: nothing covers the whole job. Android's mkbootimg/unpack_bootimg/repack_bootimg and avbtool (Python) are the authoritative oracles; magiskboot (Rust+C++, GPL) has the model of swapping one part (unpack to a directory, change, repack with the original as template) but is aimed at rooting; abootimg-oxide 0.5.2 (Rust, MIT/Apache, 2026-06) reads and writes header v0-v4 and vendor_boot; abootcrafter has an update flow, no AVB; abl-exorcist (Rust, GPL) shells out to mkbootimg; no AVB crate exists on crates.io (avbroot, GPL, does vbmeta, is no library). Rust crates for the rest: cpio 0.4.2 (newc writer), flate2, lz4_flex (maintained), dtoolkit 0.5.0 (Google, dtb read/edit, young), fdt (read). pmbootstrap is Python, ~24k lines in 129 files; its deviceinfo names (header_version, base, kernel_offset, ramdisk_offset, tags_offset, pagesize, cmdline) are the vocabulary to reuse; the boot image is not built there. Mobian, Droidian (initramfs-tools-halium: shell hooks for an initramfs only), lk2nd (a bootloader, no host tooling): nothing to take. No tool checks an image against expected header fields; unpack_bootimg plus a comparison is all there is, which is what our check scripts do. Not known yet: whether abootimg-oxide writes byte-identical v0 images; dtoolkit's maturity; whether cpio 0.4.2 reads; whether boot-deploy, Mobian and Halium scripts add anything (not read; the outside look was done by a read-only researcher from page summaries, so counts are weaker than a source read). Where tools live today: lab-tools (its README: tools for bringing up and testing Linux phones, not tied to one device) is the one place already: devlab (the phone: fastboot, flash, kernel try, provision, keeper, health, MCP; 5.4k lines with rmcp and tokio), health (runs on the phone) and tone. Device repos hold data and thin scripts.
- AOSP system/tools/mkbootimg (mkbootimg, unpack_bootimg, repack_bootimg; rust/bootimg.rs header layout) - Google The reference for header v0-v4 and vendor_boot: the oracle our Rust packer is tested against byte for byte; its unpack prints the fields we compare.
- AOSP avbtool (external/avb) - Google info_image and add_hash_footer: wrapped as a tool on PATH for the footer; no AVB crate exists on crates.io.
- Magisk magiskboot (native/src/boot, Rust and C++, GPL-3.0) and its tools.md - research-bringup-tools The model for swap one part: unpack to a directory, change a part, repack with the original image as the template. Not a dependency: GPL, cxx-bound, aimed at rooting.
- abootimg-oxide 0.5.2: Android boot image parser (Rust, binrw) - research-bringup-tools Header v0-v4 and vendor_boot read and write, MIT OR Apache-2.0, released 2026-06; the Rust header layer to wrap, if its v0 write is byte-exact (unknown, the first test settles it).
- Rust crates for the rest: cpio, cpio-archive, flate2, lz4_flex, dtoolkit, fdt - research-bringup-tools cpio 0.4.2 (newc writer, MIT), flate2 and lz4_flex (maintained), dtoolkit 0.5.0 (Google, dtb read/edit, young), fdt (read). Nothing covers AVB; wrap avbtool.
- pmbootstrap pmb/parse/deviceinfo.py and bootimg.py (Python, ~24k lines in all) - postmarketOS Only the vocabulary: deviceinfo's header_version, base, kernel_offset, ramdisk_offset, tags_offset, pagesize, cmdline names for our device.toml [boot]. The build step is not in pmbootstrap; the rest is Python and shell sprawl we leave.
- abl-exorcist (Rust, GPL-3.0): wrap a mainline kernel for Pixel ABL, then call mkbootimg - research-bringup-tools A Rust tool that shells out to mkbootimg and does the one thing a Pixel bootloader needs; evidence that wrapping mkbootimg is what Rust tools do, and a lead for the Pixel 2 Load Error.
- abootcrafter 1.1.0 (Rust boot image tool) - research-bringup-tools Its update flow (replace kernel/ramdisk of an existing image) is our swap; no AVB, no vendor_boot, ramdisk repack unfinished: idea only.
2026-11-17
What already exists for measuring a phone's health on the phone, shipping it there, and letting agents work with it - in postmarketOS and in our own commons?
postmarketOS (docs.postmarketos.org/pmaports/main/ci/hardware-ci.html): tests ship as small shell files in postmarketos-test-* packages (suspend by an RTC wake alarm; bootrr, which checks per board, keyed by the device tree's compatible, that every expected driver probed) and run in the initramfs CI hook on their hardware CI (CI-tron gateway); surya has no bootrr board file yet. In the commons: the package conveyor (linux-package-distribution-oco/conveyor) already builds static aarch64-musl binaries with signed provenance and plans signed Alpine repositories for postmarketOS (cv-apk) and machines that receive updates, the phone next (cv-machines-refresh); agent access (creation-guidelines/agent-access-oco) plans every tool's structured door offered over MCP, in Rust with rmcp, naming devlab among the first (aa-two-doors). In lab-tools itself: devlab test ran surya's checks from the lab over SSH, health kept a baseline of what ever passed, watch ran health after each boot from the lab - nothing ran on the phone by itself, and the checks were one surya-specific file.
2026-11-17
How does the lab host get prepared for the devices it serves, from each device repository's device.toml, by a tool under the lpoco roof, with no manual step outside a tool - and how do others do it?
INSIDE. Nothing prepares the lab host from declarations today; each part got there by hand or by a one-machine script. Measured read-only on the lab (grig, systemd 262): the lab user (uid 1000) is in neither disk (/dev/sdX) nor uucp (/dev/ttyACM* on Arch), so walleye's gadget nodes were unreadable after the reboot; uaccess would reach that uid while it holds the active seat0 session (it does: Plasma on tty2), but nothing tags our gadget. /etc/udev/rules.d/51-android.rules (MODE 0666 for vendors 18d1, 05c6, 2717; group plugdev, absent here) came from lab-agent's connect.sh, run by hand; android-udev and systemd 262's own hwdb tags already cover adb and fastboot, and none of it covers block or tty. usb_storage and cdc_acm could not load today until the host was rebooted into its installed kernel (the running kernel's modules were gone). The aarch64 musl Rust toolchain in ~/.local/share/devlab-cross (health/build.sh) is unrecorded hand work. devlab-watch@ units come from lab-machine setup/devlab-watch.sh, enabled by hand per device (surya yes, walleye no). The host's own tools are hand copies: ~/.local/bin/land (from grenudi/lab-machine bin/land), oco-work (its only tracked home is creation-guidelines/lab-agent oco-agent/tools/oco-work, a place that is retiring), devlab and its .before-* copies; agent-env is sourced from the ideal-agent clone or plugin; tad and ikb by their install scripts; nothing names their versions. Root is only `sudo -n lab-agent root-exec --` (devlab reads DEVLAB_ROOT); ideal-agent's 2026-11-17-lab-agent-retires-by-parts part 6 moves it to a lab-root wrapper in lab-machine or narrower per-command grants, written by the author and root. walleye's device.toml already declares [host] modules usb_storage, cdc_acm and [[host.gadget]] serial walleye-first-boot, access block and tty (lab PR 54); devlab ignores the table (no deny_unknown_fields at the top). Session logs show root-exec used by hand today for fastboot devices, pacman -S (git send-email's perl modules), the host reboot, and ssh to the phone. OUTSIDE. Nobody derives host rules from per-device declarations. LAVA declares per-device serials in data but ships one static rule calling a privileged helper; labgrid matches udev properties at run time and leaves rules to the administrator; pmbootstrap writes no rules and runs flashers as root in its chroot (whole-command doas/sudo/run0, no dry plan, a teardown verb); android-udev-rules grants MODE 0660, GROUP adbusers and TAG uaccess in one line at 51; NixOS merges rule files from many modules by name and puts extraRules at 99, too late for uaccess; Ansible's check mode is the dry plan with a diff. systemd (source and NEWS): uaccess grants only the seat's active session, so ssh-only users and services get nothing; a rule setting it must sort before 73 and must not be add-only since 258; 258+ tags ADB and fastboot by itself; 260 adds xaccess-debug-appliance for headless sessions asking through PAM; only GROUP/MODE covers services. `udevadm trigger --action=change` re-applies GROUP, MODE and uaccess to present nodes, no replug. TAKEN. A rule file per device below 73, ACTION!="remove", matching the gadget serial on the parent (ATTRS{serial}), TAG+="uaccess"; a lab group with MODE 0660 later for a headless host; nothing by vendor for adb/fastboot (systemd covers it, a check proves it); a plan that is a content diff per file plus the exact root commands, the verb writing, reloading and triggering change only where it touched; modules-load.d only for declared modules, with "the running kernel has no modules: reboot" said by the plan; root by one prefix and a printed fixed list of commands, the list a narrow grant is written from.
- android-udev-rules: 51-android.rules, sysusers.d adbusers, install.sh - M0Rf30, 2026 group plus uaccess on one grant; sysusers.d for the group; its add-only guard and replug are what not to copy
- systemd: udev-builtin-uaccess.c, 70-uaccess/71-seat/73-seat-late rules, hwdb 60-usb-interface, NEWS 258 and 260 - systemd, 2026 uaccess reaches only the seat's active session; rules setting it sort before 73 and are not add-only; 258+ tags ADB and fastboot; 260 adds xaccess-debug-appliance
- pmbootstrap: pmb/config/sudo.py, helpers/run.py, chroot/binfmt.py, chroot/shutdown.py - postmarketOS, 2026 root by doas/sudo/run0 with an override; check-then-act; a teardown verb; no udev rules, no dry plan
- LAVA: lava_dispatcher_host udev.py and device dictionaries (device_info board_id) - Linaro, 2026 per-device USB serials declared in data; one static rule and a privileged helper; rules install writes only when content differs
- labgrid: udev matching in exporter configuration, exporter unit, raw-interface helper - labgrid-project, 2026 match by ID_SERIAL_SHORT; group access for a headless service; narrow root by sudoers lines for fixed helpers
- nixpkgs: nixos/modules/services/hardware/udev.nix, boot/kernel.nix, rename.nix (programs.adb removed) - NixOS, 2026 rules from many sources merged by file name; extraRules at 99 is too late for uaccess; modules merged into modules-load.d
- Ansible check mode and community.general.modprobe - Ansible, 2026 a dry run that changes nothing and reports per resource, with a diff
- google-walleye-lab device.toml [host]: modules and gadget serial walleye-first-boot with access block and tty (lab PR 54) - linux-phone-oco, 2026 the first device declaration the tool reads; its shape kept and settled
- ideal-agent decision 2026-11-17-lab-agent-retires-by-parts, part 6 (root-exec), backlog lab-agent-6-root-exec-grant - grenudi, 2026 root moves to a lab-root wrapper or a narrower grant per command, written by the author and root; the tool must print the exact root commands it runs
2026-11-17
Where does preparing the lab host stand, and what is next?
How it stands, 2026-11-17 night. Decided, not built: lpoco-host (`lpoco host plan | prepare now | check`), a new crate in lab-tools under the lpoco roof (decision 2026-11-17-lpoco-host, research lab-host-prepare-landscape). Next for the lab-tools builder: backlog lpoco-host, rank 1, needs build, device google-walleye - its first test host/tests/plan.rs plan_grants_gadget_serial_and_changes_nothing does not exist yet and must fail first, then plan_lists_host_tools_at_pins_and_installs_nothing; acceptance is the tool's first real use on the lab: prepare now grants walleye-first-boot, the walleye keeper reads /dev/sda and /dev/ttyACM0 as the lab user. The walleye lane waits on it (its base: walleye-host-access-via-lab-prepare and the two retry items). Declared already: walleye device.toml [host] (lab PR 54). Not yet: a lab.toml in grenudi/lab-machine (the builder proposes it there with the tools at today's versions); a living home for oco-work (today only in the retiring creation-guidelines/lab-agent); the narrow root grant (ideal-agent lab-agent-6-root-exec-grant, the author's) - meanwhile root goes through LPOCO_ROOT/DEVLAB_ROOT/root-exec. The host on 2026-11-17: systemd 262, lab user on seat0, no rule for our gadget, 51-android.rules a hand leftover, usb_storage loaded, cross toolchain in ~/.local/share/devlab-cross by hand, devlab-watch@surya-lab only, land and oco-work hand copies. Later: lpoco-host-rest (headless group, watchers, cross targets, host commands, foreign rules named, NCM).
- google-walleye-lab device.toml [host]: modules and gadget serial walleye-first-boot with access block and tty (lab PR 54) - linux-phone-oco, 2026 the first device declaration the tool reads; its shape kept and settled
- ideal-agent decision 2026-11-17-lab-agent-retires-by-parts, part 6 (root-exec), backlog lab-agent-6-root-exec-grant - grenudi, 2026 root moves to a lab-root wrapper or a narrower grant per command, written by the author and root; the tool must print the exact root commands it runs
2026-11-17
Which vote or clock keeps the audio DSP awake, and is the audio DSP what stops CX, AOSS and DDR from sleeping?
Measured 2026-11-17 on the kept kernel (7.1.0-sm7150-calls+, patched qcom_wdt), cycle 15 bt-on, as systemd-run units, nothing polled during a cycle. (1) The DSP side, read awake: adsp, cdsp and modem remoteprocs running; qcom_stats adsp 0 (cdsp 56, modem 1798 counted): the three share one reader, so the layout is right for the subsystems; whether the ADSP firmware fills its own sleep-stats entry at all is not known yet. The only LPASS clocks enabled: LPASS_HW_MACRO (rx, tx macros and codec), TX_CORE_MCLK/NPL (rx, tx macros), fsgen - the macros' own clocks; the previous keeper's vote release did not change adsp. (2) Others, read awake: genpd cx on at performance 256 with the two UARTs (88c000 Bluetooth, a88000) as devices; mx on 256; usb30_prim_gdsc on (USB gadget, the lab's link: qns_llcc/ebi avg 240000 peak 700000 are the USB's vote, cut by the cycle's gadget disconnect); ufs_phy_gdsc on; interconnect: only USB and the UARTs vote with bandwidth, the CPUs 8.7 GB/s peak; the PSCI cluster domain has states S0 (6 ms residency), S1 (8.5 ms) and S2 (9.8 ms): S2 entered once during the one cycle of that boot (s2idle count 1), so the cluster reached its deepest state. (3) Floor test 1: adsp stopped for the cycle (offline, no LPASS clock left, no APR devices; the teardown logged a clk_unregister warning from tx_macro, harmless): cxsd 0, aosd 0, ddr 0 after. Floor test 2: adsp, cdsp and modem all offline: cxsd 0, aosd 0, ddr 0 after. Started again after: all three running; the sound card needed a clean reboot, then the suite: 35 pass, 0 fail. Meaning: the audio DSP is not the (only) thing keeping CX, AOSS and DDR up: with no DSP running at all they still do not count. The cause is on the Apps side or in AOSS/RPMh: the sleep set (rpmh flush at cluster power-off), the cluster's PSCI state parameter (sleep-cluster-params), the remaining CX vote of the two UARTs, or WLAN/UFS. Not known yet: which; this kernel has no RPMh trace points (events: clk, regulator, interconnect, power/psci_domain_idle_enter only). Not measured: a cycle with the UARTs closed; the PSCI state taken at the suspend; the live rpmh sleep-set contents.
2026-11-17
With surya's own cluster sleep parameters booted, does a timed cycle collapse CX/AOSS/DDR, and if not what is held?
See notes.md: cluster S2 used (genpd idle_states), wake by the RTC alarm after 15 s (trace clock stops in s2idle), CX/MX active votes 0, sleep set all zero except SH0 (x=1,y=3), stats cxsd/aosd/ddr 0 in 8 cycles. Cause not found in genpd, clk, icc or rpmh traces; candidates untested: SH0 owner, qcom_aoss prevent_* knobs, XO/VRM votes, USB gadget, display RSC.
2026-11-17
Does the AOP receive the RSC sleep flush, why is the cluster genpd S2idle column 0, and is the SoC perhaps already asleep - how does standby current arbitrate, and what is Android's to match?
(1) Does the AOP get the flush. The entry trace already shows the Apps RSC writes wake and sleep sets in one instant on the last CPU and then requests the deepest cluster state (0x4100b244), so Linux's half is done in order. The AOP's half is not observable from Linux: the only outputs are the counters it fills (aosd, cxsd, ddr in the message RAM) and the rails. Nothing in mainline reads an AOP log. What the AOP needs for cxsd is every master's sleep vote on CX gone (Apps, modem, adsp, cdsp, display, WLAN BB), not only Apps'. A peer found exactly that kind of cause: on SM7325 a WLAN BB vote prevented CX power collapse (CXPC) and, once removed, "HLOS and DDR votes remain" (pmaports#4846, 2026-11-16); on SM8550 an SD-controller IRQ storm and a USB PHY vote did (armada#274). So the entry is not the open question any more; the other masters' votes and the wakeups are. (2) Why the cluster genpd S2idle column stays 0. From core.c: usage_s2idle is incremented only in genpd_sync_power_off, after the domain's governor (pm_domain_cpu_gov, set by cpuidle-psci-domain only when the domain has idle states) approved the power-down, and that function returns early unless every device attached to the cluster domain has been suspended (suspended_count == device_count) and every child CPU domain is off. s2idle reaches it through dev_pm_genpd_suspend, not runtime PM. The trace shows the cluster bits in the PSCI state (0x4100b244), so the cluster power-off callback did run; then either the counter is read from the wrong row/domain, or the state composed is from a path that did not count. Both are cheap to tell apart and are not known yet: read idle_states of every power-domain-* after one cycle (all rows, all columns) and the psci_domain_idle_enter trace's s2idle flag. (3) Is the SoC asleep already, and the arbiter. The peer record says the counters are not the whole picture: motorola-dubai (SM7325) reads S2 for ~1 ms, and the author of the qclaptops tree removed WLAN BB, touch, audio and regulator holders with "idle drain lowered by 0.00000 W". Standby current moved only with: USB runtime PM allowed (0.196 -> 0.180 W), the camera VCM and always-on audio regulators released, modem off. The same report measures current_now: near-mainline 152 mA (later 60 mA, 0.2-0.3 W), the same-era Droidian downstream kernel on xiaomi-miatoll (SM6250) 9 mA. So a number exists to match: about 9 mA average with screen off on a Snapdragon 6/7-series phone running the vendor kernel. Android's own number on surya is not known yet: nobody has measured it, and the public sources give no standby current (android-reference). (4) Cheaper tools than the AOP: regulator_summary (what rails stay on, with users), pm_genpd_summary, qcom_stats, and current_now / charge_counter. Android's value is the end, regulators the where.
- pmaports#4846: motorola-dubai in idle consumes 17x more than a droidian device (SM7325 near-mainline) - surya-research, 2026 Closest peer: a Qualcomm phone on near-mainline, with standby current measured by current_now (mainline 150 mA then 60 mA / 0.2-0.3 W, Droidian downstream 9 mA), where regulator_summary and genpd idle_states are the tools, USB runtime PM and WLAN BB are CX holders, and removing all the known holders left the drain unchanged
- drivers/pmdomain/core.c: genpd_sync_power_off and the s2idle usage counter - surya-research usage_s2idle increments only when a power-down governor ran in genpd_sync_power_off, and that path needs suspended_count == device_count and sd_count == 0
- drivers/cpuidle/cpuidle-psci.c and cpuidle-psci-domain.c: the s2idle path into the cluster domain - surya-research s2idle enters through dev_pm_genpd_suspend, not runtime PM; the CPU domains get pm_domain_cpu_gov only when they have idle states
- Split up TF-A related PSCI configuration for sc7180 (counts ddr, cxsd, aosd) -
- armada-os/armada#274: s2idle never enters AOSD/CXSD on Odin 2 (SM8550), measured - surya-research, 2026 Same symptom on a sibling SoC found by reading: an SD-controller IRQ storm (30/s) during suspend woke CPU0 for the whole cycle, the USB PHY kept a CX vote, CPU0 deep idle disabled; counters read 0 after a suspend that reported success
- Qualcomm Linux Power guide: Debug high sleep current - Qualcomm Vendor's own order when aosd is zero: suspend with the display off and USB disconnected, then check the CPU suspend success count, then wake locks
2026-11-17
At the s2idle entry, is the RSC sleep set flushed after the last CPU, which idle state does the last CPU take, and how noisy are the interrupts?
One way-back.sh cycle 15 bt-on (BT left on, its UART wake off), tracing rpmh, cpu_idle, psci_domain_idle, suspend_resume, with before/after snapshots; the phone returned, RTC asleep 17 s. (1) After the other seven CPUs entered 0x40000004 (cpu-sleep-x-1, s2idle=yes), cpu7 wrote in one instant the wake set (tcs 5) and the sleep set (tcs 2: 0x50000=0x40000000, 0x50028=0, 0x5003c=0x60004003 (SH0 x=1,y=3), 0x50088=0, 0x50084=0x40000000, 0x5000c=0x40000000) and then entered psci_domain_idle 0x4100b244 = the DT's deepest cluster-sleep-2 (awake idle only uses 0x41001244, cluster-sleep-1): the flush is in order and the deepest state is requested. (2) The last CPU is cpu7 in 0x4100b244. (3) Between that entry and the wake the trace holds no event at all; the only interrupt counted for the sleep is pm8xxx_rtc_alarm (+1, cpu2, the first CPU out); every other delta (arch_timer, IPIs, apps_rsc, ufshcd, WLAN_CE) is the awake time around it. After: cxsd, aosd, ddr, adsp still 0; cdsp and modem counters move; the cluster genpd S2idle column stays 0 though S1 usage rose 402 to 483 awake. Not known yet: why the S2idle column is 0, what the AOP does on seeing this flush, which master holds the floor. Trace-clock time stops in suspend, so event times inside the window are not sleep time.
2026-11-17
Why do cxsd, aosd and ddr never count on surya after a real s2idle, and what is the way to the SoC floor?
See the material. Counters are the SoC's own (rpmh-stats; no client-votes field on this layout), so they are valid but name no culprit. It can be done on mainline s2idle: Acer Aspire 1 (sc7180, OSI) counts all three; X1E s2idle reaches 99.9% after subtracting icc-bwmon, PCIe, LPASS macro and console votes (AOSD only with the CDSP running); sm8250 RP5 stays 0/0 with camcc and DSI clock votes and the ADSP up. No system-level mode is missing: surya's cluster state equals downstream's and sm8150's, apps_rsc matches sc7180. Surya's weak points: the floor tests stopped DSPs that had run (their RPMh votes may stay latched) instead of never starting them; clk_summary was never captured (files empty) and the kernel command line (clk_ignore_unused?) is unrecorded; tag-7 icc votes and the a88000 serial vote through suspend (SH0 x=1,y=3). Ranked: DSP latched votes, unclaimed bootloader clocks, peripheral votes (USB/UFS/WLAN/UARTs), SH0 owner, AOSS prevent knobs, counter validity.
- Split up TF-A related PSCI configuration for sc7180 (counts ddr, cxsd, aosd) -
- archiso-aarch64-sp11 issue 38: s2idle reaches CXSD/DDR/AOSD after removing votes -
- pocknix-os PR 161: Retroid Pocket 5 s2idle aosd/cxsd stay 0 -
- Sleep stats driver v12 thread (all subsystems must power down) -
- RFC on s2idle behaving like s2ram on pre-Hamoa SoCs, reply by Bjorn -
- Pixel 4 downstream sm6150-pm.dtsi, lpm-levels, system_pm (GPL, read for observed behaviour) -
- OnePlus 6 qcom_stats counts, aosd 0 cxsd 0 (stats node patch thread) -
2026-11-17
Is SH0 x=1,y=3 the blocker at all - counter validity, clocks/GDSC, late-suspend state?
Question 1, counter validity: the counters are very probably valid. qcom_stats creates its files by reading each record's name word out of the message RAM (qcom_stats.c), and surya has aosd, cxsd and ddr: three names read, not assumed. ddr_stats also passed its magic key, and its frequency rows move while the LPM rows stay 0 (research floor-holders), so the block is live and the layout is the one sc7180 uses, where the Acer Aspire 1 counts. adsp 0 and empty apss/display/gpu are SMEM entries this firmware does not fill; they are not the SoC counters. Not found anywhere: an Android reading of these counters on SM7150 (no source, none observed). Only an independent measure can make the last doubt certain: standby current (sleep-standby-current). Question 2, is SH0 x=1,y=3 the blocker: not shown, and the reading rests on a mix-up that is worth fixing. bcm-voter.c forces keepalive BCMs only in the AMC and WAKE buckets, so a SLEEP-bucket x=1,y=3 means some request with a SLEEP-bearing tag (ALWAYS = 7) had non-zero bandwidth at the flush. The awake icc summary is not that moment: the only large vote there is USB (240000 = USB_MEMORY_AVG_HS_BW in dwc3-qcom.c, tag 7) and dwc3_qcom_suspend sets it to 0 before the last CPU flushes; the peak is cpu0/cpu6 at tag 3 (AMC|WAKE, not SLEEP). So the vote that makes x=1,y=3 is one nobody has seen being made: not USB as a floor holder (UDC unbound: counters 0 -> 0; whether SH0 changed was not read), not uart8, not the cpufreq votes by tag. Two readings remain and they cannot be told apart by subtracting: (a) the flush the log shows is stale or not the last one, i.e. the sleep set is not what the AOP sees at entry; (b) SH0 is harmless and something else blocks. So SH0 is demoted from "the blocker" to "one unexplained entry"; no more owner-hunting by tag until the entry is read. What is the blocker then: the three observations nobody has taken at the entry itself. (1) Is the RSC flush invoked on the last CPU and what does it write (tracepoints rpmh_send_msg state=sleep; rpmh_rsc_cpu_pm_callback flushes at CPU_PM_ENTER of the last online CPU). (2) What the last CPU's idle state is (power:cpu_idle with the PSCI state, per-CPU cpuidle usage/time deltas): a cycle can "take" the cluster state once and still wake every few ms. (3) Whether anything wakes the CPUs during the 15 s: /proc/interrupts delta. This last one is what the nearest measured sibling found: on the Odin 2 (SM8550) suspend succeeded, counters read 0, and the cause was an SD controller firing ~30 irq/s through the whole suspend plus a USB PHY vote and CPU0 idle disabled (armada#274). The Qualcomm guide's own order for "aosd count zero" is also: display off, USB disconnected, suspend success count, then wake locks. Surya has never had its interrupt rate read across a cycle; devlab-usb is also a wakeup source active the whole time (research floor-holders). Question 3, what a late-suspend dump should read: per-CPU cpuidle state usage/time before and after; the cluster genpd idle_states usage (taken, rejected) and the time spent; the sleep-set commands written (trace rpmh); /proc/interrupts delta; wakeup_sources; suspend_stats; qcom_stats of all nodes before and after (including each subsystem's last-entered time). All of it is tracefs/procfs/debugfs: no kernel build is needed, so floor-suspend-late-dump (a debug kernel) is not first. Also AOP QMP: the AOP does process RSC commands (regulators, rpmhpd and icc work), so it is alive; QMP is a separate channel and, as found, off the path. Sources read, not run on the phone; nothing on the phone was touched.
- drivers/soc/qcom/qcom_stats.c (rpmh-stats layout: aosd, cxsd, ddr read by name from the AOSS message RAM) - surya-research stat names are read out of the RAM (type word at 0x48 + n*size), so a file named aosd/cxsd/ddr existing proves the layout; ddr_stats needs its magic key; subsystem entries come from SMEM
- Qualcomm Linux Power guide: Debug high sleep current - Qualcomm Vendor's own order when aosd is zero: suspend with the display off and USB disconnected, then check the CPU suspend success count, then wake locks
- armada-os/armada#274: s2idle never enters AOSD/CXSD on Odin 2 (SM8550), measured - surya-research, 2026 Same symptom on a sibling SoC found by reading: an SD-controller IRQ storm (30/s) during suspend woke CPU0 for the whole cycle, the USB PHY kept a CX vote, CPU0 deep idle disabled; counters read 0 after a suspend that reported success
- [PATCH v4 0/3] Output debug information from RSC (Maulik Shah): cmd_db_read_name address-to-name lookup - surya-research, 2026 Names an RPMh address (0x30000 -> cx.lvl) so a dump of remaining votes can say who; not merged as read - a later tool, not a first step
- drivers/usb/dwc3/dwc3-qcom.c (interconnect enable/disable around suspend) - surya-research USB_MEMORY_AVG_HS_BW is 240 MB/s - the 240000 in surya's icc read; dwc3_qcom_suspend sets the path to 0, so USB's tag-7 vote is gone before the last CPU flushes the sleep set
- drivers/interconnect/qcom/bcm-voter.c (keepalive BCMs, sleep bucket) - surya-research keepalive forces x=y=1 (or enable_mask) only in the AMC and WAKE buckets; the SLEEP bucket is aggregated from consumers' tags alone
- Split up TF-A related PSCI configuration for sc7180 (counts ddr, cxsd, aosd) -
2026-11-17
Does way-back bt-on (serial power/wakeup off for the cycle) keep irq 157 quiet so Bluetooth-on standby is representative?
On 7.1.0-sm7150-calls+, USB-powered, 4 consecutive way-back.sh cycle 15 bt-on: dmesg 'nobody cared' count 0, irq 157 still listed, hci0 present after every resume, RTC 17 s asleep of 15, suspend entries and exits clean. cxsd/aosd/ddr stay 0 (soc-sleeps not met, as before). Side finding: every cycle ended with the ADSP fatal 'err_qdi.c EX:sensor_process frpc_dsp' (crashes #2-#5 in the boot; sound card gone, health UNHEALTHY) - the sensors-across-suspend crash is 4 of 4 with the sensorspd helper running, not n=1. A reboot restored healthy (37 pass, 0 fail). So the wakeup-off switch alone already quiets irq 157; r2/r3's 'nobody cared' needs a longer or off-USB run to recur.
2026-11-17
Does hexagonrpcd of PR #27 (40e5041), run over a writable state copy of the registry, stop the DSP's registry write crash on surya?
No, not as built. Built 40e5041 for the phone (static aarch64 by hand: no meson on the lab; sha256 c4557f04...), seeded a state root with sensors/persist/registry as a copy of the package registry (the layout build_persist_dir maps), one try as a transient unit, sensorspd attach. The DSP asked for /vendor/etc/sensors/sns_reg_config (not found; our tree has it under sensors/config) and for /../sns_reg_version, first read then write: the path is outside every mapped directory and the PR answers 'Function not implemented' on the write; then 'Could not fetch next FastRPC message: Broken pipe' within a second - the ADSP dropped and the audio card went. Nothing was written to the state copy. One reboot did not bring the DSP back (no apr services); the second did (35 pass, 0 fail). So a writable registry directory is not enough: sns_reg_version has to be served as a file at the path the DSP uses, and sns_reg_config found. Next try: serve /../sns_reg_version (virtual file at root, writable in the state copy) and map sns_reg_config; one try per boot, expect two reboots to recover after a crash.
- hexagonrpc PR #27: write support for the sensor registry (closed unmerged) - linux-msm, 2026 fopen in write modes, fwrite, fsync, fremove, ftrunc, frename, methods above 30 by escape, large in-buffers; branch sp11-sensors 40e5041; withdrawn by its author.
- hexagonrpc #19: sensor registry writes refused (Milos; SC8280XP, SM8650 and SG6275P reports) - linux-msm, 2026 The DSP writes the registry when sns_reg_version is missing; fwrite/fremove stop the crash; a writable state dir (-S) gave streaming sensors that survived a 15 s suspend on SG6275P (2026-11-06).
2026-11-17
What ends surya's s2idle at once with Bluetooth up, and what do mainline and others do for a qca UART Bluetooth across suspend?
Measured 2026-11-17 on 7.1.0-sm7150-calls+ with ftrace and a kprobe on pm_system_irq_wakeup (suspend-wake-arm-trace.sh in the material): s2idle was ended by irq 158 ('88c000.serial:wakeup', msmgpio 41, edge), armed by dev_pm_arm_wake_irq in the late phase because the platform device 88c000.serial has power/wakeup enabled (qcom_geni_serial sets device_init_wakeup and dev_pm_set_dedicated_wake_irq when the DT gives a second interrupt: the RX pin). The main irq 157 (GIC 636) fires 6 times at the end of qca_suspend, which waits up to 2 s for the chip's sleep indication (hci_qca.c); no 'nobody cared' appeared in these tries. Mainline source read (torvalds/linux master): uart_suspend_port keeps the irq wake only if the tty device serial0 may wakeup (here disabled); hci_qca qca_wakeup() returns device_may_wakeup of the serdev controller and the Bluetooth core then arms a passive scan for suspend, so an RX edge from the chip is a wake by design; the switch is the serial's power/wakeup, a plain sysfs file. With it off for a cycle, s2idle ends by the RTC alarm (RTC counted 7 s for 5 asked, 7 s for 5, 17 s for 15) with hci0 up and scanning after. Not read this time: what postmarketOS ships for qca Bluetooth across suspend (only the earlier note of its hook stopping Bluetooth for the Pixel 3a FastRPC crash). The earlier hang on resume was seen with Bluetooth blocked; not reproduced with it unblocked and wakeup off.
2026-11-17
Why did surya reboot by itself during standby run r2?
Read from the pstore console of the dead boot (console-ramoops-0), the journal and r2's logs. r2 (armed 20:08Z, cable out) ran 47 way-back bt-on cycles; 24 slept 0 s, 23 slept 17-19 s. At dmesg 3379 s 'irq 157: nobody cared' (qcom_geni_serial_isr, the BT UART) disabled the IRQ; then hci0 'Injecting HCI hardware error event', 'Freezing user space processes aborted ... 149 tasks refusing to freeze', and the QCA setup retried (command tx timeout, Reading QCA version failed -110, Retry BT power ON 0..2, each about 70 s). The loop kept cycling (a fuse armed every 10 s, 'watchdog did not stop!' each time is normal: busybox watchdog is killed hard by design) until a cycle's arm to defuse took over 30 s while Bluetooth was stuck, and the SoC watchdog reset the phone (console ends at 3646 s, no panic, no oops). So it was no spontaneous fault: the fuse did its job, and r2's loop does not survive a stuck Bluetooth. Scoring: r2 reached 25 measure samples (about 4.5 min of the 60 asked), all charger_online 0, current_now mean -39.6 mA, current_avg -33.8 mA (settle samples -45 mA): not a standby figure, since Bluetooth was in its retry loop and half the cycles did not sleep; unscored. Phone after: boot 20:25 healthy, stock services, kept kernel 7.1.0-sm7150-calls+.
2026-11-17
Why did surya reboot mid-r3, and what did r3 measure before it?
Order from r3's STOPPED/DONE and journalctl -b -1: scoring began 20:36:44Z (charger_online 0 in all 141 measure samples, post-settle). 21:41:39Z after 3893 s: suspend cycle 'irq 157: nobody cared', IRQ 157 (BT UART) disabled, hci0 command 0x0c01 tx timeout, controller crash dump; r3 stopped itself 'aborted, partial' - the abort rule fired FIRST, run ended on its own, not the phone. Afterwards (r3 over) hci0 setup failed three times (Reading QCA version -110, Retry BT power ON 0,1,2 at 21:42:23, 21:43:34, 21:44:45); journal ends 21:45:00Z with no panic or oops in it, the boot -1 ended 21:45:00 and boot 0 began 21:46:41Z. So the reset happened after r3, in Bluetooth's retry loop, ~15 s after retry 2: fuse or hang, not proven (pstore not readable as user; ramoops empty after boot). Figures, measure phase 792.9-4574.9 s mono, 141 samples, 0 on charger: instantaneous current mean 55.0 mA, median 31.1 mA, p10 22.7 mA, min 21.5, max 143.4 (instantaneous snapshots include wake bursts); fuel gauge current_avg 25.9-35.4 mA (28.7 at end); suspended 2380 s of 3782 s = 63% (suspended_s_cum 51 -> 2431), 289 suspends, 735 wake events. charge_counter is na on this gauge, so no charge-delta score. Against targets: 15 mA and 9 mA NOT met; Android's figure not known yet. A partial: 63 min, not the 75 min the run asks for.
2026-11-17
Does the patched hexagonrpcd, installed lasting, keep the sensors without crashing the audio DSP?
lab/build-hexagonrpcd-sns.sh builds the daemon (hexagonrpc 40e5041 + the patch, static aarch64, aarch64-linux-gnu-gcc, no meson); lab/sensors-install.sh on the phone put it at /usr/local/bin/hexagonrpcd-sns, made the state root /var/lib/hexagonrpcd-sensors from the package tree (registry also under sensors/persist/registry/registry, owner fastrpc), a drop-in 10-state-root.conf (-R) and unmasked sensorspd (rootpd masked). First start: 150 s, 0 crashes; monitor-sensor needed iio-sensor-proxy restarted once (it had started with no sensors), then accelerometer, light, proximity, compass. Three reboots in a row (devlab phone reboot): helper and proxy active, 0 crashes, 4 sensors each time, no ordering fix needed; the watch's health: 37 pass, 0 fail, sensors/motion-and-light and sensors/proximity-reads now pass (known gaps no more). The DSP writes sns_reg_version into the state root (sensors/persist). Across suspend: one way-back cycle 10 bt-on (rtcwake freeze, helper left running): the ADSP logged 'crash detected in adsp: type fatal error' 0.03 s after the suspend exit and was up again 0.5 s later; sensors came back (4); a real systemctl suspend would stop the helper (Conflicts=suspend.target, no restart): unmeasured. n=1.
2026-11-17
Does the ADSP still write the registry once the 46 sensor configs match its record (sensors-and-the-mask, one boot, kept kernel 7.1.0-sm7150-calls+)?
Yes. With touch -d @1230768000 on the configs and sensorspd unmasked and started, hexagonrpcd logged ~70 times each 'Tried to open .../registry/../temp.json for writing' and '.../sns_reg_version for writing' (no such file), 'Could not read from directory: Bad file descriptor'; the DSP asserted SNS_REG_INIT sns_registry_sensor.c:94 (SNS_RC_SUCCESS == rc) and crashed 7 times in about 25 s of the 150 s (remoteproc crash #1-#7), then 'Handover signaled, but it already happened' every second; ssccli: QRTR node was removed from the bus. After stop, the audio card stayed gone: only a reboot restored it (health 35 pass 0 fail after). Mask and mtimes put back; nothing kept. So the rule in the item applies: the way turns to sensors-registry-writes. Note: count crashes by remoteproc 'crash detected in adsp' lines, not by awk on dmesg timestamps (the probe's own count read 0).
- hexagonrpc #19: sensor registry writes refused (Milos; SC8280XP, SM8650 and SG6275P reports) - linux-msm, 2026 The DSP writes the registry when sns_reg_version is missing; fwrite/fremove stop the crash; a writable state dir (-S) gave streaming sensors that survived a 15 s suspend on SG6275P (2026-11-06).
- hexagonrpc PR #27: write support for the sensor registry (closed unmerged) - linux-msm, 2026 fopen in write modes, fwrite, fsync, fremove, ftrunc, frename, methods above 30 by escape, large in-buffers; branch sp11-sensors 40e5041; withdrawn by its author.
- hexagonrpc #29: sns_registry_sensor.c assert takes the ADSP down (X1P42100) - linux-msm, 2026 The same assert as surya's, with hexagonrpcd 0.4.0 -s -R; a local ~700-line patch writing only under /persist/sensors/registry fixes it; on X1E #27 stopped the reboot but found no sensors.
2026-11-17
What is SH0 x=1,y=3, who votes it, what do SDM845/SM8150/SC7180 do, and why does the AOP not ack QMP?
SH0 is not a holder someone took; it is a keepalive BCM. In mainline sm7150.c, bcm_sh0 is "SH0", keepalive, node qns_llcc, identical to sdm845, sm8150 and sc7180 (the sc7180 Acer Aspire 1 reaches cxsd/aosd/ddr counts with the same definition). bcm-voter.c forces keepalive BCMs to x=y=1 (or enable_mask) only in the AMC and WAKE buckets. The SLEEP bucket is aggregated from consumers' tags only, so a sleep-set SH0 x=1,y=3 means a consumer whose tag includes SLEEP (QCOM_ICC_TAG_ALWAYS = AMC|WAKE|SLEEP) has a path through qns_llcc with a tiny bandwidth. In sm7150.dtsi the candidates are the QUP nodes, which use TAG_ALWAYS interconnects (one serial toward gem_noc SLAVE_LLCC, near line 1259), the crypto engine (ALWAYS to EBI, line 460), and uart8 serial@a88000 (the debug UART), which the recorded cycles show at avg 1 peak 1 across suspend. The owner is a DT tag on a consumer, not a firmware latch. Whether the SH0 sleep vote blocks aosd is NOT known yet: no source shows the sleep-set contents of the Aspire 1 or any SM7150-class phone; SH0 is only the sole non-zero sleep entry on surya, which makes it the cheapest subtraction. QMP: the aoss_qmp node (c300000, spi 389, mboxes apss_shared 0, apss_shared at 17c00000) is identical to sm8150 and sc7180, so the wiring in the tree is not the difference. Open succeeds, every send times out: the AOP does not clear the length word after the kick; qmp_send gives no other signal. Downstream wiring (irq-reg-base 17c0000c, mask 1) could not be confirmed from a source this session - not known yet. QMP matters only for the aoss prevent knobs (cx_mol, ddr_mol; hypothesis 5, unlikely) and is not on the path to the SH0 owner. Read from the tree at kernel-rc3; nothing on the phone was touched.
- drivers/interconnect/qcom/bcm-voter.c (keepalive BCMs, sleep bucket) - surya-research keepalive forces x=y=1 (or enable_mask) only in the AMC and WAKE buckets; the SLEEP bucket is aggregated from consumers' tags alone
- drivers/interconnect/qcom/sm7150.c (bcm_sh0, qns_llcc) - surya-research SH0 is a keepalive BCM on qns_llcc, the same definition as sdm845, sm8150, sc7180
- Qualcomm AOSS QMP driver v7 (Bjorn Andersson) - surya-research, 2019 qmp_send acks only when the AOP clears the length word after a kick; the timeout path is the one surya hits
- Split up TF-A related PSCI configuration for sc7180 (counts ddr, cxsd, aosd) -
2026-11-17
Does blocking Bluetooth (88c000 quiet) drop the SH0 sleep vote?
On the kept kernel, way-back.sh enable then cycle 15 (BT blocked): the journal ends at 'cycle: sleep 15 s, fuse 30 s' and the phone came back after a reset (uptime 1 min, no pstore record), so the watchdog fired and no counters were read. icc_summary before the cycle: only usb (240000) and cpus carry bw on llcc/ebi; ufshc, i2c, spi, mmc, scm paths carry tag 7 at bw 0. So there is no consumer with bandwidth to subtract; SH0 x=1,y=3 may be by design and the holder elsewhere (clocks, GDSCs, counter validity). Wi-Fi after the reset stayed down: the saved SSID is not in range (the lab AP shows another name) - an environment change, not the cycle.
2026-11-17
Does the debug UART (uart8, a88000) hold the SH0 sleep vote?
Read-only: icc_summary on the kept kernel lists non-zero bw only for usb, a88000 (1), 88c000 BT (2, 3200 aggre1), cpus. Try 1: dtb with uart8 interconnect tags 7->3 (ACTIVE_ONLY): the kernel summary still shows tag 7 - qcom-geni-se sets ALWAYS on its paths whatever the DT says, so tags in the DT cannot subtract a QUP vote. Try 2: dtb with serial@a88000 disabled; booted (health showed audio failures on that boot only; the next normal boot is healthy). cycle 15 bt-on, rpmh trace: the suspend-time sleep flush (tcs 2 [sleep], 6 cmds) at 153.75 reads addr 0x5003c data 0x60004003 = SH0 x=1,y=3 unchanged; cxsd/aosd/ddr 0 -> 0. So uart8 is not the owner, and DT tag changes are the wrong tool for the QUP consumers. Next suspects: the BT UART 88c000 (in use in bt-on), other QUP/crypto always-consumers by driver unbind, or SH0 not coming from an icc consumer at all.
2026-11-17
Does hexagonrpcd, with the version marker served as a writable file and the packaged sns_reg.conf in the state root, stop the ADSP registry-write crash on surya, and do the sensors then appear?
Yes. 40e5041 (PR #27) plus a 62-line patch (surya-lab/patches/hexagonrpcd-sns-reg-version.patch: a create op on the virtual root that opens a mapped file entry for writing, and a mapped sns_reg_version entry at the root), static aarch64, run once as a transient unit over a state root made of the package tree (config, registry, sns_reg.conf, dsp, acdb, socinfo) with the registry copied to sensors/persist/registry/registry. The earlier try's failures were the state root lacking sns_reg.conf (so /vendor/etc/sensors/sns_reg_config was not found) and no way to create the marker. Result on the kept kernel 7.1.0-sm7150-calls+: sensorspd alone, 60 s then 150 s, 0 ADSP crashes, the daemon active throughout; the DSP read then wrote sns_reg_version into the state copy ('version=2') and 174 state files; iio-sensor-proxy started and monitor-sensor reported accelerometer (orientation right-up), ambient light (values changing, lux), proximity sensor and compass. Stopping the daemon afterwards: still 0 crashes. The suite after: 35 pass, 6 fail, 4 not measured - as before (known gaps; deep-sleep soc-sleeps lists adsp never asleep). Not done: motion-and-light and proximity-reads as suite tests with the daemon lasting (it ran as a transient unit and is stopped; the stock unit is masked as before); a witnessed proximity cover; suspend with the helper (sensors-across-suspend). Hand-built binary only; upstream would want the patch shaped for hexagonrpc #19/#29.
- hexagonrpc PR #27: write support for the sensor registry (closed unmerged) - linux-msm, 2026 fopen in write modes, fwrite, fsync, fremove, ftrunc, frename, methods above 30 by escape, large in-buffers; branch sp11-sensors 40e5041; withdrawn by its author.
- hexagonrpc #19: sensor registry writes refused (Milos; SC8280XP, SM8650 and SG6275P reports) - linux-msm, 2026 The DSP writes the registry when sns_reg_version is missing; fwrite/fremove stop the crash; a writable state dir (-S) gave streaming sensors that survived a 15 s suspend on SG6275P (2026-11-06).
2026-11-17
Does surya's SoC reach its sleep floor in one measured s2idle on the kept kernel 7.1.0-sm7150-calls+?
No. One 60 s cycle by hand (USB gadget let go via soft_connect, rtcwake -m freeze -s 60, run as a transient systemd unit so it survives the link dropping; nohup in the ssh session is killed on exit). The phone slept the whole time: the pm8xxx_rtc_alarm interrupt fired once and suspend_stats success went 0 to 1, fail 0. The 2.4 s between the kernel log's suspend entry and exit, and between date readings, is only the clocks not counting sleep (monotonic and wall time stand still in s2idle here) - read the sleep from the RTC, not from date or dmesg. qcom_stats: cxsd 0, aosd 0, ddr 0 before and after; adsp never counted a sleep, cdsp 58, modem +7. Cluster domain: S1 usage 9417 to 9482 across the run, S2 (the deepest state) never entered. The suite's soc-sleeps now says fail: suspended, yet the SoC never reached its lowest state: cxsd 0, aosd 0; suspends this boot: 1; processors never asleep: adsp; wake locks: devlab-usb (devlab-health 20261117-115521). No hands needed: the phone woke by itself on the RTC alarm and came back over USB. Careful: reading /sys/power/wakeup_count blocks while a wakeup event is held (the lab's devlab-usb wake lock) - never read it without a timeout.
2026-11-17
What holds IRQ 157 up in surya's s2idle, and what does a timed cycle do once Bluetooth is blocked?
IRQ 157 is the Bluetooth UART: GICv3 hwirq 636 = serial@88c000 (interrupts 0x25c), with hci0 UP RUNNING on it (TX 444 KB, 1847 commands); the console UART ttyMSM0 is a88000, a different device with no wakeup attribute. With bluetooth rfkill-blocked, one timed cycle (soft_connect 0, rtcwake -m freeze -s 60, run as transient unit cycle1) did NOT return: the phone showed the pmOS initramfs gadget (18d1:d001) with no network until the author force-rebooted it (vol-down+power). The previous boot's journal ends at 12:37:25, the cycle script and its log are not on disk, suspend_stats this boot 0/0: so the phone went down hard right at suspend entry, losing the last seconds, and its wake path (the PMIC RTC reads 1970, epoch 1280063 s) did not bring it back. Not known yet: whether the hang is the RTC alarm not waking s2idle, a crash entering s2idle with the audio DSP up, or a reset; and whether the IRQ-157 wake was cured. Health after reboot: healthy, 36 pass, 0 fail. Next try needs a way back not depending on USB networking: a hardware watchdog or timed reboot, the RTC set first, a log written to a place that survives (sync, pstore/ramoops or a serial console).
2026-11-17
Why does surya's s2idle end after about 2 s instead of 60, and what does the first measured cycle show?
Five cycles by hand (kept kernel 7.1.0-sm7150-calls+, one with the cluster parameters of surya's own firmware tables in the device tree) all end early: the RTC advanced a few seconds only, the suspend core goes from dpm_suspend_noirq end to dpm_resume_noirq begin in microseconds and the CPUs never enter s2idle's idle loop. A function trace names the wake: s2idle_wake <- pm_system_irq_wakeup <- irq_pm_handle_wakeup, during suspend_device_irqs, no wakeup source involved. The interrupt is IRQ 157, qcom_geni_serial_isr (the serial at 88c000, wake-enabled, count 200579 ten minutes after boot): the kernel logs 'irq 157: nobody cared' and disables it. So the cluster sleep parameters and the audio DSP cannot be judged yet: the SoC has not been let sleep once. Also seen: a suspend leaves Bluetooth hci0 dead (command tx timeout, Reading QCA version information failed -110) and pm_suspend hangs in hci_resume_dev for minutes - a reboot was needed. The soc-sleeps check says fail (suspends 1, cxsd 0, aosd 0, adsp never asleep). The earlier note that the phone slept the full 60 s was wrong: it read the RTC alarm interrupt count, which fires awake too.
2026-11-17
What does surya have, and what do mainline and others do, for a way back from a suspend that may not return?
On the phone: qcom_wdt (17c10000.watchdog) with /dev/watchdog0, ramoops 4 MiB reserved at 0x9d800000 with pstore (console 1 MiB), the PMIC RTC reading 1970 and settable with hwclock -w -u; the kernel has no suspend timeout of its own (no PM_DEBUG, hung-task, DPM watchdog). Mainline qcom-wdt.c registers late system sleep ops that STOP an active watchdog in suspend and start it on resume: so a hang before the late phase is covered by a watchdog, one inside s2idle is not. A module with that stop made optional (one parameter, no other change) builds for the running kernel (no MODVERSIONS; vermagic equals uname -r) and loads without a kernel rebuild or reboot-to-test; a reboot undoes it. The RTC alarm cannot be the way back: if the RTC wake does not reach the GIC out of s2idle the phone sleeps for good, which looks the same as a hang. A bite resets the SoC; whether it reaches a normal boot and whether ramoops survives it is what the dry run measures.
2026-11-17
Does the watchdog way back work (idle, through a suspend entry, in the hanging cycle), and what log survives?
Yes. Idle: reset in 31 s, phone back in ~1.5 min with no hands. Probe (Bluetooth on, s2idle 3 s): the patched qcom_wdt kept counting through the suspend and bit 31 s after arming. The cycle with Bluetooth blocked and a 15 s sleep hung again right at suspend entry (the journal ends at the cycle marker, no PM: suspend entry line, suspend_stats 0/0) and the watchdog reset the phone 30 s after arming, back in under a minute more, no hands. The qcom watchdog counts 32 s at most (BusyBox -T 50 is EINVAL; the default 30 s holds), so a cycle's sleep is at most 15 s. pstore/ramoops stayed empty after every reset (the reset does not keep it); the persistent journal, synced before the arm, is the log that survives up to the last second before the hang. The PMIC RTC cannot be set.
2026-11-17
What does a voice call with sound both ways need on surya, and what is there now?
Read on the phone 2026-11-17 (devlab phone sh, read only): the modem is online now - LTE on Vodafone.de (26202), registered home, packet service attached, signal 71%, UE mode csps-1, voice-centric with PS (VoLTE) preferred, so a call goes VoLTE if the modem's IMS profile allows it, else falls back to GSM; ModemManager 1.25.95, libqmi 1.38, tqftpserv 1.3, rmtfs 1.3; callaudiod and q6voiced are installed; no calls listed. The kernel (7.1.0-sm7150-mic+, linux-phone-oco/linux test/surya-mic) has no VoiceMMode PCM and no Voice Mixer controls: q6voice is not in it. pulpoff/linux-surya (7.2.15 on surya) carries calls with audio both ways: q6voice from sdm845-mainline (MVM, CVS, CVP over APR) with the CVD 2.3 set-up SM7150 needs (from the CVP version), codec DMA ports, a zeroed command buffer and the start moved from startup to prepare; the device tree adds the APR services and a hostless VoiceMMode1 link (PCM 4, hw:0,4) that q6voiced opens per call; routing 'TERT_MI2S_RX Voice Mixer VoiceMMode1' and 'VoiceMMode1 Capture Mixer TX_CODEC_DMA_TX_3' (our kernel uses the same back-end names); 'VoiceMMode1 TX Topology' at 0x10F70 (none) since the default 0x10F71 sends silence without Xiaomi's calibration; and the uplink is silent unless a 1-channel capture runs on TX_CODEC_DMA_TX_3 for the whole call (their surya-call-uplink on MultiMedia3; 2 channels or a prepared-only stream do not do). callaudiod picks a UCM Voice Call verb (earpiece or speaker). The order: q6voice and the device tree first (the PCM and controls appear - check call-audio-path), then UCM Voice Call with the topology and the uplink capture, then a call.
- pulpoff/linux-surya: mainline 7.2.15 for the POCO X3 NFC on Mobian, both microphones and call audio - , 2026 surya's microphones are analog on the WCD9375 (bottom AMIC1 on ADC1, top AMIC3 on ADC2); capture link on <&swr2 1>; qcom,tx-port-mapping <2 3 4 5> gives ADC2 its own master port 3; LPI gpio7-11 NC (no DMIC pins in use); q6voice call uplink needs a running mono capture on TX_CODEC_DMA_TX_3
2026-11-17
Which LPASS vote keeps the audio DSP from sleeping with no stream open?
Not the macros' macro/dcodec votes alone: with them released at runtime suspend (patch kept in the material, upstream-aligned) a quiet cycle 15 bt-on still counts adsp 0, cxsd 0, aosd 0; stopping the voice, sensors and sound-server services changes nothing; the kept kernel has no stay_awake. Linux itself holds CX through the two active UARTs. Not known yet: what the DSP waits for (its own firmware, sensors PD, a vote by another subsystem).
2026-11-17
What made the TX decimator to codec DMA path deliver zeros, and what does a capture of zeros tell?
The decimator-to-DSP leg worked all along: each silent recording began with ~0.5 s of ringing (-1774 settling to exact 0), the high-pass filter draining a constant input - the decimator ran and its output reached TX_CODEC_DMA_TX_3, but no samples entered it. The cause was upstream of the decimator: the capture link named the TX SoundWire controller's DAI 0, its playback DAI (qcom_swrm_register_dais makes the first num_dout_ports DAIs playback, and this controller has one dout port), so sdw_stream_add_master was never called and the codec's ports never programmed. The same one-dout-port shift moves master port numbers by one (ports start at 2; swr2's qcom,ports-* arrays begin with 0xff). For DMICs the same reading held: with no clock on the pin the data line is static and the filter removes it. So: start-up ringing then exact zeros means no input reaches the decimator - look at the source (SoundWire stream, DMIC clock), not the DMA or the AFE port. The AFE port is the vendor's too: TX AIF1 on TX_CDC_DMA_TX_3 (45111 = 0xB037), accepted by this ADSP.
- pulpoff/linux-surya: mainline 7.2.15 for the POCO X3 NFC on Mobian, both microphones and call audio - , 2026 surya's microphones are analog on the WCD9375 (bottom AMIC1 on ADC1, top AMIC3 on ADC2); capture link on <&swr2 1>; qcom,tx-port-mapping <2 3 4 5> gives ADC2 its own master port 3; LPI gpio7-11 NC (no DMIC pins in use); q6voice call uplink needs a running mono capture on TX_CODEC_DMA_TX_3
- sm7150-mainline/linux PR 60: working WCD9375 microphone capture on davinci (open) - , 2026 The four faults of SM7150 WCD capture: swr_tx_data mux 3, the TX bus wakeup IRQ, port numbering shifted by the TX controller's one dout port, and the capture link's DAI 1; plus MultiMedia2 for capture. The place to contribute surya's fixes upstream, beside it rather than in a parallel series
- LineageOS sm6150 kernel: the vendor bolero codec (tx-macro, va-macro, bolero-cdc) and sm6150 machine driver - , 2019 sm6150/sdmmagpie use qcom,va-without-decimation: the VA block gives only MCLK, the fs counter and DMIC clocks, clocked from the TX macro's MCLK through bolero's mclk mux; TX decimators record everything; TX AIF1 is TX_CDC_DMA_TX_3 (AFE 45111 = 0xB037)
2026-11-17
Why does nothing come back from surya's main microphone, now that the WCD9375 enumerates and the sound card is made?
The codec dropped off both SoundWire buses because ASoC puts every idle component into its sleep pin state, and the codec's sleep state drove its active-low reset low (traced: snd_soc_bind_card committed it 0.24 ms before both interfaces went UNATTACHED). Without a sleep state the codec stays attached and capture prepares (linux-phone-oco/linux PR #4); the SoundWire pin-mux fix is PR #3. Capture still yields exact zeros: the built-in microphones are digital mics (vendor: TX DMIC1-3 on LPI gpio26-29, function 1, mic bias 1 and 3); this ADSP rejects the VA capture port, so they go through the TX macro to TX_CODEC_DMA_TX_3; with the VA DMIC clocks forced on the TX path still reads zeros, as it does from ADC1 - the next fault sits in the TX decimator to DSP leg. Details: research/microphone.md.
2026-11-17
Why did surya's modem fail as soon as a SIM went in, and what makes mobile data work?
The modem looped 4769 times reading and writing /readwrite/lctoem.tmp: tqftpserv 1.1.1 (Alpine v3.24) never writes short WRQ files, so the state files stayed 0 bytes, the modem stayed in DMS mode shutting-down, UIM reported 'GW primary session index unknown' and ModemManager 'sim-missing'. tqftpserv 1.3 from Alpine edge (two packages, no other dependencies) fixed it on the next boot: mode online, Vodafone.de LTE, home registration, signal 71%. Mobile data then failed with 'Multiple PDN connection to same APN not allowed' when the NetworkManager connection named the APN web.vodafone.de: the modem's default profile attaches with an empty APN, which the network fills in. A gsm connection with no APN works: IPv4 and IPv6, 3/3 pings at 32 ms, 500 kB at 1.2 MB/s. The SIM sits in slot 2 (slot 1: no ATR), as pmaports #4441 found.
- qcom-sm7150 (xiaomi-surya) unable to unlock sim: QMI protocol error (3) - root cause tqftpserv 1.1.1 (pmaports #4441) - , 2026 tqftpserv 1.1.1 never writes the modem's short state files, so the modem stays in shutting-down and the SIM reads as missing; fixed in tqftpserv 1.2 (9ef11c0). On surya the SIM works in slot 2.
2026-11-17
Can the sensors helper stay attached across suspend, and what brings it back after?
postmarketOS stops sensorspd and rootpd before suspend (the units Conflicts=suspend.target; !5400 on the Pixel 3a, carried to systemd in !7303) and nothing restarts them: Restart=always does not fire on a conflict stop, by design - the helper is thought needed only while the DSP asks for its registry, and libssc talks QMI to the sensor service, not through hexagonrpcd. So after a first suspend on surya the sensors would have no helper; whether they keep working without it is unmeasured. One data point (SG6275P, #19) has a sensors helper with a writable registry surviving a 15 s rtcwake. surya's rootpd crash on suspend (24 of 24) is a separate helper; rootpd stays masked. No kernel fastrpc fix for suspend was found in 2025-2026; Qualcomm said in 2026-04 that a daemon attaching to a PD crashes the privileged PD and is being investigated.
- pmaports !5400 and !7303: stop sensorspd before suspend (Pixel 3a) - postmarketOS, 2024 The helper is needed only while the ADSP asks for its registry; the units Conflicts=suspend.target, stop-only: nothing restarts them after resume, by design.
- hexagonrpc #19: sensor registry writes refused (Milos; SC8280XP, SM8650 and SG6275P reports) - linux-msm, 2026 The DSP writes the registry when sns_reg_version is missing; fwrite/fremove stop the crash; a writable state dir (-S) gave streaming sensors that survived a 15 s suspend on SG6275P (2026-11-06).
2026-11-17
How far have SSC sensors got on SM7150 and its siblings on mainline, and what stopped them?
surya: reported working once (wiki 'SSC works', 2024-03-11, mainline 6.7.4, hexagonrpcd 0.3.x, setup unwritten), never re-checked; firmware-xiaomi-surya's registry is Android's own (mtimes 1230768000). davinci (SM7150): rarely works on v26.06, iio-sensor-proxy at 100% CPU (#4674), the audio failure loop from ADSP crashes (#3871); a fix serving the real persist (!8203) was closed unmerged. tucana works (mount matrix fixed); sweet light and accel, its proximity is ultrasonic; sunfish (Pixel 4a) does not. miatoll (SM7125, ADSP only like surya) works with a registry rebuilt on Linux (sns_reg_config 1720791834). Fairphone 4 (SM7225) works. Upstream: no hexagonrpcd release writes (v0.5.0, 2026-08, none); write support exists out of tree (#27 withdrawn, a -S state dir on SG6275P, a 700-line patch on X1P42100) and the maintainers have not settled where writes go. Other routes: Linux driving the sensor chips on the SSC buses fights the DSP for them (X1E) and needs drivers stk3a5x lacks; Ubuntu Touch on surya has sensors through Android's vendor kernel (Halium).
- postmarketOS wiki, POCO X3 NFC: revision 56784 'SSC works' - postmarketOS community, 2024 The one report of surya sensors working on Linux: accel, magnet, light, proximity set Y on 2024-03-11 on mainline 6.7.4 (hexagonrpcd 0.3.x then); setup unwritten, never re-checked.
- pmaports #4674: davinci sensors rarely work on v26.06 - postmarketOS, 2026 SM7150 sibling: sensors rarely work and iio-sensor-proxy spins at 100% CPU (libssc #130).
- pmaports !8203: mount persist for hexagonrpcd (closed unmerged) - postmarketOS, 2026 Aimed at davinci's ADSP crash loop (#3871) by serving the real persist registry; closed the same day, reason not visible.
- pmaports !5941: miatoll (SM7125, ADSP only) sensors - postmarketOS, 2024 An ADSP-only sibling with working proximity through hexagonrpcd, libssc and iio-sensor-proxy; its registry's sns_reg_config records 1720791834, a registry rebuilt on Linux.
- hexagonrpc #19: sensor registry writes refused (Milos; SC8280XP, SM8650 and SG6275P reports) - linux-msm, 2026 The DSP writes the registry when sns_reg_version is missing; fwrite/fremove stop the crash; a writable state dir (-S) gave streaming sensors that survived a 15 s suspend on SG6275P (2026-11-06).
- hexagonrpc PR #27: write support for the sensor registry (closed unmerged) - linux-msm, 2026 fopen in write modes, fwrite, fsync, fremove, ftrunc, frename, methods above 30 by escape, large in-buffers; branch sp11-sensors 40e5041; withdrawn by its author.
- hexagonrpc #29: sns_registry_sensor.c assert takes the ADSP down (X1P42100) - linux-msm, 2026 The same assert as surya's, with hexagonrpcd 0.4.0 -s -R; a local ~700-line patch writing only under /persist/sensors/registry fixes it; on X1E #27 stopped the reboot but found no sensors.
- LKML: SSC-bound I2C driven from the application processor (X1E) - Linux kernel, 2026 Bit-banging an SSC QUP's pins from Linux works on X1E, but the DSP may drive the same bus; the DSP route is preferred for power.
- firmware-xiaomi-surya (sensors configs and pre-parsed registry) - sm7150-mainline, 2024 Ships 46 sensor configs and a pre-parsed registry of 193 files (stk3a5x light and proximity included) whose sns_reg_config records every config with data 1230768000, Android's fixed vendor mtime; no sns_reg_version.
2026-11-17
Which sensors does surya carry, where, and is in-call proximity a real sensor?
All on the audio DSP's sensor core (no SLPI on SM7150), none on a bus Linux drives: the motion chip (accelerometer+gyroscope; one of bmi220, bmi26x, icm4x6xx, lsm6dso, probed by the DSP - the wiki names BMI220) on SPI instance 3; magnetometer AK09918 (ak0991x) on I2C 1 at 0x0c; adux1050, a capacitive SAR sensor for radio power, on I2C 1 at 0x2c (not the call proximity); Sensortek stk3a5x ambient light + infrared proximity on I2C 5 at 0x46, polled, near/far 12000/10000, one calibration value differing by panel (huaxing 2.0, tianma 1.0, chosen on Android by ro.boot.lcmtype through an apps-side get_property hexagonrpcd does not implement; the pre-parsed registry already holds stk3a5x). In-call proximity is that physical IR sensor: surya's tree has none of the ultrasound parts its sibling sweet carries (elliptic, mius, ro.vendor.audio.us), so the microphones and earpiece are not involved. The phone runs libssc 0.4.3 with ssccli, iio-sensor-proxy 3.9 with ssc support, and its udev tags fastrpc-adsp ssc-light, ssc-compass, ssc-accel, ssc-proximity; iio-sensor-proxy starts and waits ('registry sensor unavailable'). The suite's motion-and-light counted IIO devices only, so it could never pass through the sensor core.
- LineageOS device tree and vendor blobs for surya - Xiaomi, 2025 Sensors only through sensors.ssc; no ultrasound parts (no elliptic, mius or ro.vendor.audio.us), unlike sibling sweet; stk3a5x I2C instance 5 0x46 polled, ak0991x and adux1050 (SAR) on I2C 1, the motion chip on SPI 3; Android serves the registry as user system with persist writable, and resolves property= lines through an apps-side sns_registry get_property hexagonrpcd lacks.
- firmware-xiaomi-surya (sensors configs and pre-parsed registry) - sm7150-mainline, 2024 Ships 46 sensor configs and a pre-parsed registry of 193 files (stk3a5x light and proximity included) whose sns_reg_config records every config with data 1230768000, Android's fixed vendor mtime; no sns_reg_version.
- postmarketOS wiki, POCO X3 NFC: revision 56784 'SSC works' - postmarketOS community, 2024 The one report of surya sensors working on Linux: accel, magnet, light, proximity set Y on 2024-03-11 on mainline 6.7.4 (hexagonrpcd 0.3.x then); setup unwritten, never re-checked.
- iio-sensor-proxy !409: ssc-accel and ssc-proximity udev tags - freedesktop, 2026 libssc support merged in 3.9 (!381); the accel and proximity tags still open upstream; surya's v26.06 carries them in its own rule.
- libssc: Qualcomm Sensor Core sensors for Linux - libssc, 2026 accelerometer, gyroscope, light, proximity, magnetometer, compass; ssccli reads one; #70: the same SNS_REG_INIT assert on SM8250 from missing configs; #120 ADSP fatal SNS_SEE near screen lock.
2026-11-17
The sensor hub on surya: how it stands, what was tried, what never to do again
2026-11-17 (research-sensor-hub): broken by our own mask - hexagonrpcd-adsp-sensorspd and -rootpd masked in surya-lab device.toml; iio-sensor-proxy runs and waits for the registry. Way decided: the registry kept current (decision 2026-11-17-sensors-registry-kept-current); queue sensors-and-the-mask (10, first), sensors-without-crash (11), sensors-proximity-in-calls (12), sensors-registry-writes (13, fallback only), sleep-fastrpc-helpers (4) for suspend, sensors-upstream (no phone). Dead ends: swapping registries (packaged, or the phone's own persist with the marker beside it) - hexagonrpcd cannot serve the marker, so those trials changed nothing (2026-11-09, surya-lab adsp/registry-trial.sh, which counts crashes and can take the probe). Tools on the phone: ssccli --sensor proximity|light|accelerometer|magnetometer, monitor-sensor, busctl on net.hadess.SensorProxy. Never: unmask rootpd (the DSP dies at every suspend attempt); leave sensorspd crash-looping - each crash restarts the DSP that carries the microphones and calls; read /sys/kernel/debug/gpio or the LPI pinctrl at 62b40000 - the sensor core's pins are there. The sensor chips are not on any bus Linux drives.
- hexagonrpc source (rpcd_builder.c, apps_std.c, hexagonfs_mapped.c), v0.4.0 to v0.5.0 - linux-msm, 2026 Writes are refused by design (fopen w/a: AEE_EUNSUPPORTED); stat passes the file's real mtime to the DSP; persist/sensors/registry maps only its registry subdirectory, so sns_reg_version beside it is never served; v0.5.0 (2026-08-13) changes none of this; Alpine edge ships 0.4.0-r3.
- firmware-xiaomi-surya (sensors configs and pre-parsed registry) - sm7150-mainline, 2024 Ships 46 sensor configs and a pre-parsed registry of 193 files (stk3a5x light and proximity included) whose sns_reg_config records every config with data 1230768000, Android's fixed vendor mtime; no sns_reg_version.
2026-11-17
Why does the ADSP sensors service crash-loop the audio DSP on surya, and what would stop it without changing the firmware?
Measured on the phone (read only, kept kernel 7.1.0-sm7150-calls+, 2026-11-17) and read in hexagonrpcd's source. At start the DSP's registry sensor compares each config it knows (the registry's sns_reg_config: 47 configs, every one recorded with data 1230768000 - 2009-01-01, Android's fixed vendor mtime) with the config files hexagonrpcd serves, and hexagonrpcd passes their real mtime: all 46 on the phone carry 1779945838 (the package's build time), and sns_pickup.json is listed but absent. Every config therefore looks changed, the DSP re-parses and writes (temp.json), hexagonrpcd refuses every write by design, and the DSP asserts (SNS_REG_INIT, sns_registry_sensor.c) and restarts with audio. The version marker sns_reg_version, whose absence also forces a rebuild elsewhere (hexagonrpc #19), cannot be served at all: the virtual persist/sensors/registry holds only its registry subdirectory. So no trial of 2026-11-09 had both conditions of an untouched registry - the marker reached and the configs unchanged; they disproved only a registry swap. Hypothesis to settle first: configs touched to 1230768000 (and no listed config missing) make the pre-parsed registry current, so nothing is written and the ADSP stays up. Independent of it: the same assert is open upstream on X1P42100 (#29, 2026-11-14) and was stopped by writes elsewhere (#19, #27).
- hexagonrpc source (rpcd_builder.c, apps_std.c, hexagonfs_mapped.c), v0.4.0 to v0.5.0 - linux-msm, 2026 Writes are refused by design (fopen w/a: AEE_EUNSUPPORTED); stat passes the file's real mtime to the DSP; persist/sensors/registry maps only its registry subdirectory, so sns_reg_version beside it is never served; v0.5.0 (2026-08-13) changes none of this; Alpine edge ships 0.4.0-r3.
- hexagonrpc #19: sensor registry writes refused (Milos; SC8280XP, SM8650 and SG6275P reports) - linux-msm, 2026 The DSP writes the registry when sns_reg_version is missing; fwrite/fremove stop the crash; a writable state dir (-S) gave streaming sensors that survived a 15 s suspend on SG6275P (2026-11-06).
- hexagonrpc PR #27: write support for the sensor registry (closed unmerged) - linux-msm, 2026 fopen in write modes, fwrite, fsync, fremove, ftrunc, frename, methods above 30 by escape, large in-buffers; branch sp11-sensors 40e5041; withdrawn by its author.
- hexagonrpc #29: sns_registry_sensor.c assert takes the ADSP down (X1P42100) - linux-msm, 2026 The same assert as surya's, with hexagonrpcd 0.4.0 -s -R; a local ~700-line patch writing only under /persist/sensors/registry fixes it; on X1E #27 stopped the reboot but found no sensors.
- firmware-xiaomi-surya (sensors configs and pre-parsed registry) - sm7150-mainline, 2024 Ships 46 sensor configs and a pre-parsed registry of 193 files (stk3a5x light and proximity included) whose sns_reg_config records every config with data 1230768000, Android's fixed vendor mtime; no sns_reg_version.
- libssc: Qualcomm Sensor Core sensors for Linux - libssc, 2026 accelerometer, gyroscope, light, proximity, magnetometer, compass; ssccli reads one; #70: the same SNS_REG_INIT assert on SM8250 from missing configs; #120 ADSP fatal SNS_SEE near screen lock.
2026-11-17
Does sm7150's device tree ask the firmware for the cluster states surya's firmware knows?
Apparently not, for the two deepest. sm7150.dtsi (sm7150-mainline, the same in our tree) carries three cluster states whose latencies are surya's own but whose PSCI parameters are SC7180's: 0x41000044 (cluster power collapse), 0x41001244 and 0x4100b244. surya's own Android device tree (lpm-levels, cluster mode shifted by 4) has l3-pc 0x4, cx-off 0x224 and llcc-off 0xc24 - that is 0x41000044, 0x41002244 and 0x4100c244; 0x4100c244 is also what SM8150, the closest sibling, uses for its one cluster sleep. On the phone the deepest state (0x4100b244) was never entered once at runtime. Whether the firmware rejects, demotes or honours SC7180's values is not known: it is the first thing a measured suspend settles. SM7150 is not yet in mainline: the 2025 upstreaming series is to be resent, so a correction can go into it.
- sm7150-mainline's sm7150.dtsi (branch v7.2): CPU and cluster idle states, PSCI domains, apps_rsc on the cluster domain, rpmh-stats -
- sm7150-mainline/downstream-fdt: the device trees of the phones' own Android kernels (fdt-surya: lpm-levels, rpm-stats) -
- sm8150.dtsi in mainline: one cluster sleep state, PSCI parameter 0x4100c244 -
- Danila Tikhonov: the SM7150 upstreaming series (v1, 2025-04-22) -
2026-11-17
Should standby drain be a proper repeatable test (idle, unplugged, fixed time, screen off, radios as in daily use) rather than a single measurement, and what should the one-off run prepared now take from it?
Yes, repeatable - but scored as mean current, not battery percent. Observed (Android power-component guide, source.android.com/docs/core/power/component): measure suspend with no wakelocks, confirm the device really suspends, wait for the reading to settle, average radio current over time, unplug USB first (a host can feed current). GameBench: hourly drain = capacity / average current. No standard 'suitcase test' or 'overnight drain test' found; the name is ours. pmaports#4846 (motorola-dubai 17x Droidian; method unread). Droidian miatoll 9 mA: its method not found; PinePhone anecdotes are single reports. Inference: charge_counter delta over the whole window is the primary number, current_now only a cross-check (wake samples inflate it), the gauge percentage least trustworthy. Take: average over a window, a settle period, unplug before the run, proof of real suspend. Leave: percentage scoring, the 30-80 mA 'normal' figures, 6-8 h windows. Test-catalogue fit: test standby-current, threshold 15 mA, median of 3 runs, a witness step 'unplug USB, confirm'; one run row per attempt (start/end charge_counter, elapsed, mean mA, samples, suspended fraction, radio state, kernel, unplug time), a failed unplug is an invalid run not a zero. One-off run: >=60 min measured after a 10 min settle (10 min is too short, the counter is coarse); Wi-Fi on the lab AP, Bluetooth as two separate runs (on, off), SIM out so record the modem state and do not call it airplane mode; screen off; log current_now, charge_counter, voltage_now, status every 30-60 s with a monotonic time, plus wakeup and suspend counts; discard samples while status is Charging; score from the charge_counter delta, report suspended fraction, compare with 15 mA and 9 mA now, Android 'not known yet'.
2026-11-17
Where does surya's deep sleep stand, measured on the phone itself?
Measured 2026-11-17 on the test kernel 7.1.0-rc3-sm7150-wcd, read only. The kernel offers only s2idle, as on every Qualcomm phone. PSCI 1.1 runs in OS-initiated mode, and the CPU and cluster idle states are in use at runtime. The SoC's own sleep counters are readable (qcom_stats, from rpmh-stats at 0xc3f0000). Since boot: no suspend at all (suspend_stats success 0 - on USB the lab holds devlab-usb, and Sxmo holds sxmo_not_suspendable and sxmo_modem_warming_up); CX collapse (cxsd) 0, AOSS sleep (aosd) 0, DDR low-power states 0; the deepest cluster state (cluster-sleep-2) never entered once while the lighter two were entered thousands of times. The audio DSP never slept (adsp 0) while the compute DSP and the modem slept about 200 times each; no audio stream was open, yet the VA, TX and RX macros stayed active, and the command line carries soundwire_qcom.stay_awake=1 from the microphone hunt. So no measurement of deep sleep exists yet, and two things already seen would keep the SoC from its floor.
2026-11-17
How can calls, messages and data be checked without a person?
Data checks itself: a small download over the mobile connection. A call needs someone to answer: a second phone on a test stand that answers and confirms, or a programmable telephone number that answers and plays a known tone the phone can hear. Until then, half-manual: the phone calls a person's number and the person confirms through the inbox.
- Programmable voice (a number that answers and plays a tone) - Twilio and others, 2010 A telephone number driven by a program can answer a test call and play a known tone - a fully automatic call check without a second phone.
2026-11-11
Why does the modem not go online once a SIM card is in?
With the SIM in (operator 1&1, card present and ready) the modem refuses every request to go online: its own operating mode reads shutting-down from the start of boot, and ModemManager gets DeviceNotReady. The modem processor boots cleanly; rmtfs and tqftpserv run; the kernel's pd-mapper module is loaded. Meanwhile the modem reads and writes /readwrite/lctoem.tmp over tqftpserv in an endless loop, with rsize=0 seek=0 options, each read ending at once - the same kind of loop that postmarketOS fixed for the Fairphone 4 and 5 with a tqftpserv that handles rsize and seek. A reboot with the SIM in place changed nothing.
- modem/tqftpserv: upgrade and add patches for rsize & seek option handling (pmaports !4747) - Luca Weiss A modem's file transfers with rsize and seek options need a tqftpserv that handles them; it made the modem work on two close Qualcomm phones (sm6350, qcm6490).
2026-11-11
What does the community report for surya, and where does it disagree with what our checks measure?
Of 19 parts, 9 agree. The wiki reports calls, SMS and NFC working where our checks say unknown (no SIM card yet); mobile data and Bluetooth working where we measured partial; the speaker partial where we measured it working; and the sensors working where we measured broken - possibly our own doing, since we masked the sensor service to stop the audio processor crashing on suspend. The claims were gathered earlier, on an unrecorded date; this comparison is of today.
- Xiaomi POCO X3 NFC (xiaomi-surya) - device wiki page - postmarketOS community What the community reports working, part by part. The address is as the claims recorded it, to be confirmed as the current wiki.
2026-11-11
What must a phone have, structurally, to be a daily driver - judged from everything the open and proprietary platforms already built, learned and failed at?
Nine structural concepts, from ten projects, two operating systems and one firmware: Two Minds (a small always-on processor beside the main one, proven by Crust), Radio Wall, Notification Sovereignty, Consolidation Path, Platform Compatibility, Security Substrate, Update Covenant, Power Covenant, and the Observatory that maps every project against them. The open ecosystem's hard gaps are standby with push, a hardware security processor and long-term updates; Android and iOS solved them in closed ways. The model, its map and the prior-art files for Android/AOSP, iOS and GrapheneOS are the material; it is the why layer of the grand picture. (Moved into the dated layout on 2026-11-17.)
2026-11-10
Other sources
- Enabling serial port (console UART) on Pixel 2 and other Pixels - ikb-cli, 2020 Pixel 2 UART on USB-C SBU1/SBU2 at 1.8 V, 115200 8N1, fastboot oem uart enable; the stock cable lacks the lines; orientation differs between Pixels
- usb-cereal - ikb-cli SBU1 = TX, SBU2 = RX, DIP 1.8/3.3 V (a wrong setting can damage the target), orientation-specific, archived 2023-01-10, not an official Google product
- lab-agent: the pull-based agent that runs jobs on the real phone and reports back through git - , 2026
- device-xiaomi-{davinci,surya}: Move from testing to community -
- linux-postmarketos-qcom-sm7150: the sm7150-mainline kernel fork and its changelog across releases - , 2026
- sm7150-mainline: the community org hosting the kernel fork, nightly builds, and firmware repos -
- Pixel KGDB over UART - ikb-cli USB-Cereal at 1.8 V and 115200 on a Pixel 8; an FT232R supports break (KGDB sysrq), a CP2102N edition did not
- The vendor-derived WCD937x driver (LineageOS sm6150 kernel) - LineageOS, from Qualcomm's GPL audio techpack Bring-up: supplies, a reset pulse, 5 ms for enumeration, then bind; the reset is touched only at bind and on DSP restart; nothing in headset detection touches reset, supplies or SoundWire. Insertion debounce 256 ms (mainline uses less).
- Xiaomi's GPL kernel for surya: the WCD937x node - Xiaomi (GPL release, surya-q-oss) Supplies: L10A rxtx and px and BOB mic bias always on, L15A buck only on demand; micbias 1-3 at 2.7 V; a plain 3.5 mm jack with both MBHC switches set (hphl-swh, gnd-swh), no USB-C audio switch.
- Xiaomi's GPL kernel for surya: the LPASS pin states - Xiaomi (GPL release, surya-q-oss) The SoundWire pins' functions (TX data1 gpio19 func3, data2 gpio20 func2, RX data gpio22/23 func2) - mainline's corrected table agrees; the WCD937x reset is gpio24, active state driven high, sleep state low.