Root Hub (主机控制器内置
  ├── Hub
    ├── Device A
    └── Device B
  └── Device C

设备描述符（Device Descriptor)
  └── 配置描述符（Configuration Descriptor)
        ├── 接口描述符（Interface Descriptor)
            └── 端点描述符（Endpoint Descriptor)
        └── 接口描述符（Interface Descriptor)
              └── 端点描述符（Endpoint Descriptor)

// linux/usb.h（简化）
struct usb_driver {
    const char *name;
    int  (*probe)(struct usb_interface *intf,
                  const struct usb_device_id *id);
    void (*disconnect)(struct usb_interface *intf);
    int  (*suspend)(struct usb_interface *intf, pm_message_t msg);
    int  (*resume)(struct usb_interface *intf);
    const struct usb_device_id *id_table;
    struct device_driver driver;  // 内嵌device_driver。.8统一设备模型
};

module_usb_driver(my_usb_driver);
// 等价于 module_init + usb_register + module_exit + usb_deregister

// linux/mod_devicetable.h（简化）
struct usb_device_id {
    __u16 match_flags;       // 哪些字段参与匹配
    __u16 idVendor;          // VID
    __u16 idProduct;         // PID
    __u16 bDeviceClass;      // 设备。    __u16 bDeviceSubClass;   // 设备子类
    __u16 bDeviceProtocol;   // 设备协议
    __u16 bInterfaceClass;   // 接口。    __u16 bInterfaceSubClass;// 接口子类
    __u16 bInterfaceProtocol;// 接口协议
    kernel_ulong_t driver_info; // 驱动私有数据
};

// 精确匹配VID/PID
{ USB_DEVICE(0x1234, 0x5678) }

// 匹配某类设备（如HID类）
{ USB_INTERFACE_INFO(USB_CLASS_HID, 0, 0) }

// 匹配某VID的所有设。{ USB_DEVICE_VENDOR(0x1234) }

// linux/usb.h（简化）
struct urb {
    struct usb_device *dev;       // 目标设备
    unsigned int pipe;            // 管道（端点+方向+类型编码）    void *transfer_buffer;        // 传输缓冲区    u32 transfer_buffer_length;   // 缓冲区长度    u32 actual_length;            // 实际传输长度
    usb_complete_t complete;      // 完成回调
    void *context;                // 回调上下。    int status;                   // 传输状态    unsigned int transfer_flags;  // 传输标志
    int interval;                 // 轮询间隔（中断/等时）    // ... 更多字段
};

static struct usb_device_id my_usb_table[] = {
    { USB_DEVICE(0x1234, 0x5678) },
    { }  // 末尾空项，必。};
MODULE_DEVICE_TABLE(usb, my_usb_table);

// my_usb_drv.c - Linux 6.8 USB批量传输驱动示例
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/slab.h>

#define VENDOR_ID  0x1234
#define PRODUCT_ID 0x5678

// 驱动私有数据
struct my_usb_dev {
    struct usb_device  *udev;       // USB设备
    struct usb_interface *intf;     // USB接口
    __u8               bulk_in_addr;  // IN端点地址
    __u8               bulk_out_addr; // OUT端点地址
    size_t             bulk_in_size;  // IN端点最大包。    struct urb         *bulk_in_urb;  // IN端点urb
    void               *bulk_in_buf;  // IN端点缓冲。    struct mutex        io_mutex;     // IO互斥。};

// 匹配置static struct usb_device_id my_usb_table[] = {
    { USB_DEVICE(VENDOR_ID, PRODUCT_ID) },
    { }
};
MODULE_DEVICE_TABLE(usb, my_usb_table);

// IN端点urb完成回调
static void my_bulk_in_callback(struct urb *urb)
{
    struct my_usb_dev *dev = urb->context;

    switch (urb->status) {
    case 0:
        // 传输成功，处理数。        dev_info(&dev->intf->dev, "收到 %d 字节\n",
                 urb->actual_length);
        break;
    case -ECONNRESET:   // urb被kill
    case -ENOENT:       // urb被unlink
    case -ESHUTDOWN:    // 设备已断开
        // 这些是正常断开，不报错
        return;
    default:
        dev_err(&dev->intf->dev, "urb错误: %d\n", urb->status);
        break;
    }

    // 重新提交urb，持续接。    usb_submit_urb(dev->bulk_in_urb, GFP_ATOMIC);
}

// 查找批量端点
static int find_bulk_endpoints(struct my_usb_dev *dev,
                                struct usb_interface *intf)
{
    struct usb_host_interface *alts;
    struct usb_endpoint_descriptor *epd;
    int i;

    // 使用当前altsetting
    alts = intf->cur_altsetting;

    for (i = 0; i < alts->desc.bNumEndpoints; i++) {
        epd = &alts->endpoint[i].desc;

        if (!usb_endpoint_is_bulk_in(epd) &&
            !usb_endpoint_is_bulk_out(epd))
            continue;

        if (usb_endpoint_is_bulk_in(epd)) {
            dev->bulk_in_addr = epd->bEndpointAddress;
            dev->bulk_in_size = usb_endpoint_maxp(epd);
        } else {
            dev->bulk_out_addr = epd->bEndpointAddress;
        }
    }

    if (!dev->bulk_in_addr || !dev->bulk_out_addr) {
        dev_err(&intf->dev, "找不到批量端点\n");
        return -ENODEV;
    }

    return 0;
}

// probe回调
static int my_usb_probe(struct usb_interface *intf,
                         const struct usb_device_id *id)
{
    struct my_usb_dev *dev;
    struct usb_device *udev = interface_to_usbdev(intf);
    int ret;

    dev_info(&intf->dev, "probe: VID=%04x PID=%04x\n",
             id->idVendor, id->idProduct);

    // 分配私有数据
    dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    if (!dev)
        return -ENOMEM;

    dev->udev = udev;
    dev->intf = intf;
    mutex_init(&dev->io_mutex);

    // 查找端点
    ret = find_bulk_endpoints(dev, intf);
    if (ret)
        goto fail_find_ep;

    // 分配IN端点urb
    dev->bulk_in_urb = usb_alloc_urb(0, GFP_KERNEL);
    if (!dev->bulk_in_urb) {
        ret = -ENOMEM;
        goto fail_alloc_urb;
    }

    // 分配IN端点缓冲。    dev->bulk_in_buf = kzalloc(dev->bulk_in_size, GFP_KERNEL);
    if (!dev->bulk_in_buf) {
        ret = -ENOMEM;
        goto fail_alloc_buf;
    }

    // 填充IN端点urb
    usb_fill_bulk_urb(dev->bulk_in_urb,
                      udev,
                      usb_rcvbulkpipe(udev, dev->bulk_in_addr),
                      dev->bulk_in_buf,
                      dev->bulk_in_size,
                      my_bulk_in_callback,
                      dev);

    // 提交IN端点urb，开始接。    ret = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL);
    if (ret) {
        dev_err(&intf->dev, "提交urb失败: %d\n", ret);
        goto fail_submit;
    }

    // 保存私有数据到interface
    usb_set_intfdata(intf, dev);

    return 0;

fail_submit:
    kfree(dev->bulk_in_buf);
fail_alloc_buf:
    usb_free_urb(dev->bulk_in_urb);
fail_alloc_urb:
fail_find_ep:
    kfree(dev);
    return ret;
}

// disconnect回调
static void my_usb_disconnect(struct usb_interface *intf)
{
    struct my_usb_dev *dev;

    dev = usb_get_intfdata(intf);
    if (!dev)
        return;

    // 先清空interface私有数据，防止其他地方还在用
    usb_set_intfdata(intf, NULL);

    // 杀掉urb，等回调执行。    usb_kill_urb(dev->bulk_in_urb);

    // 释放资源
    usb_free_urb(dev->bulk_in_urb);
    kfree(dev->bulk_in_buf);
    mutex_destroy(&dev->io_mutex);
    kfree(dev);

    dev_info(&intf->dev, "设备已断开\n");
}

// usb_driver定义
static struct usb_driver my_usb_driver = {
    .name       = "my_usb_drv",
    .id_table   = my_usb_table,
    .probe      = my_usb_probe,
    .disconnect = my_usb_disconnect,
};

module_usb_driver(my_usb_driver);

MODULE_AUTHOR("linuxros");
MODULE_DESCRIPTION("USB批量传输驱动示例");
MODULE_LICENSE("GPL");

// 批量传输
void usb_fill_bulk_urb(struct urb *urb,
                       struct usb_device *dev,
                       unsigned int pipe,
                       void *transfer_buffer,
                       int buffer_length,
                       usb_complete_t complete_fn,
                       void *context);

// 中断传输
void usb_fill_int_urb(struct urb *urb,
                      struct usb_device *dev,
                      unsigned int pipe,
                      void *transfer_buffer,
                      int buffer_length,
                      usb_complete_t complete_fn,
                      void *context,
                      int interval);

// 控制传输（需要手动设置setup_packet。// 没有usb_fill_control_urb，手动填充：
urb->setup_packet = (u8 *)dr;  // struct usb_ctrlrequest
urb->transfer_buffer = buf;
urb->transfer_buffer_length = len;

// 同步批量传输
int usb_bulk_msg(struct usb_device *dev,
                 unsigned int pipe,
                 void *data,
                 int len,
                 int *actual_length,
                 int timeout);  // 超时ms0=无限等待

// 同步控制传输
int usb_control_msg(struct usb_device *dev,
                    unsigned int pipe,
                    __u8 request,
                    __u8 requesttype,
                    __u16 value,
                    __u16 index,
                    void *data,
                    __u16 size,
                    int timeout);

# 列出所有USB设备
lsusb

# 查看设备详细描述符
lsusb -v -d 1234:5678

# 只看设备树拓扑
lsusb -t

# 查看USB设备
ls /sys/bus/usb/devices/

# 查看特定设备的VID/PID
cat /sys/bus/usb/devices/1-1/idVendor
cat /sys/bus/usb/devices/1-1/idProduct

# 查看设备配置
cat /sys/bus/usb/devices/1-1/bConfigurationValue

# 查看接口驱动绑定
cat /sys/bus/usb/devices/1-1:1.0/driver_override
ls -l /sys/bus/usb/devices/1-1:1.0/driver

// 用户空间USB操作示例（libusb。#include <libusb.h>

libusb_device_handle *handle;
libusb_init(NULL);
handle = libusb_open_device_with_vid_pid(NULL, 0x1234, 0x5678);
libusb_claim_interface(handle, 0);

unsigned char buf[64];
int actual;
libusb_bulk_transfer(handle, 0x81, buf, sizeof(buf), &actual, 1000);

libusb_release_interface(handle, 0);
libusb_close(handle);
libusb_exit(NULL);

# 1. 挂载debugfs
mount -t debugfs none /sys/kernel/debug

# 2. 查看可用总线
cat /sys/kernel/debug/usb/usbmon/0t

# 3. 抓取总线1的数据
cat /sys/kernel/debug/usb/usbmon/1t > usb_trace.log

# 4. 也可以用二进制格式（信息更全）
cat /sys/kernel/debug/usb/usbmon/1u > usb_trace.bin

ee998280 2765.123456 S Co:001:00 s 80 06 0100 0000 0012 18
ee998280 2765.123789 C Co:001:00 0 18

# 1. 生成二进制抓包
cat /sys/kernel/debug/usb/usbmon/1u | socat - UDP4-DATAGRAM:127.0.0.1:5555 &

# 或者直接用Wireshark。# Wireshark 4.x原生支持usbmon接口

# 开启usbcore的所有调试输出
echo 'module usbcore +p' > /sys/kernel/debug/dynamic_debug/control

# 开启特定驱动的调试
echo 'file my_usb_drv.c +p' > /sys/kernel/debug/dynamic_debug/control

# 开启USB核心的枚举调试echo 'file hub.c +p' > /sys/kernel/debug/dynamic_debug/control

# 关闭调试
echo 'module usbcore -p' > /sys/kernel/debug/dynamic_debug/control

# 强制指定驱动
echo "my_usb_drv" > /sys/bus/usb/devices/1-1:1.0/driver_override
echo "1-1:11.0" > /sys/bus/usb/drivers_probe

// 安全的urb提交模式
mutex_lock(&dev->io_mutex);
if (dev->intf)  // disconnect还没被调试    ret = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL);
mutex_unlock(&dev->io_mutex);