Add kernel drivers, V4L2 capture, device tree overlay, and rewrite README

Kernel modules:
- hello: minimal loadable module (init/exit, printk)
- chardev: character device with file_operations, ioctl, mutex
- bme280: I2C client driver with device tree matching and sysfs

Userspace:
- V4L2 multi-planar capture program for i.MX8MP ISI
- Camera detection app (TFLite + VX Delegate + GStreamer)
- M7 RPMsg heartbeat firmware skeleton

Device tree:
- Annotated OV5640 camera overlay (MIPI CSI-2, OF graph, clocks)

Docs:
- Rewrite README with actual repo structure and verified results
- Update camera+NPU guide with correct device paths

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Corning-AI

README.md

@@ -1,143 +1,130 @@
-# embedded-linux
+# Embedded Linux on i.MX 8M Plus
 
-An i.MX 8M Plus heterogeneous platform project: Yocto Linux on Cortex-A53 + FreeRTOS on Cortex-M7 + NPU edge inference.
+Heterogeneous SoC platform project built on the NXP i.MX 8M Plus EVK. Covers BSP bring-up, kernel driver development, camera/NPU pipelines, and real-time co-processing with FreeRTOS on the Cortex-M7.
 
-<!-- 异构多核嵌入式 Linux 项目：A53 跑 Linux，M7 跑 FreeRTOS，NPU 做边缘推理 -->
-
-I'm building this on the NXP i.MX 8M Plus EVK to explore the full stack of embedded Linux development — from writing kernel drivers and custom Yocto images, to real-time firmware on a dedicated MCU core, to deploying quantized neural networks on the onboard NPU. The goal is a working sensor platform where the A53 and M7 cores each do what they're good at.
-
-## Current Status
-
-**Phase 1 complete** — the EVK boots a custom Yocto scarthgap image from SD card. All core peripherals verified (CPU, RAM, storage, network interfaces, I2C buses). See the [first boot verification log](docs/02-hardware-guide.md#first-boot-verification-2026-03-09) for details.
-
-<!-- 当前进度：Phase 1 已完成，EVK 已成功从 SD 卡启动自定义 Yocto 镜像。所有基本外设验证通过。 -->
+## Hardware
 
-| Milestone | Status |
-| --------- | ------ |
-| Phase 1 — Yocto first boot & peripheral verification | **Done** |
-| Phase 2 — BME280 I2C kernel driver (A53 Linux) | Next up |
-| Phase 3 — FreeRTOS on M7 + RPMsg inter-core comms | Planned |
-| Phase 4 — NPU edge inference with eIQ / TFLite | Planned |
+- **SoC:** NXP i.MX 8M Plus — quad Cortex-A53 (1.8 GHz) + Cortex-M7 + 2.3 TOPS NPU
+- **Board:** 8MPLUSLPD4-EVK (6 GB LPDDR4, 32 GB eMMC)
+- **Camera:** OV5640 MIPI CSI-2 via MINISASTOCSI adapter (J12)
+- **Display:** HDMI 2.0a (J17), Weston/Wayland compositor
+- **Kernel:** 6.6.52-lts (Yocto Scarthgap)
 
-## Architecture
+## Repository Structure
 
 ```text
-┌──────────────────────────────────────────────────────────────┐
-│                                                              │
-│   Cortex-A53 (Linux / Yocto)                                │
-│   ├── Custom Yocto image (Scarthgap)                        │
-│   ├── BME280 I2C kernel driver module                       │
-│   ├── Userspace data collector daemon (C)                   │
-│   ├── NPU inference — anomaly detection (eIQ / TFLite)     │
-│   └── Lightweight web UI for live sensor data               │
-│                                                              │
-│                    ┌──────────────┐                          │
-│                    │  RPMsg / MU  │                          │
-│                    │ (inter-core) │                          │
-│                    └──────────────┘                          │
-│                                                              │
-│   Cortex-M7 (FreeRTOS)                                      │
-│   ├── MPU6050 6-axis real-time sampling (1 kHz)             │
-│   ├── Hard real-time control loop                           │
-│   ├── SSD1306 OLED local display                            │
-│   └── Data packing + forwarding to A53 via RPMsg            │
-│                                                              │
-└──────────────────────────────────────────────────────────────┘
-
-I2C buses:
-  I2C3 (A53 Linux)  ──── BME280 (temp / humidity / pressure)
-  I2C2 (M7 FreeRTOS) ─┬─ MPU6050 (accel / gyro)
-                       └─ SSD1306 (OLED display)
+kernel-modules/
+├── hello/          Minimal loadable kernel module
+├── chardev/        Character device driver (/dev node, ioctl, mutex)
+└── bme280/         I2C client driver with sysfs interface
+
+drivers/
+└── v4l2-capture/   V4L2 mmap frame capture (C, multi-planar API)
+
+dts/
+└── imx8mp-evk-ov5640.dts   Annotated device tree overlay (camera pipeline)
+
+scripts/
+├── build-multimedia.sh      Yocto build helper for imx-image-multimedia
+└── serial_transfer.py       File transfer over debug UART (base64)
+
+docs/
+├── 01-dev-environment.md    Build host setup
+├── 02-hardware-guide.md     EVK wiring, boot config, peripheral map
+├── 03-yocto-bsp.md          Yocto BSP build (repo init → bitbake)
+├── 07-camera-npu.md         Camera + NPU object detection pipeline
+└── 08-device-tree-explained.md  Device tree walkthrough
 ```
 
-<!-- 架构说明：环境传感（BME280）走 Linux 内核驱动，运动传感（MPU6050）走 M7 实时采样，两核通过 RPMsg 通信 -->
+## What's Working
 
-The split is deliberate: environmental sensing (BME280) goes through a proper Linux kernel driver so I can expose it via sysfs and feed it into the NPU pipeline. Motion sensing (MPU6050) needs deterministic sub-millisecond timing, so it runs bare-metal on the M7 under FreeRTOS. The two cores talk over RPMsg through the Messaging Unit (MU) hardware.
+| Subsystem | Status | Details |
+| --------- | ------ | ------- |
+| Yocto BSP | Boots from SD | `imx-image-multimedia`, Scarthgap branch |
+| OV5640 camera | Live HDMI preview | MIPI CSI-2 → ISI → GStreamer → Weston |
+| NPU (VIP8000) | Driver loaded | galcore 6.4.11, VX Delegate + TFLite 2.16.2 |
+| GPU (GC7000UL) | Weston @ 60 FPS | `weston-simple-egl` verified |
+| Debug UART | Working | J23, 3rd COM port = A53 console (115200 8N1) |
 
-## Hardware
+## Quick Start
 
-| Item | Part | Notes |
-| ---- | ---- | ----- |
-| Dev board | 8MPLUSLPD4-EVK | i.MX 8M Plus EVK, 6 GB LPDDR4, 32 GB eMMC |
-| Camera adapter + OV5640 | MINISASTOCSI | MIPI CSI camera module |
-| Industrial SD card | SanDisk SDXC 64 GB | SD boot for development |
-| Temp/humidity/pressure sensor | BME280 (I2C, 3.3 V) | Connected to I2C3 (A53 Linux) |
-| 6-axis IMU | MPU6050 GY-521 | Connected to I2C2 (M7 FreeRTOS) |
-| OLED display | SSD1306 0.96" I2C | Shares I2C2 bus with MPU6050 |
-
-### Verified Specs (from first boot)
-
-<!-- 首次启动验证数据 -->
-
-| Parameter | Value |
-| --------- | ----- |
-| CPU | 4x Cortex-A53 @ 1.8 GHz (ARMv8-A) |
-| Usable RAM | 5.5 GiB (of 6 GB LPDDR4) |
-| eMMC | 29.1 GB on-board |
-| SPI NOR | 32 MB |
-| Ethernet | 2x GbE (FEC + DWMAC/TSN) |
-| I2C | 3 buses available (I2C1–I2C3) |
-| Kernel | 6.6.52-lts (Yocto scarthgap) |
+```bash
+# 1. Build the Yocto image (Ubuntu 22.04 host, ~2 hours first build)
+source scripts/build-multimedia.sh
+
+# 2. Flash to SD card (use Rufus DD image mode on Windows)
+#    Set SW4: OFF OFF ON ON (SD card boot)
+
+# 3. Connect: USB-C to J5 (power), micro-USB to J23 (debug UART)
+#    Serial: 3rd COM port, 115200 8N1
+
+# 4. Camera preview (on the EVK, over serial console)
+export XDG_RUNTIME_DIR=/run/user/0
+gst-launch-1.0 v4l2src device=/dev/video3 ! \
+    video/x-raw,width=640,height=480,framerate=30/1 ! \
+    videoconvert ! autovideosink
+
+# 5. Build and load the hello module (cross-compile or on-device)
+cd kernel-modules/hello
+make ARCH=arm64 CROSS_COMPILE=aarch64-poky-linux- \
+     KERNELDIR=/path/to/yocto/build/tmp/work/.../linux-imx/build
+scp hello.ko root@<EVK_IP>:/tmp/
+# On EVK:
+insmod /tmp/hello.ko && dmesg | tail -3
+```
 
-## Roadmap
+## Kernel Modules
 
-### Phase 1 — Environment + first Yocto boot ✓
+Three out-of-tree modules demonstrating progressive driver complexity:
 
-- [x] Set up Ubuntu 22.04 build host with all Yocto dependencies
-- [x] `repo init` the NXP BSP manifest, sync sources
-- [x] Build a minimal custom image with `bitbake`
-- [x] Flash to SD card, boot the EVK, get a serial console
-- [x] Verify basic peripherals (CPU, RAM, storage, network, I2C)
+**hello** — Module lifecycle (`init`/`exit`), `printk`, section markers (`__init`/`__exit`).
 
-### Phase 2 — Linux kernel driver development (BME280)
+**chardev** — Full character device with dynamic major allocation, `file_operations` (read/write/ioctl), `copy_to_user`/`copy_from_user`, mutex synchronization, and automatic `/dev` node creation via `class_create`/`device_create`.
 
-- [ ] Write an out-of-tree I2C kernel driver module for BME280
-- [ ] Modify the device tree to describe the BME280 on I2C3
-- [ ] Expose temperature, humidity, and pressure readings via sysfs
-- [ ] Build a userspace data collector daemon in C
-- [ ] Integrate the driver into the Yocto build as a recipe
+**bme280** — I2C client driver using the `probe`/`remove` lifecycle, device tree `compatible` matching, `i2c_smbus_*` register access, sysfs attributes, and `devm_` managed allocation.
 
-### Phase 3 — FreeRTOS dual-core development (M7 + RPMsg)
+## V4L2 Capture
 
-<!-- M7 实时核开发：MCUXpresso SDK + FreeRTOS + RPMsg 核间通信 -->
+Userspace C program demonstrating the V4L2 multi-planar API as used by i.MX8MP's ISI:
 
-- [ ] Set up the MCUXpresso SDK build environment for Cortex-M7
-- [ ] Port or write a FreeRTOS application for MPU6050 sampling at 1 kHz
-- [ ] Bring up RPMsg communication between A53 (Linux) and M7 (FreeRTOS)
-- [ ] Implement data packing on M7 and unpacking on the Linux side
-- [ ] Add SSD1306 OLED output for local IMU status display
+- `VIDIOC_QUERYCAP` → capability query
+- `VIDIOC_S_FMT` → format negotiation (multi-planar)
+- `VIDIOC_REQBUFS` + `mmap()` → zero-copy DMA buffer setup
+- `VIDIOC_QBUF`/`VIDIOC_DQBUF` → streaming capture loop
 
-### Phase 4 — NPU edge AI integration
+## Device Tree
 
-<!-- NPU 边缘推理：eIQ + TFLite + INT8 量化模型 -->
+The [`dts/imx8mp-evk-ov5640.dts`](dts/imx8mp-evk-ov5640.dts) overlay is annotated to explain how the camera pipeline is described in hardware:
 
-- [ ] Explore the eIQ ML framework and its TFLite delegate for the NPU
-- [ ] Train and quantize a small anomaly detection model (INT8)
-- [ ] Deploy on the NPU, feed it sensor data from both cores
-- [ ] Build a lightweight web UI to display real-time data and inference results
-- [ ] Profile NPU inference latency and power consumption
+```text
+OV5640 (I2C, 0x3c) → MIPI CSI-2 RX → ISI ch0 → /dev/video3
+```
 
-## Documentation
+Covers clock providers, regulator bindings, OF graph endpoint linking, and MIPI lane configuration.
 
-| Doc | Content |
-| --- | ------- |
-| [01-dev-environment.md](docs/01-dev-environment.md) | Host PC setup: Ubuntu, Yocto deps, toolchains |
-| [02-hardware-guide.md](docs/02-hardware-guide.md) | EVK wiring, serial console, DIP switches, boot verification |
-| [03-yocto-bsp.md](docs/03-yocto-bsp.md) | Full Yocto build walkthrough (repo init to bitbake) |
-| [04-freertos-m7.md](docs/04-freertos-m7.md) | Cortex-M7 FreeRTOS development (MCUXpresso SDK) |
-| [05-npu-eiq.md](docs/05-npu-eiq.md) | NPU edge AI (eIQ, TFLite, quantized models) |
-| [06-references.md](docs/06-references.md) | Official docs, community resources, useful links |
+## i.MX8MP Video Device Map
 
-## Quick Start
+On this SoC, `/dev/video0` is **not** the camera:
+
+| Device | Function |
+| ------ | -------- |
+| /dev/video0 | VPU H.264/HEVC encoder |
+| /dev/video1 | VPU decoder |
+| /dev/video2 | ISI memory-to-memory (CSC) |
+| /dev/video3 | **ISI capture (camera)** |
 
-1. **Set up the build host** — Install Ubuntu 22.04 and the required packages. See [01-dev-environment.md](docs/01-dev-environment.md).
-2. **Build the Yocto image** — Follow [03-yocto-bsp.md](docs/03-yocto-bsp.md) to `repo init`, sync, and `bitbake` a bootable image.
-3. **Flash and boot** — Write the `.wic` image to SD card with Rufus (use DD image mode), set SW4 to `OFF OFF ON ON`, power on via J5. Login as `root` (no password) over the serial console at J23 (3rd COM port, 115200 8N1).
-4. **Wire up sensors** — Connect BME280 to I2C3 and MPU6050 + SSD1306 to I2C2. Pinout details in [02-hardware-guide.md](docs/02-hardware-guide.md).
-5. **Build M7 firmware** — Compile the FreeRTOS application and load it onto the Cortex-M7. See [04-freertos-m7.md](docs/04-freertos-m7.md).
+## Roadmap
 
-<!-- 快速开始提示：烧录用 Rufus DD 模式，SW4 拨到 OFF OFF ON ON，串口选第三个 COM 口 -->
+- [x] Yocto BSP bring-up and first boot verification
+- [x] Camera pipeline: OV5640 → ISI → GStreamer → HDMI
+- [x] NPU stack verification (galcore, VX Delegate, TFLite)
+- [x] Kernel module examples (hello, chardev, I2C driver)
+- [x] V4L2 capture program and device tree overlay
+- [ ] NPU benchmark: CPU vs NPU inference latency
+- [ ] Real-time object detection (MobileNet SSD + camera + NPU)
+- [ ] FreeRTOS on Cortex-M7 with RPMsg inter-core communication
+- [ ] End-to-end demo: camera → NPU → overlay → HDMI
 
 ## License
 
-MIT — see [LICENSE](LICENSE).
+MIT