USB Drivers Michael Mitchell COP 5641 CIS 4930

USB Drivers Michael Mitchell COP 5641 / CIS 4930

USB Device Basics n Universal Serial Bus (USB) connects between a computer and peripheral devices n Created to replace various slow buses (parallel, serial, and keyboard connections) n n USB 2. 0: up to 480 Mb/s (35 MB/s) USB 3. 0: up to 6 Gb/s (625 MB/s)

USB Device Basics A USB device can never start sending data without first being asked by the host controller n Single-master implementation n n Host polls various devices A device can request a fixed bandwidth (for audio and video I/O) Universal Serial Bus is a misnomer… n Actually a tree built out of point-to-point links § Links are four-wire cables (ground, power, and two signal wires)

USB Device Basics – The Protocol n USB protocol defines a set of standards that any device can follow No need to write a driver for a device that is in a predefined class and follows that standard, n Predefined classes: storage devices, keyboards, mice, joysticks, network devices, and modems n No defined standard for video devices and USB-to-serial devices n n A driver is needed for every device

USB Device Basics – Driver Types n Linux supports two types of USB drivers n Drivers on a host system n n Drivers on a device (USB gadget drivers) n n Control the USB devices that are plugged into it Control how that single device looks to the host computer as a USB device Some hardware devices can actually be both n n Called USB OTG (On The Go), E. g. Android 3. 0+, some printers

USB Device Basics Different kernel subsystems An interface for USB drivers to access HW

USB Device Basics USB drivers bind to interfaces, not the device

USB Overview n A USB device has one or more configurations n E. g. , power and bandwidth requirements n A configuration has one or more interfaces n E. g. , audio data, knobs for speakers n An interface has one or more settings n Different quality of services n n E. g. , different frame sizes for digital cameras Also zero or more endpoints n E. g. , bulk, interrupt endpoints.

Endpoints n The most basic form of USB communication is through an endpoint n Unidirectional: Carries data in one direction n n From the host to device (OUT endpoint) From the device to the host (IN endpoint)

Endpoints n Four endpoint types n CONTROL n INTERRUPT n BULK n ISOCHRONOUS

Endpoints n CONTROL n n Used for configuring the device, retrieving information and status about the device, or sending commands to the device Every device has a control endpoint called endpoint 0 § Used by USB core to configure the device at insertion time § Transfers are guaranteed with reserved bandwidth

Endpoints n INTERRUPT n n n Transfer small amounts of data at a fixed rate For USB keyboards and mice Also used to control the device Not for large transfers Guaranteed reserved bandwidth

Endpoints n BULK n n n Transfer large amounts of data No data loss Not time guaranteed A BULK packet might be split up across multiple transfers Used for printers, storage, and network devices

Endpoints n ISOCHRONOUS n n n Transfer large amount of data For real-time data collections, A/V devices Unlike bulk endpoints, no guarantees (potential data loss) n Control and bulk endpoints are used for asynchronous data transfers n Interrupt and isochronous endpoints are periodic with reserved bandwidth

Endpoints n Endpoint information is in struct usb_endpoint_descriptor n embedded in struct usb_host_endpoint n Note: defined by the USB standard, so not Linux looking n Some important fields n b. Endpoint. Address (8 -bit) n Use USB_DIR_OUT and USB_DIR_IN bit masks to determine the direction of data flow

Endpoints n bm. Attributes n n n Type of the endpoint & USB_ENDPOINT_XFERTYPE_MASK to determine if the endpoint is of type USB_ENDPOINT_XFER_ISOC, USB_ENDPOINT_XFER_BULK, or USB_ENDPOINT_XFER_INT w. Max. Packet. Size n n Maximum bytes that an endpoint can handle Larger transfers will be split into multiple transfers

Endpoints n b. Interval n For interrupt endpoints, this value specifies the milliseconds between interrupt requests for the endpoint

Interfaces n USB endpoints are bundled into interfaces n A interface handles only one type of logical connection (E. g. , a mouse) n Some devices have multiple interfaces n E. g. , a speaker § One interface for buttons and one for audio stream n USB interface may have alternate settings n E. g. , different settings to reserve different amounts of bandwidth for the device

Interfaces n Described via struct usb_interface n Passed from USB core to USB drivers n Some important fields n struct usb_host_interface *altsetting n n An array of settings for this interface unsigned num_altsetting n Number of alternative settings

Interfaces n struct usb_host_interface *cur_altsetting n n A pointer into the altsetting array, denoting the current setting int minor n n Minor number assigned by the USB core to the interface Valid after a successful call to usb_register_dev

Configurations n USB interfaces are bundled into configurations n A USB device can have multiple configurations Only one can be active at a time n Can switch between them n n Described in struct usb_host_config n embedded in struct usb_device

USB Webcam Device Example endpoint control input Interface Audio endpoint control input Interface Video Configuration Active Interface Video Configuration Standby Device USB webcam

USB and Sysfs n Both USB devices and its interfaces are shown in sysfs as individual devices n A USB mouse device can be represented as /sys/devices/pci 0000: 00/0000: 09. 0/usb 2/2 -1 n The interface of the USB mouse device driver is represented as /sys/devices/pci 0000: 00/0000: 09. 0/usb 2/2 -1: 1. 0 root_hub-hub_port: configuration. interface

USB and Sysfs n For a two-level USB connection, the device name is in the following format root_hub-hub_port: configuration. interface n In the sysfs directory, all USB information is available E. g. , id. Vendor, id. Product, b. Max. Power n b. Configuration. Value can be written to change the active configuration n

USB and Sysfs n More information is available in /proc/bus/usb directory n User-space programs can directly communicate with USB devices via the directory

USB Urbs (USB Request Block) n Communication between the host and device is done asynchronously using USB Request Blocks (URBs). Similar to packets in network communications. n Every endpoint can handle a queue of URBs. n Every URB has a completion handler. n Flexible: A driver may allocate many URBs for a single endpoint, or reuse the same URB for different endpoints. n See Documentation/usb/URB. txt in kernel sources. n

USB Urbs (USB Request Block) n struct urb Used to send and receive data between endpoints n Asynchronous n Dynamically created n n Contains reference count for garbage collection Designed to achieve high throughput n Defined in <include/linux/usb. h> n n Must be created with the usb_alloc_urb() function. Shouldn't be allocated statically or with kmalloc().

USB Urbs (USB Request Block) n A typical lifecycle of an Urb n A USB device driver creates an Urb n n Assigns it to a specific endpoint of a device Submits it to the USB core The USB core submits the Urb to specific USB host controller driver n The USB host controller driver processes the Urb and transfers it to the device n n Notifies the USB device driver when the Urb is done

USB Urbs (USB Request Block) n An Urb can be cancelled by the driver or the USB core if the device is removed from the system

Life Cycle of an Urb Creation Device driver USB core (controller driver) Assigned to an endpoint yes Submitted to the USB core can be reused? no Deletion Transfered to the device Notification at transfer completion

struct urb n Important fields /* destination USB device */ /* must be initialized by the USB driver before the urb can be sent to the USB core */ struct usb_device *dev; /* end point type information */ /* set to the return value from one of the usb send and receive pipe functions */ /* must be initialized by the USB driver before the urb can be sent to the USB core */ unsigned int pipe;

struct urb /* assigned to one of the transfer flags */ unsigned int transfer_flags; void *transfer_buffer; /* points to a kmalloced buffer */ dma_addr_t transfer_dma; /* buffer for DMA transfers */ /* buffer length for either the transfer_buffer or the transfer_dma variable, 0 if neither buffers are used */ int transfer_buffer_length; /* pointer to a setup packet for a control urb */ /* transferred before the data in the transfer buffer */ unsigned char *setup_packet; /* DMA buffer for the setup packet for a control urb */ dma_addr_t setup_dma;

struct urb /* pointer to the completion handler called by USB core */ usb_complete_t complete; /* pointer to a data blob that can be set by the USB driver */ void *context; /* actual length of data sent/received by the urb */ int actual_length; /* accessed in the completion handler */ /* see status values */ int status; /* the initial frame number for isochronous transfers */ int start_frame;

struct urb /* polling interval for the urb */ /* valid only for interrupt or isochronous urbs */ /* for slow devices, the unit is in frames or milliseconds */ /* for other devices, the unit is in 1/8 milliseconds */ interval; /* the number of isochronous transfer buffers handled by this urb */ /* must be set by the USB driver before the urb is sent to the USB core */ int number_of_packets; /* number of isochronous transfers with errors */ int error_count;

struct urb /* allows a single urb to define a number of isochronous transfers at once */ struct usb_iso_packet_descriptor iso_frame_desc[0]; struct usb_iso_packet_descriptor { unsigned int offset; /* byte into the transfer buffer */ unsigned int length; /* length of the transfer buffer */ /* length of data received into the transfer buffer */ unsigned int actual_length; unsigned int status; /* see status values */ };

USB send and receive pipe functions /* specifies a control OUT endpoint for the specified USB device with the specified endpoint number */ unsigned int usb_sndctrlpipe(struct usb_device *dev, unsigned int endpoint); /* specifies a control IN endpoint for the specified USB device with the specified endpoint number */ unsigned int usb_rcvctrlpipe(struct usb_device *dev, unsigned int endpoint); /* specifies a bulk OUT endpoint for the specified USB device with the specified endpoint number */ unsigned int usb_sndbulkpipe(struct usb_device *dev, unsigned int endpoint);

USB send and receive pipe functions /* specifies a bulk IN endpoint for the specified USB device with the specified endpoint number */ unsigned int usb_rcvbulkpipe(struct usb_device *dev, unsigned int endpoint); /* specifies a interrupt OUT endpoint for the specified USB device with the specified endpoint number */ unsigned int usb_sndintpipe(struct usb_device *dev, unsigned int endpoint); /* specifies a interrupt IN endpoint for the specified USB device with the specified endpoint number */ unsigned int usb_rcvintpipe(struct usb_device *dev, unsigned int endpoint);

USB send and receive pipe functions /* specifies a isochronous OUT endpoint for the specified USB device with the specified endpoint number */ unsigned int usb_sndisocpipe(struct usb_device *dev, unsigned int endpoint); /* specifies a isochronous IN endpoint for the specified USB device with the specified endpoint number */ unsigned int usb_rcvisocpipe(struct usb_device *dev, unsigned int endpoint);

URB Transfer flags n URB_SHORT_NOT_OK n Partial read should be treated as an error by the USB core n URB_ISO_ASAP If the driver wants the isochronous urb to be scheduled as soon as bandwidth allows n Set the start_frame variable n

URB Transfer flags n URB_NO_TRANSFER_DMA_MAP Set when the urb contains a DMA buffer to be transferred n Tells the USB core to use the buffer pointed by the transfer_dma pointer, not the transfer_buffer pointer n

URB Transfer flags n URB_NO_SETUP_DMA_MAP Used for control urbs with DMA buffer already set up n Tells the USB core to use the buffer pointed by the setup_dma pointer instead of the setup_packet pointer n n URB_ASYNC_UNLINK n Tells usb_unlink_urb() to return immediate and unlink the urb in the background

URB Transfer flags n URB_NO_FSBR For UHCI USB host controller n Generally not used n n URB_ZERO_PACKET n Tells a bulk out urb finishes by sending an empty packet when the data is aligned to an endpoint packet boundary

URB Transfer flags n URB_NO_INTERRUPT Indicates that the HW may not generate an interrupt when the urb is finished n Used when queuing multiple urbs to the same endpoint n Used by USB core to perform DMA transfers n

URB Status Values n 0 The urb transfer was successful n For isochronous urbs, only indicates whether the urb has been unlinked n n Detailed status in iso_frame_desc n -ENOENT n Urb stopped by usb_kill_urb n -ECONNRESET n n Urb was unlinked by usb_unlink_urb transfer_flags set to URB_ASYNC_UNLINK

URB Status Values n -EINPROGRESS Urb still being processed by the USB host controller n A bug if seen at the driver level n n -EPROTO (a HW problem) A bitstuff error happened during the transfer n No response packet was received n n -EILSEQ (a HW problem) n CRC mismatch

URB Status Values n -EPIPE The endpoint is now stalled n If not a control endpoint, can clear this error with usb_clear_halt n n -ECOMM n Data received faster than it could be written to system memory n -ENOSR n Data cannot be retrieved from the system memory during the transfer fast enough to keep up with the requested USB data rate

URB Status Values n -EOVERFLOW (a HW problem) n When the endpoint receives more data than the specified max n -EREMOTEIO Full amount of data was not received n Occurs when the URB_SHORT_NOT_OK is set n n -ENODEV n The USB device is gone from the system

URB Status Values n -ESHUTDOWN Host controller driver has been disabled or disconnected n Urb was submitted after the device was removed n Configuration change while the urb was submitted n

URB Status Values n -EXDEV Only for a isochronous urb n Transfer was partially completed n n -EINVAL ISO madness, if this happens: Log off and go home n Incorrect function parameter n

Creating and Destroying Urbs n All URBs need to be created dynamically n Or the reference count would not work n To create a URB, call struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags); Returns pointer to the URB or NULL on failure n iso_packets: number of isochronous packets this urb should contain n mem_flags: same as kmalloc flags n n To destroy a urb, call void usb_free_urb(struct urb *urb);

Interrupt urbs n To initialize an interrupt urb, call 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, void *context, interval); urb: a pointer to the urb to be initialized n dev: The destination USB device n pipe: the destination endpoint of this urb n

Interrupt urbs transfer_buffer: a pointer to a kmalloced buffer n buffer_length: the length of the transfer buffer n complete: pointer to the completion handler n context: pointer to the blob, retrieved by the completion handler function n interval: scheduling interval for this urb n

Bulk urbs n To initialize an bulk urb, call 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, void *context); n Similar to interrupt urb initialization n Exception: No final interval parameter

Control urbs n To initialize a control urb, call void usb_fill_control_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe, unsigned char *setup_packet, void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context); n Similar to bulk urb initialization n n setup_packet: points to the setup packet data Also, does not set the transfer_flags

Isochronous urbs n Have no initialization functions n Need to be initialized by hand /* from /drivers/media/video/usbvideo/konicawc. c */ urb->dev = dev; urb->context = uvd; urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp - 1); urb->interval = 1; urb->transfer_flags = URB_ISO_ASAP; urb->transfer_buffer = cam->sts_buf[i]; urb->complete = konicawc_isoc_irq; urb->number_of_packets = FRAMES_PER_DESC; urb->transfer_buffer_length = FRAMES_PER_DESC; for (j=0; j < FRAMES_PER_DESC; j++) { urb->iso_frame_desc[j]. offset = j; urb->iso_frame_desc[j]. length = 1; }

Submitting Urbs n To send a urb to the USB core, call int usb_submit_urb(struct urb *urb, gfp_t mem_flags); urb: a pointer to the urb n mem_flags: same as kmalloc flags n n n GTP_KERNEL, GFP_ATOMIC, etc. Should not access a submitted urb until the complete function is called

Completing Urbs: The Completion Callback Handler n Called exactly once when the urb is completed n When this function is called, the USB core is finished with the urb, and control is returned to the device driver

Completing Urbs: The Completion Callback Handler n The completion handler is called under three conditions The urb is successfully sent to the device and acknowledged n An error has occurred n n n Check the status variable The urb was unlinked (the submission was cancelled) when a device is removed from the system

Canceling Urbs n To stop a submitted urb, call int usb_kill_urb(struct urb *urb); n Used when the device is disconnected from the system int usb_unlink_urb(struct urb *urb); Tells the USB core to stop an urb n Returns before the urb is fully stopped n n n Useful while in an interrupt handler Requires setting the URB_ASYNC_UNLINK

Actually writing a USB Driver n Similar to a pci_driver Driver registers its driver object with the USB subsystem n Later uses vendor and device identifiers to tell if its hardware has been installed n

What Devices Does the Driver Support? n struct usb_device_id lists supported types of USB devices n Important fields n __u 16 match_flags n n Determines which fields in the structure the device should be matched against Check include/linux/mod_devicetable. h __u 16 id. Vendor n __u 16 id. Product n

What Devices Does the Driver Support? __u 16 bcd. Device_lo n __u 16 bcd. Device_hi n n n Define low and high ends of the range of the vendor-assigned product version number Expressed in binary-coded decimal (BCD) __u 8 b. Device. Class n __u 8 b. Device. Sub. Class n __u 8 b. Device. Protocol n n Define the class, subclass, and protocol of the device

What Devices Does the Driver Support? __u 8 b. Interface. Class n __u 8 b. Interface. Sub. Class n __u 8 b. Interface. Protocol n n n Class, subclass, and protocol of the individual interface kernel_ulong_t driver_info n Used to differentiate different devices in the probe callback function

What Devices Does the Driver Support? n To initialize usb_device_id, use the following macros USB_DEVICE(vendor, product) n Creates a usb_device_id that can be used to match only the specified vendor and product IDs USB_DEVICE_VER(vendor, product, lo, hi) n Creates a usb_device_id that can be used to match only the specified vendor and product IDs within a version range USB_DEVICE_INFO(class, subclass, protocol) n Creates a usb_device_id that can be used to match a specific class of USB devices

What Devices Does the Driver Support? USB_INTERFACE_INFO(class, subclass, protocol) n Creates a usb_device_id that can be used to match a specific class of USB interfaces n Example /* table of devices that work with this driver */ static struct usb_device_id skel_table[] = { { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) }, { } /* Terminating entry */ }; /* allow user-space tools to figure out what devices this driver can control */ MODULE_DEVICE_TABLE(usb, skel_table);

Registering a USB Driver n The main structure for a USB driver is struct usb_driver n Important fields n struct module *owner n n Set to THIS_MODULE to track the reference count of the module owning this driver const char *name n Points to a unique driver name

Registering a USB Driver n const struct usb_device_id *id_table n n Pointer to the list of supported USB devices If you want your driver always be called for every USB device, create an entry that sets only the driver_info field static struct usb_device_id usb_ids[] = { {. driver_info = 42}, { } };

Registering a USB Driver n int (*probe) (struct usb_interface *intf, const struct usb_device_id *id) n n n Called when the USB core thinks it has a struct usb_interface that this driver can handle The USB driver should initialize the usb interface and return 0, or return a negative error number on failure void (*disconnect) (struct usb_interface *intf) n Called when the usb_interface has been removed from the system, or when the driver is being unloaded

Registering a USB Driver n To create a struct usb_driver, only five fields need to be initialized static struct usb_driver skel_driver = {. owner = THIS_MODULE, . name = "skeleton", . id_table = skel_table, . probe = skel_probe, . disconnect = skel_disconnect, };

Registering a USB Driver n To register a USB driver call usb_register_driver n Example static int __init usb_skel_init(void) { int result; /* register this driver with the USB subsystem */ result = usb_register(&skel_driver); if (result) err("usb_register failed. Error number %d", result); return result; }

Registering a USB Driver n To unload a USB driver call usb_deregister n Example static void __exit usb_skel_exit(void) { /* deregister this driver with the USB subsystem */ /* invokes disconnect() within usb_deregister() */ usb_deregister(&skel_driver); }

Probe and Disconnect in Detail n Called in the context of the USB hub kernel thread Sleep is allowed n However, should do most of the work when the device is opened by a user n n n USB core handles addition and removal of USB devices in a single thread A slow device driver can slow down USB device detection

Probe and Disconnect in Detail n Probe function should n Initialize local structures that it might use to manage the USB device n Save any information that it needs to the local structure n Detect endpoint address and buffer sizes n Example usb/usb-skeleton. c

Probe and Disconnect in Detail static int skel_prob(struct usb_interface *interface, const struct usb_device_id *id) { struct usb_skel *dev = NULL; struct usb_host_interface *iface_desc; struct usb_endpoint_descriptor *endpoint; size_t buffer_size; int i; int retval = -ENOMEM; dev = kmalloc(sizeof(struct usb_skel), GFP_KERNEL); if (dev == NULL) { err(“Out of memory”); goto error; } memset(dev, 0 x 00, sizeof(*dev)); kref_init(&dev->kref);

Probe and Disconnect in Detail dev->udev = usb_get_dev(interface_to_usbdev(interface)); dev->interface = interface; /* set up the endpoint information */ /* use only the first bulk-in and bulk-out endpoints */ iface_desc = interface->cur_altsetting; for (i = 0; i < iface_desc->desc. b. Num. Endpoints; ++i) { endpoint = &iface_desc->endpoint[i]. desc; if (!dev->bulk_in_endpoint. Addr && (endpoint->b. Endpoint. Address & USB_DIR_IN) && ((endpoint->bm. Attributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)) { /* we found a bulk in endpoint */

Probe and Disconnect in Detail /* we found a bulk in endpoint */ buffer_size = endpoint->w. Max. Packet. Size; dev->bulk_in_size = buffer_size; dev->bulk_in_endpoint. Addr = endpoint->b. Endpoint. Address; dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL); if (!dev->bulk_in_buffer) { err("Could not allocate bulk_in_buffer"); goto error; } } if (!dev->bulk_out_endpoint. Addr && !(endpoint->b. Endpoint. Address & USB_DIR_IN) && ((endpoint->bm. Attributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)) { /* we found a bulk out endpoint */

Probe and Disconnect in Detail /* we found a bulk out endpoint */ dev->bulk_out_endpoint. Addr = endpoint->b. Endpoint. Address; } } if (!(dev->bulk_in_endpoint. Addr && dev->bulk_out_endpoint. Addr)) { err("Could not find both bulk-in and bulk-out endpoints"); goto error; } /* save our data pointer in this interface device */ usb_set_intfdata(interface, dev); Use usb_get_intfdata(interface) to retrieve dev

Probe and Disconnect in Detail /* we can register the device now, as it is ready */ retval = usb_register_dev(interface, &skel_class); if (retval) { err(“Not able to get a minor for this device. ”); usb_set_intfdata(interface, NULL); Need to call goto error; usb_register_dev() } instead of return 0; usb_register() for error: input, tty, video USB if (dev) devices that are not kref_put(&dev->kref, skel_delete); associated with return retval; predefined types } Call usb_put_dev(), free bulk_in_buffer and dev

Probe and Disconnect in Detail n The definition of skel_class static struct usb_class_driver skel_class = {. name = "usb/skel%d", . fops = &skel_fops, . mode = S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH, . minor_base = USB_SKEL_MINOR_BASE, }; n The definition of skel_fops static struct file_operations skel_fops = {. owner = THIS_MODULE, . read = skel_read, . write = skel_write, . open = skel_open, . release = skel_release, }; The start of the assigned minor range for this driver

Probe and Disconnect in Detail n The disconnect function static void skel_disconnect(struct usb_interface *interface) { struct usb_skel *dev; int minor = interface->minor; /* prevent skel_open() from racing skel_disconnect() */ lock_kernel(); The big dev = usb_get_intfdata(interface); kernel lock usb_set_intfdata(interface, NULL); /* give back our minor */ All in-transit urbs are usb_deregister_dev(interface, &skel_class); canceled by the USB core before unlock_kernel(); /* decrement our usage count */ kref_put(&dev->kref, skel_delete); } disconnect() is called; no need to call usb_kill_urb()

Submitting and Controlling an Urb static ssize_t skel_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *ppos) { struct usb_skel *dev; int retval = 0; struct urb *urb = NULL; Initialized in char *buf = NULL; skel_open() if (count == 0) goto exit; dev = (struct usb_skel *)file->private_data; /* create a urb and its buffer; copy the data to the urb */ urb = usb_alloc_urb(0, GFP_KERNEL); if (!urb) { retval = -ENOMEM; goto error; }

Submitting and Controlling an Urb buf = usb_buffer_alloc(dev->udev, count, GFP_KERNEL, &urb->transfer_dma); if (!buf) { retval = -ENOMEM; goto error; } if (copy_from_user(buf, user_buffer, count)) { retval = -EFAULT; goto error; } /* initialize the urb properly */ usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, dev->bulk_out_endpoint. Addr), buf, count, skel_write_bulk_callback, dev); urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

Submitting and Controlling an Urb /* send the data out the bulk port */ retval = usb_submit_urb(urb, GFP_KERNEL); if (retval) { err("%s - failed submitting write urb, error %d", __FUNCTION__, retval); goto error; } /* release our reference to this urb, the USB core will eventually free it entirely */ usb_free_urb(urb); exit: return count;

Submitting and Controlling an Urb error: usb_buffer_free(dev->udev, count, buf, urb->transfer_dma); usb_free_urb(urb); kfree(buf); return retval; }

Probe and Disconnect in Detail n The callback (complete) function static void skel_write_bulk_callback(struct urb *urb, struct pt_regs *regs) { /* in interrupt context */ /* sync/async unlink faults aren't errors */ if (urb->status && !(urb->status == -ENOENT || urb->status == -ECONNRESET || urb->status == -ESHUTDOWN)) { dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status); } /* free up our allocated buffer */ usb_buffer_free(urb->dev, urb->transfer_buffer_length, urb->transfer_buffer, urb->transfer_dma); }

USB Transfers Without Urbs n usb_bulk_msg Creates a USB bulk urb and sends it to the specified device n Waits for it to complete before returning to the caller n int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe, void *data, int len, int *actual_length, int timeout); n timeout n n in jiffies Set to 0 to wait until the message to complete

USB Transfers Without Urbs n Exceptions: n Cannot be called from within interrupt context n Cannot be called with a spinlock held n Cannot be cancelled by any other function n The disconnect call needs to wait for usb_bulk_msg to complete before allowing itself to be unloaded

USB Transfers Without Urbs n Example static ssize_t skel_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos) { struct usb_skel *dev; int retval = 0; dev = (struct usb_skel *)file->private_data; /* do a blocking bulk read to get data from the device */ retval = usb_bulk_msg(dev->udev, usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpoint. Addr), dev->bulk_in_buffer, min(dev->bulk_in_size, count), &count, HZ*10);

USB Transfers Without Urbs /* if successful read, copy the data to user space */ if (!retval) { if (copy_to_user(buffer, dev->bulk_in_buffer, count)) retval = -EFAULT; else retval = count; } return retval; }

usb_control_msg n Works just like the usb_bulk_msg n Allows a driver to send and receive USB control messages int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u 8 requesttype, __u 16 value, __u 16 index, void *data, __u 16 size, int timeout); Returns the number of bytes transferred on success, or a negative error number n Same restrictions as usb_bulk_msg n

Other USB Data Functions n Cannot be called from within interrupt context or with a spinlock held int usb_get_descriptor(struct usb_device *dev, unsigned char type, unsigned char index, void *buf, int size); int usb_get_string(struct usb_device *dev, unsigned short langid, unsigned char index, void *buf, int size);