&usb20_otg {
    compatible = "rockchip,rk3506-usb", "snps,dwc2";
    reg = <0x0 0xff400000 0x0 0x40000>;
    interrupts = <GIC_SPI 62 IRQ_TYPE_LEVEL_HIGH>;
    clocks = <&cru HCLK_OTG>, <&cru HCLK_OTG_PMU>;
    clock-names = "otg", "otg_pmu";
    dr_mode = "otg";
    g-use-dma;
    g-rx-fifo-size = <512>;
    g-np-tx-fifo-size = <32>;
    phys = <&usb2phy_otg>;
    phy-names = "usb2-phy";
    status = "okay";
};

&usb2phy_otg {
    status = "okay";
};

CONFIG_USB=y
CONFIG_USB_DWC2=y
CONFIG_USB_DWC2_HOST=y
CONFIG_USB_DWC2_DUAL_ROLE=y
CONFIG_USB_ANNOUNCE_NEW_DEVICES=y

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/usb.h>

#define DRIVER_NAME "usb_demo"
#define VENDOR_ID   0x1234
#define PRODUCT_ID  0x5678

struct usb_demo_dev {
    struct usb_device *udev;
    struct usb_interface *intf;

    unsigned char *bulk_in_buf;
    size_t bulk_in_size;
    __u8 bulk_in_ep;
    __u8 bulk_out_ep;

    struct urb *bulk_in_urb;
};

static const struct usb_device_id usb_demo_ids[] = {
    { USB_DEVICE(VENDOR_ID, PRODUCT_ID) },
    { }
};
MODULE_DEVICE_TABLE(usb, usb_demo_ids);

static void usb_demo_bulk_in_cb(struct urb *urb)
{
    struct usb_demo_dev *dev = urb->context;
    int ret;

    if (urb->status) {
        if (urb->status != -ENOENT && urb->status != -ESHUTDOWN)
            dev_err(&dev->intf->dev,
                    "URB error: %d\n", urb->status);
        return;
    }

    dev_info(&dev->intf->dev,
             "received %d bytes\n", urb->actual_length);

    ret = usb_submit_urb(urb, GFP_ATOMIC);
    if (ret)
        dev_err(&dev->intf->dev,
                "resubmit URB failed: %d\n", ret);
}

static int usb_demo_probe(struct usb_interface *intf,
                          const struct usb_device_id *id)
{
    struct usb_device *udev = interface_to_usbdev(intf);
    struct usb_demo_dev *dev;
    struct usb_host_interface *iface_desc;
    struct usb_endpoint_descriptor *ep;
    int i, ret;

    dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL);
    if (!dev)
        return -ENOMEM;

    dev->udev = udev;
    dev->intf = intf;

    /* 1. 遍历端点，记录批量IN/OUT端点地址 */
    iface_desc = &intf->altsetting[0];
    for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
        ep = &iface_desc->endpoint[i].desc;

        if (!dev->bulk_in_ep &&
            usb_endpoint_is_bulk_in(ep)) {
            dev->bulk_in_size = usb_endpoint_maxp(ep);
            dev->bulk_in_ep = ep->bEndpointAddress;
        }

        if (!dev->bulk_out_ep &&
            usb_endpoint_is_bulk_out(ep)) {
            dev->bulk_out_ep = ep->bEndpointAddress;
        }
    }

    if (!dev->bulk_in_ep || !dev->bulk_out_ep) {
        dev_err(&intf->dev, "endpoints not found\n");
        return -ENODEV;
    }

    /* 2. 分配接收缓冲区 */
    dev->bulk_in_buf = kmalloc(dev->bulk_in_size, GFP_KERNEL);
    if (!dev->bulk_in_buf)
        return -ENOMEM;

    /* 3. 分配并填充批量IN URB */
    dev->bulk_in_urb = usb_alloc_urb(0, GFP_KERNEL);
    if (!dev->bulk_in_urb) {
        ret = -ENOMEM;
        goto err_free_buf;
    }

    usb_fill_bulk_urb(dev->bulk_in_urb, udev,
                      usb_rcvbulkpipe(udev, dev->bulk_in_ep),
                      dev->bulk_in_buf, dev->bulk_in_size,
                      usb_demo_bulk_in_cb, dev);

    /* 4. 保存私有数据 */
    usb_set_intfdata(intf, dev);

    /* 5. 提交URB，启动异步传输 */
    ret = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL);
    if (ret) {
        dev_err(&intf->dev, "submit URB failed: %d\n", ret);
        goto err_free_urb;
    }

    dev_info(&intf->dev, "USB device probed, "
             "ep_in=0x%02x ep_out=0x%02x\n",
             dev->bulk_in_ep, dev->bulk_out_ep);
    return 0;

err_free_urb:
    usb_free_urb(dev->bulk_in_urb);
err_free_buf:
    kfree(dev->bulk_in_buf);
    return ret;
}

static void usb_demo_disconnect(struct usb_interface *intf)
{
    struct usb_demo_dev *dev = usb_get_intfdata(intf);

    usb_kill_urb(dev->bulk_in_urb);
    usb_free_urb(dev->bulk_in_urb);
    kfree(dev->bulk_in_buf);

    usb_set_intfdata(intf, NULL);

    dev_info(&intf->dev, "USB device removed\n");
}

static struct usb_driver usb_demo_driver = {
    .name = DRIVER_NAME,
    .id_table = usb_demo_ids,
    .probe = usb_demo_probe,
    .disconnect = usb_demo_disconnect,
};

module_usb_driver(usb_demo_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Driver Developer");
MODULE_DESCRIPTION("USB Demo Driver");

static int usb_demo_bulk_out(struct usb_demo_dev *dev,
                              void *data, size_t len)
{
    int ret, actual_len;

    ret = usb_bulk_msg(dev->udev,
                       usb_sndbulkpipe(dev->udev, dev->bulk_out_ep),
                       data, len, &actual_len, 5000);
    if (ret) {
        dev_err(&dev->intf->dev,
                "bulk out failed: %d\n", ret);
        return ret;
    }

    if (actual_len != len) {
        dev_warn(&dev->intf->dev,
                 "short write: %d/%zu\n", actual_len, len);
        return -EIO;
    }

    return 0;
}

# 查看所有USB设备（含VID/PID和速度）
lsusb -v

# 查看USB设备树拓扑
lsusb -t

# 查看内核USB设备原始信息
cat /sys/kernel/debug/usb/devices

# 查看USB驱动绑定关系
ls -l /sys/bus/usb/drivers/

# 手动解绑/绑定设备（调试用）
echo "1-1:1.0" > /sys/bus/usb/drivers/usb_demo/unbind
echo "1-1:1.0" > /sys/bus/usb/drivers/usb_demo/bind

# 查看内核日志
dmesg | grep -i usb

# 抓取USB总线原始数据（需usbmon模块）
modprobe usbmon
cat /sys/kernel/debug/usb/usbmon/1u

# 查看dwc2控制器寄存器和参数（路径因平台而异）
ls /sys/kernel/debug/*.dwc2/
cat /sys/kernel/debug/*.dwc2/params

# 查看USB PHY注册信息
cat /sys/kernel/debug/usb/phy

/* 错误！disconnect中先释放缓冲区再取消URB */
kfree(dev->bulk_in_buf);     // URB可能还在访问buffer！
usb_kill_urb(dev->bulk_in_urb);

/* 正确！先取消URB，再释放资源 */
usb_kill_urb(dev->bulk_in_urb);   // 1. 等待URB完全停止
usb_free_urb(dev->bulk_in_urb);   // 2. 释放URB结构
kfree(dev->bulk_in_buf);          // 3. 最后释放缓冲区