《Linux总线、设备与驱动》USB设备发现机制

最新推荐文章于 2024-05-14 04:24:49 发布
置顶 最新推荐文章于 2024-05-14 04:24:49 发布
阅读量1.6w 收藏 29
点赞数 4
分类专栏： arm-Linux学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tankai19880619/article/details/11639185
版权

说明：本分析基于mstar801平台Linux2.6.35.11内核，其他内核版本仅供参考。

一、程序在内核中的位置

1.usb host做为pci总线下的一个设备存在(嵌入式系统中有可能也会直接挂在CPU上)；这部分驱动由厂家实现，本分析以mstar为例。

2.USB总线驱动

kernel/drivers/usb/core/driver.c

EXPORT_SYMBOL_GPL(usb_register_driver);
EXPORT_SYMBOL_GPL(usb_deregister);
EXPORT_SYMBOL_GPL(usb_register_device_driver);
EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
struct bus_type usb_bus_type = {
	.name =		"usb",
	.match =	usb_device_match,
	.uevent =	usb_uevent,
};
kernel/drivers/usb/core/usb.c 
static int __init usb_init(void){
  bus_register(&usb_bus_type);
  usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
}
3.uvc camera设备驱动

kernel/drivers/media/video/uvc/uvc_driver.c

usb_register(&uvc_driver.driver);

二、所有总线、设备和驱动的注册函数

1.设备注册

kernel/drivers/base/core.c

int device_register(struct device *dev){
  device_initialize(dev);
  return device_add(dev);
}
int device_add(struct device *dev){  //所有的设备注册都需要走这里！！！！！！
  error = bus_add_device(dev);
  kobject_uevent(&dev->kobj, KOBJ_ADD);  //上报uevent事件
  bus_probe_device(dev);  //添加到总线
}
2.驱动注册

kernel/drivers/base/driver.c

int driver_register(struct device_driver *drv){  //所有的驱动注册都要走这里！！！！！！！
  ret = bus_add_driver(drv);  //添加到总线
}
3.总线注册

kernel/drivers/base/bus.c

int bus_register(struct bus_type *bus);

三、具体分析

情况一：当插入USB设备时USB host会检测到这一事件；然后通过USB core去匹配驱动。

  当守护程序第一次运行（特殊USB设备USB hub就是这种情况）或usb port上状态发生变化（其余所有USB设备插入都是这种情况）守护进程被唤醒时，会运行hub_events函数、USB的枚举过程就是由它完成。

1.USB host部分代码

说明：从硬件层面来看，ehci主控器从PCI总线桥接，是PCI驱动程序实例。

kernel/drivers/usb/host/ehci-hcd.c

module_init(ehci_hcd_init);
#define PCI_DRIVER      ehci_pci_driver    //利用pci中断
#define PLATFORM_DRIVER                 ehci_hcd_mstar_driver    //利用定时器轮询
static int __init ehci_hcd_init(void){
#ifdef PLATFORM_DRIVER
  platform_driver_register(&PLATFORM_DRIVER);
#endif
#ifdef PCI_DRIVER
  pci_register_driver(&PCI_DRIVER);
#endif
}
下边分两种情况：

==============================================

定时器轮询：

kernel/drivers/usb/host/ehci-mstar.c

static struct platform_driver ehci_hcd_mstar_driver = {
  .probe          = ehci_hcd_mstar_drv_probe,
};
static int ehci_hcd_mstar_drv_probe(struct platform_device *pdev){
  usb_ehci_mstar_probe(&ehci_mstar_hc_driver, &hcd, pdev);
}
int usb_ehci_mstar_probe(const struct hc_driver *driver,struct usb_hcd **hcd_out, struct platform_device *dev){
  usb_create_hcd(driver, &dev->dev, "mstar");
}
kernel/drivers/usb/core/hcd.c 
struct usb_hcd *usb_create_hcd(const struct hc_driver *driver, struct device *dev, const char *bus_name){
  return usb_create_shared_hcd(driver, dev, bus_name, NULL);
}
struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver, struct device *dev, const char *bus_name, struct usb_hcd *primary_hcd){
  init_timer(&hcd->rh_timer);
  hcd->rh_timer.function = rh_timer_func;
}
static void rh_timer_func (unsigned long _hcd)                                                                                                   {
  usb_hcd_poll_rh_status((struct usb_hcd *) _hcd);
}
void usb_hcd_poll_rh_status(struct usb_hcd *hcd){
  hcd->driver->hub_status_data(hcd, buffer);
  usb_hcd_giveback_urb(hcd, urb, 0);  
}

===================

当有pci中断发生后：

kernel/drivers/usb/host/ehci-pci.c

static struct pci_driver ehci_pci_driver = {
  .id_table = pci_ids,
}
static const struct pci_device_id pci_ids [] = { {
    .driver_data =  (unsigned long) &ehci_pci_hc_driver,
  }
}
static const struct hc_driver ehci_pci_hc_driver = {
  .irq =          ehci_irq,  //中断
  .hub_status_data =  ehci_hub_status_data,
  .urb_enqueue = ehci_urb_enqueue,
  .urb_dequeue = ehci_urb_dequeue,
}
kernel/drivers/usb/host/ehci-hcd.c 
static irqreturn_t ehci_irq (struct usb_hcd *hcd){
  usb_hcd_poll_rh_status(hcd);
}

kernel/drivers/usb/core/hcd.c

void usb_hcd_poll_rh_status(struct usb_hcd *hcd){
  hcd->driver->hub_status_data(hcd, buffer);
  usb_hcd_giveback_urb(hcd, urb, 0);
}

kernel/drivers/usb/host/ehci-hub.c

static int ehci_hub_status_data (struct usb_hcd *hcd, char *buf){

}

=====================================================================

从以上分析可以看出；不论是定时器轮询还是pci中断，最终都会执行usb_hcd_giveback_urb函数：

kernel/drivers/usb/core/hcd.c

void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status){
  urb->complete (urb);
}

而上处urv->complete函数其实就是如下的hub_irq函数，后边会分析：

kernel/drivers/usb/core/hub.c

static void hub_irq(struct urb *urb){
  kick_khubd(hub);
}

2.USB core即USB总线部分代码——可以看到hub是第一个USB设备而且与USB总线密切相关

kernel/drivers/usb/core/usb.c

subsys_initcall(usb_init);
struct bus_type usb_bus_type = {
  .name =         "usb",
  .match =        usb_device_match,
  .uevent =       usb_uevent,
};
static int __init usb_init(void){
  bus_register(&usb_bus_type);
  usb_register_device_driver(&usb_generic_driver, THIS_MODULE);  //USB设备驱动，在没有root hub时使用
  usb_hub_init();
}
kernel/drivers/usb/core/hub.c 
static struct usb_driver hub_driver = {
  .name =         "hub",
  .probe =        hub_probe,
};
int usb_hub_init(void){
  usb_register(&hub_driver);  //USB设备驱动，第一个USB设备—root hub
  kthread_run(hub_thread, NULL, "khubd");
}

=====================================

插句话：下边就是之前我们说的urv->complete被赋为hub_irq函数的过程；

这里说明一下：hub的探测函数的执行是在守护线程第一次运行时的情况；为什么不需要USB总线轮询后或PCI总线中断后就执行？我们会在后边hub创建线程处看到。

static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id){
  hub_configure(hub, endpoint);
}
static int hub_configure(struct usb_hub *hub,struct usb_endpoint_descriptor *endpoint){
  usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq, hub, endpoint->bInterval);
}
kernel/include/linux/usb.h 
static inline 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){
  urb->complete = complete_fn;
}
=============================================

kernel/drivers/usb/core/hub.c

这里特别强调：hub设备是第一个USB设备，也是必须的USB设备；它不需要通过USB总线定时器轮询或PCI总线中断来触发。从下边代码也可以看出，在执行第一次hub_events之后（hub驱动的probe函数被执行、urv->complete被赋值hub_irq），该线程才会睡眠！

static int hub_thread(void *__unused){
  do {
    hub_events(); //重要！最核心部分
    wait_event_freezable(khubd_wait,!list_empty(&hub_event_list) || kthread_should_stop());
  } while (!kthread_should_stop() || !list_empty(&hub_event_list));
}  
//内核守护线程khubd，它被kick_khubd唤醒(当prot上状态发生变化时，USB host会调用usb_hcd_poll_rh_status去查询usb root hub port状态，并调用hub中的interrupt urb的回调函数hub_irq，最终去唤醒usb内核守护线程)、通过自身调用wait_event_freezable进入睡眠。   
static void hub_events(void){
  if (connect_change)  hub_port_connect_change(hub, i, portstatus, portchange);
}
static void hub_port_connect_change(struct usb_hub *hub, int port1, u16 portstatus, u16 portchange){
  status = hub_port_init(hub, udev, port1, i);
  status = usb_new_device(udev);
}
int usb_new_device(struct usb_device *udev){
  err = device_add(&udev->dev);
  (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
  /*
  kernel/drivers/usb/core/endpoint.c
  int usb_create_ep_devs(struct device *parent,struct usb_host_endpoint *endpoint,struct usb_device *udev){
    device_register(&ep_dev->dev);
  }
  */
}
kernel/drivers/base/core.c 
int device_add(struct device *dev){  //所有的设备注册都需要走这里！！！！！！
  error = bus_add_device(dev);
  kobject_uevent(&dev->kobj, KOBJ_ADD);  //上报uevent事件
  bus_probe_device(dev);
}
kernel/drivers/base/bus.c 
void bus_probe_device(struct device *dev){
  ret = device_attach(dev);
}
kernel/drivers/base/dd.c 
int device_attach(struct device *dev){
  ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
}
kernel/drivers/base/bus.c 
int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,void *data, int (*fn)(struct device_driver *, void *)){
  while ((drv = next_driver(&i)) && !error)
    error = fn(drv, data);
}
kernel/drivers/base/dd.c 
static int __device_attach(struct device_driver *drv, void *data){
  if (!driver_match_device(drv, dev))
    return 0;
  /*
  kernel/drivers/base/base.h
  static inline int driver_match_device(struct device_driver *drv,struct device *dev){
    return drv->bus->match ? drv->bus->match(dev, drv) : 1;
  }
  kernel/drivers/usb/core/driver.c
  static int usb_device_match(struct device *dev, struct device_driver *drv){
    intf = to_usb_interface(dev);
    usb_drv = to_usb_driver(drv);
    if (id)  return 1;
    id = usb_match_dynamic_id(intf, usb_drv);
    if (id)  return 1;
    return 0;
  }
  */
  return driver_probe_device(drv, dev);
}
int driver_probe_device(struct device_driver *drv, struct device *dev){
  ret = really_probe(dev, drv);
}
static int really_probe(struct device *dev, struct device_driver *drv){
  dev->driver = drv;
  if (dev->bus->probe) {
    ret = dev->bus->probe(dev);
    if (ret)  goto probe_failed;
  } else if (drv->probe) {
    ret = drv->probe(dev);
    if (ret)  goto probe_failed;
  }
}
情况二：当加入USB设备驱动时，也会通过USB core调用mattch函数去匹配设备。

kernel/drivers/media/video/uvc/uvc_driver.c

struct uvc_driver uvc_driver = {
  .driver = {
    .name       = "uvcvideo",
    .probe      = uvc_probe,
    .disconnect = uvc_disconnect,
    .suspend    = uvc_suspend,
    .resume     = uvc_resume,
    .reset_resume   = uvc_reset_resume,
    .id_table   = uvc_ids,
    .supports_autosuspend = 1,
  },
};
module_init(uvc_init);
static int __init uvc_init(void){
  result = usb_register(&uvc_driver.driver);
}
kernel/include/linux/usb.h 
static inline int usb_register(struct usb_driver *driver){
  return usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
}
kernel/drivers/usb/core/driver.c 
int usb_register_driver(struct usb_driver *new_driver, struct module *owner, const char *mod_name){
  retval = driver_register(&new_driver->drvwrap.driver);
}
kernel/drivers/base/driver.c    
int driver_register(struct device_driver *drv){  //所有的驱动注册都要走这里！！！！！！！
  ret = bus_add_driver(drv);
}
kernel/drivers/base/bus.c 
int bus_add_driver(struct device_driver *drv){
  error = driver_attach(drv);
  kobject_uevent(&priv->kobj, KOBJ_ADD);
}
kernel/drivers/base/dd.c 
int driver_attach(struct device_driver *drv){
  return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
}
kernel/drivers/base/bus.c 
int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, int (*fn)(struct device *, void *)){
  while ((dev = next_device(&i)) && !error)  error = fn(dev, data);
}
kernel/drivers/base/dd.c 
static int __driver_attach(struct device *dev, void *data){
  if (!driver_match_device(drv, dev)) return 0;
  /*
  kernel/drivers/base/base.h
  static inline int driver_match_device(struct device_driver *drv,struct device *dev){
    return drv->bus->match ? drv->bus->match(dev, drv) : 1;
  }
  kernel/drivers/usb/core/driver.c
  static int usb_device_match(struct device *dev, struct device_driver *drv){
    intf = to_usb_interface(dev);
    usb_drv = to_usb_driver(drv);
    if (id)  return 1;
    id = usb_match_dynamic_id(intf, usb_drv);
    if (id)  return 1;
    return 0;
  }
  */
  if (!dev->driver) driver_probe_device(drv, dev);
}
int driver_probe_device(struct device_driver *drv, struct device *dev){
  ret = really_probe(dev, drv);
}
static int really_probe(struct device *dev, struct device_driver *drv){
  dev->driver = drv;
  if (dev->bus->probe) {
    ret = dev->bus->probe(dev);
    if (ret)  goto probe_failed;
  } else if (drv->probe) {
    ret = drv->probe(dev);
    if (ret)  goto probe_failed;
  }
}

3.总结

经过分析，总结：

(1).当总线上插入设备、总线会调用设备注册函数device_add/device_register；

(2).当insmod设备驱动、module_init函数里边一定有driver_register；

(3).通过上边分析，如上两个函数最终都会调用到总线驱动的match函数、进行匹配；如USB的总线match函数如下：

kernel/drivers/usb/core/driver.c

struct bus_type usb_bus_type = {
        .name =         "usb",
        .match =        usb_device_match,
        .uevent =       usb_uevent,
        .pm =           &usb_bus_pm_ops,
};
static int usb_device_match(struct device *dev, struct device_driver *drv)
{
        /* devices and interfaces are handled separately */
        if (is_usb_device(dev)) {

                /* interface drivers never match devices */
                if (!is_usb_device_driver(drv))
                        return 0;

                /* TODO: Add real matching code */
                return 1;

        } else if (is_usb_interface(dev)) {
                struct usb_interface *intf;
                struct usb_driver *usb_drv;
                const struct usb_device_id *id;

                /* device drivers never match interfaces */
                if (is_usb_device_driver(drv))
                        return 0;

                intf = to_usb_interface(dev);
                usb_drv = to_usb_driver(drv);

                id = usb_match_id(intf, usb_drv->id_table);//USB是匹配驱动中的id_table
                if (id)
                        return 1;

                id = usb_match_dynamic_id(intf, usb_drv);
                if (id)
                        return 1;
        }

        return 0;
}

下边也看看UVC Camera驱动的id_table:

kernel/drivers/media/video/uvc/uvc_driver.c

struct uvc_driver uvc_driver = {
  .driver = {
    .name		= "uvcvideo",
    .probe		= uvc_probe,
    .disconnect	= uvc_disconnect,
    .suspend	= uvc_suspend,
    .resume		= uvc_resume,
    .reset_resume	= uvc_reset_resume,
    .id_table	= uvc_ids,
    .supports_autosuspend = 1,
  },
};
static struct usb_device_id uvc_ids[] = {
	/* Microsoft Lifecam NX-6000 */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x045e,
	  .idProduct		= 0x00f8,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_PROBE_MINMAX },
	/* Microsoft Lifecam VX-7000 */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x045e,
	  .idProduct		= 0x0723,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_PROBE_MINMAX },
	/* Logitech Quickcam Fusion */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x046d,
	  .idProduct		= 0x08c1,
	  .bInterfaceClass	= USB_CLASS_VENDOR_SPEC,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0 },
	/* Logitech Quickcam Orbit MP */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x046d,
	  .idProduct		= 0x08c2,
	  .bInterfaceClass	= USB_CLASS_VENDOR_SPEC,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0 },
	/* Logitech Quickcam Pro for Notebook */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x046d,
	  .idProduct		= 0x08c3,
	  .bInterfaceClass	= USB_CLASS_VENDOR_SPEC,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0 },
	/* Logitech Quickcam Pro 5000 */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x046d,
	  .idProduct		= 0x08c5,
	  .bInterfaceClass	= USB_CLASS_VENDOR_SPEC,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0 },
	/* Logitech Quickcam OEM Dell Notebook */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x046d,
	  .idProduct		= 0x08c6,
	  .bInterfaceClass	= USB_CLASS_VENDOR_SPEC,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0 },
	/* Logitech Quickcam OEM Cisco VT Camera II */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x046d,
	  .idProduct		= 0x08c7,
	  .bInterfaceClass	= USB_CLASS_VENDOR_SPEC,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0 },
	/* Apple Built-In iSight */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x05ac,
	  .idProduct		= 0x8501,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info 		= UVC_QUIRK_PROBE_MINMAX
				| UVC_QUIRK_BUILTIN_ISIGHT },
	/* Genesys Logic USB 2.0 PC Camera */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x05e3,
	  .idProduct		= 0x0505,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_STREAM_NO_FID },
	/* MT6227 */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x0e8d,
	  .idProduct		= 0x0004,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_PROBE_MINMAX },
	/* Syntek (HP Spartan) */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x174f,
	  .idProduct		= 0x5212,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_STREAM_NO_FID },
	/* Syntek (Samsung Q310) */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x174f,
	  .idProduct		= 0x5931,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_STREAM_NO_FID },
	/* Asus F9SG */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x174f,
	  .idProduct		= 0x8a31,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_STREAM_NO_FID },
	/* Syntek (Asus U3S) */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x174f,
	  .idProduct		= 0x8a33,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_STREAM_NO_FID },
	/* Lenovo Thinkpad SL500 */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x17ef,
	  .idProduct		= 0x480b,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_STREAM_NO_FID },
	/* Ecamm Pico iMage */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x18cd,
	  .idProduct		= 0xcafe,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_PROBE_EXTRAFIELDS },
	/* Bodelin ProScopeHR */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_DEV_HI
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x19ab,
	  .idProduct		= 0x1000,
	  .bcdDevice_hi		= 0x0126,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_STATUS_INTERVAL },
	/* SiGma Micro USB Web Camera */
	{ .match_flags		= USB_DEVICE_ID_MATCH_DEVICE
				| USB_DEVICE_ID_MATCH_INT_INFO,
	  .idVendor		= 0x1c4f,
	  .idProduct		= 0x3000,
	  .bInterfaceClass	= USB_CLASS_VIDEO,
	  .bInterfaceSubClass	= 1,
	  .bInterfaceProtocol	= 0,
	  .driver_info		= UVC_QUIRK_PROBE_MINMAX
				| UVC_QUIRK_IGNORE_SELECTOR_UNIT
				| UVC_QUIRK_PRUNE_CONTROLS },
	/* Generic USB Video Class */
	{ USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, 0) },
	{}
};
(4).如果匹配成功，会执行设备驱动的probe函数。 我们关心的设备节点的创建也是在设备驱动的探测函数中被创建（因为这时的设备注册会附带主次设备号，内核通过netlink上报uevent事件后、用户空间的udevd服务会执行mknod创建设备节点）详见Linux驱动中uevent、netlink及kobject初探——kobject部分 和 Linux驱动中uevent、netlink及kobject初探——ueventd部分。

三、usb相关结构说明

1.设备描述符

struct usb_device_descriptor {
 __u8  bLength;              --描述符长度
 __u8  bDescriptorType;      --描述符类型：设备描述符0x01
 __le16 bcdUSB;              --usb规范版本号
 __u8  bDeviceClass;         --类代码
 __u8  bDeviceSubClass;      --子类代码
 __u8  bDeviceProtocol;      --协议代码
 __u8  bMaxPacketSize0;      --端点0支持最大数
 __le16 idVendor;            --供应商ID
 __le16 idProduct;           --产品ID
 __le16 bcdDevice;           --设备版本号
 __u8  iManufacturer;        --供应商字符串描述符的索引值
 __u8  iProduct;             --产品字符串描述符的索引值
 __u8  iSerialNumber;        --设备序列号
 __u8  bNumConfigurations;   --所支持的配置数
} __attribute__ ((packed));   --结构体字符类型对齐

2.配置描述符

struct usb_config_descriptor {
 __u8  bLength;              --描述符长度
 __u8  bDescriptorType;      --描述符类型
 __le16 wTotalLength;        --配置信息的总长度
 __u8  bNumInterfaces;       --所支持的接口数
 __u8  bConfigurationValue;  --配置值
 __u8  iConfiguration;       --字符串描述符的索引值
 __u8  bmAttributes;         --配置特征
 __u8  bMaxPower;            --所需最大的总线电流
} __attribute__ ((packed));

3.接口描述符 
struct usb_interface_descriptor {
 __u8  bLength;
 __u8  bDescriptorType;
 __u8  bInterfaceNumber;     --接口编号
 __u8  bAlternateSetting;    --备用接口标号
 __u8  bNumEndpoints;        --接口数目
 __u8  bInterfaceClass;      --接口类型
 __u8  bInterfaceSubClass;   --接口子类型
 __u8  bInterfaceProtocol;   --接口所用协议
 __u8  iInterface;           --接口索引字符串数值
} __attribute__ ((packed));
4.端点描述符 
struct usb_endpoint_descriptor {
 __u8  bLength;
 __u8  bDescriptorType;
 __u8  bEndpointAddress;      --端点号包括传输方向
 __u8  bmAttributes;          --端点属性
 __le16 wMaxPacketSize;       --最大数据包长度
 __u8  bInterval;             --访问间隔
 __u8  bRefresh;              
 __u8  bSynchAddress;
} __attribute__ ((packed));

usb总线驱动中对于设备和设备驱动的匹配函数，其实就是上述1和3的匹配过程

见：kernel/drivers/usb/core/driver.c中usb_device_match函数，这部分可以进一步分析；在此、我不再分析。

大致会匹配设备所属类(Input设备？Camera设备？Audio设备？或显示设备等)和VID、PID。

五、urb数据传输分析

未完待续

雷古拉斯
关注
  • 4
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LINUX USB驱动开发（1）-USB驱动重要数据结构
夜黯竹亭风的博客
02-12 513
USB设备为主机提供了多种多样的附加功能，如文件传输，声音播放等，但对USB主机来说，它与所有USB设备的接口都是一致的。一个USB设备由3个功能模块组成：USB总线接口、USB逻辑设备和功能单元： a – 这里的USB总线接口指的是USB设备中的串行接口引擎（SIE）； b – USB逻辑设备被USB系统软件看作是一个端点的集合； c – 功能单元被客户软件看作是一个接口的集合。SIE、端点
Linux Platform Bus(3) - 平台设备注册
四季帆的博客
06-01 434
1. 注册device概述 platform_device_register()注册device的过程 platform_device_register -->platform_device_add -->device_add -->bus_probe_device -->device_attach -->bus_for_each_drv //传
2024年最全Linux内核中识别USB设备过程_linux系统内核usb插入中断识别过程，2024年最新物联网嵌入式开发架构师必备框架技能核心笔记
最新发布
2401_85014260的博客
05-14 882
写的usb总线驱动程序相当于写的usb主机控制器驱动程序，usb主机控制器接有usb设备，设备驱动程序相当于是支持usb设备的，设备驱动程序为了能够访问usb设备，需要借助usb总线驱动程序提供的函数，把包发给usb主机控制器，然后主机控制器将数据发给usb设备。8，在设备完成它自己的脉冲信号（K脉冲）后，它将寻找高速集线器的脉冲信号。A），假如设备检测到脉冲序列K-J-K-J-K-J，则在检测到后的500 us（TWTHS）之内，设备要求断开D+的上拉电阻，并使能高速端接，进入高速缺省状态。
总线设备驱动模型
极创it的博客
08-19 248
platform_device_register platform_device_add ret = device_add(&pdev->dev); error = bus_add_device(dev); klist_add_tail(&dev->p->knode_bus, &bus->p-&...
Linux驱动开发之USB驱动深入学习（三）——USB2.0ECHI驱动注册
陈子陌的博客
05-31 1715
一、USB 1、概述 USB（Universal Serial Bus）即“通用外部总线”，在各种场所已经大量使用。它的接口简单（只有5v电源和地、两根数据线D+和D-），可以外接硬盘、键盘、鼠标、打印机等多种设备。 USB总线规范有1.1版和2.0版。USB1.1支持两种传输速率：低速1.5Mbit/s，全速12Mbit/s，对于鼠标、键盘、CD-ROM等设备，这样的速率够了。但是在访问硬盘、摄像机时，还是稍显不足、为此，USB2.0提供了一种更高的传输速率：高速，他可以达到480Mbit/s。US
Linux kernel: USB driver编写入门（一）
qq_42000667的博客
07-18 2270
Linux Kernel的usb驱动程序最基础框架编写，能实现加载(load)/注册(register)和卸载(unload)/注销(deregister）。适合于初学Linux驱动人士。
Linux 总线设备和驱动实验
04-25
在Linux操作系统中，总线、设备和驱动是构成硬件与软件交互...总的来说，Linux总线设备和驱动实验旨在提升你对硬件抽象层的理解，通过实际操作，你将学会如何编写和调试驱动，从而更好地掌控操作系统与硬件之间的交互。
Linux-USBCore.rar_linux usbcore_linux 设备_linux 驱动
09-21
USBCore是Linux内核中处理USB设备的核心部分，它负责管理USB总线上的设备，提供驱动程序与硬件之间的交互。本文将深入探讨Linux USBCore的工作原理、设备模型以及相关的驱动开发。 USBCore的主要职责包括设备枚举、...
浅谈LinuxPCI设备驱动
01-31
不知道读者理不理解这句话，本人觉得这句话很重要，对于PCI、USB这样的驱动来说，必须要理解这个概念，才能明白该如何看待Linux下的PCI和USB以及类似的总线型的驱动。理由也很简单，就是Linux PCI驱动是内核自带的，...
《Linux设备驱动开发详解-基于最新的Linux4.0内核》源码
06-21
驱动开发首先需要理解Linux设备模型，包括总线、设备、驱动的抽象概念。书中会介绍如何注册和注销设备，以及如何匹配设备和驱动。此外，还会讲解设备文件的创建和操作，如通过`open()`, `read()`, `write()`等系统调...
基于Linux的USB从设备驱动研究
08-13
【基于Linux的USB从设备驱动研究】 USB（通用串行总线）是一种高效、双向、同步的串行接口，广泛应用于各种设备，如手持设备，它不仅支持高速数据传输，还具备供电功能。Linux作为开源操作系统，其设备驱动程序开发...
V4L2视频监控项目：USB摄像头+QT5
12-18
这是一个V4L2的视频监控项目，ARM板连接一个USB摄像头作为服务器端，QT程序作为客户端，支持多个客户端同时观看视频监控
USB协议学习
liu749929309的博客
02-26 559
除了HID的三个特定描述符组成对HID设备的解释外，5个标准描述符中与HID设备有关的部分有： 设备描述符中：bDeviceClass（USB 分配的设备类代码，第四位）, bDeviceSubClass（USB 分配的子类代码，第5位）, bDeviceProtocol（USB 分配的设备协议代码第六位）三个值必须为 0 接口描述符中： bInterfaceClass（接口类型，第6位） 的值必须是 0x03； bInterfaceSubClass（按口子类型，第7位） 的值为 0 或 1， 为
usb主机控制器ehci
chenliang0224的专栏
03-25 4407
1. 主机控制器流程图device_add()上图和下图的连接！关于hub_probe()内部的具体实现，详见：点击打开链接2. echi设备注册static struct platform_device *nuc970_public_dev[] __initdata = { &&nuc970_device_ehci, };static u64 nuc970_dev...
七，USB设备驱动 - 分析USB储存驱动程序
滴水藏海
03-19 1238
usb设备驱动demo
浅谈Linux USB设备驱动
JJ1116的博客
03-23 5124
1、USB基础介绍 1-1、USB硬件接口介绍 USB接口在硬件上总共有四根线组成VCC、D+、D-、GND，通过计算D+和D-的差值来确定数据。USB设备在传输速率上可以分为低速(1.5Mbps)、全速(12Mbps)，高速(480Mbps)。在USB主机控制器端D+和D-都皆有一个下拉电阻，在USB设备端的D+或D-接了一个上拉电阻，USB设备插入后USB主机控制器的D+或D-会被拉高，这样USB主机控制器就能发现有设备接入。USB设备是主从式的设备，主机是在host端的主机控制器，从机就是如鼠标、
Linux 总线bus、设备device、驱动device_driver三者之间的关系
weixin_43845195的博客
09-02 2677
以下内容都为自己理解： 1.总线bus 通常所说的总线都是cpu与设备之间通信的协议，就像两个地方，一个地方住着cpu，一个地方住着设备，总线就相当于CPU通过什么方式到达设备。（就像你要通过一个墓道，就要按照墓主人设计的方式过去，要不就会被暗器杀掉，永远也到达不了）。 但是，Linux里面的总线，我的理解就是连接设备和驱动，不是常规意义上的总线，最简单就是platform总线，它不是一个协议，它就是为了那些没有广义上协议（usb、spi、iic）的设备服务的。 bus的结构体如下所示： struct bu
USB你真的了解它吗？USB的进化史
一口Linux的专栏
05-02 1364
电脑界的上古时期是没有USB接口的。在那个时期电脑用于连接外设的常见接口有这5种： 1、 串口（有9针、25针这2种）通常指COM接口 -不支持热插拔 串口用于低速设备，例如鼠标、调制解调器等，也有一些低速打印机采用串口连接。常常也用来连接其他设备进行调试、刷入固件等。 串口传输数据是一位一位的顺序传送，只要一对传输线就可以实现双向通信（可用电话线作为传输线），特别适用于远距离通信，但传输速度较慢。 串口&串口鼠标 2、 并行 也称IEEE1284 -不支持热插拔 并行接口用于"高速
linux usb运行,在Linux下使用USB设备的方法
weixin_29419979的博客
04-30 2414
在Linux下使用usb设备的方法(包括Linux下使用U盘或者usb硬盘)实用很强，分享给各位,希望有用.1.先不要插入use盘(U盘或者usb硬盘)，运行如下命令：fdisk -l /dev/sd?记录下此时会显示那些东西，主要记住/dev/sd(a，b,c)(1,2,3)那几行即可；(一般USB U盘和硬盘的对应设备文件是/dev/sda /dev/sdb /dev/sdc)2.执行完以上命...
USB设备驱动Linux内核代码介绍
10-14
USB设备驱动Linux内核代码分析介绍，可供参考入门

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值