Wi-Fi 网络协议栈与 Rust Wi-Fi Driver 实战

┌──────────────────────────────────────────────────────────┐
│                   主机 CPU (Host Platform)               │
│ Linux 内核驱动 --(读取 /lib/firmware/xxx.bin)             │
└──────────────────────────┬───────────────────────────────┘
                           │ 1. 通过 USB/PCIe/SDIO 总线发送 `.bin` 固件
                           ▼
┌──────────────────────────────────────────────────────────┐
│                  Wi-Fi 芯片 (Wi-Fi SoC)                  │
│ 内部微控制器 (ARM Cortex-M / DSP) 接收固件并加载到 RAM 运行  │
│ 启动独立 802.11 物理层 & 毫秒级 MAC 协议栈                │
└────────────────└─────────────────────────────────────────┘

[用户态 Socket]
      │ 1. HTTP / TCP 数据流
      ▼
[内核网络协议栈] ──(802.3 转 802.11 帧)──► [mac80211 / cfg80211]
                                                 │
                                                 │ 2. 封装 URB / DMA 描述符
                                                 ▼
[Wi-Fi 芯片 Firmware] ◄──(USB / PCIe 总线)── [网卡驱动 Driver]
      │
      │ 3. CSMA/CA 载波监听 + 硬件 WPA 加密
      ▼
[基带 & 射频 PHY 芯片]
      │
      │ 4. OFDM / QAM 调制 + 2.4G/5G/6G 载波 + 功率放大 (PA)
      ▼
   天线 (空气电磁波) ──────────────► 无线路由器 (Access Point)

                       Linux 内核网络协议栈 (net_device / mac80211)
                                         │
                         Rust 驱动控制层 (URB 生命周期管理)
                         ┌───────────────┴───────────────┐
                         ▼                               ▼
               Bulk OUT (发送数据帧)            Bulk IN (接收数据帧)
                         │                               ▲
                         ▼                               │
               ┌───────────────────────────────────────────┐
               │    USB 总线控制器 (xHCI / EHCI / PHY)     │
               └───────────────────────────────────────────┘
                                         │
                                   物理 Wi-Fi 天线

// 内核态 Rust USB 无线网卡驱动核心架构
use kernel::prelude::*;
use kernel::usb::{self, Endpoint, Urb, DeviceId};
use kernel::net::device::{NetDevice, NetDeviceOps};
use kernel::sync::Arc;

// 声明 USB 匹配表 (Vendor ID & Product ID)
const USB_WIFI_DEVICES: &[DeviceId] = &[
    DeviceId::new(0x0bda, 0x8179), // 示例：Realtek USB Wi-Fi ID
];

module_usb_driver! {
    type: UsbWifiDriver,
    name: "rust_usb_wifi",
    author: "Developer",
    description: "Rust Driver for USB Wireless Adapter",
    license: "GPL",
    id_table: USB_WIFI_DEVICES,
}

struct UsbWifiDevice {
    usb_dev: usb::Device,
    bulk_in_ep: Endpoint,
    bulk_out_ep: Endpoint,
    netdev: Ref<NetDevice>,
}

struct UsbWifiDriver;

impl usb::Driver for UsbWifiDriver {
    type Data = Arc<UsbWifiDevice>;

    fn probe(dev: &mut usb::Device, id: &DeviceId) -> Result<Self::Data> {
        pr_info!("Rust USB Wi-Fi Adapter detected: {:?}\n", id);

        // 1. 解析端点描述符，寻找 Bulk IN 和 Bulk OUT 端点
        let bulk_in = dev.find_bulk_in_endpoint(0x81)?;
        let bulk_out = dev.find_bulk_out_endpoint(0x02)?;

        // 2. 分配并注册内核 net_device 网卡接口 (如 wlan0)
        let netdev = NetDevice::new("wlan%d", &WifiNetOps)?;

        let wifi_dev = Arc::new(UsbWifiDevice {
            usb_dev: dev.clone(),
            bulk_in_ep: bulk_in,
            bulk_out_ep: bulk_out,
            netdev,
        });

        // 3. 提交异步 Bulk IN URB 准备接收空中数据包
        wifi_dev.submit_rx_urb()?;

        Ok(wifi_dev)
    }

    fn disconnect(data: &Self::Data) {
        pr_info!("Rust USB Wi-Fi Adapter disconnected\n");
        // RAII 机制自动取消所有未完成的 URB 并注销 netdev
    }
}

// 网卡操作契约
struct WifiNetOps;

impl NetDeviceOps for WifiNetOps {
    fn ndo_start_xmit(skb: &SkBuff, dev: &NetDevice) -> NetXmit {
        // 将 skb 802.11 数据包打包为 USB Bulk OUT URB 并异步提交给网卡发送
        NetXmit::Success
    }
}

// 用户态 Rust USB 无线网卡高吞吐收发器
use rusb::{Context, DeviceHandle, UsbContext};
use std::time::Duration;
use tokio::sync::mpsc;

const VID: u16 = 0x0bda;
const PID: u16 = 0x8179;
const BULK_IN_EP: u8 = 0x81;
const BULK_OUT_EP: u8 = 0x02;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let context = Context::new()?;
    let handle = context
        .open_device_with_vid_pid(VID, PID)
        .ok_or("USB Wi-Fi adapter not found")?;

    // 申请接口与配置
    if handle.kernel_driver_active(0).unwrap_or(false) {
        handle.detach_kernel_driver(0)?;
    }
    handle.claim_interface(0)?;

    // 创建异步 MPSC Channel 用于发送待下发的 802.11 数据包
    let (tx_chan, mut rx_chan) = mpsc::channel::<Vec<u8>>(100);

    // 独立数据帧接收线程 (Bulk IN)
    let handle_rx = handle.clone();
    tokio::task::spawn_blocking(move || loop {
        let mut packet_buf = vec![0u8; 2048];
        match handle_rx.read_bulk(BULK_IN_EP, &mut packet_buf, Duration::from_millis(10)) {
            Ok(bytes_read) => {
                let frame = &packet_buf[..bytes_read];
                // 解析 802.11 数据包头部 (MAC 地址、RSSI、Payload)
                println!("Rx 802.11 Frame: {} bytes", frame.len());
            }
            Err(rusb::Error::Timeout) => continue,
            Err(e) => {
                eprintln!("Rx Error: {:?}", e);
                break;
            }
        }
    });

    // 独立数据帧发送任务 (Bulk OUT)
    tokio::spawn(async move {
        while let Some(tx_packet) = rx_chan.recv().await {
            let handle_tx = handle.clone();
            tokio::task::spawn_blocking(move || {
                handle_tx.write_bulk(BULK_OUT_EP, &tx_packet, Duration::from_secs(1)).ok();
            }).await.ok();
        }
    });

    Ok(())
}