usb driver 分析

1） 写一个usb driver需要调用 usb_register_driver 来注册。

/**
* usb_register_driver - register a USB interface driver
* @new_driver: USB operations for the interface driver
* @owner: module owner of this driver.
* @mod_name: module name string
*
* Registers a USB interface driver with the USB core.  The list of
* unattached interfaces will be rescanned whenever a new driver is
* added, allowing the new driver to attach to any recognized interfaces.
* Returns a negative error code on failure and 0 on success.
*
* NOTE: if you want your driver to use the USB major number, you must call
* usb_register_dev() to enable that functionality.  This function no longer
* takes care of that.
*/
int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
const char *mod_name)
{
int retval = 0;

if (usb_disabled())
return -ENODEV;

new_driver->drvwrap.for_devices = 0;
new_driver->drvwrap.driver.name = (char *) new_driver->name;
new_driver->drvwrap.driver.bus = &usb_bus_type;
new_driver->drvwrap.driver.probe = usb_probe_interface;
new_driver->drvwrap.driver.remove = usb_unbind_interface;
new_driver->drvwrap.driver.owner = owner;
new_driver->drvwrap.driver.mod_name = mod_name;
spin_lock_init(&new_driver->dynids.lock);
INIT_LIST_HEAD(&new_driver->dynids.list);

retval = driver_register(&new_driver->drvwrap.driver);
if (retval)
goto out;

usbfs_update_special();

retval = usb_create_newid_file(new_driver);
if (retval)
goto out_newid;

retval = usb_create_removeid_file(new_driver);
if (retval)
goto out_removeid;

pr_info("%s: registered new interface driver %s\n",
usbcore_name, new_driver->name);

out:
return retval;

out_removeid:
usb_remove_newid_file(new_driver);
out_newid:
driver_unregister(&new_driver->drvwrap.driver);

printk(KERN_ERR "%s: error %d registering interface "
"	driver %s\n",
usbcore_name, retval, new_driver->name);
goto out;
}

2） usb bus

struct bus_type usb_bus_type = {
.name =		"usb",
.match =	usb_device_match,
.uevent =	usb_uevent,
.pm =		&usb_bus_pm_ops,
};

这个函数定义了usb 设备如何mach usb  driver 的。

/**
* usb_match_id - find first usb_device_id matching device or interface
* @interface: the interface of interest
* @id: array of usb_device_id structures, terminated by zero entry
*
* usb_match_id searches an array of usb_device_id's and returns
* the first one matching the device or interface, or null.
* This is used when binding (or rebinding) a driver to an interface.
* Most USB device drivers will use this indirectly, through the usb core,
* but some layered driver frameworks use it directly.
* These device tables are exported with MODULE_DEVICE_TABLE, through
* modutils, to support the driver loading functionality of USB hotplugging.
*
* What Matches:
*
* The "match_flags" element in a usb_device_id controls which
* members are used.  If the corresponding bit is set, the
* value in the device_id must match its corresponding member
* in the device or interface descriptor, or else the device_id
* does not match.
*
* "driver_info" is normally used only by device drivers,
* but you can create a wildcard "matches anything" usb_device_id
* as a driver's "modules.usbmap" entry if you provide an id with
* only a nonzero "driver_info" field.  If you do this, the USB device
* driver's probe() routine should use additional intelligence to
* decide whether to bind to the specified interface.
*
* What Makes Good usb_device_id Tables:
*
* The match algorithm is very simple, so that intelligence in
* driver selection must come from smart driver id records.
* Unless you have good reasons to use another selection policy,
* provide match elements only in related groups, and order match
* specifiers from specific to general.  Use the macros provided
* for that purpose if you can.
*
* The most specific match specifiers use device descriptor
* data.  These are commonly used with product-specific matches;
* the USB_DEVICE macro lets you provide vendor and product IDs,
* and you can also match against ranges of product revisions.
* These are widely used for devices with application or vendor
* specific bDeviceClass values.
*
* Matches based on device class/subclass/protocol specifications
* are slightly more general; use the USB_DEVICE_INFO macro, or
* its siblings.  These are used with single-function devices
* where bDeviceClass doesn't specify that each interface has
* its own class.
*
* Matches based on interface class/subclass/protocol are the
* most general; they let drivers bind to any interface on a
* multiple-function device.  Use the USB_INTERFACE_INFO
* macro, or its siblings, to match class-per-interface style
* devices (as recorded in bInterfaceClass).
*
* Note that an entry created by USB_INTERFACE_INFO won't match
* any interface if the device class is set to Vendor-Specific.
* This is deliberate; according to the USB spec the meanings of
* the interface class/subclass/protocol for these devices are also
* vendor-specific, and hence matching against a standard product
* class wouldn't work anyway.  If you really want to use an
* interface-based match for such a device, create a match record
* that also specifies the vendor ID.  (Unforunately there isn't a
* standard macro for creating records like this.)
*
* Within those groups, remember that not all combinations are
* meaningful.  For example, don't give a product version range
* without vendor and product IDs; or specify a protocol without
* its associated class and subclass.
*/
const struct usb_device_id *usb_match_id(struct usb_interface *interface,
const struct usb_device_id *id)
{
/* proc_connectinfo in devio.c may call us with id == NULL. */
if (id == NULL)
return NULL;

/* It is important to check that id->driver_info is nonzero,
since an entry that is all zeroes except for a nonzero
id->driver_info is the way to create an entry that
indicates that the driver want to examine every
device and interface. */
for (; id->idVendor || id->idProduct || id->bDeviceClass ||
id->bInterfaceClass || id->driver_info; id++) {
if (usb_match_one_id(interface, id))
return id;
}

return NULL;
}

for 3G modem serial usb driver , 我们用venderid 和productid以及接口来匹配。

/* returns 0 if no match, 1 if match */
int usb_match_one_id(struct usb_interface *interface,
const struct usb_device_id *id)
{
struct usb_host_interface *intf;
struct usb_device *dev;

/* proc_connectinfo in devio.c may call us with id == NULL. */
if (id == NULL)
return 0;

intf = interface->cur_altsetting;
dev = interface_to_usbdev(interface);

if (!usb_match_device(dev, id))
return 0;

/* The interface class, subclass, and protocol should never be
* checked for a match if the device class is Vendor Specific,
* unless the match record specifies the Vendor ID. */
if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
!(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
(id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
USB_DEVICE_ID_MATCH_INT_SUBCLASS |
USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
return 0;

if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
(id->bInterfaceClass != intf->desc.bInterfaceClass))
return 0;

if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
(id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
return 0;

if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
(id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
return 0;

return 1;
}

这个是usb driver pm 的调用栈，我们可以看到它采用了runtime pm的机制。

[<c003e5a0>] (unwind_backtrace+0x0/0xf0) from [<c02b6448>] (option_suspend+0x6c/0x98)
[<c02b6448>] (option_suspend+0x6c/0x98) from [<c02b2b18>] (usb_serial_suspend+0x38/0x8c)
[<c02b2b18>] (usb_serial_suspend+0x38/0x8c) from [<c029cd70>] (usb_suspend_both+0x7c/0x1d0)
[<c029cd70>] (usb_suspend_both+0x7c/0x1d0) from [<c029cf04>] (usb_runtime_suspend+0x40/0x8c)
[<c029cf04>] (usb_runtime_suspend+0x40/0x8c) from [<c023ce04>] (__pm_runtime_suspend+0x1e0/0x46c)
[<c023ce04>] (__pm_runtime_suspend+0x1e0/0x46c) from [<c023d0fc>] (pm_runtime_work+0x6c/0xa8)
[<c023d0fc>] (pm_runtime_work+0x6c/0xa8) from [<c007d888>] (worker_thread+0x180/0x22c)
[<c007d888>] (worker_thread+0x180/0x22c) from [<c0080ed8>] (kthread+0x78/0x80)
[<c0080ed8>] (kthread+0x78/0x80) from [<c003a9e0>] (kernel_thread_exit+0x0/0x8)

usb 设备的探测：当有设备插入和拔出时， 此函数会调用，

/* Handle physical or logical connection change events.

 * This routine is called when:

 * a port connection-change occurs;

 * a port enable-change occurs (often caused by EMI);

 * usb_reset_and_verify_device() encounters changed descriptors (as from

 * a firmware download)

 * caller already locked the hub

 */

static void hub_port_connect_change(struct usb_hub *hub, int port1,

u16 portstatus, u16 portchange)

{

struct usb_device *hdev = hub->hdev;

struct device *hub_dev = hub->intfdev;

struct usb_hcd *hcd = bus_to_hcd(hdev->bus);

unsigned wHubCharacteristics =

le16_to_cpu(hub->descriptor->wHubCharacteristics);

struct usb_device *udev;

int status, i;

dev_dbg (hub_dev,

"port %d, status %04x, change %04x, %s\n",

port1, portstatus, portchange, portspeed (portstatus));

#ifdef MXS_USB_HOST_HACK

{

struct device *dev = hcd->self.controller;

struct fsl_usb2_platform_data *pdata;

pdata = (struct fsl_usb2_platform_data *)dev->platform_data;

if (dev->parent && dev->type) {

if (port1 == 1 && pdata->platform_init)

pdata->platform_init(NULL);

}

if (port1 == 1) {

if (!(portstatus&USB_PORT_STAT_CONNECTION)) {

/* Must clear HOSTDISCONDETECT when disconnect*/

fsl_platform_set_usb_phy_dis(pdata, 0);

}

}

}

#endif

if (hub->has_indicators) {

set_port_led(hub, port1, HUB_LED_AUTO);

hub->indicator[port1-1] = INDICATOR_AUTO;

}

#ifdef CONFIG_USB_OTG

/* during HNP, don't repeat the debounce */

if (hdev->bus->is_b_host)

portchange &= ~(USB_PORT_STAT_C_CONNECTION |

USB_PORT_STAT_C_ENABLE);

#endif

/* Try to resuscitate an existing device */

udev = hdev->children[port1-1];

if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&

udev->state != USB_STATE_NOTATTACHED) {

usb_lock_device(udev);

if (portstatus & USB_PORT_STAT_ENABLE) {

status = 0; /* Nothing to do */

#ifdef CONFIG_USB_SUSPEND

} else if (udev->state == USB_STATE_SUSPENDED &&

udev->persist_enabled) {

/* For a suspended device, treat this as a

* remote wakeup event.

*/

status = usb_remote_wakeup(udev);

#endif

} else {

status = -ENODEV; /* Don't resuscitate */

}

usb_unlock_device(udev);

if (status == 0) {

clear_bit(port1, hub->change_bits);

return;

}

}

/* Disconnect any existing devices under this port */

if (udev)

usb_disconnect(&hdev->children[port1-1]);

clear_bit(port1, hub->change_bits);

/* We can forget about a "removed" device when there's a physical

* disconnect or the connect status changes.

*/

if (!(portstatus & USB_PORT_STAT_CONNECTION) ||

(portchange & USB_PORT_STAT_C_CONNECTION))

clear_bit(port1, hub->removed_bits);

if (portchange & (USB_PORT_STAT_C_CONNECTION |

USB_PORT_STAT_C_ENABLE)) {

status = hub_port_debounce(hub, port1);

if (status < 0) {

if (printk_ratelimit())

dev_err(hub_dev, "connect-debounce failed, "

"port %d disabled\n", port1);

portstatus &= ~USB_PORT_STAT_CONNECTION;

} else {

portstatus = status;

}

}

/* Return now if debouncing failed or nothing is connected or

* the device was "removed".

*/

if (!(portstatus & USB_PORT_STAT_CONNECTION) ||

test_bit(port1, hub->removed_bits)) {

/* maybe switch power back on (e.g. root hub was reset) */

if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2

&& !(portstatus & USB_PORT_STAT_POWER))

set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);

if (portstatus & USB_PORT_STAT_ENABLE)

  goto done;

return;

}

for (i = 0; i < SET_CONFIG_TRIES; i++) {

/* reallocate for each attempt, since references

* to the previous one can escape in various ways

*/

udev = usb_alloc_dev(hdev, hdev->bus, port1);

if (!udev) {

dev_err (hub_dev,

"couldn't allocate port %d usb_device\n",

port1);

goto done;

}

usb_set_device_state(udev, USB_STATE_POWERED);

  udev->bus_mA = hub->mA_per_port;

udev->level = hdev->level + 1;

udev->wusb = hub_is_wusb(hub);

/*

* USB 3.0 devices are reset automatically before the connect

* port status change appears, and the root hub port status

* shows the correct speed.  We also get port change

* notifications for USB 3.0 devices from the USB 3.0 portion of

* an external USB 3.0 hub, but this isn't handled correctly yet

* FIXME.

*/

if (!(hcd->driver->flags & HCD_USB3))

udev->speed = USB_SPEED_UNKNOWN;

else if ((hdev->parent == NULL) &&

(portstatus & USB_PORT_STAT_SUPER_SPEED))

udev->speed = USB_SPEED_SUPER;

else

udev->speed = USB_SPEED_UNKNOWN;

/*

* xHCI needs to issue an address device command later

* in the hub_port_init sequence for SS/HS/FS/LS devices.

*/

if (!(hcd->driver->flags & HCD_USB3)) {

/* set the address */

choose_address(udev);

if (udev->devnum <= 0) {

status = -ENOTCONN; /* Don't retry */

goto loop;

}

}

/* reset (non-USB 3.0 devices) and get descriptor */

status = hub_port_init(hub, udev, port1, i);

if (status < 0)

goto loop;

usb_detect_quirks(udev);

if (udev->quirks & USB_QUIRK_DELAY_INIT)

msleep(1000);

/* consecutive bus-powered hubs aren't reliable; they can

* violate the voltage drop budget.  if the new child has

* a "powered" LED, users should notice we didn't enable it

* (without reading syslog), even without per-port LEDs

* on the parent.

*/

if (udev->descriptor.bDeviceClass == USB_CLASS_HUB

&& udev->bus_mA <= 100) {

u16 devstat;

status = usb_get_status(udev, USB_RECIP_DEVICE, 0,

&devstat);

if (status < 2) {

dev_dbg(&udev->dev, "get status %d ?\n", status);

goto loop_disable;

}

le16_to_cpus(&devstat);

if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {

dev_err(&udev->dev,

"can't connect bus-powered hub "

"to this port\n");

if (hub->has_indicators) {

hub->indicator[port1-1] =

INDICATOR_AMBER_BLINK;

schedule_delayed_work (&hub->leds, 0);

}

status = -ENOTCONN; /* Don't retry */

goto loop_disable;

}

}

 

/* check for devices running slower than they could */

if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200

&& udev->speed == USB_SPEED_FULL

&& highspeed_hubs != 0)

check_highspeed (hub, udev, port1);

/* Store the parent's children[] pointer.  At this point

* udev becomes globally accessible, although presumably

* no one will look at it until hdev is unlocked.

*/

status = 0;

/* We mustn't add new devices if the parent hub has

* been disconnected; we would race with the

* recursively_mark_NOTATTACHED() routine.

*/

spin_lock_irq(&device_state_lock);

if (hdev->state == USB_STATE_NOTATTACHED)

status = -ENOTCONN;

else

hdev->children[port1-1] = udev;

spin_unlock_irq(&device_state_lock);

/* Run it through the hoops (find a driver, etc) */

if (!status) {

status = usb_new_device(udev);  /× 注册新的设备×/

if (status) {

spin_lock_irq(&device_state_lock);

hdev->children[port1-1] = NULL;

spin_unlock_irq(&device_state_lock);

}

}

if (status)

goto loop_disable;

status = hub_power_remaining(hub);

if (status)

dev_dbg(hub_dev, "%dmA power budget left\n", status);

return;

loop_disable:

hub_port_disable(hub, port1, 1);

loop:

usb_ep0_reinit(udev);

release_address(udev);

hub_free_dev(udev);

usb_put_dev(udev);

if ((status == -ENOTCONN) || (status == -ENOTSUPP))

break;

}

if (hub->hdev->parent ||

!hcd->driver->port_handed_over ||

!(hcd->driver->port_handed_over)(hcd, port1))

dev_err(hub_dev, "unable to enumerate USB device on port %d\n",

port1);

 

done:

hub_port_disable(hub, port1, 1);

if (hcd->driver->relinquish_port && !hub->hdev->parent)

hcd->driver->relinquish_port(hcd, port1);

}

usb driver的probe 

new_driver->drvwrap.for_devices = 0;

new_driver->drvwrap.driver.name = (char *) new_driver->name;

new_driver->drvwrap.driver.bus = &usb_bus_type;

new_driver->drvwrap.driver.probe = usb_probe_interface;

new_driver->drvwrap.driver.remove = usb_unbind_interface;

new_driver->drvwrap.driver.owner = owner;

new_driver->drvwrap.driver.mod_name = mod_name;

spin_lock_init(&new_driver->dynids.lock);

INIT_LIST_HEAD(&new_driver->dynids.list);

/* 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 = to_usb_interface(dev);

struct usb_device *udev = interface_to_usbdev(intf);

const struct usb_device_id *id;

int error = -ENODEV;

dev_dbg(dev, "%s\n", __func__);

intf->needs_binding = 0;

if (usb_device_is_owned(udev))

return error;

if (udev->authorized == 0) {

dev_err(&intf->dev, "Device is not authorized for usage\n");

return error;

}

id = usb_match_id(intf, driver->id_table);

if (!id)

id = usb_match_dynamic_id(intf, driver);

if (!id)

return error;

dev_dbg(dev, "%s - got id\n", __func__);

error = usb_autoresume_device(udev);

if (error)

return error;

intf->condition = USB_INTERFACE_BINDING;

/* Probed interfaces are initially active.  They are

* runtime-PM-enabled only if the driver has autosuspend support.

* They are sensitive to their children's power states.

*/

pm_runtime_set_active(dev);

pm_suspend_ignore_children(dev, false);

if (driver->supports_autosuspend)

pm_runtime_enable(dev);

/* Carry out a deferred switch to altsetting 0 */

if (intf->needs_altsetting0) {

error = usb_set_interface(udev, intf->altsetting[0].

desc.bInterfaceNumber, 0);

if (error < 0)

goto err;

intf->needs_altsetting0 = 0;

}

error = driver->probe(intf, id);   /* 调用新的驱动的probe */

if (error)

goto err;

intf->condition = USB_INTERFACE_BOUND;

usb_autosuspend_device(udev);

return error;

 err:

intf->needs_remote_wakeup = 0;

intf->condition = USB_INTERFACE_UNBOUND;

usb_cancel_queued_reset(intf);

/* Unbound interfaces are always runtime-PM-disabled and -suspended */

if (driver->supports_autosuspend)

pm_runtime_disable(dev);

pm_runtime_set_suspended(dev);

usb_autosuspend_device(udev);

return error;

}