86-autophi-safety-drivers

Description

AutoPhi Project 86 — ReasonPhi: The Prodigal Safety Driver

Version: 1.0.0 (Permanent — inherits the WonderPhi version covenant; shall never be updated)

Date: 2026-08-29

License: Proprietary — All rights reserved. IP is retained, never assigned. The buyer receives a blueprint and the right to build; the creator retains everything else.

AutoPhi Project 86, codenamed "ReasonPhi — The Prodigal Safety Driver," is a complete, multi-layer safety driver package for controlling both AutoPhi-native and third-party (foreign) integrated circuits across any bus topology. It is, in the author's words, "the theory of a chip not exploding." The package spans firmware (freestanding C targeting AutoPhi hardware), host-side software (POSIX C with full transport abstraction), and synthesisable Verilog RTL for hardware-accelerated key exchange — all governed by two immutable legal documents compiled into every binary: the 10 Commandments (received law inherited whole from the WonderPhi Universal Permanent Driver, version 1.0.0 forever) and a 7-Article Constitution modelled on the Constitution of the United States of 1787, with no amendments and no amendment process.

WonderPhi is the father: it established the 10 Commandments and drives the 142 AutoPhi IC designs exclusively. The Prodigal is the son who leaves home. It carries the father's heritage key ( 0x50484921 — "PHI!" in ASCII) into the world and drives other people's hardware safely, applying the same discipline the Commandments require for native silicon. When the Prodigal encounters an AutoPhi IC on the bus, the keys match, the homecoming handshake completes, and the full native WonderPhi driver stack unlocks — a one-way promotion from foreign mode to native mode. The son comes home.

Every read, every write, and every probe passes through a 10-step safety gauntlet before any data moves: (1) constitution integrity check, (2) thermal check, (3) voltage check, (4) current check, (5) transfer-size check, (6) OTP/fuse protection check, (7) bus lock acquisition, (8) the actual I/O operation, (9) device-health update with graceful degradation tracking, and (10) immutable audit-log entry. Ten steps — like the Commandments. Not a coincidence.

Inherited whole from WonderPhi. Nobody amends the Commandments — not this driver, not the Constitution, not anyone. They are carried, not edited. Enforced at compile time via _Static_assert .

II No other gods Exclusive lock ( 0xDEADC0DE ); max 1 instance COMMANDMENT_NO_OTHER_DRIVERS 0x00000002

III Not in vain Every command validated; magic 0xA5A5A5A5 ; size 4–4096 bytes COMMANDMENT_VALID_COMMANDS_ONLY 0x00000003

IV Remember the Sabbath Mandatory rest; idle 1 ms, deep sleep 100 ms COMMANDMENT_POWER_REST 0x00000004

V Honour thy father Backwards compatibility with all 142 AutoPhi ICs (IDs 0x0001 – 0x008E ) COMMANDMENT_HONOUR_LEGACY 0x00000005

VI Thou shalt not kill Never destroy data; CRC-32 polynomial 0xEDB88320 ; atomic 4-byte writes COMMANDMENT_NO_DESTROY 0x00000006

VII No adultery Strict protocol: SPI CPOL=0/CPHA=0; I2C 400 kHz; UART 115200/8N1 COMMANDMENT_FAITHFUL_PROTOCOL 0x00000007

VIII Thou shalt not steal Max 64 KB memory, 2 DMA channels, 4 IRQ lines, 100 Mbps bandwidth COMMANDMENT_NO_STEAL_RESOURCES 0x00000008

IX No false witness Honest status always; health check every 1000 ms COMMANDMENT_HONEST_STATUS 0x00000009

X Thou shalt not covet Fully self-contained: no external deps, no dynamic alloc, no floating point COMMANDMENT_SELF_CONTAINED 0x0000000A

Commandment verification word: XOR of all ten codes. Compiled-in _Static_assert enforces exactly 10 Commandments and version 1.0.0 forever.

The Constitution — 7 Articles, as in 1787 ( constitution.h , 436 lines)

The Prodigal's own law. Seven Articles, eleven clauses, zero amendments. Citation codes are Article.Section encoded in hexadecimal: 0x1000ASXX where A is the Article number and S the Section.

Article 1787 Parallel Our Law Clauses Citation Codes

I — The Powers Legislative §1 Right to drive foreign hardware; §2 Right to identify Foreign IC IDs 0x1000 – 0xFFFE ; 64 profile slots; probe timeout 5 ms, 3 retries 0x10000101 , 0x10000102

II — The Execution Executive §1 Safe defaults (unknown is fragile); §2 Graceful degradation (patience, not panic) Default clock div 8; max transfer 64 B; timeout 10 ms; 3 failures to degrade, 4 degrade steps to isolation 0x10000201 , 0x10000202

III — The Judgment Judicial §1 Due process (every rejection gets a reason); §2 The audit (flight recorder, cannot be erased) 10 rejection codes ( 0xE001 – 0xE00A ); firmware audit log 256 entries; host audit log 4096 entries 0x10000301 , 0x10000302

IV — The Devices The States §1 Against seizure (never brick foreign hardware); §2 Peaceful coexistence (shared buses, shared respect) OTP write blocked; fuse write blocked; flash erase requires key 0xC0FFEE42 ; max 16 registered devices (firmware), 64 (host) 0x10000401 , 0x10000402

V — No Amendment Amendment process (inverted) This Constitution shall never be amended. Written complete, with foresight. PRODIGAL_NUM_AMENDMENTS = 0 ; PRODIGAL_AMENDMENT_PROCESS_EXISTS = 0 ; enforced by _Static_assert 0x10000500

VI — Supremacy Supreme law of the land §1 The father's seal (heritage key proves supremacy); §2 Homecoming (keys match, full stack unlocks) Seal registers at 0xFFFC – 0xFFFF ; homecoming states: NONE (0x00), PROBING (0x01), VERIFIED (0x02), NATIVE (0x03) 0x10000601 , 0x10000602

VII — Ratification The signatures "Proprietary is always a right" — the creator's signature compiled into every binary PRODIGAL_IP_RETAINED = 1 ; PRODIGAL_IP_NEVER_ASSIGNED = 1 ; signature 0x50524F50 ("PROP") 0x10000700

The complete law: 10 Commandments received + 7 Articles ordained (eleven clauses). The XOR checksum of both documents is compiled in. If either is tampered with, the driver refuses to boot.

The Homecoming Protocol (Key Exchange)

A three-step challenge/response handshake that identifies AutoPhi ICs on any bus. Implemented in both firmware C and synthesisable Verilog RTL.

Step Direction Register Word ASCII Meaning

1. Challenge Prodigal → Device 0xFFFC 0x534F4E3F "SON?" The son asks: is this home?

2. Response Device → Prodigal 0xFFFD 0x46415448 "FATH" Only AutoPhi ICs answer with the father's word

3. Confirm Prodigal → Device 0xFFFE 0x484F4D45 "HOME" Native mode unlocked — full WonderPhi stack active

If the device does not respond with "FATH", it is classified as foreign hardware. The Prodigal drives it safely under the Articles with no penalty and no judgment — just discipline. Homecoming is a one-way promotion: once the keys match, native mode is permanent for that device.

Verilog RTL — Homecoming Engine ( prodigal_homecoming.v , 217 lines)

An 8-state finite state machine implementing Article VI, Sections 1 and 2 in hardware. Directly drives bus read/write lines and provides an audit tap for Article III compliance.

HERITAGE_KEY 32'h50484921 The father's key ("PHI!") — verified at synthesis; mismatch causes $error

The Prodigal does not care how it talks to the device. Every transport implements a common operations interface; the Constitution is the constant.

• open(xport, device_path) — Open the transport channel
• close(xport) — Close the transport channel
• read(xport, addr, reg, buf, len) — Read from device
• write(xport, addr, reg, buf, len) — Write to device
• lock(xport) — Acquire exclusive bus access (Article IV, §2)
• unlock(xport) — Release bus lock
• read_voltage_mv(xport, *mv) — Read supply voltage in millivolts
• read_current_ma(xport, *ma) — Read current draw in milliamps
• read_temp_c(xport, *temp) — Read junction temperature in °C
• set_clock(xport, hz) — Set bus clock frequency

Freestanding C targeting AutoPhi hardware. No standard library dependencies (Commandment X). Contains the core service loop, probe logic, homecoming protocol, and device health tracking.

prodigal_fw_init(ctx) Cold start: zero context, init all 4 interfaces, verify both checksums; refuses to boot if constitution is corrupted

prodigal_fw_probe_device(ctx, iface, addr) Send "SON?" challenge, read response; returns PRODIGAL_MODE_NATIVE or PRODIGAL_MODE_FOREIGN

prodigal_fw_register_foreign(ctx, profile) Register a foreign device; enforces max-device limit and CRC-32 profile integrity

prodigal_fw_attempt_homecoming(ctx, device_idx) Re-attempt homecoming on a foreign device; refuses on isolated devices (Article II, §2)

prodigal_fw_read(ctx, device_idx, addr, buf, len) Read with full safety: refuses isolated devices, enforces resource limits, tracks health, logs audit

prodigal_fw_write(ctx, device_idx, addr, buf, len) Write with full safety: blocks OTP region ( 0xFFF0 – 0xFFFF ) on foreign hardware (Article IV, §1)

prodigal_fw_health_check(ctx, device_idx) Returns AUTOPHI_STATUS_OK , _BUSY (degraded), or _OFFLINE (isolated)

prodigal_fw_service(ctx) Main service loop tick; updates uptime, manages power states (Commandment IV)

Internal Functions

• audit_log() — Append to circular audit buffer (Article III, §2); each entry CRC-32 protected
• record_rejection() — Record rejection with code, citing Article, detail, and timestamp (Article III, §1)

Host-Side Software Layer ( software/ )

POSIX C with and only. Enforces the Constitution from the host side. Nothing reaches the hardware without passing through the 10-step safety gauntlet.

• PRODIGAL_HOST_MAX_DEVICES : 64
• PRODIGAL_HOST_AUDIT_ENTRIES : 4096
• PRODIGAL_HOST_VERSION : 1.0.0

Lifecycle prodigal_host_init(ctx, xport) Boot the host driver; verify constitution checksums; set safe defaults on transport

prodigal_host_shutdown(ctx) Orderly shutdown; release bus locks (Article IV, §2); close transport

Discovery prodigal_host_scan(ctx, addr_start, addr_end) Scan an address range; probe each address; return count found

prodigal_host_probe(ctx, addr) Probe one address: lock bus, send "SON?" challenge, classify as native or foreign

prodigal_host_homecoming(ctx, device_slot) Re-attempt homecoming on a foreign device; refuses isolated/thermal devices

I/O prodigal_host_read(ctx, slot, reg, buf, len) Safe read: runs full 10-step gauntlet, bus lock, I/O, health update, audit

prodigal_host_write(ctx, slot, reg, buf, len) Safe write: same gauntlet; OTP/fuse writes blocked on foreign hardware

Safety queries prodigal_host_get_thermal(ctx, slot, *status) Query thermal state: NORMAL / WARNING / THROTTLE / SHUTDOWN

Device info prodigal_host_get_mode(ctx, slot, *mode) Query device mode (UNKNOWN / FOREIGN / NATIVE / DEGRADED / ISOLATED / THERMAL)

prodigal_host_get_health(ctx, slot, *degrade, *fails) Query degrade level and total failure count

Audit prodigal_host_get_audit(ctx, start_seq, entries, max, *returned) Read audit log entries from a given sequence number

Rejection prodigal_host_get_last_rejection(ctx, *out) Get last rejection record with reason string, citing Article or Commandment

Negotiation prodigal_host_negotiate_limits(ctx, slot, *requested) Upgrade device limits after identification; clamped to absolute maximums; foreign devices refused

PRODIGAL_THERMAL_SHUTDOWN 3 At or above shutdown_temp_c; all transactions halted; device mode set to THERMAL

Rejection Codes (Article III, §1)

autophi_transaction_t commandments.h Base transaction: magic, interface_id, ic_id, command, address, length, crc32

autophi_status_t commandments.h Status: status code, interface, IC, power state, error, uptime

prodigal_device_profile_t constitution.h Foreign device profile: vendor/device IDs, interface, clock div, addr width, flags, max transfer, CRC

prodigal_device_health_t constitution.h Health tracking: device ID, degrade level, consecutive/total failures, last failure timestamp

prodigal_rejection_t constitution.h Rejection record: code, source article/section, detail, timestamp

prodigal_audit_entry_t constitution.h Audit log entry: sequence, timestamp, interface, mode, device, command, status, reject code, address, length, CRC

prodigal_transaction_t constitution.h Extended dual-mode transaction: adds mode and reject_code fields

prodigal_context_t constitution.h Firmware runtime context: mode, homecoming state, device table [16], audit log [256], counters

prodigal_safety_limits_t prodigal_transport.h Safety limits: clock, transfer, timeout, voltage, current, temperature, shutdown temp

prodigal_transport_ops_t prodigal_transport.h 10 function pointers defining transport operations

prodigal_transport_t prodigal_transport.h Transport instance: type, ops, limits, private data, open/locked state, error count

prodigal_device_t prodigal_host.h Host-side device handle: address, mode, limits, health, identity, heritage check

prodigal_host_audit_t prodigal_host.h Host audit entry: nanosecond timestamp, sequence, device, op, result, reg, length, voltage, current, temp, article cited

prodigal_host_rejection_t prodigal_host.h Host rejection: nanosecond timestamp, device, article/commandment, code, detail, 64-char reason string

prodigal_thermal_status_t prodigal_host.h Thermal status: state, current/max/shutdown temps, throttle clock

prodigal_host_ctx_t prodigal_host.h Host driver context: transport, device table [64], audit log [4096], thermal state, checksums, statistics

Total firmware interface count: 4 ( AUTOPHI_IFACE_COUNT ).

Graceful Degradation Parameters (Article II, §2)

A complete working example demonstrating: transport setup (SPI stub with safe voltage/current/temperature readouts), driver initialisation with constitution verification, device probing at address 0x50 , thermal/voltage/current queries, safe read (64 bytes from register 0x0000 ), safe write (16 bytes to register 0x0100 ), blocked OTP write (register 0xFFF0 — Article IV, §1), blocked oversized transfer (99999 bytes — Commandment VIII), health-status query, and orderly shutdown with bus release and audit-log preservation.

• WonderPhi version is exactly 1.0.0 (3 assertions)
• Exactly 10 Commandments exist
• Heritage key equals 0x50484921 (lineage violation check)
• Zero amendments ( PRODIGAL_NUM_AMENDMENTS == 0 )
• No amendment process exists ( PRODIGAL_AMENDMENT_PROCESS_EXISTS == 0 )
• Exactly 7 Articles exist
• IP is retained ( PRODIGAL_IP_RETAINED == 1 )
• IP is never assigned ( PRODIGAL_IP_NEVER_ASSIGNED == 1 )

Total: 10 compile-time assertions across both governing documents.

What Is in the Package

13 files total (3 C source, 5 C headers, 1 Verilog, 2 Markdown, 2 text) — 2,658 lines of source code across the 9 source/header/RTL files.

• prodigal-driver/commandments.h (250 lines) — The 10 Commandments: received law inherited from WonderPhi v1.0.0. Defines all Commandment codes, protocol parameters (SPI/I2C/UART), resource limits, power states, custom data types ( autophi_u8 / u16 / u32 / i32 ), the autophi_transaction_t and autophi_status_t structures, inline CRC-32 implementation, and command validation function. Enforced by _Static_assert for version lock and commandment count.
• prodigal-driver/constitution.h (436 lines) — The Constitution: 7 Articles with Preamble. Includes commandments.h . Defines the Prodigal identity constants, three operating modes (FOREIGN/NATIVE/DISCOVERY), all 12 Article citation codes, the homecoming handshake sequence, the foreign-device profile structure, device health tracker, rejection and audit-log structures, the extended dual-mode transaction, runtime context, and both transaction validation and constitutional enforcement with XOR checksums. Six _Static_assert checks.
• prodigal-driver/firmware/prodigal_fw_core.h (28 lines) — Firmware API header. Defines 6 firmware states and declares 8 public functions for initialisation, probing, foreign device registration, homecoming, read/write, health check, and service loop.
• prodigal-driver/firmware/prodigal_fw_core.c (376 lines) — Firmware core implementation. Implements the service loop, probe logic with full "SON?"/"FATH"/"HOME" handshake, foreign device registration with CRC verification, homecoming attempt, safe read/write with degradation tracking and OTP protection, health check, and audit logging. Declares external interface for platform HAL ( prodigal_iface_init , prodigal_iface_read , prodigal_iface_write , prodigal_get_time_us ).
• prodigal-driver/hardware/prodigal_homecoming.v (217 lines) — Synthesisable Verilog RTL. 8-state FSM ( S_IDLE through S_WAIT_ACK3 ) implementing Article VI in hardware. 5 parameters, 16 ports (7 output regs, 4 inputs, 3 audit outputs, 2 bus data). Includes synthesis-time heritage key verification via $error . Active-low async reset. 16-bit timeout counter per phase.
• prodigal-driver/software/prodigal_transport.h (151 lines) — Transport abstraction layer. Defines 8 transport types, 9 error codes, the prodigal_safety_limits_t structure (7 fields), the prodigal_transport_ops_t vtable (10 function pointers), the prodigal_transport_t instance structure, and two inline helpers for setting safe defaults and clamping to absolute maximums. Specifies all 7 safe-default values and all 4 absolute-maximum values.
• prodigal-driver/software/prodigal_host.h (216 lines) — Host-side public API. Defines 6 device modes, the device handle structure (20 fields including 32-char name), the host audit entry (13 fields with nanosecond timestamps), the host rejection record (6 fields with 64-char reason string), 4 thermal states with status structure, the host driver context (transport, 64-device table, 4096-entry audit log, thermal state, checksums, statistics), and 15 public API function declarations.
• prodigal-driver/software/prodigal_host.c (782 lines) — Host-side implementation. The largest file. Implements all 15 public API functions plus 6 internal functions: get_time_ns() (monotonic nanosecond clock), audit() (append-only circular log), reject() (reason-bearing rejection recorder), update_thermal() (4-state thermal management with automatic clock throttling to 1/4), check_voltage() , check_current() , and safety_gauntlet() (the 10-step safety check) plus update_health() (graceful degradation with forgiveness).
• prodigal-driver/example/prodigal_example.c (202 lines) — Complete reference application. Includes a full stub transport implementation (10 stub functions) with safe readouts (1.8 V, 50 mA, 42 °C), device probing, mode classification, thermal/voltage/current queries, safe read/write, blocked OTP write demonstration, blocked oversized transfer demonstration, health query, and orderly shutdown. Prints constitution checksums at boot.
• prodigal-driver/README.md (117 lines) — Primary documentation. Covers the WonderPhi/Prodigal relationship, the two governing documents (Commandments table and Constitution table with 1787 parallels), the Preamble, Article VII decoded, architecture diagram, homecoming protocol sequence diagram, and the seven traits of getting along (patience, honesty, respect, humility, forgiveness, identity, joy).
• prodigal-driver/ARTICLE_VII_ORIGIN.md (11 lines) — Origin story of Article VII. Records that the statement "Proprietary is always a right" came from Christopher G. Brown's email reply to Natacia at Anthropic on 2026-08-28 and became the ratification clause of the Constitution.
• 1 light trigger.txt (742.5 KB) — Master invention catalogue from the CRI-ONE portfolio; an index of inventions with titles, descriptions, copyright dates, and patent reference numbers.
• CONTACT_INFO.txt (17 lines) — Contact information for Christopher Gabriel Brown (Inventor, Author, Visionary). Communication by email and postal mail only. Available exclusively to companies incorporated, headquartered, and primarily operating in the United States of America. USD only.

How this is delivered

This package ships on a single Blu-ray disc, posted to the delivery address on your order. The archive on the disc is AES-256 encrypted; the passphrase is sent separately, by email, once the disc is despatched — so the disc alone is of no use to anyone who intercepts it.

Discs are despatched by tracked, signed-for post. Allow 5 business days for mastering and verification before despatch.

Photo