1.usb_register和usb_register_driver用来注册一个interface接口驱动for_devices = 0;2.usb_register_device_driver用来注册一个usb设备驱动,for_devices = 1;用来解析设备描述符, 进而生成配置描述符下的功能接口,尝试匹配usb_register_driver注册的接口驱动来驱动该usb设备的功能接口.[luther.gliethttp]在整个kernel中,只有usb_init即[subsys_initcall(usb_init)]一处调用了usb_register_device_driver函数,usb_register_device_driver(&usb_generic_driver, THIS_MODULE);所以所有通过hub_thread检测到插入的usb设备也都将调用到generic_probe设备枚举函数,我们这里需要提到一些usb通信方面的知识,以便我们能够透彻理解kernel中usb代码,一个插入到HUB上的usb设备使用4种描述符来描述自己,(1) 设备描述符(2) 配置描述符(3) 接口描述符(4) 端点描述符一个usb设备只能有1个设备描述符,1个设备描述符可以有多个配置描述符,然后每个配置描述符下面又可以有多个接口描述符用来具体描述一个设备在该配置下的一个或多个独立功能,每个接口下面又由端点描述符来具体声明该功能接口在usb物理通信中使用哪几个端点管道来执行usb物理信道的实际收发工作[luther.gliethttp].所以一个usb设备的具体功能是由接口描述符来描述的,因此我们开发的usb driver也就几乎99.9%都在使用usb_register函数来实现一个接口对应的驱动,进而驱动usb设备上该接口对应的具体功能,比如UMS.[luther.gliethttp]当kernel使用generic_probe()函数完成插入到HUB上的usb设备的合法检验之后,将调用设置配置描述符操作usb_set_configuration,生成该配置描述符下面若干个接口描述符对应的dev设备,usb_set_configuration==>device_add(&intf->dev);// 这样该接口dev将扫描usb_bus_type总线上的所有drivers驱动,kernel尝试为该接口dev找到驱动它的driver.[luther.gliethttp]如下几个函数中都会调用到usb_set_configurationusb_authorize_device // 以sysfs中attr性质存在,这样用户空间的程序就可以通过attr属性文件来强制控制接口驱动的关联.usb_deauthorize_devicedriver_set_config_workproc_setconfigset_bConfigurationValuegeneric_disconnectgeneric_probeusb设备的检测工作是通过内核线程hub_thread完成的.usb_hub_init==>khubd_task = kthread_run(hub_thread, NULL, “khubd”); // 创建内核线程hub_thread,监控hub上usb设备的插拔情况hub_thread==>hub_events==>hub_port_connect_change==>udev =usb_alloc_dev // 添加usb设备==>hub_port_connect_change==>usb_new_device(udev)==>device_add(&udev->dev); // 将检测到的usb设备添加到usb_bus_type总线上,// 该dev的type值为usb_device_type,最后函数执行device_add==>bus_add_device实现具体添加操作[luther.gliethttp]// bus_add_device将调用上面usb_register_device_driver(&usb_generic_driver, THIS_MODULE);注册的唯一一个设备描述符解析驱动// usb_generic_driver==>generic_probe来完成接口设备生成和相应的接口设备驱动关联动作[luther.gliethttp].usb_add_hcd==>usb_alloc_dev // 添加HCDusb_alloc_dev==>dev->dev.bus = &usb_bus_type;设置dev为usb总线上的设备==>dev->dev.type = &usb_device_type;设置该dev为usb设备而非接口driver_register或者device_register调用driver_attach或者bus_attach_device==>device_attach来为设备尝试匹配驱动或者为驱动尝试添加设备,不论是哪一种情况,都将执行到:driver_probe_device函数.int driver_probe_device(struct device_driver *drv, struct device *dev){ int ret = 0; if (!device_is_registered(dev)) // 1.设备已经完成了注册到bus总线工作 return -ENODEV; if (drv->bus->match && !drv->bus->match(dev, drv)) // 2.执行bus提供的match操作usb_device_match goto done; pr_debug(“bus: ‘%s’: %s: matched device %s with driver %s/n”, drv->bus->name, __FUNCTION__, dev->bus_id, drv->name); ret = really_probe(dev, drv); // bus的match通过检验,这里做进一步的probe检验, // 如果bus提供了probe,那么执行bus->probe(dev); // 否则执行driver提供的probe函数drv->probe(dev);done: return ret;}usb_register(&mct_u232_driver);==>usb_register_driver new_driver->drvwrap.for_devices = 0; // 仅仅用来驱动interface接口,所以上面hub_port_connect_change由usb_alloc_dev生成的usb设备不会调用该usb接口驱动 new_driver->drvwrap.driver.bus = &usb_bus_type; new_driver->drvwrap.driver.probe = usb_probe_interface; // 当检测到usb设备插入后,将调用usb_probe_interface进行细致处理 // 提供为device_driver提供probe处理函数,因为bus总线usb_bus_type不提供probe操作[luther.gliethttp]==>driver_register(&new_driver->drvwrap.driver); // 将驱动添加到usb bus总线管理的driver驱动链表上usb_device_match==>is_usb_devicestatic inline int is_usb_device(const struct device *dev){ return dev->type == &usb_device_type;}开看看驱动hub_thread==>usb_alloc_dev创建的插入到HUB上的usb设备的probe函数generic_probe.[luther.gliethttp]subsys_initcall(usb_init);==>usb_init==>usb_register_device_driver(&usb_generic_driver, THIS_MODULE);struct usb_device_driver usb_generic_driver = { .name = “usb”, .probe = generic_probe, .disconnect = generic_disconnect,#ifdef CONFIG_PM .suspend = generic_suspend, .resume = generic_resume,#endif .supports_autosuspend = 1,};==>generic_probe==>usb_set_configuration // 生成该设置配置描述下的所有接口描述符所描述的接口dev对象==>ret = device_add(&intf->dev);int usb_set_configuration(struct usb_device *dev, int configuration){ int i, ret; struct usb_host_config *cp = NULL; struct usb_interface **new_interfaces = NULL; int n, nintf; if (dev->authorized == 0 || configuration == -1) configuration = 0; else { for (i = 0; i < dev->descriptor.bNumConfigurations; i++) { if (dev->config[i].desc.bConfigurationValue == configuration) { cp = &dev->config[i]; break; } } } if ((!cp && configuration != 0)) return -EINVAL; /* The USB spec says configuration 0 means unconfigured. * But if a device includes a configuration numbered 0, * we will accept it as a correctly configured state. * Use -1 if you really want to unconfigure the device. */ if (cp && configuration == 0) dev_warn(&dev->dev, “config 0 descriptor??/n”); /* Allocate memory for new interfaces before doing anything else, * so that if we run out then nothing will have changed. */ n = nintf = 0; if (cp) { nintf = cp->desc.bNumInterfaces; new_interfaces = kmalloc(nintf * sizeof(*new_interfaces), GFP_KERNEL); if (!new_interfaces) { dev_err(&dev->dev, “Out of memory/n”); return -ENOMEM; } for (; n < nintf; ++n) { new_interfaces[n] = kzalloc( sizeof(struct usb_interface), GFP_KERNEL); if (!new_interfaces[n]) { dev_err(&dev->dev, “Out of memory/n”); ret = -ENOMEM;free_interfaces: while (–n >= 0) kfree(new_interfaces[n]); kfree(new_interfaces); return ret; } } i = dev->bus_mA – cp->desc.bMaxPower * 2; if (i < 0) dev_warn(&dev->dev, “new config #%d exceeds power ” “limit by %dmA/n”, configuration, -i); } /* Wake up the device so we can send it the Set-Config request */ ret = usb_autoresume_device(dev); if (ret) goto free_interfaces; /* if it’s already configured, clear out old state first. * getting rid of old interfaces means unbinding their drivers. */ if (dev->state != USB_STATE_ADDRESS) usb_disable_device(dev, 1); /* Skip ep0 */ ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION, 0, configuration, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); if (ret < 0) { /* All the old state is gone, so what else can we do? * The device is probably useless now anyway. */ cp = NULL; } dev->actconfig = cp; if (!cp) { usb_set_device_state(dev, USB_STATE_ADDRESS); usb_autosuspend_device(dev); goto free_interfaces; } usb_set_device_state(dev, USB_STATE_CONFIGURED); /* Initialize the new interface structures and the * hc/hcd/usbcore interface/endpoint state. */ for (i = 0; i < nintf; ++i) { struct usb_interface_cache *intfc; struct usb_interface *intf; struct usb_host_interface *alt; cp->interface[i] = intf = new_interfaces[i]; intfc = cp->intf_cache[i]; intf->altsetting = intfc->altsetting; intf->num_altsetting = intfc->num_altsetting; intf->intf_assoc = find_iad(dev, cp, i); kref_get(&intfc->ref); alt = usb_altnum_to_altsetting(intf, 0); /* No altsetting 0? We’ll assume the first altsetting. * We could use a GetInterface call, but if a device is * so non-compliant that it doesn’t have altsetting 0 * then I wouldn’t trust its reply anyway. */ if (!alt) alt = &intf->altsetting[0]; intf->cur_altsetting = alt; usb_enable_interface(dev, intf); intf->dev.parent = &dev->dev; intf->dev.driver = NULL; intf->dev.bus = &usb_bus_type; // 位于usb_bus_type总线 intf->dev.type = &usb_if_device_type; // 为接口设备,这样在usb_device_match中将去和接口驱动去匹配[luther.gliethttp] intf->dev.dma_mask = dev->dev.dma_mask; device_initialize(&intf->dev); mark_quiesced(intf); sprintf(&intf->dev.bus_id[0], “%d-%s:%d.%d”, dev->bus->busnum, dev->devpath, configuration, alt->desc.bInterfaceNumber); } kfree(new_interfaces); if (cp->string == NULL) cp->string = usb_cache_string(dev, cp->desc.iConfiguration); /* Now that all the interfaces are set up, register them * to trigger binding of drivers to interfaces. probe() * routines may install different altsettings and may * claim() any interfaces not yet bound. Many class drivers * need that: CDC, audio, video, etc. */ for (i = 0; i < nintf; ++i) { struct usb_interface *intf = cp->interface[i]; dev_dbg(&dev->dev, “adding %s (config #%d, interface %d)/n”, intf->dev.bus_id, configuration, intf->cur_altsetting->desc.bInterfaceNumber); ret = device_add(&intf->dev); // 将接口设备添加bus总线上同时到sysfs系统中. if (ret != 0) { dev_err(&dev->dev, “device_add(%s) –> %d/n”, intf->dev.bus_id, ret); continue; } usb_create_sysfs_intf_files(intf); } usb_autosuspend_device(dev); return 0;}如下是一个整体代码流程:driver_probe_deviceint driver_probe_device(struct device_driver *drv, struct device *dev){ int ret = 0; if (!device_is_registered(dev)) // 1.设备已经完成了注册到bus总线工作 return -ENODEV; if (drv->bus->match && !drv->bus->match(dev, drv)) // 2.执行bus提供的match操作usb_device_match goto done; pr_debug(“bus: ‘%s’: %s: matched device %s with driver %s/n”, drv->bus->name, __FUNCTION__, dev->bus_id, drv->name); ret = really_probe(dev, drv); // bus的match通过检验,这里做进一步的probe检验, // 如果bus提供了probe,那么执行bus->probe(dev); // 否则执行driver提供的probe函数drv->probe(dev);done: return ret;}==>usb_bus_type==>usb_device_matchstatic 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 { 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); // 转为接口dev设备 usb_drv = to_usb_driver(drv); // 转为usb驱动 id = usb_match_id(intf, usb_drv->id_table); // 接口设备与usb接口驱动的id_table值表进行匹配尝试[luther.gliethttp] if (id) return 1; id = usb_match_dynamic_id(intf, usb_drv); if (id) return 1; } return 0;}==>really_probestatic int really_probe(struct device *dev, struct device_driver *drv){ int ret = 0; atomic_inc(&probe_count); pr_debug(“bus: ‘%s’: %s: probing driver %s with device %s/n”, drv->bus->name, __FUNCTION__, drv->name, dev->bus_id); WARN_ON(!list_empty(&dev->devres_head)); dev->driver = drv; // 先假定该driver就是驱动本dev的驱动,后面讲做进一步确认[luther.gliethttp] if (driver_sysfs_add(dev)) { printk(KERN_ERR “%s: driver_sysfs_add(%s) failed/n”, __FUNCTION__, dev->bus_id); goto probe_failed; } if (dev->bus->probe) { ret = dev->bus->probe(dev); // 如果bus总线提供probe,那么执行之 if (ret) goto probe_failed; } else if (drv->probe) { ret = drv->probe(dev); // 如果driver提供probe,那么执行之, // 我们这里就是new_driver->drvwrap.driver.probe = usb_probe_interface; if (ret) goto probe_failed; } driver_bound(dev); ret = 1; pr_debug(“bus: ‘%s’: %s: bound device %s to driver %s/n”, drv->bus->name, __FUNCTION__, dev->bus_id, drv->name); goto done;probe_failed: devres_release_all(dev); driver_sysfs_remove(dev); dev->driver = NULL; if (ret != -ENODEV && ret != -ENXIO) { /* driver matched but the probe failed */ printk(KERN_WARNING “%s: probe of %s failed with error %d/n”, drv->name, dev->bus_id, ret); } /* * Ignore errors returned by ->probe so that the next driver can try * its luck. */ ret = 0;done: atomic_dec(&probe_count); wake_up(&probe_waitqueue); return ret;}==>usb_probe_interface 即:new_driver->drvwrap.driver.probe = usb_probe_interface;/* called from driver core with dev locked */static int usb_probe_interface(struct device *dev){ struct usb_driver *driver = to_usb_driver(dev->driver); struct usb_interface *intf; struct usb_device *udev; const struct usb_device_id *id; int error = -ENODEV; dev_dbg(dev, “%s/n”, __FUNCTION__); if (is_usb_device(dev)) /* Sanity check */ return error; intf = to_usb_interface(dev); udev = interface_to_usbdev(intf); if (udev->authorized == 0) { dev_err(&intf->dev, “Device is not authorized for usage/n”); return -ENODEV; } id = usb_match_id(intf, driver->id_table); if (!id) id = usb_match_dynamic_id(intf, driver); if (id) { dev_dbg(dev, “%s – got id/n”, __FUNCTION__); error = usb_autoresume_device(udev); if (error) return error; /* Interface “power state” doesn’t correspond to any hardware * state whatsoever. We use it to record when it’s bound to * a driver that may start I/0: it’s not frozen/quiesced. */ mark_active(intf); intf->condition = USB_INTERFACE_BINDING; /* The interface should always appear to be in use * unless the driver suports autosuspend. */ intf->pm_usage_cnt = !(driver->supports_autosuspend); error = driver->probe(intf, id); // 调用usb_driver驱动定义的probe函数,我们这里就是usb_serial_probe即:mct_u232_driver.probe if (error) { mark_quiesced(intf); intf->needs_remote_wakeup = 0; intf->condition = USB_INTERFACE_UNBOUND; } else intf->condition = USB_INTERFACE_BOUND; usb_autosuspend_device(udev); } return error;}==>usb_serial_probe即:mct_u232_driver.probe函数int usb_serial_probe(struct usb_interface *interface, const struct usb_device_id *id){ struct usb_device *dev = interface_to_usbdev (interface); struct usb_serial *serial = NULL; struct usb_serial_port *port; struct usb_host_interface *iface_desc; struct usb_endpoint_descriptor *endpoint; struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS]; struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS]; struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS]; struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS]; struct usb_serial_driver *type = NULL; int retval; int minor; int buffer_size; int i; int num_interrupt_in = 0; int num_interrupt_out = 0; int num_bulk_in = 0; int num_bulk_out = 0; int num_ports = 0; int max_endpoints; lock_kernel(); /* guard against unloading a serial driver module */ type = search_serial_device(interface); // 遍历usb_serial_driver_list链表,搜索与该interface匹配上的串口驱动, // usb_serial_driver_list链表元素由函数usb_serial_driver_list添加 // 我们这里将返回type = &mct_u232_device;[luther.gliethtp] /* static struct usb_serial_driver *search_serial_device(struct usb_interface *iface) { const struct usb_device_id *id; struct usb_serial_driver *drv; list_for_each_entry(drv, &usb_serial_driver_list, driver_list) { id = get_iface_id(drv, iface); if (id) return drv; } return NULL; }==>usb_serial_register // 添加serial驱动到usb_serial_driver_list链表上[luther.gliethttp] static struct usb_serial_driver mct_u232_device = {…}; usb_serial_register(&mct_u232_device); // 注册mct_u232串口驱动到usb_serial_driver_list链表上 int usb_serial_register(struct usb_serial_driver *driver) { int retval; fixup_generic(driver); // 填入driver没有定义的默认方法 if (!driver->description) driver->description = driver->driver.name; // Add this device to our list of devices list_add(&driver->driver_list, &usb_serial_driver_list); // 将mct_u232_device添加到usb_serial_driver_list链表上 retval = usb_serial_bus_register(driver); if (retval) { err(“problem %d when registering driver %s”, retval, driver->description); list_del(&driver->driver_list); } else info(“USB Serial support registered for %s”, driver->description); return retval; } int usb_serial_bus_register(struct usb_serial_driver *driver) { int retval; driver->driver.bus = &usb_serial_bus_type; spin_lock_init(&driver->dynids.lock); INIT_LIST_HEAD(&driver->dynids.list); retval = driver_register(&driver->driver); return retval; } */ if (!type) { unlock_kernel(); dbg(“none matched”); return -ENODEV; } serial = create_serial (dev, interface, type); // 创建serial串口设备/*static struct usb_serial * create_serial (struct usb_device *dev, struct usb_interface *interface, struct usb_serial_driver *driver){ struct usb_serial *serial; serial = kzalloc(sizeof(*serial), GFP_KERNEL); // 全0空间 if (!serial) { dev_err(&dev->dev, “%s – out of memory/n”, __FUNCTION__); return NULL; } serial->dev = usb_get_dev(dev); // 该serial对应的usb设备描述符对应的设备结构体[luther.gliethttp] serial->type = driver; // 该serial对应的driver serial->interface = interface; // 该serial对应的interface kref_init(&serial->kref); mutex_init(&serial->disc_mutex); return serial;}*/ if (!serial) { unlock_kernel(); dev_err(&interface->dev, “%s – out of memory/n”, __FUNCTION__); return -ENOMEM; } /* if this device type has a probe function, call it */ if (type->probe) { // mct_u232_device串口驱动没有probe函数 const struct usb_device_id *id; if (!try_module_get(type->driver.owner)) { unlock_kernel(); dev_err(&interface->dev, “module get failed, exiting/n”); kfree (serial); return -EIO; } id = get_iface_id(type, interface); retval = type->probe(serial, id); module_put(type->driver.owner); if (retval) { unlock_kernel(); dbg (“sub driver rejected device”); kfree (serial); return retval; } } /* descriptor matches, let’s find the endpoints needed */ /* check out the endpoints */ iface_desc = interface->cur_altsetting; // 当前接口对应的接口描述符信息[luther.gliethttp] for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { // 为该接口dev设备收集端点通信管道 endpoint = &iface_desc->endpoint[i].desc; if (usb_endpoint_is_bulk_in(endpoint)) { /* we found a bulk in endpoint */ dbg(“found bulk in on endpoint %d”, i); bulk_in_endpoint[num_bulk_in] = endpoint; // 批量IN端点 ++num_bulk_in; } if (usb_endpoint_is_bulk_out(endpoint)) { /* we found a bulk out endpoint */ dbg(“found bulk out on endpoint %d”, i); bulk_out_endpoint[num_bulk_out] = endpoint; // 批量OUT端点 ++num_bulk_out; } if (usb_endpoint_is_int_in(endpoint)) { /* we found a interrupt in endpoint */ dbg(“found interrupt in on endpoint %d”, i); interrupt_in_endpoint[num_interrupt_in] = endpoint; // 中断IN端点 ++num_interrupt_in; } if (usb_endpoint_is_int_out(endpoint)) { /* we found an interrupt out endpoint */ dbg(“found interrupt out on endpoint %d”, i); interrupt_out_endpoint[num_interrupt_out] = endpoint; // 中断OUT端点 ++num_interrupt_out; } }#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE) // 执行PL2303 usb转串口设备的IN端点信息特殊处理[luther.gliethttp] /* BEGIN HORRIBLE HACK FOR PL2303 */ /* this is needed due to the looney way its endpoints are set up */ if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) && (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) || ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) && (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) || ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) && (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID))) { if (interface != dev->actconfig->interface[0]) { // 如果当前PL2303 usb转串口不等于0接口,dev->actconfig->interface[0] /* check out the endpoints of the other interface*/ iface_desc = dev->actconfig->interface[0]->cur_altsetting; // 那么将0接口中的中断IN端点添加到该serial设备中 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { endpoint = &iface_desc->endpoint[i].desc; if (usb_endpoint_is_int_in(endpoint)) { /* we found a interrupt in endpoint */ dbg(“found interrupt in for Prolific device on separate interface”); interrupt_in_endpoint[num_interrupt_in] = endpoint; ++num_interrupt_in; } } } /* Now make sure the PL-2303 is configured correctly. * If not, give up now and hope this hack will work * properly during a later invocation of usb_serial_probe */ if (num_bulk_in == 0 || num_bulk_out == 0) { unlock_kernel(); dev_info(&interface->dev, “PL-2303 hack: descriptors matched but endpoints did not/n”); kfree (serial); return -ENODEV; } } /* END HORRIBLE HACK FOR PL2303 */#endif#ifdef CONFIG_USB_SERIAL_GENERIC if (type == &usb_serial_generic_device) { num_ports = num_bulk_out; if (num_ports == 0) { // 如果是usb_serial_generic_device驱动,那么批量OUT端点务必要存在,并且可用端点个数就是批量OUT端点个数. unlock_kernel(); dev_err(&interface->dev, “Generic device with no bulk out, not allowed./n”); kfree (serial); return -EIO; } }#endif if (!num_ports) { // 好,不是usb_serial_generic_device驱动 /* if this device type has a calc_num_ports function, call it */ if (type->calc_num_ports) { // 是否需要调用计算函数计算端点个数 if (!try_module_get(type->driver.owner)) { unlock_kernel(); dev_err(&interface->dev, “module get failed, exiting/n”); kfree (serial); return -EIO; } num_ports = type->calc_num_ports (serial); module_put(type->driver.owner); } if (!num_ports) num_ports = type->num_ports; // 由usb转串口接口驱动定义端点个数:mct_u232_device定义num_ports为1 } serial->num_ports = num_ports; // 端点个数 serial->num_bulk_in = num_bulk_in; // 批量IN端点个数 serial->num_bulk_out = num_bulk_out; // 批量OUT端点个数 serial->num_interrupt_in = num_interrupt_in; // 中断IN端点个数 serial->num_interrupt_out = num_interrupt_out; // 中断OUT端点个数#if 0 /* check that the device meets the driver’s requirements */ if ((type->num_interrupt_in != NUM_DONT_CARE && type->num_interrupt_in != num_interrupt_in) || (type->num_interrupt_out != NUM_DONT_CARE && type->num_interrupt_out != num_interrupt_out) || (type->num_bulk_in != NUM_DONT_CARE && type->num_bulk_in != num_bulk_in) || (type->num_bulk_out != NUM_DONT_CARE && type->num_bulk_out != num_bulk_out)) { dbg(“wrong number of endpoints”); kfree(serial); return -EIO; }#endif /* found all that we need */ dev_info(&interface->dev, “%s converter detected/n”, type->description); /* create our ports, we need as many as the max endpoints */ /* we don’t use num_ports here cauz some devices have more endpoint pairs than ports */ max_endpoints = max(num_bulk_in, num_bulk_out); max_endpoints = max(max_endpoints, num_interrupt_in); max_endpoints = max(max_endpoints, num_interrupt_out); max_endpoints = max(max_endpoints, (int)serial->num_ports); serial->num_port_pointers = max_endpoints; unlock_kernel(); dbg(“%s – setting up %d port structures for this device”, __FUNCTION__, max_endpoints); for (i = 0; i < max_endpoints; ++i) { port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL); // 申请4种端点集合结构体struct usb_serial_port if (!port) goto probe_error; port->serial = serial; spin_lock_init(&port->lock); mutex_init(&port->mutex); INIT_WORK(&port->work, usb_serial_port_work); // 设置工作队列work_queue serial->port[i] = port; } /* set up the endpoint information */ for (i = 0; i < num_bulk_in; ++i) { endpoint = bulk_in_endpoint[i]; port = serial->port[i]; port->read_urb = usb_alloc_urb (0, GFP_KERNEL); // 申请URB控制结构体 if (!port->read_urb) { dev_err(&interface->dev, “No free urbs available/n”); goto probe_error; } buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); port->bulk_in_size = buffer_size; // 端点大小 port->bulk_in_endpointAddress = endpoint->bEndpointAddress; // 端点地址 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL); // 端点管道数据缓冲区 if (!port->bulk_in_buffer) { dev_err(&interface->dev, “Couldn’t allocate bulk_in_buffer/n”); goto probe_error; } // 填充上面申请到的read_urb URB控制结构体 usb_fill_bulk_urb (port->read_urb, dev, usb_rcvbulkpipe (dev, endpoint->bEndpointAddress), port->bulk_in_buffer, buffer_size, serial->type->read_bulk_callback, // 在mct_u232_device中定义的批量读回调函数 port); } for (i = 0; i < num_bulk_out; ++i) { endpoint = bulk_out_endpoint[i]; port = serial->port[i]; port->write_urb = usb_alloc_urb(0, GFP_KERNEL);// 申请URB控制结构体 if (!port->write_urb) { dev_err(&interface->dev, “No free urbs available/n”); goto probe_error; } buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); port->bulk_out_size = buffer_size; port->bulk_out_endpointAddress = endpoint->bEndpointAddress; port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL); if (!port->bulk_out_buffer) { dev_err(&interface->dev, “Couldn’t allocate bulk_out_buffer/n”); goto probe_error; } // 填充上面申请到的write_urb URB控制结构体 usb_fill_bulk_urb (port->write_urb, dev, usb_sndbulkpipe (dev, endpoint->bEndpointAddress), port->bulk_out_buffer, buffer_size, serial->type->write_bulk_callback,// 在mct_u232_device中定义的批量写回调函数 port); } if (serial->type->read_int_callback) { for (i = 0; i < num_interrupt_in; ++i) { endpoint = interrupt_in_endpoint[i]; port = serial->port[i]; port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);// 申请URB控制结构体 if (!port->interrupt_in_urb) { dev_err(&interface->dev, “No free urbs available/n”); goto probe_error; } buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); port->interrupt_in_endpointAddress = endpoint->bEndpointAddress; port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL); if (!port->interrupt_in_buffer) { dev_err(&interface->dev, “Couldn’t allocate interrupt_in_buffer/n”); goto probe_error; } // 填充上面申请到的interrupt_in_urb URB控制结构体 usb_fill_int_urb (port->interrupt_in_urb, dev, usb_rcvintpipe (dev, endpoint->bEndpointAddress), port->interrupt_in_buffer, buffer_size, serial->type->read_int_callback, port, // 在mct_u232_device中定义的INT中断读回调函数 endpoint->bInterval); } } else if (num_interrupt_in) { dbg(“the device claims to support interrupt in transfers, but read_int_callback is not defined”); } if (serial->type->write_int_callback) { for (i = 0; i < num_interrupt_out; ++i) { endpoint = interrupt_out_endpoint[i]; port = serial->port[i]; port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);// 申请URB控制结构体 if (!port->interrupt_out_urb) { dev_err(&interface->dev, “No free urbs available/n”); goto probe_error; } buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); port->interrupt_out_size = buffer_size; port->interrupt_out_endpointAddress = endpoint->bEndpointAddress; port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL); if (!port->interrupt_out_buffer) { dev_err(&interface->dev, “Couldn’t allocate interrupt_out_buffer/n”); goto probe_error; } // 填充上面申请到的interrupt_out_urb URB控制结构体 usb_fill_int_urb (port->interrupt_out_urb, dev, usb_sndintpipe (dev, endpoint->bEndpointAddress), port->interrupt_out_buffer, buffer_size, serial->type->write_int_callback, port,// 在mct_u232_device中定义的INT中断写回调函数 endpoint->bInterval); } } else if (num_interrupt_out) { dbg(“the device claims to support interrupt out transfers, but write_int_callback is not defined”); } /* if this device type has an attach function, call it */ if (type->attach) { // mct_u232_device定义了attach方法的实现mct_u232_startup if (!try_module_get(type->driver.owner)) { dev_err(&interface->dev, “module get failed, exiting/n”); goto probe_error; } retval = type->attach (serial); module_put(type->driver.owner); if (retval < 0) goto probe_error; if (retval > 0) { /* quietly accept this device, but don’t bind to a serial port * as it’s about to disappear */ goto exit; } } if (get_free_serial (serial, num_ports, &minor) == NULL) { // 申请次设备号,同时:serial->port[j++]->number = i; dev_err(&interface->dev, “No more free serial devices/n”); goto probe_error; } serial->minor = minor; // 该serial的次设备号为minor /* register all of the individual ports with the driver core */ for (i = 0; i < num_ports; ++i) { port = serial->port[i]; port->dev.parent = &interface->dev; // 接口当然为端点端口的父object port->dev.driver = NULL; port->dev.bus = &usb_serial_bus_type; // port位于usb_serial_bus_type总线 port->dev.release = &port_release; snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), “ttyUSB%d”, port->number); dbg (“%s – registering %s”, __FUNCTION__, port->dev.bus_id); retval = device_register(&port->dev); // 登记注册该port对应的dev设备信息,同样在bus总线usb_serial_bus_type上执行match动作. if (retval) dev_err(&port->dev, “Error registering port device, ” “continuing/n”); } usb_serial_console_init (debug, minor);exit: /* success */ usb_set_intfdata (interface, serial); return 0;probe_error: for (i = 0; i < num_bulk_in; ++i) { port = serial->port[i]; if (!port) continue; usb_free_urb(port->read_urb); kfree(port->bulk_in_buffer); } for (i = 0; i < num_bulk_out; ++i) { port = serial->port[i]; if (!port) continue; usb_free_urb(port->write_urb); kfree(port->bulk_out_buffer); } for (i = 0; i < num_interrupt_in; ++i) { port = serial->port[i]; if (!port) continue; usb_free_urb(port->interrupt_in_urb); kfree(port->interrupt_in_buffer); } for (i = 0; i < num_interrupt_out; ++i) { port = serial->port[i]; if (!port) continue; usb_free_urb(port->interrupt_out_urb); kfree(port->interrupt_out_buffer); } /* free up any memory that we allocated */ for (i = 0; i < serial->num_port_pointers; ++i) kfree(serial->port[i]); kfree (serial); return -EIO;}==>usb_serial_bus_type总线驱动port各种端点端口组合结构体 device_register(&port->dev); // 登记注册该port对应的dev设备信息,同样在bus总线usb_serial_bus_type上执行match动作.struct bus_type usb_serial_bus_type = { .name = “usb-serial”, .match = usb_serial_device_match, .probe = usb_serial_device_probe, .remove = usb_serial_device_remove, .drv_attrs = drv_attrs,};==>usb_serial_device_matchstatic int usb_serial_device_match (struct device *dev, struct device_driver *drv){ struct usb_serial_driver *driver; const struct usb_serial_port *port; /* * drivers are already assigned to ports in serial_probe so it’s * a simple check here. */ port = to_usb_serial_port(dev); if (!port) return 0; driver = to_usb_serial_driver(drv); if (driver == port->serial->type) // 等于mct_u232_device驱动,那么返回1 // port->serial在serial = create_serial (dev, interface, type); 中创建. // serial->type = driver; // 该serial对应的driver return 1; return 0;}==>usb_serial_device_probestatic int usb_serial_device_probe (struct device *dev){ struct usb_serial_driver *driver; struct usb_serial_port *port; int retval = 0; int minor; port = to_usb_serial_port(dev); if (!port) { retval = -ENODEV; goto exit; } driver = port->serial->type; if (driver->port_probe) { // mct_u232_device没有port_probe if (!try_module_get(driver->driver.owner)) { dev_err(dev, “module get failed, exiting/n”); retval = -EIO; goto exit; } retval = driver->port_probe (port); module_put(driver->driver.owner); if (retval) goto exit; } retval = device_create_file(dev, &dev_attr_port_number); // 创建sysfs文件系统中对应的文件[luther.gliethttp] if (retval) goto exit; minor = port->number; // 在上面的get_free_serial函数中执行了serial->port[j++]->number = i;赋值操作,所以可以为ttyUSB0,ttyUSB1,… // port->number就是serial_table[port->number]数组索引号 tty_register_device (usb_serial_tty_driver, minor, dev); // 注册次设备号为minor的tty设备,该/dev/ttyUSBx设备由usb_serial_tty_driver驱动程序管理 dev_info(&port->serial->dev->dev, “%s converter now attached to ttyUSB%d/n”, driver->description, minor);exit: return retval;}==>tty_register_device(usb_serial_tty_driver, minor, dev);// usb_serial_tty_driver在usb_serial_init,即:module_init(usb_serial_init);// usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;// tty_set_operations(usb_serial_tty_driver, &serial_ops);// tty_register_driver(usb_serial_tty_driver);==>list_add(&driver->tty_drivers, &tty_drivers);将自己添加到tty_drivers链表中struct device *tty_register_device(struct tty_driver *driver, unsigned index, struct device *device){ char name[64]; dev_t dev = MKDEV(driver->major, driver->minor_start) + index; if (index >= driver->num) { printk(KERN_ERR “Attempt to register invalid tty line number ” ” (%d)./n”, index); return ERR_PTR(-EINVAL); } if (driver->type == TTY_DRIVER_TYPE_PTY) pty_line_name(driver, index, name); else tty_line_name(driver, index, name); // 非pty设备 return device_create(tty_class, device, dev, name); // 创建sysfs文件系统下的文件,同时uevent到用户空间,创建/dev/ttyUSB0…等 // 对/dev/ttyUSB0…等操作方法为tty_fops // /dev/ttyUSB0…等在SERIAL_TTY_MAJOR ~ SERIAL_TTY_MAJOR + SERIAL_TTY_MINORS之间的设备号读写操作均由tty_fops // 方法集提供, // tty_register_driver(usb_serial_tty_driver); // 比如open // tty_open==>tty->driver->open即:serial_ops.serial_open}==>tty_register_driver(usb_serial_tty_driver); // 注册驱动/dev/xxx字符设备的tty驱动程序 dev = MKDEV(driver->major, driver->minor_start); error = register_chrdev_region(dev, driver->num, driver->name); // 设备号从dev到dev+driver->num个字符设备都将由该driver驱动 cdev_init(&driver->cdev, &tty_fops); // 注册该MAJOR到MINOR之间的/dev/xxx字符设备节点对应的操作函数集为tty_fops cdev_add(&driver->cdev, dev, driver->num); // 添加到字符管理数值中static const struct file_operations tty_fops = { .llseek = no_llseek, .read = tty_read, .write = tty_write, .poll = tty_poll, .ioctl = tty_ioctl, .compat_ioctl = tty_compat_ioctl, .open = tty_open, .release = tty_release, .fasync = tty_fasync,};==>cdev_addint cdev_add(struct cdev *p, dev_t dev, unsigned count){ p->dev = dev; p->count = count; return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p); // 将&driver->cdev添加到cdev_map字符设备驱动管理数组中,以备下面sys_open时kobj_lookup使用[luther.gliethttp]}看看系统调用open函数open(“/dev/ttyUSB0”)==>chrdev_open // sys_open将调用字符设备驱动函数集中open函数chrdev_openconst struct file_operations def_chr_fops = { .open = chrdev_open,};==>kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx); // 搜索上面cdev_add登记的usb_serial_tty_driver驱动 调用exact_match返回&driver->cdev.kobj new = container_of(kobj, struct cdev, kobj); inode->i_cdev = p = new; // 由上面cdev_init(&driver->cdev, &tty_fops); 初始化cdev->ops = &tty_fops filp->f_op = fops_get(p->ops); // 获取驱动方法集 filp->f_op->open(inode,filp);==>tty_open同时在tty_drivers链表上调用get_tty_driver函数搜索, “/dev/ttyUSB0″设备节点号对应的tty_drivers,比如搜索到usb_serial_tty_driver驱动, 那么它就是tty->driver了.同时生成tty:init_dev(driver, index, &tty);其中index表示该字符设备为驱动管理的第index索引处设备. 之后init_dev==>tty = alloc_tty_struct(); ==>initialize_tty_struct(tty); // 初始化该tty的ldisc等于tty_ldisc_N_TTY即tty->ldisc = &tty_ldisc_N_TTY; tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));为tty->ldisc绑定线路规程 console_init==>注册tty_ldisc_N_TTY线路规程 tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY); struct tty_ldisc tty_ldisc_N_TTY = { .magic = TTY_LDISC_MAGIC, .name = “n_tty”, .open = n_tty_open, .close = n_tty_close, .flush_buffer = n_tty_flush_buffer, .chars_in_buffer = n_tty_chars_in_buffer, .read = read_chan, .write = write_chan, .ioctl = n_tty_ioctl, .set_termios = n_tty_set_termios, .poll = normal_poll, .receive_buf = n_tty_receive_buf, .write_wakeup = n_tty_write_wakeup }; ==>tty->driver = driver; ==>tty->index = idx; // 该tty在driver中的索引值 ==>tty_line_name(driver, idx, tty->name); ==>driver->ttys[idx] = tty; // dirver管理的第index个设备指针[luther.gliethttp] ==>(tty->ldisc.open)(tty); // 调用tty_ldisc_N_TTY.open即n_tty_open函数 之后filp->private_data = tty; 之后tty->driver->open==>tty->driver->open就是usb_serial_tty_driver.open即:serial_ops.serial_open==>serial_open // 执行设备实际打开操作static int serial_open (struct tty_struct *tty, struct file * filp){ struct usb_serial *serial; struct usb_serial_port *port; unsigned int portNumber; int retval; dbg(“%s”, __FUNCTION__); /* get the serial object associated with this tty pointer */ serial = usb_serial_get_by_index(tty->index); // 就是 return serial_table[index];因为driver的串口索引就等于serial_table数组的索引. if (!serial) { tty->driver_data = NULL; return -ENODEV; } portNumber = tty->index – serial->minor; // 端口号为当前dev设备的串口索引index减去该serial设备登记的起始索引值,比如一个 // serial设备可以有多个port,比如有3个,那么portNumber就可能等于0,1或者2.[luther.gliethttp] port = serial->port[portNumber]; // 获取’/dev/ttyUSBx’对应的port if (!port) { retval = -ENODEV; goto bailout_kref_put; } if (mutex_lock_interruptible(&port->mutex)) { retval = -ERESTARTSYS; goto bailout_kref_put; } ++port->open_count; /* set up our port structure making the tty driver * remember our port object, and us it */ tty->driver_data = port; // 驱动driver_data似有数据为port port->tty = tty; // 该port服务于该tty if (port->open_count == 1) { // 第1次打开 /* lock this module before we call it * this may fail, which means we must bail out, * safe because we are called with BKL held */ if (!try_module_get(serial->type->driver.owner)) { retval = -ENODEV; goto bailout_mutex_unlock; } retval = usb_autopm_get_interface(serial->interface); if (retval) goto bailout_module_put; /* only call the device specific open if this * is the first time the port is opened */ retval = serial->type->open(port, filp); // 执行mct_u232_device.open即:mct_u232_open if (retval) goto bailout_interface_put; } mutex_unlock(&port->mutex); return 0; // ok,至此sys_open工作就算彻底完成了[luther.gliethttp]bailout_interface_put: usb_autopm_put_interface(serial->interface);bailout_module_put: module_put(serial->type->driver.owner);bailout_mutex_unlock: port->open_count = 0; tty->driver_data = NULL; port->tty = NULL; mutex_unlock(&port->mutex);bailout_kref_put: usb_serial_put(serial); return retval;}tty_write==>do_tty_write(ld->write, tty, file, buf, count);调用线路规程tty_ldisc_N_TTY的write函数write_chan==>write_chan==>tty->driver->write(tty, b, nr);就是上面的usb_serial_tty_driver.write即:serial_ops.serial_write==>serial_write将调用port->serial->type->write(port, buf, count);就是mct_u232_device的write函数 在usb_serial_register(&mct_u232_device);中将使用fixup_generic(driver);函数填充mct_u232_device未定义的操作函数集. 所以mct_u232_device的write函数为usb_serial_generic_write==>mct_u232_device.write即:usb_serial_generic_write==>usb_serial_generic_write==>usb_submit_urb(port->write_urb, GFP_ATOMIC); // 提交一个URB==>usb_hcd_submit_urb(urb, mem_flags);==>hcd->driver->urb_enqueue(hcd, urb, mem_flags);tty_read==>(ld->read)(tty, file, buf, count);调用线路规程tty_ldisc_N_TTY的read函数read_chan==>read_chan在mct_u232_device中定义了mct_u232_read_int_callback,即中断IN回调函数,当usb转串口设备从usb接口接收到数据之后,它将执行mct_u232_read_int_callback回调函数,static void mct_u232_read_int_callback (struct urb *urb){ struct usb_serial_port *port = (struct usb_serial_port *)urb->context; struct mct_u232_private *priv = usb_get_serial_port_data(port); struct usb_serial *serial = port->serial; struct tty_struct *tty; unsigned char *data = urb->transfer_buffer; int retval; int status = urb->status; unsigned long flags; switch (status) { case 0: /* success */ break; case -ECONNRESET: case -ENOENT: case -ESHUTDOWN: /* this urb is terminated, clean up */ dbg(“%s – urb shutting down with status: %d”, __FUNCTION__, status); return; default: dbg(“%s – nonzero urb status received: %d”, __FUNCTION__, status); goto exit; } if (!serial) { dbg(“%s – bad serial pointer, exiting”, __FUNCTION__); return; } dbg(“%s – port %d”, __FUNCTION__, port->number); usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data); /* * Work-a-round: handle the ‘usual’ bulk-in pipe here */ if (urb->transfer_buffer_length > 2) { int i; tty = port->tty; if (urb->actual_length) { for (i = 0; i < urb->actual_length ; ++i) { tty_insert_flip_char(tty, data[i], 0); // 将从usb接收到的数据放入tty缓冲区中[luther.gliethttp] } tty_flip_buffer_push(tty); // 唤醒pending着的read_chan函数,这样tty就收到数据了 } goto exit; } /* * The interrupt-in pipe signals exceptional conditions (modem line * signal changes and errors). data[0] holds MSR, data[1] holds LSR. */ spin_lock_irqsave(&priv->lock, flags); priv->last_msr = data[MCT_U232_MSR_INDEX]; /* Record Control Line states */ mct_u232_msr_to_state(&priv->control_state, priv->last_msr);#if 0 /* Not yet handled. See belin_sa.c for further information */ /* Now to report any errors */ priv->last_lsr = data[MCT_U232_LSR_INDEX]; /* * fill in the flip buffer here, but I do not know the relation * to the current/next receive buffer or characters. I need * to look in to this before committing any code. */ if (priv->last_lsr & MCT_U232_LSR_ERR) { tty = port->tty; /* Overrun Error */ if (priv->last_lsr & MCT_U232_LSR_OE) { } /* Parity Error */ if (priv->last_lsr & MCT_U232_LSR_PE) { } /* Framing Error */ if (priv->last_lsr & MCT_U232_LSR_FE) { } /* Break Indicator */ if (priv->last_lsr & MCT_U232_LSR_BI) { } }#endif spin_unlock_irqrestore(&priv->lock, flags);exit: retval = usb_submit_urb (urb, GFP_ATOMIC); if (retval) err (“%s – usb_submit_urb failed with result %d”, __FUNCTION__, retval);}todo …mct_u232_device驱动位于usb_serial_bus_type总线上,mct_u232_driver驱动位于usb_bus_type总线上,当hub发现usb新硬件之后,会首先调用usb_bus_type总线上的mct_u232_driver驱动的probe(),也就是usb_serial_probe(),在usb_serial_probe()中,程序会遍历usb_serial_driver_list驱动链表的所有驱动,并usb_serial_driver_list尝试和发现的新硬件进行匹配,在计算匹配的过程中会调用,drv->bus->match,即:usb_serial_bus_type->match()和dev->bus->probe或者drv->probe即:usb_serial_device_probe(),这样设备就和分别处在两条独立总线上的mct_u232_driver驱动以及mct_u232_device驱动关联上了[gliethttp_20090430].
转自：http://blog.csdn.net/ling1874/archive/2010/06/18/5678100.aspx
蚁穴虽小，溃之千里。
