diff --git a/device/bluejay/BRINGUP-M1.md b/device/bluejay/BRINGUP-M1.md new file mode 100644 index 000000000..fa7a053f7 --- /dev/null +++ b/device/bluejay/BRINGUP-M1.md @@ -0,0 +1,157 @@ + +# Pixel 6a: first-boot gates + +Status (2026-11-05): first Linux boot passed. The M1 initramfs runs from B +on `7.3.0-rc6-omamobile-push1-g29a7a9326bf0`; USB SSH and guarded UFS +passed, as did more than nine minutes in the same boot. Before that test, +the approved matching stock OTA completed with recovery status 0 and +fastboot reported stock A active, successful and not unbootable. The +applied stock OTA is `CP3A.261005.002.A1`. Private backups are verified. +The Omarchy desktop has not been installed. Facts: [NOTES.md](NOTES.md). + +## Sources and outputs + +- Mobile worktree: `~/src/omarchy-mobile-bluejay-20261105`, branch + `bringup/bluejay-20261105`, based on `80ef270`. +- Kernel worktree: `~/android/mainline/wt-bluejay-m1-20261105`, branch + `omamobile-bluejay-m1-20261105`, published base `29a7a9326bf0`. +- Kernel output: `~/android/mainline/out-bluejay-m1-20261105`. +- Kernel C and DT sources are unchanged. Build the shared config with + `W=1`, `Image.gz` and `exynos/google/gs101-bluejay.dtb`. The M1 initramfs + uses the shared init, no board-specific register writes or probes, and + only `boot_b vendor_boot_b dtbo_b userdata` on its storage allowlist. +- Captures, serial selection, stock packages, checksums and private + recovery instructions stay outside this repository. Never put their + identifying contents or vendor images into a commit. + +## R0: current facts (complete; read-only, low risk) + +Serial-pin adb and fastboot, assert `product=bluejay`, and capture Android +state before unlocking. The owner approved the reboot, data erasure and +unlock, and confirmed the bootloader prompt physically. Fastboot now +reports `unlocked=yes`, `current-slot=b`. A's contradictory successful / +unbootable flags remain unchanged. Stop on a product or serial mismatch. +Rollback: none for reads; the approved unlock's data wipe is irreversible. + +## R1: establish stock recovery (complete; high impact) + +Prepare Google's full `bluejay` OTA for `CP3A.261005.002.A1` on the laptop. +Check the complete file's SHA-256 against Google's published download +table, its ZIP metadata's `pre-device`, resulting fingerprint and security +patch, and its payload partition inventory. Do not use a partial download. + +The package contains bootloader, modem, vbmeta and system firmware as well +as boot images. A recovery sideload is therefore outside the project's +Linux slot-B writer allowlist. **Ask the owner for this specific stock +recovery exception before entering the recovery/sideload sequence.** A +general acceptance of erasing user data is not this exception. + +The owner explicitly approved the exact recovery / signed OTA / stock A +verification / return-to-bootloader sequence. The full OTA checksum +matched Google's published SHA-256, its metadata matched the captured +phone fingerprint, and the serial-pinned sideload completed. This +approval covers this stock recovery operation, not a later Linux flash. + +Results (2026-11-05): adb sideload exited 0 with `Total xfer: 2.00x`. +Owner-provided photos show package verification result 0 and **Install +from ADB completed with status 0**. Earlier metadata mount / formatting +and missing `tune2fs` messages are visible; they did not prevent recovery +from reporting successful installation. The approved stock reboot returned +the phone as a normal Android MTP USB device; debugging was unavailable +after the wipe. After the owner returned it to fastboot, serial-pinned +queries report `current-slot=a`, `slot-successful:a=yes`, +`slot-unbootable:a=no`; B is also successful and not unbootable. The +bootloader remains unlocked at `bluejay-17.0-15681480`. Slot-A success is +the bootloader's reported evidence; no post-OTA Android properties were +read, and no explicit Welcome-screen confirmation was received. The +installed package's device and fingerprint were verified before sideload. + +After approval, use the captured serial and stock B's recovery, with the +owner at the buttons. Expected sequence: recovery menu, Apply update from +ADB, exact verified package via `adb -s sideload `, successful +verification and installation, then owner-approved stock boot. Record the +actual resulting slot rather than assuming recovery updated A. + +Pass: stock Android boots on A, reports the expected build, and fastboot +subsequently reports A bootable and successful. Inspect B's state too. +Stop: recovery rejects the signature, build, timestamp or device; an +installation error; unexpected slot; or no working A boot. Do not bypass +verification, downgrade, run a factory flash script or manually write +protected firmware partitions. Keep the working B images until A is +verified. Rollback: remain in recovery/fastboot and diagnose with the +matching stock package available; a partially applied update has no +assumed automatic rollback. Do not relock the bootloader for development. + +## R2: offline images (complete; not permission to flash) + +Once the kernel build finishes, build this device's boot images with the +project tool and the explicit kernel source/output above. Verify the +bluejay compatible, both gs101 SoC revision entries, MP1.0 overlay IDs, +image sizes and boot AVB footer/index against the stock capture. Run the +storage-guard checks and device-tree validation. Keep build logs and +record warnings; a completed build alone is not a phone test. + +Results (2026-11-05): `W=1` built +`7.3.0-rc6-omamobile-push1-g29a7a9326bf0` and the bluejay DTB with no +compiler errors. The unchanged published sources produced 1,145 warning +lines, 1,138 of them initializer overrides; this is not a warning-free +build. No kernel source patch was made, so checkpatch has no patch to +review. Google board-schema validation reported no diagnostics (limited +to `arm/google.yaml`, not all subsystem bindings). Storage-guard tests +passed 24 checks; image-layout tests passed 37. + +The shared initramfs and all three images built. Offline preflight checked +both SoC revision IDs, bluejay compatible and symbols, MP1.0 overlay IDs, +vendor header and command line without earlycon, boot footer rollback +index `1791158400` / security patch `2026-10-05`, and image sizes against +the actual partition sizes. The packed allowlist has exactly the expected +four names, with no board MMIO trigger, probe or USB-switch file. Image +hashes and build receipts remain in the private output directory. No +phone test or flash is implied by these results. + +## R3: first Linux boot (complete, explicitly approved) + +Use only `DEVICE=bluejay bin/omamobile flash` with the explicit validated +M1 output. It writes B's three images and activates/reboots B. The owner +must approve that concrete image set and be present for physical recovery. +Do not install a root filesystem or reuse another phone's data yet. + +Expect USB NCM/ACM and SSH to the initramfs at `172.16.42.1` within about a +minute. Display refresh is not enabled, so a stationary bootloader logo +is not the pass/fail signal. Verify uptime beyond 120 seconds, watchdog +handover and storage-guard state. Stop if USB is absent after three minutes +or there is a reset loop; do not keep retrying or change two things. + +Rollback: owner-assisted Volume Down + Power to fastboot, then approved +selection and boot of the previously verified stock A. With no verified A, +R3 must not run. Risk: high, first custom kernel on this board. + +Results (2026-11-05): all three writes returned OKAY; SSH answered at +uptime 2.57 seconds. Compatible and native kernel release matched bluejay +and the validated image set. USB is configured/high-speed. Both cluster +watchdogs report reset disabled. At 565.6 seconds SSH still answered in +the same boot, without panic, oops, UFS error-handler or guard-failure +signatures. All flashed image prefixes matched the original image hashes +on readback. Slot A stayed read-only. The same-boot storage guard verified +every protected partition, with `/dev/sda` absent as intended. No custom +driver load, display-register access or additional reboot followed. + +## R4: capture and backups before subsystem work (backups complete; memory audit open) + +If R3 passes, capture the live FDT, dmesg, memory map, interrupts, native +kernel release and read-only partition state. Verify reserved memory. +Read and checksum this phone's own calibration / modem partitions into a +private backup before radio, PMIC, AoC or Trusty experiments. No such +backup exists from the unprivileged stock capture. No Wi-Fi, GPU, touch, +audio, charging or suspend capability is claimed by these first-boot gates. + +Results: live FDT, kernel logs, iomem, interrupts, modules, mounts, USB, +watchdog and block guard state were captured privately. The six required +calibration / modem partitions plus stock A's three boot images and +`devinfo` were read without mounting or changing flags, each matched by +exact size and remote-before / local-copy / remote-after SHA-256. All +protected partitions remained read-only. Twelve native static reserved +regions match exclusions in iomem. The static stock-reference comparison +has unresolved differences: [MEMORY-PLAN](MEMORY-PLAN.md). Do not enable +new hardware until that gate is resolved. B's boot-success flags have not +been changed by this test. diff --git a/device/bluejay/DISPLAY-PLAN.md b/device/bluejay/DISPLAY-PLAN.md new file mode 100644 index 000000000..35801221b --- /dev/null +++ b/device/bluejay/DISPLAY-PLAN.md @@ -0,0 +1,37 @@ + +# Bluejay retained display + +Status (2026-11-08): an actual Omarchy desktop renders at 1080x2400 on retained +simpledrm, approximately 60 Hz. Panfrost renders through a separate Mali-G78 +node. Native panel/DSI modesetting remains unfinished. + +The selected stock panel is Samsung S6E3FC3 Bluejay (`samsung,s6e3fc3_6a`), +not the Pixel 7 P10 variant handled by the existing similarly named driver. +Do not copy its reset, brightness or panel-command sequence without an audit. + +Google's GS101 display source locates DECON0 at 0x1c300000. Its powered retained +path reported VERSION 0x06010000, GLOBAL_CON 0x133 and TRIG_CON 0x3070, with a +stationary frame counter. The qualified refresh operation changes only the +trigger mask/software-enable bits: TRIG_CON 0x3070 to 0x3061. It does not alter +DSI, panel reset, timing or brightness. Counter progress measured 60.06 Hz and +the owner observed numbered framebuffer alternation. The corrected whole-frame +readback matched all 10,368,000 bytes after stopping fbcon cursor repaint. + +The installed hardware service restores this exact operation after USB SSH and +touch setup, under a persisted failure marker and deadline. The framebuffer is +1080x2400, stride 4320, 32 bpp. Never use the generic GS201 `tools/display-hz` +address unchanged on this GS101 board, and never sweep unpowered registers. + +Aquamarine 0.16.0 needs the opt-in patch under `patches/` to avoid its unused +auxiliary EGL-device probe on display-only simpledrm. Without a GPU, Mesa GBM +software rendering works. With Panfrost, Aquamarine's existing sole-render-node +fallback pairs the separate GPU with simpledrm; no additional patch was needed. +See [GPU-PLAN](GPU-PLAN.md) for headless pixel and compositor results. + +Before a new display test, announce the screen change, stream logs and require +the watchdog. Confirm the exact board/register state and touch/SPI health first. +Stop on a mismatch, loss of transport or new fault; recover with the retained B +images through the project helper. PMU registers are never accessed from userspace. + +Sources: Google's Bluejay and GS101 display DT/driver at +`android-16.0.0_r0.9`, the owner's own captures and the upstream/project kernel. diff --git a/device/bluejay/GPU-PLAN.md b/device/bluejay/GPU-PLAN.md new file mode 100644 index 000000000..64936e9c5 --- /dev/null +++ b/device/bluejay/GPU-PLAN.md @@ -0,0 +1,132 @@ + +# Bluejay GPU bring-up + +Status (2026-11-08): G1 headless rendering and the accelerated Omarchy desktop +pass. The owner confirms unlocking, opening an app and scrolling with correct +display and normal response. A subsequent normal reboot independently passed +automatic GPU, touch, Wi-Fi and desktop startup. Native panel modesetting remains separate: presentation still +uses the retained simpledrm framebuffer. + +## Source and initial state + +- Running kernel: `7.3.0-rc6-omamobile-bluejay-input-gated0`, built in + `~/android/mainline/out-bluejay-input-20261107` from + `~/android/mainline/wt-bluejay-input-20261107`. Keep those frozen. +- Its Panfrost already matches `google,gs101-mali`, identifies G78 and forces + AArch64 page tables. See [raven's results](../raven/GPU-PLAN.md); those results + establish driver provenance, not Bluejay qualification. +- The installed Mesa is `1:26.2.4-1.4`; its project build includes the G78 model. + At the initial audit Bluejay's GPU node was disabled, no render node existed, + and the GPU modules were absent from the installed tree. Software rendering + was explicit in the session environment. +- GS101's GPU node defines its own job/MMU/GPU interrupts (420/421/419), register + range and ACPM clock. G1 retains them. The four supplies follow Google's + `gs101-pmic.dtsi`, included by Bluejay's own board source: BUCK2S (G3D), + BUCK8S (G3D L2), LDO1S (G3D memory), BUCK7M (internal memory). + +Sources: the exact local kernel sources above and the owner's already retrieved +[Google GS101 device sources](https://android.googlesource.com/kernel/devices/google/gs101/+/refs/tags/android-16.0.0_r0.9/dts/gs101-pmic.dtsi), +plus [Bluejay PMIC overrides](https://android.googlesource.com/kernel/devices/google/bluejay/+/refs/tags/android-16.0.0_r0.9/dts/gs101-bluejay-pmic.dtsi). + +## G1: bounded driver and headless rendering qualification + +`overlays/gpu-g1.dtso` enables only the GPU, adds its supply references and points +it at a single 151 MHz OPP. The existing ACPM driver pairs that shader rate with +302 MHz L2; the full frequency range is deliberately a later test. +`tools/bluejay-development-images.py --dt-overlay FILE` applies this overlay to +both silicon variants in the known persistent images. The kernel, packed RAM, +boot image, empty board DTBO, bootargs and every unrelated DT property must +remain identical. The exact matching Panfrost and gpu-sched modules are added +without replacing the installed module tree. Keep the boot blacklist. + +1. **Read-only / low risk:** verify actual image structure and semantic DT delta, + GPU/OPP schemas, overlay checkpatch, matching module release/hash and current + USB SSH/watchdog state. Preserve the private results in the current GPU + evidence directory. Stop on an unexpected DT/image/module delta. No protected-data write is part of this probe. +2. **B images and reboot / bounded boot risk:** announce the screen interruption; + use the existing project `bin/omamobile push` with the candidate directory and + the original matching module-archive marker, so it does not replace modules. + Expect a new boot ID, the same kernel and working automatic desktop/input/ + Wi-Fi. Panfrost remains unloaded. Stop if USB does not return; request physical + Fastboot recovery when necessary. Roll back through the same project helper + using the retained persistent baseline or known RAM rescue images. +3. **Manual probe / hardware hang risk:** stream kernel logs to the host first. + Require systemd's active 20-second watchdog. Run one bounded transient service + with a persisted pending marker, startup/stop deadlines and reboot on failure. + Load Panfrost once. Expect Mali-G78, a render node and 151 MHz devfreq; reject + new faults or SPI/storage errors. A failed attempt stays marked and is not + retried in the same boot. Never unload/rebind or read PMU registers. +4. **Headless GLES / bounded GPU-job risk:** use explicit GBM render-node EGL, + require the renderer to identify G78, and check pixel readback for clear and + shader draws under the same logging/deadline protection. Stop at the first + job/MMU fault, timeout or wrong pixel. Probe success alone is insufficient. + +Compositor acceleration is a later stage after headless rendering passes. +Changing its environment/restarting SDDM affects the screen and must be announced. +Native panel, suspend and full GPU DVFS remain unqualified by G1. + +The tested handset owner authorized the staged B-image changes and reboots. +Bootloader and calibration remain preserved. Other handset owners must follow +the project installation/recovery policy before repeating a hardware step. + +## G1 results and startup integration, 2026-11-08 + +The actual image checks prove that the kernel, boot image, empty board DTBO and +packed RAM archive retain their exact bytes. The semantic delta in both silicon +DT variants is confined to GPU status, four supply references and the one-entry +OPP table. GPU/OPP binding validation passes against the exact kernel's compiled +schemas; overlay checkpatch has zero errors/warnings/checks. The default image +tool path also reproduces the existing persistent vendor image byte-for-byte. + +The first manual probe deferred (`get clock failed -517`): `clk_acpm` was absent +from the root. The guarded service then failed its render-node assertion and +requested an orderly reboot. This was not a GPU hang. Its saved journal, pending +marker and original host stream are retained privately. After recovery, the +exact matching clock module was added and blacklisted. Before its manual load, +`cpufreq-dt` received a driver override to hold that unrelated deferred consumer; +this keeps CPU DVFS out of the GPU qualification. + +The corrected clock/Panfrost stage completed in 149 ms. GPU ID is `0x9202`, +Mali-G78 MC20, shader mask `0x779fff`; Panfrost initialized and exposed +`renderD128`. The only available devfreq rate is 151 MHz. The native build of +`tools/bluejay-gpu-smoke.c` passed `-Wall -Wextra -Werror` and explicitly opened +that render node. Mesa reports OpenGL ES 3.1 and `Mali-G78 MC20 (Panfrost)`. +All pixels passed clear, solid shader and alpha-blended shader checks at +64x64, 257x257 and 1024x1024, in 225 ms. No GPU/MMU fault, SPI error or timeout +appeared. + +The compositor uses the existing Aquamarine library: its sole-render-node +fallback pairs the display-only simpledrm device with Panfrost. No additional +Aquamarine patch was needed. Hyprland opens the render node and has Panfrost +buffer allocations; software forcing was disabled and Quickshell uses RHI. +The lock screen rendered and the owner confirmed normal unlock/app/scroll use. +An initial capture during DPMS wake was black; the later capture from the same +process rendered the lock screen. Capture was stopped before local PIN entry. +For this installed Lua Hyprland, the working wake command is +`hyprctl dispatch 'hl.dsp.dpms("on")'`. + +`omamobile-bluejay-gpu.service` now stages the same exact module hashes and CPU +hold before SDDM. It requires explicit `/etc/omamobile/bluejay-gpu-enable`, which +is present only on this qualified development root. A persisted attempt marker, +30-second startup deadline, five-second stop deadline and systemd watchdog +bound failure; a retained marker skips the GPU on the next boot. The session +environment selects Panfrost only with the service's volatile ready marker and +render node; otherwise it explicitly restores llvmpipe/software rendering. +Package tests cover the opt-in policy, stale/ready fast paths and both renderer +environment branches. Device package version is 0.1.3. + +Private evidence is `~/android/reference/bluejay-gpu-20261108`; the candidate used +by the project helper is `candidate-g1-validated`. Three exact-build modules were +added without replacing the root's touch, Wi-Fi or netfilter modules. Full GPU +DVFS, CPU DVFS, Vulkan, suspend and native panel modesetting remain unqualified. + +Final fresh boot: `f0708eb4-e748-4456-abe1-5cb3bd3aa8c5`, same kernel as above. +The actual Hyprland process has `GALLIUM_DRIVER=panfrost`, +`LIBGL_ALWAYS_SOFTWARE=0` and open Panfrost render-node descriptors. All four +startup services and SDDM are active, all pending markers are absent, compositor +config errors are empty, and there are no failed system units. Wi-Fi-bound HTTPS +returns HTTP 200 with TLS verification 0; touch SPI errors/timeouts are zero. +No GPU faults appeared. The watchdog remains owned by systemd at 20 seconds; +automatic boot writes remain off and boot-success remains masked. No host +capture/wait jobs remain. The owner interaction check preceded this final reboot; +it was not repeated afterward. diff --git a/device/bluejay/MEMORY-PLAN.md b/device/bluejay/MEMORY-PLAN.md new file mode 100644 index 000000000..10309e1a4 --- /dev/null +++ b/device/bluejay/MEMORY-PLAN.md @@ -0,0 +1,431 @@ + +# Pixel 6a: reconcile reserved memory before further bring-up + +Status (2026-11-06): the approved M2 boot **passes live memory validation**; +fresh post-stock backups and their independent check are complete. USB SSH +timeouts during bulk copy remain a separate observation. The first-boot kernel is +`7.3.0-rc6-omamobile-push1-g29a7a9326bf0`, published kernel commit +`29a7a9326bf0`, branch `omamobile-bluejay-m1-20261105` in +`~/android/mainline/wt-bluejay-m1-20261105`, output +`~/android/mainline/out-bluejay-m1-20261105`. No new driver or register +probe is authorized by this plan. First-boot results: [NOTES](NOTES.md). + +## Evidence and limits + +The native live FDT has twelve enabled static reserved-memory entries, +covering eleven distinct ranges. All are excluded from unreserved System +RAM in the captured iomem, but two entries cover the same debug-info page. +This exclusion check alone does not validate the stock-reference layout. + +The verified, read-only stock-A `vendor_boot` backup contains two stock +base DTBs, A0 and B0. Applying entry 9 (MP1.0, board ID `0x20506`, revision +`0x10000`) from stock A's `dtbo` to B0 succeeds offline. This reconstructed +tree has twenty-two enabled static reserved regions and five nodes without +a static `reg`. It is **not** a captured stock live DT: ABL runtime edits, +memory reservations and its DPM overlay are not represented. Stock Android +did not expose `/sys/firmware/fdt` to the unprivileged shell. + +These stock ranges overlap native unreserved System RAM: + +| Stock node | Start | Size | Native unreserved overlap | +| --- | --- | --- | --- | +| `ect_binary` | `0x90000000` | 237568 bytes | entire range | +| `abl@f8800000` | `0xf8800000` | 32 MiB | `0xf9800000`–`0xfa800000` (end exclusive) | +| `suspend_diag_log_reserved@fd90c000` | `0xfd90c000` | 4 KiB | entire range | +| `ramoops_mem@fd3ff000` | `0xfd3ff000` | 4 MiB | entire range | +| `cp_rmem` | `0xf0000000` | 8 MiB | entire range | +| `cp_rmem_1` | `0xe8000000` | 28 MiB | entire range | +| `cp_rmem_2` | `0xee000000` | 4 MiB | entire range | +| `seclog_mem` | `0xc3000000` | 512 KiB | entire range | +| `xhci_dma@97000000` | `0x97000000` | 4 MiB | entire range | + +Nodes without static `reg`: `vstream`, `vframe`, `vscaler`, `tui`, `mfc_fw`. +Their dynamic allocations cannot be compared by assuming an address. + +An overlap is an audit candidate, not proof of an active firmware writer. +Some stock buffers serve Android drivers which are not running in the M1 +kernel. Do not blindly reserve all stock ranges or claim all can be freed. + +## Resumed audit: allocator reservations are not firmware carve-outs + +[V] Re-examining the saved first-boot log finds CMA at +`[0xc8000000, 0xe0000000)` (384 MiB) and the software I/O TLB at +`[0xf4800000, 0xf8800000)` (64 MiB). Both appear as child `reserved` +resources inside System RAM in iomem. They are Linux allocation pools, +not proof that overlapping stock buffers are protected. The original +comparison subtracted those child resources and therefore missed seven +additional candidates: + +| Stock node | Range, end exclusive | Native allocator overlap | +| --- | --- | --- | +| `header` | `0xd8100000`–`0xd8110000` | CMA, 64 KiB | +| `log_kevents` | `0xd8110000`–`0xd8810000` | CMA, 7 MiB | +| `log_s2d` | `0xd8810000`–`0xda010000` | CMA, 24 MiB | +| `log_array_reset` | `0xda010000`–`0xdaa10000` | CMA, 10 MiB | +| `log_bcm` | `0xdd610000`–`0xdda10000` | CMA, 4 MiB | +| `log_itmon` | `0xdda10000`–`0xdda20000` | CMA, 64 KiB | +| `cp_msi_rmem` | `0xf6200000`–`0xf6201000` | SWIOTLB, 4 KiB | + +There are consequently **sixteen**, not nine, stock static regions not +wholly covered by native static reserved-memory entries. Nine intersect +the earlier definition of unreserved RAM; six intersect CMA and one +intersects SWIOTLB. This identifies layout conflicts to investigate; it +does not establish that firmware currently accesses those addresses. + +The distinction follows the running kernel's +[CMA implementation](https://github.com/derekross/linux-omarchy-mobile/blob/29a7a9326bf064c7079396090c262271196b4a7b/mm/cma.c) +and [SWIOTLB implementation](https://github.com/derekross/linux-omarchy-mobile/blob/29a7a9326bf064c7079396090c262271196b4a7b/kernel/dma/swiotlb.c). +The stock debug consumer is Google's +[debug-snapshot driver](https://android.googlesource.com/kernel/google-modules/soc/gs/+/204078758737776959ecc85c527a00fd2cabb62f/drivers/soc/google/debug/debug-snapshot.c), +which acquires the described memory regions and initializes its enabled +buffers. That driver is absent from the native board's device tree. +The driver sources do not establish which firmware-only dump paths may +still run. Keep that uncertainty separate from Linux driver activity. + +## Consumer trace and disposition + +Reference sources are Google's GPL +[gs101 reservations](https://android.googlesource.com/kernel/devices/google/gs101/+/refs/tags/android-16.0.0_r0.9/dts/gs101-rmem.dtsi), +[SoC tree](https://android.googlesource.com/kernel/devices/google/gs101/+/refs/tags/android-16.0.0_r0.9/dts/gs101.dtsi) +and the consumers below. These Android 16 references have not been proved +identical to the phone's Android 17 firmware. Driver presence, handshake +requirements and a static DT cannot prove that a firmware agent is idle. + +| Candidate | Verified consumer or runtime fact | Disposition before a new image | +| --- | --- | --- | +| ECT | Stock `exynos-ect` references `ect_binary`; its GPL parser maps that reservation. The native live `/ect` has address `0x90000000`, size `0x34000`, although the built tree's node was empty. The stock static reservation is `0x3a000`. | Preserve boot-populated data in a proposed board reservation; check bounds against live properties. Do not read its payload or treat it as unused because the native parser is absent. | +| ABL | Both stock reference and built native DTB reserve 32 MiB at `0xf8800000`. The native live DT and early log reserve only 16 MiB at the same base. | Runtime contraction is observed; its purpose is unknown. A source-only size change can be overwritten again. Resolve the runtime contract or design an independently checked conservative reservation before claiming protection of the tail. | +| Suspend diagnostic page | Stock DT references the page from `pixel-suspend-diag`. In the inspected GPL driver, probe creates sysfs controls and the state is a static kernel object; no use of that `memory-region` was found there. | An unused property in this driver is not proof no other agent uses the page. Keep as an unresolved diagnostic ABI candidate or quarantine conservatively. | +| Ramoops | Stock node binds the standard ramoops backend, with 2 MiB console and 2 MiB pmsg storage. M1 has `CONFIG_PSTORE_RAM=y` but no ramoops DT node. | No active M1 ramoops backend is established. Reserving bytes and enabling a persistent-log writer are separate changes; importing the stock compatible would enable behavior. | +| CP IPC, RX, TX | Stock `cp_shmem` uses reservation indices 0, 2 and 3 for IPC, PKTPROC and PKTPROC_UL. IPC's described 4 MiB region is within an 8 MiB reservation. | No CPIF module is loaded in M1. This does not establish the physical CP state. A future modem stage needs explicit ownership of all four reservations, including MSI, before power/link changes. | +| Secure log | GPL probe maps the reserved buffer and passes address, size and interrupt to EL3 via `SMC_CMD_SEC_LOG_INFO`; the header defines eight 64 KiB buffers at `0xc3000000`. | Native driver/handshake absent; secure-world behavior without that handshake is not proved. Conservatively preserve the buffer or establish the firmware contract; do not infer inactivity from missing Linux logs. | +| xHCI DMA | Stock DWC3 references a fixed 4 MiB shared DMA pool; Google's xHCI allocator assigns it through reserved-memory operations. Native M1 uses USB peripheral mode without this pool reference. | Host/offload pool consumer is not established in M1. Any later host/offload change must revisit this region and the AoC relationship. Importing pool bindings is separate from excluding RAM. | +| Six snapshot buffers | GPL debug-snapshot maps and initializes enabled regions; all six stock addresses fall inside native CMA. | Resolve firmware ownership and allocator placement together. A normal iomem `reserved` child is insufficient evidence. No debug driver or firmware dump service should be enabled as a diagnostic shortcut. | +| CP MSI | Stock index 1 supplies the MSI page; the native default SWIOTLB pool includes that address. | Include this page in the CP memory policy. Verify any reservation change relocates SWIOTLB safely instead of assuming its old address stays valid. | + +Consumer references: + +- [ECT probe](https://android.googlesource.com/kernel/google-modules/soc/gs/+/204078758737776959ecc85c527a00fd2cabb62f/drivers/soc/google/ect_parser.c) +- [Suspend diagnostic driver](https://android.googlesource.com/kernel/google-modules/soc/gs/+/204078758737776959ecc85c527a00fd2cabb62f/drivers/soc/google/debug/pixel-suspend-diag.c) +- [Native ramoops implementation](https://github.com/derekross/linux-omarchy-mobile/blob/29a7a9326bf064c7079396090c262271196b4a7b/fs/pstore/ram.c) +- [Stock CP memory-region wiring](https://android.googlesource.com/kernel/devices/google/gs101/+/refs/tags/android-16.0.0_r0.9/dts/gs101-cp-s5200-sit.dtsi), + [CP shared-memory parser](https://android.googlesource.com/kernel/google-modules/radio/samsung/s5300/+/a8976934fe7f396627f9900958eb1457a74ebcca/shm_ipc.c), + [CP power control](https://android.googlesource.com/kernel/google-modules/radio/samsung/s5300/+/a8976934fe7f396627f9900958eb1457a74ebcca/modem_ctrl_s5100.c) +- [Secure-log handshake](https://android.googlesource.com/kernel/google-modules/soc/gs/+/204078758737776959ecc85c527a00fd2cabb62f/drivers/soc/google/exynos-seclog.c), + [buffer constants](https://android.googlesource.com/kernel/google-modules/soc/gs/+/204078758737776959ecc85c527a00fd2cabb62f/include/dt-bindings/soc/google/exynos-seclog.h) +- [xHCI pool declaration](https://android.googlesource.com/kernel/devices/google/gs101/+/refs/tags/android-16.0.0_r0.9/dts/gs101-dma-heap.dtsi), + [allocator](https://android.googlesource.com/kernel/google-modules/soc/gs/+/204078758737776959ecc85c527a00fd2cabb62f/drivers/usb/host/xhci-goog-dma.c) + +## Native duplicate and bootloader edits + +[V] The live tree contains both `debug-kinfo-reserved@fd3fe000` and +`debug_kinfo_reserved@fd3fe000`, each covering `[0xfd3fe000, 0xfd3ff000)`. +The former is in the built DTB; the latter is additional in the live tree. +The early kernel log explicitly reports their overlap. This is a duplicate +reservation of the same page, not evidence the page was allocatable. +The exact bootloader code which added it is not available in this audit. + +The recorded native twelve-entry exclusion result remains true, but it is +not a clean overlap check. A board-local naming fix must be compared with +the bootloader's actual injection behavior and keep the existing label's +consumers intact. Do not change shared gs101 behavior solely from bluejay. + +## Next offline work and Wi-Fi attribution + +The candidate below completes the initial offline proposal and build. +Its observed-bootloader projection is not a verified live result. Keep the +remaining runtime checks as gates, rather than treating the model as proof +of the next boot's layout. + +1. Choose and document retention versus conservative exclusion for every + candidate. Keep the five dynamic stock nodes separate. Do not add their + guessed boot addresses to a static map. +2. Design a board-only candidate which accounts for the observed ABL + contraction and duplicate debug-info node. State which runtime edits it + expects, and how a subsequent live capture would falsify that expectation. +3. Recompute CMA and SWIOTLB placement from the candidate reservations and + Linux's allocation rules, including DMA address limits. Check the kernel, + initrd, splash and other bootloader reservations as well as each other. + A reservation which intersects a current pool requires this analysis; + it must not be applied to the running kernel. +4. Build a memory-only image set in a new output directory, with no PCIe, + Wi-Fi, PMIC, display or rootfs enablement. Review the DTB changes and + schemas, then prepare an attended approval-gated boot and rollback. +5. Record before/after allocator placement in [WIFI-PLAN](WIFI-PLAN.md). + Memory changes can change future DMA addresses; that is a hypothesis + to measure, not an identified explanation of the 7a's failure. + +Reproduction, entirely offline: +`python3 ~/android/reference/bluejay-memory-audit-20261106/audit-memory.py`. +It reads the saved live and built DTBs, iomem, dmesg and original comparison; +its JSON receipt pins input hashes and checks the 12/11 native entries/ranges, +22 stock regions, 9 direct candidates, 6 CMA candidates, 1 SWIOTLB candidate, +16 incomplete static covers, ECT properties, ABL contraction and duplicate. +Raw DTs, source copies and receipts stay outside the public repository. + +Resumed read-only SSH at uptime 3484 seconds identified the same kernel and +boot ID as the handoff, zero loaded modules and an absent `/dev/sda`. +No new kernel patch, build, driver load, register access, reboot or flash +was performed during this audit. + +## 2026-11-06: conservative memory-only candidate M2 + +Worktree `~/android/mainline/wt-bluejay-memory-20261106`, branch +`omamobile-bluejay-memory-20261106`, base `29a7a9326bf0`; output +`~/android/mainline/out-bluejay-memory-20261106`. +Only `arch/arm64/boot/dts/exynos/google/gs101-bluejay.dts` is changed. +The M1 source tree/output and phone images have been preserved. + +All sixteen unresolved reference ranges receive independent board-local +exclusions, based on the consumer trace above. This chooses conservative +retention instead of asserting that absent Linux drivers make firmware +buffers reclaimable. About 109.86 MiB is withheld from ordinary Linux +allocation. The new nodes have `no-map` and no driver or DMA-pool compatible: +they do not start CPIF, secure logging, ramoops, xHCI offload or snapshot +collection. Any later consumer needs a separate mapping/ownership review. +The five dynamic Android pools are not added. + +The named ABL node is split into the observed 16 MiB prefix and an +independent 16 MiB tail exclusion. This preserves the full stock reference +extent without relying on ABL retaining the original node's 32 MiB size. +The debug-info node uses the underscore spelling observed live, while +retaining its shared source label. No other board's shared DTS is changed. +These choices predict specific runtime behavior; a different ABL edit or +another duplicate is a failed live gate. + +The ECT exclusion covers the stock static `0x3a000` size and the captured +live `0x34000` payload at `0x90000000`. A changed live address or a size +outside the reservation is a stop condition, not permission to inspect the +payload or enlarge a live reservation. + +### Allocator evidence and limits + +A host harness links the pinned kernel's actual `mm/memblock.c` through +its tools/testing headers, with address/undefined-behavior sanitizers. Slab +use and region-table growth abort instead of being simulated. The broader +upstream simulator build lacked liburcu; this is a focused allocation test, +not a claim that the full upstream test suite passed. + +Inputs are the saved RAM banks, static exclusions, FDT reservation map and +kernel/initrd/other boot allocations from the original capture. The +allocation order and constraints follow `arch/arm64/mm/init.c`, +`mm/cma.c`, `kernel/dma/contiguous.c` and `kernel/dma/swiotlb.c` at the +pinned base: CMA before SWIOTLB, low 32-bit RAM, full 384/64 MiB sizes, +4 MiB CMA alignment and 4 KiB SWIOTLB alignment. + +| Case | CMA, end exclusive | SWIOTLB, end exclusive | +| --- | --- | --- | +| M1 control reproduced | `0xc8000000`–`0xe0000000` | `0xf4800000`–`0xf8800000` | +| M2 with observed ABL insertions | `0x98000000`–`0xb0000000` | `0xf2200000`–`0xf6200000` | + +Both modeled M2 pools retain their full sizes below 4 GiB, with no +intersection with a proposed exclusion or captured boot allocation. All +22 stock static regions are covered. The built tree has 25 static entries; +adding only the observed `sec_pt` and `sec_dram` insertions projects 27 +distinct live entries and no duplicate debug page. No CMA base is pinned +in the DT or command line; the allocator remains free to choose safely. + +A deliberate negative case reserves a page at `0xa0000000` before pool +allocation. The model then cannot fit the full CMA pool: it reports +failure rather than overlapping the page. This demonstrates why new +bootloader placement cannot be assumed away. Live CMA failure, shrinkage +or an unexplained pool relocation must stop the test before driver work. +The harness does not emulate ABL, page-table construction or every early +allocation; the next live map is required evidence. + +Reproduce offline with +`python3 ~/android/reference/bluejay-memory-candidate-20261106/check-layout.py`. +The receipt pins source/DTB/input hashes. `preflight.py` checks the packed +images and initramfs. Private evidence remains in that directory. + +### Build and packed images + +`W=1 exynos/google/gs101-bluejay.dtb` completed without diagnostics. +Strict checkpatch reports zero errors, warnings or checks. Google board +schema and installed reserved-memory schema validation report no diagnostics; +this is not a full subsystem binding validation. The 24 storage-guard and +37 image-layout tests pass. + +The kernel C binary, modules within the initramfs, and compressed initramfs +are reused byte-for-byte from M1. No new C/module build is claimed. The +native kernel release therefore remains +`7.3.0-rc6-omamobile-push1-g29a7a9326bf0`; identify M2 by its DTB and +image hashes, not by `uname` alone. Packed B0 matches the built DTB's full +property tree; A0 differs only in its SoC ID. + +| Image | Bytes | SHA-256 | Change from M1 | +| --- | --- | --- | --- | +| `boot.img` | 67108864 | `38f185103449a2ff2a6204c064a8451de6c32e195df58cf337d40a4a2fd2636e` | identical | +| `vendor_boot.img` | 6819840 | `7dc6afd4d01b149121c3ca75406d4d5a5bc6b2d81ab9cb5e163d4946adde7930` | memory DTBs only | +| `dtbo.img` | 4096 | `72d5e0020cbdbfd6de6e2581f11c459e0b0aca0ded2acb616ae87ad49dc2144d` | identical | + +All fit the previously captured partition sizes. Boot's AVB footer and +rollback index remain unchanged. The packed init, four-name storage +allowlist and absence of MMIO/display/USB-switch hooks were checked again. +Images, source patch hash and validation receipt are pinned in +`out-bluejay-memory-20261106/preflight-validation.json`. + +### Attended test runbook — executed once with owner approval, results below + +1. **Identify the current environment, read-only; low risk.** On this + session's reconnect, host USB identifies Google's Pixel 6a interface, + serial-pinned ADB reports a bluejay transport, and shell requests return + `error: closed`. There is no native USB network. This does not establish + an Android boot, current slot or the reason for leaving Linux by itself. + The owner subsequently confirms Android setup/lock screen: stock has + booted and the original calibration backup is stale. Current slot and + the shutdown/reboot history remain unverified. Stop on an + unexpected identity, recovery error or ambiguity. Rollback: no action + for reads. Do not spend another boot to clarify a screen. +2. **Fastboot preflight, read-only; low risk.** Once the owner approves + entering fastboot, pin the saved private serial. Read `product`, + `version-bootloader`, `current-slot`, slot A/B successful/unbootable + flags and retry counts if supported, plus the three B partition sizes. + Require bluejay, the previously captured bootloader, stock A still + bootable/successful, and sizes matching the receipt. Stop on any + mismatch; unsupported retry queries are unknown, not zero. This step + does not activate a slot. Rollback: leave fastboot untouched. +3. **Approve the exact M2 set and one B boot; medium/high risk.** Re-run + local preflight and compare all three hashes. The proposed command is + `DEVICE=bluejay KERNEL_DIR=~/android/mainline/wt-bluejay-memory-20261106 KERNEL_OUT=~/android/mainline/out-bluejay-memory-20261106 bin/omamobile flash`, + from the mobile worktree, with `FASTBOOT_SERIAL` set privately from the + saved selection. The helper writes the three suffixed B images, + activates B and boots it. Ask before running it. No userdata, devinfo, + slot-success marker, firmware or protected-partition write is included. + Expect USB/SSH within a minute; logo refresh is still not enabled. + Stop if USB is absent after three minutes or a reset loop occurs; do + not repeat automatically. Rollback: owner-assisted fastboot, then a + separately approved baseline-image restore or stock-A boot. A previous + approval from the first-light session is not this approval. +4. **Capture the new boot before further work; read-only, low risk.** + Save compatible, release, boot ID, uptime, live FDT, iomem, dmesg, + module/binding state and storage guard into a new private directory. + Read back image prefixes and compare their hashes. Require unchanged + no-driver/no-Android-mount state, protected partitions read-only and + `/dev/sda` absent. Require all 22 stock static extents covered; 27 + distinct expected entries, ECT bounds and named ABL prefix/tail intact; + no reserved-memory overlap; and full-size CMA/SWIOTLB disjoint from + every exclusion and boot allocation. Investigate a new address rather + than accepting the model blindly. Stop on any failed gate. Rollback + requires the owner-approved recovery action from step 3. +5. **Refresh private backups if stock may have booted; read-only, low + risk.** Keep the original backups. Obtain a fresh verified set through + the guarded native environment before any radio, PMIC, AoC or Trusty + work. Record stock-boot uncertainty if it cannot be resolved; do not + treat old checksums as a current baseline. Stop on guard, size or + checksum failures; never relax read-only flags. Rollback: retain both + evidence sets without writing a partition. + + The public bluejay descriptor currently lacks `NV_PARTS`. A private + backup kit stages the unchanged project `nv-backup` / `phone-ssh` tools + and a descriptor listing the ten partitions verified in M1: six NV + regions plus stock A's three boot images and devinfo. Run the kit from + `~/android/reference/bluejay-memory-candidate-20261106/backup-kit/tools/nv-backup -d bluejay ` + only after guarded native SSH returns, followed by its `--check` mode. + It refuses missing, writable or mounted partitions. The staged list + does not change any boot image or the public device descriptor. + +Wi-Fi, display refresh, charging control and rootfs installation remain +separate tests. M2 is one bundled memory policy: a regression would require +an offline reduction before a later approved test, not attribution to one +reservation without evidence. + +### M2 live result, 2026-11-06 + +The owner approved the checks, exact image set and one B boot, live capture +and fresh read-only backups. Serial-pinned ADB rejected reboot with +`error: closed`; the owner entered Fastboot Mode with the buttons. +Fastboot reported the unchanged expected bootloader, A active/successful/ +bootable, B unsuccessful/not-unbootable with zero retries, and the expected +three partition sizes. No slot-success marker was written. The project +helper wrote the approved three B images, each OKAY, then activated/booted +B; helper exit 0, SSH first answered at uptime 2.57 seconds. + +The new live FDT has exactly the projected 27 distinct static reservations. +All 22 stock static extents are covered, ECT's actual `0x34000` bytes fit +inside its exclusion, the named ABL prefix and independent tail remain, +and the debug-info page appears once. There is no reserved-memory overlap. +The full 384 MiB CMA pool is at `[0x98000000, 0xb0000000)` and full 64 MiB +SWIOTLB at `[0xf2200000, 0xf6200000)`, exactly matching the checked model, +disjoint from the exclusions and captured boot allocations. No allocator +base was forced at boot. + +All three flashed image prefixes match their local hashes. The protected +partitions remain read-only, `/dev/sda` is absent, no Android partition is +mounted and no module is loaded. A fresh health read at uptime 303.58 seconds +identifies the same boot, with no panic, oops, UFS error-handler, I/O-error +or reserved-memory-overlap signature. These observations pass the narrow +memory-layout test, not subsystem or indefinite stability qualification. + +The first full-backup attempt encountered SSH connection timeouts. The log +shows recovery between them and all six NV copies verified before the +host stopped the remaining stock-image copies. USB did not disconnect in +the host log, and fresh SSH answered in the same native boot. The partial +copies and logs are retained. A second full attempt uses the same project +backup code with 2 MiB rather than 8 MiB host chunks; only its eventual +backup and independent check receipts can establish a completed fresh set. +Do not equate a retried connection with a kernel hang or attribute the +timeouts to M2 without a matched comparison. + +Private run/evidence: `~/android/reference/bluejay-m2-20261106T143907Z`, +including `authority.json`, `fastboot-gates.json`, flash log, readbacks, +live memory/guard validation, same-boot health and backup receipts. +This is the executed result for M2; older proposed/unapproved status text +in build receipts records their creation time rather than revoking approval. + +Final result: all ten partitions in the second full backup were copied, +size-checked and checksum-verified, and the independent `--check` reports +all ten SAME (both commands exit 0). The final native health read is the +same boot at uptime **1100.72 seconds**, with the guard intact, no modules +or Android mounts, and no panic/oops/UFS-handler/I/O-error/overlap signatures. +The copy recovered from 17 SSH connection timeouts; the independent check +had none. Smaller chunks therefore did not eliminate the observation. +The host recorded no USB reset/disconnect after native enumeration. + +The fresh verified backup is private at +`~/android/reference/bluejay-backup-post-stock-m2-small-20261106T144843Z`. +Old verified and interrupted copies are preserved; the interrupted directory +is explicitly marked INCOMPLETE. Four NV partitions differ from the pre-stock +set (`efs`, `efs_backup`, `modem_userdata`, `persist`), confirming that the +older set is not the current baseline. Nothing was restored or written to +those partitions. Keep this fresh set until another stock Android boot. + +The live-memory gate is complete for this image/boot. USB/SSH reliability +under bulk reads remains open before any driver bring-up. No second reboot, +slot-success mark, Wi-Fi load or other subsystem action followed. + +Later U1 read-only diagnostics reproduced a stall with `/dev/zero`, before +any partition read. Initial state was the same healthy M2 boot; after the +stall one bounded fresh SSH connection timed out and phone commands stopped. +Current execution state is unknown. See [USB-SSH-PLAN](USB-FIX-T6.md). +This does not reopen or invalidate the completed memory-layout result; +causal attribution remains unassigned without a matched control. Historical +backup logs count 47 failed chunk attempts alongside 17 timeout messages. +Subsequent U2/U3 checks establish the same M2 boot is alive: a network +stall was reproduced while all 30 serial status samples continued, without +new kernel errors. TX completion accounting paused while RX/IRQ progressed. +The exact network/bulk-path cause remains open; no M2 attribution follows. + +## Offline gate + +For each candidate, trace Google's GPL board/SoC sources and its actual +consumer: who reads or writes it, whether that agent can run without the +Linux driver, and whether ABL changes its location or size. Compare the +published gs101 tree and raven's notes, keeping board-specific differences. +Quote citable source facts only; vendor blobs and reconstructed DTBs remain +private. Keep the native twelve-region audit separate from this stock +reference comparison. + +Pass: every range has a sourced disposition, or a conservative board-only +reservation with its effect on existing pools checked. Stop: an unknown +firmware writer, an unaccounted runtime relocation, an overlap with a +live allocation, or an unsafe pool change. Leave hardware bring-up paused. +No phone mutation is needed for this gate; rollback is discarding only the +new local source change. Risk: low for offline analysis. + +If a new kernel/DTB is needed, build it in a separate output, run the +relevant validation and prepare an exact gated test and stock-A rollback. +Ask the owner before its flash/reboot. A request for stock live capture, +raw register access or a new driver load is a separate staged operation; +do not infer permission from the completed first-boot test. Keep private +calibration backups fresh after any later stock boot. diff --git a/device/bluejay/NOTES.md b/device/bluejay/NOTES.md index ff32e014e..0e804fbb2 100644 --- a/device/bluejay/NOTES.md +++ b/device/bluejay/NOTES.md @@ -1,7 +1,89 @@ # Pixel 6a (bluejay) bring-up notes -Findings for the Pixel 6a port, newest first. The port shares the Pixel 6 (oriole) and 6 Pro (raven) effort tracked in [issue #2](https://github.com/derekross/omarchy-mobile/issues/2). Facts are marked [V] (checked, with the source) or [I] (an inference to check on a phone or in the factory image). Nothing has been flashed or booted yet, and no 6a has been queried: every fact below comes from public GPL sources and Google's public factory image, read on the laptop. +## 2026-11-09: review split and slot-success audit (offline) + +The development source remains inspectable in [#543](https://github.com/derekross/omarchy-mobile/pull/543). +As of 2026-11-10, it is closed unmerged in favour of documentation +[#561](https://github.com/derekross/omarchy-mobile/pull/561), initramfs +[#562](https://github.com/derekross/omarchy-mobile/pull/562), installer +[#563](https://github.com/derekross/omarchy-mobile/pull/563) and bring-up +[#565](https://github.com/derekross/omarchy-mobile/pull/565). +The exact tested kernel is `c934e316b` in the contributor's +`bringup/bluejay-tested-20261108` branch; the revised [kernel topics #225 through #231](UPSTREAM.md#kernel-topics-in-review) are not a new hardware-qualified stack. This documentation submission +changes no package, descriptor, initramfs, startup service or phone. + +The 2026-11-08 saved dry-run and write logs identify the existing project's +`omamobile-bootctl mark-successful` helper, invoked through +`omamobile-boot-success`. They record devinfo layout 3.15's slot bytes: + +| State | Slot A, offsets 0x30–0x33 | Slot B, offsets 0x34–0x37 | +| --- | --- | --- | +| Before the write | `02 0a 00 00` | `01 04 00 00` | +| After the write | `02 0a 00 00` | `01 06 00 00` | + +Only offset `0x35` changed, `04` to `06`; the helper reported that all 8192 +bytes were read back and compared. A subsequent read-only check recorded the +partition and its whole disk read-only again. The automatic boot-success unit +was masked. A read-only devinfo backup made earlier that day is retained; its +slot bytes match the write log's before-state exactly. +The saved command output does not record a hash of the actual boot-control +executable, so the precise binary provenance is not established by those logs. + +This was an actual protected-data write and is not covered by the statement +that no radio NV/calibration was changed. Further gs101 slot marking is on +hold under [#252](https://github.com/derekross/omarchy-mobile/issues/252). +No slot write, reboot, hardware probe or fresh device backup was performed for +this offline revision. A fresh read-only backup and independent validation +remain required before further hardware work; do not restore the old devinfo +image or repeat the marking command. + +## 2026-11-08: persistent accelerated desktop and station Wi-Fi + +The Pixel 6a now boots Arch Linux ARM on userdata with systemd, USB SSH, +SDDM, Hyprland and Omarchy's Quickshell. Normal reboots automatically start +ALIX touch, retained simpledrm display refresh, BCM4389 station Wi-Fi and +Mali-G78/Panfrost rendering. The owner confirmed unlocking, opening apps and +scrolling normally. Kernel: `7.3.0-rc6-omamobile-bluejay-input-gated0`. + +| Subsystem | Verified result | Limit | +| --- | --- | --- | +| Boot/storage | Slot B, persistent ext4 root, 49-partition read-only guard, root expanded to 109 GiB | Development overlay; not a release installer | +| USB | NCM SSH and ACM; aggregation timer retries a full TX request pool | Replug/suspend not qualified | +| Touch | ALIX 36:48, one/two-finger motion and release, all four edge zones; zero SPI errors/timeouts | Polling; no firmware or calibration writes | +| Display | 1080x2400 retained simpledrm, approximately 60 Hz, actual desktop frames | No native DSI/panel modesetting | +| GPU | Mali-G78 MC20, GLES 3.1, Panfrost render node, correct clear/solid/blended pixels through 1024x1024 | 151 MHz shader point; no Vulkan/full DVFS qualification | +| Wi-Fi | BCM4389/3, NetworkManager association/reconnect, wireless-bound HTTPS with TLS verification | Station only; P2P, hotspot, roaming and suspend untested | +| Keys | Both volume press/release pairs | Power release remains unresolved | + +The platform changes are still development source. They are not in a +published release kernel, and the installed root contains manually staged +matching modules, privately extracted firmware and a patched Aquamarine +library. Do not treat this PR as a downloadable ready-to-flash distribution. +See [UPSTREAM.md](UPSTREAM.md) for source dependencies and reproduction gaps, +[PERSISTENCE-PLAN](PERSISTENCE-PLAN.md) for recovery/startup, and +[GPU-PLAN](GPU-PLAN.md) for GPU qualification. + +The initial GPU probe deferred because `clk_acpm` was missing; its bounded +service requested an orderly reboot. Adding the exact matching module and +holding the unrelated `cpufreq-dt` consumer allowed the probe and rendering +tests to pass. Startup now has durable failure markers, deadlines and a +software-rendering fallback. No automatic boot-image or boot-success writer +is enabled. Existing backups were retained; no bootloader, radio NV or +calibration data was modified by the Linux bring-up. + +A later submission smoke test found the development root lacked its FUSE +module. Adding the matching module repaired `xdg-document-portal`. The smoke +report still discloses the inherited early trace-format warning and the +expected `-ECANCELED` USI hold before manual initialization. Audio, modem, +Bluetooth, battery/charging, sensors, cameras and suspend are not qualified. + + +The Pixel 6a's tracking thread is [#348](https://github.com/derekross/omarchy-mobile/issues/348). +The earlier shared GS101 effort is [#2](https://github.com/derekross/omarchy-mobile/issues/2). +Facts are marked [V] (checked, with a source) or [I] (inferred). +The dated stage-0 entries below predate the first phone boot and describe +what was known from public GPL sources and the factory image at that time. Sources: diff --git a/device/bluejay/PERSISTENCE-PLAN.md b/device/bluejay/PERSISTENCE-PLAN.md new file mode 100644 index 000000000..34334f324 --- /dev/null +++ b/device/bluejay/PERSISTENCE-PLAN.md @@ -0,0 +1,82 @@ + +# Bluejay persistent desktop integration + +Status (2026-11-08): verified persistent Arch Linux ARM on userdata. Normal +reboots automatically start USB SSH, polling ALIX touch, retained display +refresh, NetworkManager station Wi-Fi and Panfrost-backed Hyprland/Quickshell. +The owner confirmed unlock, app launch and scrolling. See [UPSTREAM.md](UPSTREAM.md) +for the tested source and the remaining release-packaging work. + +## Root handover + +The init checks the ext4 label `omamobile-root` before repair or a writable +mount. Only e2fsck results 0 and 1 continue. The explicit +`persistent-development` selector skips early filesystem growth, writes a +root-pending marker before handing over to systemd, and holds in the RAM rescue +environment after an incomplete boot. The installed USB SSH-ready service clears +that marker. The actual root was expanded online after persistent boot passed. + +A development selector with an unknown value stays in RAM. The earlier RAM-only +qualification harness and its private control protocol are not installed by +this integration. The host's private qualification artifacts remain retained. + +## Guarded startup + +The package keeps drivers blacklisted and starts them through bounded services +after SSH is available. Each subsystem has a durable pending marker and a +volatile ready marker. A failed attempt remains held after reset; hardware +startup never loops through unload/rebind retries. Systemd owns watchdog0 at +20 seconds. Touch/display startup has a 25-second deadline, Wi-Fi 45 seconds +and GPU 30 seconds, with five-second stop deadlines. + +SDDM waits for the hardware and GPU units. GPU initialization requires an +explicit `/etc/omamobile/bluejay-gpu-enable`. A held GPU leaves its ready marker +absent, and the session environment falls back to llvmpipe/software rendering. +The GPU's ACPM clock provider is registered only after holding the unrelated +`cpufreq-dt` consumer; CPU DVFS has not been qualified. + +The package ships no automatic boot-success writer and sets `AUTO_WRITE=no`. +The installer must retain the descriptor's `BOOT_UPDATE_AUTO_WRITE=no` policy. +The existing project helper marked B successful once after the installed +system passed its original fresh-boot test. The boot-control write changed devinfo; its eight-byte before/after table +and the limits of the saved tool provenance are recorded in [NOTES](NOTES.md). +Further gs101 marking is on hold; no automatic marking service is shipped. + +## Reproduction and recovery gates + +1. Build the exact kernel source, module closure, device package and root in an + isolated output directory. Inspect the actual packed images, both DT variants, + module release/provenance, blacklists and automatic-write policy. Stop on an + unexpected difference. This is offline and changes no phone. +2. Retain a host-held RAM rescue image set. The persistent selector automatically + enters the installed root, so it is not a RAM rescue image. Use only the + project's serial-pinned B-image helper and `tools/install-phone` for userdata. + These steps replace the OS and require the owner's authorization. +3. Install after the actual installer dry run, with account secrets entered + locally. Expect USB SSH, Arch PID 1, the 49-partition storage guard and the + subsystem ready markers. Stop if transport or the guard fails. Never restore + NV/calibration as a recovery shortcut. +4. Test one normal reboot and actual unlock/app use. Confirm matching kernel and + modules, Panfrost rendering, Wi-Fi-bound TLS traffic, no new hardware faults + and no pending markers. Buttons/Fastboot plus the retained RAM images are the + recovery path if the device does not return. + +The development handset's owner accepted loss of Android/userdata and retained +existing backups. That acceptance is specific to this test phone. Other owners +must use the project's own installation and recovery policy. + +Native panel modesetting, full GPU/CPU DVFS, Power-key release, audio, modem, +Bluetooth, battery/charging, sensors, cameras and suspend remain unfinished. + +## Review split, 2026-11-09 + +The tested implementation above is historical development evidence, not an +installed-package claim. Its code remains inspectable at the immutable #543 +source linked in [UPSTREAM.md](UPSTREAM.md). The separate initramfs, installer +and bring-up changes are under review as #562, #563 and #565; passive-package +coordination with #346 remains pending. The neutral +initramfs proposal uses descriptor settings and `root-boot-pending`; the tested +Bluejay helper used `bluejay-root-pending`. Those paths must not be mixed. +No revised source has been booted. The shared no-USB crash is disabled only +by an explicit descriptor choice: a development phone may boot without a +host, and RAM rescue must stay reachable without consuming boot retries. diff --git a/device/bluejay/TOUCH-PLAN.md b/device/bluejay/TOUCH-PLAN.md new file mode 100644 index 000000000..6d4742b2e --- /dev/null +++ b/device/bluejay/TOUCH-PLAN.md @@ -0,0 +1,52 @@ + +# Bluejay ALIX touch + +Status (2026-11-08): polling ALIX input works in the installed Omarchy session, +automatically after reboot, on `7.3.0-rc6-omamobile-bluejay-input-gated0`. +Single/two-finger motion, complete contact release and all four edge zones were +observed. SPI errors and timeouts remain zero. Volume press/release pairs passed; +Power release is unresolved. No interrupt-driven touch or suspend claim. + +## Sources and implementation + +Google's Bluejay touch DT selects ALIX chip ID 36:48 on SPI11/USI11. The existing +SALIXP profile accepts 36:40. Keep separate match data rather than accepting both +IDs without board-specific initialization. + +The GPL references are Google's `kernel/google-modules/touch/fts_touch` at +`2a0089b3c7b9f1f1dbb52a1460a26621e50f61cf` and touch/common at +`340d76ec988f2960427647e9ac4852f072a86c88`, plus the Bluejay/GS101 DTS at +`android-16.0.0_r0.9`. ALIX shares the register/framebuffer/FIFO read protocol and +scan command. Its flash programming differences are irrelevant to this driver: +no firmware update, calibration, production test or repair command is sent. + +The active-low AP request/acknowledgment pair is acquired before reset, power or +SPI. The acknowledgment deadline is 500 ms. The existing CRC, AFE/MP, firmware +ready and scan-echo gates remain enforced. No AoC startup or attention IRQ is +needed for the polling path. + +Wiring: USI11 at 0x10d400c0, SPI11 at 0x10d40000, bus/CS gpp23, reset gpp26-0, +attention gpa9-0, AP request gpp26-1 and acknowledgment gpa8-6. Supplies are +S2MPG10 LDO25M/LDO26M. The kernel DT leaves all three path nodes disabled. + +## Gates and recovery + +`alix_stage` is read-only after load: 0 discovers resources, 1 checks identity, +2 checks CRC/system information and 3 starts input. Higher values fail before +hardware. SALIXP retains its existing full-input behavior. Optional +`exynos_usi.probe_hold_base=0x10d400c0` prevents just this controller from +configuring hardware until the guarded service clears the hold and binds it. +Other already-enabled USIs remain unchanged. + +Qualify controller creation, SPI/resources, identity, read-only firmware state +and sensing on separate bounded attempts. Stream logs before loading drivers, +require the owned watchdog and stop on an unexpected ID, missing acknowledgment, +CRC/firmware repair condition or SPI fault. Do not unload/rebind to retry. +Recover through the next guarded boot or retained B RAM images. + +The final polling capture contained 1,133 evdev records, 288 frames, three +contacts begun/released and two simultaneous contacts, positive pressure and +all slots released. Later edge/volume feedback passed, followed by actual +Hyprland unlock/app/scroll use. No raw touch or screen capture ran during local +PIN entry. Startup is in the device package; [PERSISTENCE-PLAN](PERSISTENCE-PLAN.md) +describes its failure hold and deadlines. diff --git a/device/bluejay/UPSTREAM.md b/device/bluejay/UPSTREAM.md new file mode 100644 index 000000000..53aae8fea --- /dev/null +++ b/device/bluejay/UPSTREAM.md @@ -0,0 +1,65 @@ + +# Bluejay development source and review status + +Status (2026-11-10): documentation split from [#543](https://github.com/derekross/omarchy-mobile/pull/543), now closed unmerged in favour of the split PRs below. +The historical source below demonstrates one working development handset; it +is not a release installer. No code or device descriptor is changed by this +PR. Source-only instructions are not authority to run a phone operation. + +## Kernel topics in review + +| Topic | PR | Remaining work | +| --- | --- | --- | +| NCM aggregation retry | [#225](https://github.com/derekross/linux-omarchy-mobile/pull/225) | Suspend handling revised; separate selftests and validate on the reference phone, including laptop sleep | +| Retained-memory exclusions | [#226](https://github.com/derekross/linux-omarchy-mobile/pull/226) | Provenance and node naming addressed; passing CI, awaiting maintainer merge | +| GS101 PCIe/PHY | [#227](https://github.com/derekross/linux-omarchy-mobile/pull/227) | Power control and match data revised; explain single link try/history suppression and qualify a fresh 6a boot | +| BCM4389 bring-up | [#228](https://github.com/derekross/linux-omarchy-mobile/pull/228) | Cache DMA-size limit at probe, count size drops and keep chip-only bring-up separate | +| ALIX touch | [#229](https://github.com/derekross/linux-omarchy-mobile/pull/229) | Staging knobs removed; check reset-order header and qualify a fresh 6a boot | +| Disabled Wi-Fi DT | [#230](https://github.com/derekross/linux-omarchy-mobile/pull/230) | Merge after both #227 and #228, then rebase to its own two commits | +| Trusty trace API | [#231](https://github.com/derekross/linux-omarchy-mobile/pull/231) | Merged 2026-11-09; no Trusty runtime claimed | + +All seven submitted heads passed CI. That is build/policy evidence, not +runtime qualification of the rebased stack. The tested source is the +contributor's `bringup/bluejay-tested-20261108`, commit `c934e316b`, based on +`29a7a9326bf0`; the tested release is +`7.3.0-rc6-omamobile-bluejay-input-gated0`. + +## Separate changes + +The initramfs and installer changes affect every device and are submitted +separately as [#562](https://github.com/derekross/omarchy-mobile/pull/562) and +[#563](https://github.com/derekross/omarchy-mobile/pull/563), with existing +descriptors retaining their behavior unless explicitly opted in. Historical +startup is submitted in [#565](https://github.com/derekross/omarchy-mobile/pull/565), +which follows #562 for its matching root-ready marker. The planned +Bluejay package builds on the passive first-light proposal [#346](https://github.com/derekross/omarchy-mobile/pull/346). +Kernel-release pins, module hashes and experimental startup belong in +`device/bluejay/bringup/` until their dependencies merge. No combined package +agreement with #346's author or new phone qualification is claimed here. + +The tested overlays, startup files, Aquamarine patch and probe tools remain +inspectable at [the immutable #543 source](https://github.com/latentoperator/omarchy-mobile/tree/6ad4651f8ac151333345c72db99f1fd83259696f). +The subsystem plans describe them historically; their relative file paths do +not imply that this documentation-only PR installs those files. The original +#543 is closed unmerged in favour of documentation [#561](https://github.com/derekross/omarchy-mobile/pull/561), +initramfs #562, installer #563 and bring-up #565. + +## Tested desktop dependencies and limits + +The development root used matching manually staged modules, the owner's +privately extracted firmware and Aquamarine 0.16.0 patched to support the +retained simpledrm output with a separate Panfrost renderer. The package +database reported device-bluejay 0.1.1, with later files staged directly. +It did not run an installed release package matching #543's 0.1.3 label. +No firmware, device addresses, credentials, captures or binaries are published. + +The owner verified unlock, app launch and scrolling. Polling touch, station +Wi-Fi reconnect/TLS and Panfrost rendering at 151 MHz passed on that handset. +Native panel modesetting, Power-key release, full DVFS, Vulkan, Wi-Fi hotspot, +roaming/suspend, audio, modem, Bluetooth, battery monitoring/charging, sensors, +cameras and suspend remain unqualified. Native display, Bluetooth, battery +monitoring and torch are owner priorities, not working-feature claims. + +Before any new phone run, follow the subsystem's gated runbook, confirm the +actual device state read-only, and take/validate the required fresh backups. +Further gs101 slot-success writes are on hold; see [NOTES](NOTES.md). diff --git a/device/bluejay/USB-FIX-T6.md b/device/bluejay/USB-FIX-T6.md new file mode 100644 index 000000000..ed259ec77 --- /dev/null +++ b/device/bluejay/USB-FIX-T6.md @@ -0,0 +1,146 @@ + +# Pixel 6a: NCM flush retry fix + +Status (2026-11-06): flashed and live gates passed; matched fixed-image trace +passes all 16 transfers and confirms retry at a full request pool. Broader +read-only transfer and backup qualification also passed under standing +project authority. Wi-Fi/display/input and desktop installation remain pending. + +## Evidence and change + +T5's corrected generic USB trace has no loss, all 35 serial samples and a +working ACM positive control. All 361 NCM requests complete successfully. +At the final flush timer expiry the ten-request pool is full; the first +request returns four microseconds later, all ten within 3.182 ms. These +events occur in the same CPU/task, with no reconstruction anomalies. +Normal network submissions continue returning success, but no new flush +timer or NCM USB request follows. The buffered tail is stranded. + +The pinned `ncm_tx_timeout()` invokes `ndo_start_xmit(NULL, netdev)` and +ignores `NETDEV_TX_BUSY`, returning `HRTIMER_NORESTART`. The gether path +returns BUSY when no request is free; its ordinary queue wakeup cannot +resubmit NCM's internal aggregation buffer. This matches the observed +loss of progress, while serial and USB completions remain responsive. + +T6 changes only the callback's BUSY handling: forward by the existing +300 microsecond interval and return `HRTIMER_RESTART`. Success and null +netdev still stop. Each invocation returns promptly; this is not a +synchronous polling loop. Existing unbind cancellation remains intact. +Matched fixed-image validation below now exercises this retry path. + +The DWC3 request-name metadata defect is separate. T5 uses existing generic +gadget events that copy their names; no trace-header patch is bundled here. +The earlier spontaneous USB disconnects also remain separate observations, +not automatically explained by this network aggregation bug. + +## Exact candidate + +Base `29a7a9326bf064c7079396090c262271196b4a7b`, branch +`omamobile-bluejay-usbfix-20261106`, worktree +`~/android/mainline/wt-bluejay-usbfix-20261106`, output +`~/android/mainline/out-bluejay-usbfix-20261106`. +Release `7.3.0-rc6-omamobile-usbfix1`. + +The config differs from T4 only in its release suffix. Exact T4 initramfs, +DTB, DTBO and guard retained, including no deliberate no-USB panic/fallback. +No new driver, memory policy, GPIO, firmware or Wi-Fi change. + +| Image | Bytes | SHA-256 | +| --- | ---: | --- | +| boot.img | 67108864 | `798d6276b8afb82333b617adc29726b520f632512e73a44f45300d7de00a3b2c` | +| vendor_boot.img | 6819840 | `44caeba83b30f2a5d619d0a32928468bc85e0a30a0e1f716fb837fa345afbb0d` | +| dtbo.img | 4096 | `72d5e0020cbdbfd6de6e2581f11c459e0b0aca0ded2acb616ae87ad49dc2144d` | + +Actual callback-body host tests pass success, repeated BUSY then success, +and null-netdev handling. The pinned control callback stops on BUSY; the +fixed callback schedules one existing-interval retry per BUSY result. +This is a function-level test with stubs, not full USB integration. + +Strict checkpatch clean. W=1 Image.gz/bluejay DTB builds without errors, +1,143 warning lines retained, not warning-free. Image/AVB/payload preflight +passes. Guard/layout results are inherited from exact T4 init/helper inputs; +limited DT schemas only, because DTB bytes match. No full-schema claim. + +## Staged validation + +Private exact runbook, source patch, tests, hashes and scripts: +`~/android/reference/bluejay-usbfix-candidate-20261106/`. + +Fresh read-only T4 prestate, then owner-assisted fastboot entry and +serial-pinned identity/bootloader/A-recovery/slot/size gates. One invocation +of the project helper writes only the three B images and boots once. Keep +the preserved M2/T4 sets; no slot-success or protected write. The temporary +host access rule should grant the recreated ACM node automatically; verify it. + +After boot, bounded ACM image-prefix hashes, guard and memory validation +must pass before tracing. Require 27 reservations/all 22 stock extents, +full CMA/SWIOTLB pools, no overlap/fatal logs, no modules or Android mounts, +and `/dev/sda` absent. Stop on any mismatch; do not force allocator addresses. + +Then run the matched T5 trace profile on the fixed image: max 16 × 2 MiB +zero chunks, 20 s transfer stage, 35 serial samples, bounded ring and host +capture, first failure stops traffic. Require zero loss and positive ACM +control; inspect full-pool timer expiry followed by retry/queue progress. + +If that passes, qualify without active tracing: fresh 128 MiB zero stream +and 64 × 2 MiB shared chunks with an independent serial observer, followed +by guarded UFS bulk reads into a new private backup and independent check. +Require zero failures/retries, exact sizes/hashes, final guard/health and +host USB continuity. A first-failure host gate prevents tool retries from +masking errors. All original backups and incomplete evidence stay preserved. + +Risk: new-kernel boot medium/high; bounded existing-path traffic afterward. +No new driver, radio, raw register access or rootfs install. B stays unmarked +by us; no watchdog or intentional fallback loop. Stop on failed gates, serial +loss, reset loop or new kernel/storage error. No blind repeat. Recovery uses +owner-assisted fastboot and the exact preserved T4 set with fresh gates, +recorded separately under standing authority. Avoid stock A unless needed; +a stock boot requires fresh calibration backups before subsystem work. + +Preserve the Pixel 7a comparison. A common USB transport fix is not evidence +about its Qualcomm firmware/BHI failure or bluejay's untested Broadcom path. + +## Hardware results + +One serial-pinned project-helper flash wrote the three B images and booted +`7.3.0-rc6-omamobile-usbfix1`. Read-only ACM capture matches all three image +prefixes, all 49 guard flags and M2 memory geometry: 27 distinct regions, all +22 stock extents covered, full disjoint CMA/SWIOTLB pools. No modules or +Android mounts, no fatal kernel signatures. Slot B remains unmarked by us. + +Matched capture: all 16 × 2 MiB transfers have exact sizes/hashes; all 35 +serial samples, zero ring loss, ACM positive control. All 2,749 NCM queues +return full length successfully; no reconstruction anomalies or unmatched +requests. The ten-request pool is full at 216 timer entries; 215 have an +immediate core ABS rearm, including six that expire again before another +timer start. The core enqueues HRTIMER_RESTART as ABS; ordinary NCM starts +use REL|SOFT. This directly observes the repaired callback path and continued +queue progress under the condition that stranded the control. Two ordinary +network BUSY results are handled without transfer failure. One full-pool +entry has no immediate rearm, so the count is not claimed as 216 BUSY results. + +Private evidence: `bluejay-t6-20261106T182004Z/causal-validation.json`, +`trace/trace-integrity.json`, chronology and original serial capture. +The first offline analysis incorrectly expected no hrtimer_start event on +core restart; the pinned core emits ABS start on restart. Corrected source +backed analysis is preserved with the original failed attempt; no extra +hardware capture was needed. Historical spontaneous disconnects remain +unqualified by this matched result. + +Broader untraced test: one fresh 128 MiB stream plus 64 shared 2 MiB +chunks, 256 MiB total, all exact sizes/hashes and no failed requests. All +60 serial samples, unchanged 49 guard flags, no modules/Android mounts or +fatal signatures. Fresh ten-partition UFS backup with the original 8 MiB +chunk/shared-SSH profile copies 629 MiB without retry or timeout; separate +fresh-session independent check reports all ten SAME. Local hashes also +pass, and all ten match the preserved M2 backup, including stock A images. +The first-failure gate never latched. Original backups remain untouched. + +Final same-boot ACM recheck at 445.87 s repeats all three image-prefix +hashes, storage guard and full memory gates successfully. Host kernel +journal has no entries after the initial boot enumeration through the +qualification window. No extra reboot, slot-success mark, driver load or +Wi-Fi operation. This qualifies the observed workbench transfer profiles; +it does not establish indefinite stability or explain earlier spontaneous +disconnects. Next gate is the pinned gs101 Wi-Fi source/board/firmware port +review before any PCIe or WLAN driver probe. diff --git a/device/bluejay/WIFI-PLAN.md b/device/bluejay/WIFI-PLAN.md new file mode 100644 index 000000000..8f0e7df08 --- /dev/null +++ b/device/bluejay/WIFI-PLAN.md @@ -0,0 +1,57 @@ + +# Bluejay station Wi-Fi + +Status (2026-11-08): BCM4389 revision 3 station Wi-Fi initializes and reconnects +automatically in the installed Arch/Omarchy desktop. NetworkManager owns +association, DHCP and DNS. Fresh boots passed wireless-interface-bound HTTPS +with certificate verification. No P2P, hotspot, roaming/endurance or suspend claim. + +## Kernel dependencies + +The tested source adds the GS101 PCIe1 controller/PHY variant, Bluejay supply +and GPIO wiring, a restricted DMA pool and the brcmfmac board path. The PHY +calibration table comes from Google's GPL `pcie-exynos-gs101-rc-cal.c` at +`204078758737776959ecc85c527a00fd2cabb62f`. GS201-only CMU holes and TCXO paths +must not be touched on GS101. + +The enabled pool is 64 MiB at 0xc4000000, below 4 GiB and separate from the +retained firmware/CMA/SWIOTLB reservations. The driver verifies the exact DMA +attachment before bus mastering, bounds packet/index geometry and obtains the +provisioned MAC from ABL's `/chosen/config/wlan_mac1`, without copying it into +source. The current work also retains an identification-only diagnostic gate. + +The kernel board source leaves the new path disabled. Apply `wifi-pool`, +`wifi-controller`, `wifi-endpoint` and `wifi-intx` in that order for the qualified +configuration. The last overlay matters: the parent's PCI INTx specifiers are +1 through 4, not 0 through 3. The qualified image proved IRQ delivery before +association; an interface node alone was not treated as success. + +## Firmware and startup + +Use only the owner's own matching stock files, never another handset's data: +`bcmdhd4389.bin` becomes `brcmfmac4389c1-pcie.bin`, +`bcmdhd.cal` becomes `brcmfmac4389c1-pcie.google,gs101-bluejay.txt`, and +`bcmdhd_clm.blob_ROW` becomes +`brcmfmac4389c1-pcie.google,gs101-bluejay.clm_blob` under `/usr/lib/firmware/brcm`. +Firmware, hashes, network names and credentials are not redistributed. + +The device package starts only after USB rescue and the tested hardware path. +It holds the endpoint while the PHY/controller and brcmfmac/WCC modules are +loaded, then binds once. `feature_disable=16` masks BRCMF_FEAT_P2P in the pinned +kernel so NetworkManager does not request the unqualified P2P-device path. +A root-only NetworkManager profile supplies the user's own credentials. +USB stays unmanaged by NetworkManager. + +## Gates and recovery + +Check reserved memory, disabled DT nodes, exact matching modules/firmware and +USB transport before the first probe. Stream logs, require the watchdog and +qualify pool, controller, link, chip identity, firmware/IRQ and station traffic +in bounded stages. Stop on DMA geometry mismatch, loss of transport, firmware +control failure or new faults. Never unload/rebind to retry or restore NV data. +The installed startup's persisted marker and 45-second deadline leave a failed +radio held on the next boot, with USB available for diagnosis. + +The current kernel is `7.3.0-rc6-omamobile-bluejay-input-gated0`; the tested +source is linked from [UPSTREAM.md](UPSTREAM.md). The phone uses dynamic interface +naming; read `/run/omamobile-bluejay-wifi-interface` rather than assuming wlan0. diff --git a/docs/DEVICES.md b/docs/DEVICES.md index 35da976d8..52c6674cf 100644 --- a/docs/DEVICES.md +++ b/docs/DEVICES.md @@ -71,7 +71,7 @@ Devices we'd like to support, with the closest starting point. Open an issue to | Pixel Tablet | tangorpro | gs201 | as panther; no modem | | Pixel 6 | oriole | gs101 | **WIP, community port: [#2](https://github.com/derekross/omarchy-mobile/issues/2)**; our preferred second device. Upstream mainline `gs101-oriole.dts` | | Pixel 6 Pro | raven | gs101 | upstream mainline `gs101-raven.dts`; shares oriole's port ([#2](https://github.com/derekross/omarchy-mobile/issues/2)). Boots our kernel from slot B to Omarchy's Hyprland on the Mali-G78 ([kernel #2](https://github.com/derekross/linux-omarchy-mobile/pull/2), [#3](https://github.com/derekross/linux-omarchy-mobile/pull/3)); its device package and plans ([#41](https://github.com/derekross/omarchy-mobile/pull/41)) and provisioning tools ([#22](https://github.com/derekross/omarchy-mobile/pull/22)) are merged | -| Pixel 6a | bluejay | gs101 | **WIP, community port: [#2](https://github.com/derekross/omarchy-mobile/issues/2)**; stage 0 facts from Google's GPL bluejay tree, no phone yet ([notes](../device/bluejay/NOTES.md)); its first-light board DTS (`gs101-bluejay.dts`, [kernel #179](https://github.com/derekross/linux-omarchy-mobile/pull/179)) is merged into the published kernel but not yet booted on a 6a; shares oriole's port | +| Pixel 6a | bluejay | gs101 | **WIP, community port: [#348](https://github.com/derekross/omarchy-mobile/issues/348)**; persistent Arch/Omarchy desktop on a development kernel ([notes](../device/bluejay/NOTES.md)); polling touch ([kernel #229](https://github.com/derekross/linux-omarchy-mobile/pull/229)), station Wi-Fi ([#227](https://github.com/derekross/linux-omarchy-mobile/pull/227), [#228](https://github.com/derekross/linux-omarchy-mobile/pull/228), [#230](https://github.com/derekross/linux-omarchy-mobile/pull/230)) and Panfrost GPU are development-kernel results, not release support; display is retained simpledrm, native panel modesetting unqualified; source/reproduction limits in [UPSTREAM](../device/bluejay/UPSTREAM.md) | | Pixel 8, 8 Pro, 8a | shiba, husky, akita | zuma (Tensor G3) | **WIP, community port: [#1](https://github.com/derekross/omarchy-mobile/issues/1)**. 8 Pro (husky): WIP, in the matrix above; its device package and UFS plan are merged ([#42](https://github.com/derekross/omarchy-mobile/pull/42)), and its bootloader picks the base DTB by `/soc_compatible`, not `/soc_id`. 8a (akita): stage 0 stock facts and a descriptor from a retail phone ([notes](../device/akita/NOTES.md)); this phone's bootloader picks the IPOP base DTB where husky's picks FOPLP. WIP, in the matrix above: the first-light board file is merged ([kernel #192](https://github.com/derekross/linux-omarchy-mobile/pull/192)) and boots from slot B with USB networking, SSH and the framebuffer console ([BRINGUP-M1](../device/akita/BRINGUP-M1.md)); UFS is merged too ([kernel #206](https://github.com/derekross/linux-omarchy-mobile/pull/206)), and the device package with its storage plan is in review ([#456](https://github.com/derekross/omarchy-mobile/pull/456)) | | Pixel 9 family | tokay, caiman, komodo, comet, tegu | zumapro (Tensor G4) | 9a (tegu): in the matrix above; its SoC and board device tree is merged ([kernel #81](https://github.com/derekross/linux-omarchy-mobile/pull/81)), with the rest of its kernel work merging into linux-omarchy-mobile; tracking [#28](https://github.com/derekross/omarchy-mobile/issues/28) | | Pixel 10 family | mustang (10 Pro XL) | laguna (Tensor G5) | 10 Pro XL (mustang): stage 0 stock facts ([notes](../device/mustang/NOTES.md)), contributors welcome ([#18](https://github.com/derekross/omarchy-mobile/issues/18)) |