Phase 8.4: daemon ↔ kernel decode round-trip (VP9 end-to-end)

Wires the Phase 8.3 FFmpeg loader through the Phase 8.2 chardev
bridge: kernel injects REQ_DECODE carrying a raw VP9 access unit,
daemon hands the bitstream to libavcodec via dlopen, sends
RESP_FRAME back with a content-dependent FNV-1a digest of the
decoded YUV planes. Pure CPU decode for now — Phase 8.5 swaps in
dmabuf + QPU dispatch.

Protocol (include/daedalus_v4l2_proto.h):
- New REQ_DECODE (kernel→daemon) and RESP_FRAME (daemon→kernel)
  message types, with fixed-size payload structs.
- New DAEDALUS_CODEC_VP9/AV1/H264 enum (wire-stable so 8.6's
  AV1+H.264 work doesn't move existing values).
- New DAEDALUS_DECODE_* status enum (OK / NO_FRAME / ERR_OPEN /
  ERR_SEND / ERR_RECV / ERR_CODEC).
- Converted the prior `enum daedalus_msg_type` to #defines —
  high-bit values exceed INT_MAX and tripped -Wpedantic on
  userspace; kernel uABI headers use the same idiom.

Kernel (kernel/daedalus_v4l2_chardev.c):
- New debugfs entry /sys/kernel/debug/daedalus_v4l2/test_decode:
  writing raw bitstream bytes wraps them in a REQ_DECODE
  (codec=VP9 for Phase 8.4) and enqueues with an
  auto-incrementing cookie.
- daedalus_chardev_write learned RESP_FRAME: parses the payload
  and emits a single pr_info line with decode metadata. Keeps
  existing PONG handling on the default arm.

Daemon (daemon/src/...):
- chardev_client.{c,h} — opens /dev/daedalus-v4l2, blocking read
  loop, single-buffer write() responses (kernel chardev has only
  .write, not .write_iter, so writev lands as -EINVAL —
  discovered the hard way during first run).
- decoder.{c,h} — lazily-opened AVCodecContext per codec, shared
  AVPacket/AVFrame pair, descriptor-driven plane walker
  (av_pix_fmt_desc_get) so the same hash path covers YUV420P,
  YUV422P, YUV444P, GBRP and other 8-bit planar layouts.
  Generalised after first run decoded testsrc as GBRP (71)
  rather than the assumed YUV420P.
- `daemon` command in main.c opens the chardev and runs the loop
  until SIGINT/SIGTERM. Cookie correlation handled end-to-end.
- ffmpeg_loader gained av_pix_fmt_desc_get (23 symbols total).

Build:
- CMakeLists adds chardev_client.c + decoder.c; explicit
  -I../include for the shared protocol header.
- Still -Wall -Wextra -Wpedantic clean.

Verification on hertz (Pi 5, 6.12.75+rpt-rpi-2712):

  $ ffmpeg ... -pix_fmt yuv420p -c:v libvpx-vp9 -frames:v 1 \
           -y /tmp/vp9_test.ivf
  $ python3 ... strip IVF framing → vp9_keyframe.bin (3268 B)

  $ sudo insmod kernel/daedalus_v4l2.ko
  $ daedalus_v4l2_daemon -v daemon &
  $ sudo dd if=vp9_keyframe.bin \
         of=/sys/kernel/debug/daedalus_v4l2/test_decode

  daemon: REQ_DECODE cookie=2 → decoded yuv420p 320x240
          fnv1a=0x6ef10d71 luma=76800 chroma=38400
  kernel: RESP_FRAME cookie=2 status=0 320x240 pixfmt=0
          fnv1a=0x6ef10d71  ← matches daemon ✓

Hash properties verified:
  cookie=2  testsrc 3268 B → 0x6ef10d71  (first decode)
  cookie=3  red     44 B   → 0x7f6e5dc5  (content-dependent ✓)
  cookie=4  testsrc 3268 B → 0x6ef10d71  (deterministic ✓)
  cookie=5  64 B random    → status=101  (ERR_SEND, daemon alive)

Daemon survives bad input (FFmpeg "Invalid sync code" wrapped
into structured ERR_SEND response). Clean SIGTERM shutdown,
clean rmmod.

Phase 8.4 acceptance criteria met:
- ✓ end-to-end kernel→daemon→FFmpeg→kernel round-trip
- ✓ cookie correlation per request/response pair
- ✓ content-dependent + deterministic digest
- ✓ structured error responses (no daemon crash on bad input)
- ✓ clean teardown (SIGTERM + rmmod)
- ✓ builds clean on both kernel kbuild and daemon CMake

Per correctness-before-speed:
- Real chardev I/O (no shortcuts, no select-loop hacks)
- Real FFmpeg AVCodecContext lifecycle (lazily opened, properly
  freed on cleanup)
- Descriptor-driven plane walk (generalises across pix_fmts)
- Structured error path (not just log-and-continue)
- All resource paths cleaned up on every error branch
- Documented why FNV-1a digest, why write() not writev(), why
  pix_desc walk in docs/phase_8_4_closure.md

Phase 8.5 next: V4L2 m2m queue submits REQ_DECODE from
vidioc_qbuf; dmabuf carries actual pixel data so the chardev's
64 KiB cap doesn't gate frame size; begin substituting
daedalus_dispatch_* into the daemon's decode path.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

kernel/daedalus_v4l2_chardev.c

@@ -259,11 +259,34 @@ static ssize_t daedalus_chardev_write(struct file *file,
 	}
 
 	/*
-	 * Phase 8.2 handling: log the response type.  Phase 8.4
-	 * will wire RESP_FRAME etc. to the V4L2 buffer queue.
+	 * Response dispatch.  Phase 8.4 understands PONG (echoes
+	 * back at debug level) and RESP_FRAME (logs decode result
+	 * at info so the test harness can see it without enabling
+	 * dyndbg).  Phase 8.5+ will wire RESP_FRAME to the V4L2
+	 * buffer-done path.
 	 */
-	pr_debug("daedalus_v4l2: chardev got response type=0x%08x cookie=%u plen=%u\n",
-		 hdr.type, hdr.cookie, hdr.payload_len);
+	switch (hdr.type) {
+	case DAEDALUS_MSG_RESP_FRAME: {
+		struct daedalus_resp_frame fr;
+
+		if (hdr.payload_len < sizeof(fr)) {
+			pr_warn("daedalus_v4l2: RESP_FRAME payload too short (%u < %zu)\n",
+				hdr.payload_len, sizeof(fr));
+			kfree(payload);
+			return -EBADMSG;
+		}
+		memcpy(&fr, payload, sizeof(fr));
+		pr_info("daedalus_v4l2: RESP_FRAME cookie=%u status=%u codec=%u %ux%u pixfmt=%d luma=%u chroma=%u fnv1a=0x%08x\n",
+			hdr.cookie, fr.status, fr.codec_id,
+			fr.width, fr.height, fr.pix_fmt,
+			fr.luma_len, fr.chroma_len, fr.fnv1a_yuv);
+		break;
+	}
+	default:
+		pr_debug("daedalus_v4l2: chardev got response type=0x%08x cookie=%u plen=%u\n",
+			 hdr.type, hdr.cookie, hdr.payload_len);
+		break;
+	}
 
 	kfree(payload);
 	return expected;
@@ -328,6 +351,66 @@ static const struct file_operations daedalus_test_ping_fops = {
 	.write	= daedalus_test_ping_write,
 };
 
+/*
+ * Writing bitstream bytes to
+ * /sys/kernel/debug/daedalus_v4l2/test_decode enqueues a REQ_DECODE
+ * carrying those bytes as a VP9 access unit (Phase 8.4 fixed
+ * codec).  The wire payload prepends a struct daedalus_req_decode
+ * header so the daemon knows the codec id and bitstream length.
+ *
+ * Phase 8.6 generalises codec_id (via a sysfs / debugfs control);
+ * for Phase 8.4 VP9 is hard-wired since that's what the cycle-9
+ * stack targets first.
+ */
+static atomic_t daedalus_decode_cookie = ATOMIC_INIT(0);
+
+static ssize_t daedalus_test_decode_write(struct file *file,
+					  const char __user *buf,
+					  size_t count, loff_t *ppos)
+{
+	struct daedalus_req_decode req;
+	u8 *blob;
+	size_t total;
+	u32 cookie;
+	int ret;
+
+	if (count == 0)
+		return -EINVAL;
+	if (count + sizeof(req) > DAEDALUS_PROTO_MAX_PAYLOAD)
+		return -EMSGSIZE;
+
+	total = sizeof(req) + count;
+	blob = kmalloc(total, GFP_KERNEL);
+	if (!blob)
+		return -ENOMEM;
+
+	req.codec_id	  = DAEDALUS_CODEC_VP9;
+	req.bitstream_len = (u32) count;
+	req.flags	  = 0;
+	memcpy(blob, &req, sizeof(req));
+
+	if (copy_from_user(blob + sizeof(req), buf, count)) {
+		kfree(blob);
+		return -EFAULT;
+	}
+
+	cookie = (u32) atomic_inc_return(&daedalus_decode_cookie);
+	ret = daedalus_chardev_enqueue_req(DAEDALUS_MSG_REQ_DECODE, cookie,
+					   blob, total);
+	kfree(blob);
+	if (ret)
+		return ret;
+
+	pr_info("daedalus_v4l2: REQ_DECODE enqueued cookie=%u codec=VP9 bitstream=%zu\n",
+		cookie, count);
+	return count;
+}
+
+static const struct file_operations daedalus_test_decode_fops = {
+	.owner	= THIS_MODULE,
+	.write	= daedalus_test_decode_write,
+};
+
 /* -- registration ---------------------------------------------------- */
 
 int daedalus_chardev_init(void)
@@ -355,9 +438,12 @@ int daedalus_chardev_init(void)
 	}
 
 	dev->debugfs_dir = debugfs_create_dir("daedalus_v4l2", NULL);
-	if (!IS_ERR(dev->debugfs_dir))
+	if (!IS_ERR(dev->debugfs_dir)) {
 		debugfs_create_file("test_ping", 0200, dev->debugfs_dir,
 				    NULL, &daedalus_test_ping_fops);
+		debugfs_create_file("test_decode", 0200, dev->debugfs_dir,
+				    NULL, &daedalus_test_decode_fops);
+	}
 
 	g_chardev = dev;
 	pr_info("daedalus_v4l2: /dev/%s registered\n", DAEDALUS_CHARDEV_NAME);