Linux's own r8169 through LDLS, deep idle, and the GPU plan

The RTL8168 is now driven by Linux's r8169, unmodified, in a process.
`make ldls-r8169` stages it from the running kernel together with libphy,
mdio-bus, mdio_devres and the Realtek PHY driver, the kernel's BTF and
the RTL PHY firmware, and etc/schinit/ldls-r8169.job starts it at boot
with its log in /var/log/ldls-r8169.log. The native driver is out of the
registry; its code, now with Linux's 8168H setup, stays as the fallback.

LDLS grows what that needed:
- ldlsd loads a comma-separated module set in dependency order, each
  linking against the ones before it, with BTF read before any
  init_module runs;
- a driver core (bus match, driver probe), devres, kernel printf, real
  udelay/msleep/ktime and 1000 Hz jiffies, phylib's bitmaps and
  link_mode_params, firmware from /lib/firmware, and the symbols whose
  stub zero was a lie (list validity, try_module_get, dev_err_probe,
  eth_platform_get_mac_address);
- pdev->bus is a real pci_bus, and cmovcc from per-CPU memory is
  rewritten like the other %gs forms.
In QEMU all five modules load, link and initialise, and r8169 registers
and finds no device. Probe and traffic are untested until real hardware.

The kernel turns ASPM off on Realtek NIC links at boot, as r8169 does
through pci_disable_link_state, which a process cannot.

Idle CPUs enter ACPI _CST's C2 (CC6 on Zen) by port read or MWAIT when
the APIC timer keeps running, instead of only ever halting at C1.

docs/plan/gpu.md: amdgpu and nouveau through LDLS, with measurements.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S1giNvrHTrPMPw7V6x1kQ4

kernel/acpi/aml.c

@@ -41,6 +41,7 @@ static int ready;
 static int s5_typ_a = -1, s5_typ_b = -1;
 
 static uacpi_interrupt_ret power_button(uacpi_handle ctx);
+static void cstate_find(void);
 
 void
 acpi_aml_init(void)
@@ -98,6 +99,7 @@ acpi_aml_init(void)
   }
   ready = 1;
   kinfo("acpi: namespace loaded\n");
+  cstate_find();
 }
 
 // --- power -------------------------------------------------------------------
@@ -526,3 +528,111 @@ acpi_psu_get(int i, struct acpi_psu *b)
   }
   return 0;
 }
+
+// --- idle states --------------------------------------------------------------
+//
+// An idle CPU used to run hlt and nothing else. hlt is C1: the core stops
+// executing and stays powered. The states below it -- CC6 on Zen, C3 and
+// deeper on Intel -- switch the core off, and the firmware lists how to reach
+// them in each processor's _CST. Without them a laptop sitting at a shell
+// keeps every core warm and the fans going.
+//
+// _CST is a count followed by one package per state: a register (a Generic
+// Register descriptor in a buffer), a type (1 = C1, 2 = C2, 3 = C3), the
+// worst-case wake-up latency in microseconds, and the power. A register in
+// system I/O space is entered by reading it; one in functional fixed hardware
+// is MWAIT, with the hint in the address.
+//
+// Only types 1 and 2 are taken. C3 asks the OS to stop bus-master activity
+// or flush caches first (ACPI 8.1.4), which this does not do.
+
+struct acpi_idle acpi_idle;
+
+static int cst_done;
+
+static void
+cst_parse(uacpi_namespace_node *node)
+{
+  uacpi_object *o = 0;
+  uacpi_object_array p, e;
+  uacpi_data_view d;
+
+  if (uacpi_eval_package(node, "_CST", 0, &o) != UACPI_STATUS_OK)
+    return;
+  if (uacpi_object_get_package(o, &p) == UACPI_STATUS_OK) {
+    for (uacpi_size i = 1; i < p.count; i++) {
+      if (uacpi_object_get_package(p.objects[i], &e) != UACPI_STATUS_OK ||
+          e.count < 4)
+        continue;
+      uint32 type = pkg_int(&e, 1), lat = pkg_int(&e, 2);
+      if (type != 2 || lat > 1000)
+        continue;
+      if (uacpi_object_get_buffer(e.objects[0], &d) != UACPI_STATUS_OK ||
+          d.length < 15 || d.const_bytes[0] != 0x82)
+        continue;
+      uint8 space = d.const_bytes[3];
+      uint64 addr = 0;
+      for (int k = 0; k < 8; k++)
+        addr |= (uint64)d.const_bytes[7 + k] << (8 * k);
+      if (space == UACPI_ADDRESS_SPACE_SYSTEM_IO && addr && addr < 0x10000) {
+        acpi_idle.kind = ACPI_IDLE_IO;
+      } else if (space == UACPI_ADDRESS_SPACE_FFIXEDHW && (d.const_bytes[4] == 1)) {
+        // Intel's FFH encoding: vendor 1, class 2 (native C-state), and
+        // the MWAIT hint in the low byte of the address.
+        acpi_idle.kind = ACPI_IDLE_MWAIT;
+      } else {
+        continue;
+      }
+      acpi_idle.addr = addr;
+      acpi_idle.latency = lat;
+      break;
+    }
+  }
+  uacpi_object_unref(o);
+}
+
+static uacpi_iteration_decision
+found_cpu(void *user, uacpi_namespace_node *node, uacpi_u32 depth)
+{
+  (void)user; (void)depth;
+  if (cst_done)
+    return UACPI_ITERATION_DECISION_BREAK;
+  cst_parse(node);
+  cst_done = 1;                 // every processor's _CST is the same in practice
+  return UACPI_ITERATION_DECISION_BREAK;
+}
+
+static void
+cstate_find(void)
+{
+  uint32 a, b, c, dd;
+
+  // The local APIC timer is what wakes an idle CPU for the scheduler tick.
+  // Below C1 it may stop, unless the CPU says it keeps running (ARAT,
+  // CPUID 6 EAX bit 2); without that an idle CPU would sleep for good.
+  cpuid_leaf(6, &a, &b, &c, &dd);
+  if (!(a & 4)) {
+    kinfo("acpi: no always-running APIC timer; idle stays at C1\n");
+    return;
+  }
+
+  uacpi_namespace_for_each_child(uacpi_namespace_root(), found_cpu, 0,
+                                 UACPI_OBJECT_PROCESSOR_BIT,
+                                 UACPI_MAX_DEPTH_ANY, 0);
+  if (!cst_done)
+    uacpi_find_devices("ACPI0007", found_cpu, 0);
+
+  if (acpi_idle.kind == ACPI_IDLE_MWAIT) {
+    cpuid_leaf(1, &a, &b, &c, &dd);
+    if (!(c & (1u << 3)))       // no MONITOR/MWAIT after all
+      acpi_idle.kind = ACPI_IDLE_HLT;
+  }
+  if (acpi_idle.kind == ACPI_IDLE_IO)
+    kinfo("acpi: idle CPUs enter C2 through port %x (wake-up %d us)\n",
+          (uint)acpi_idle.addr, acpi_idle.latency);
+  else if (acpi_idle.kind == ACPI_IDLE_MWAIT)
+    kinfo("acpi: idle CPUs enter C2 by MWAIT hint %x (wake-up %d us)\n",
+          (uint)acpi_idle.addr, acpi_idle.latency);
+  else
+    kinfo("acpi: no usable C2 in _CST; idle stays at C1\n");
+}