projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
USB: ehci-omap: Fix resume failures after bus suspend
[deliverable/linux.git] / drivers / usb / core / hcd.c
CommitLineData
1da177e4
LT		 1/*
2 * (C) Copyright Linus Torvalds 1999
3 * (C) Copyright Johannes Erdfelt 1999-2001
4 * (C) Copyright Andreas Gal 1999
5 * (C) Copyright Gregory P. Smith 1999
6 * (C) Copyright Deti Fliegl 1999
7 * (C) Copyright Randy Dunlap 2000
8 * (C) Copyright David Brownell 2000-2002
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 * for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
1da177e4
LT		 25#include <linux/module.h>
26#include <linux/version.h>
27#include <linux/kernel.h>
28#include <linux/slab.h>
29#include <linux/completion.h>
30#include <linux/utsname.h>
31#include <linux/mm.h>
32#include <asm/io.h>
1da177e4
LT		 33#include <linux/device.h>
34#include <linux/dma-mapping.h>
4186ecf8 35#include <linux/mutex.h>
1da177e4
LT		 36#include <asm/irq.h>
37#include <asm/byteorder.h>
b3476675 38#include <asm/unaligned.h>
64a21d02 39#include <linux/platform_device.h>
6b157c9b 40#include <linux/workqueue.h>
9bbdf1e0 41#include <linux/pm_runtime.h>
1da177e4
LT		 42
43#include <linux/usb.h>
27729aad 44#include <linux/usb/hcd.h>
1da177e4
LT		 45
46#include "usb.h"
1da177e4
LT		 47
48
1da177e4
LT		 49/*-------------------------------------------------------------------------*/
50
51/*
52 * USB Host Controller Driver framework
53 *
54 * Plugs into usbcore (usb_bus) and lets HCDs share code, minimizing
55 * HCD-specific behaviors/bugs.
56 *
57 * This does error checks, tracks devices and urbs, and delegates to a
58 * "hc_driver" only for code (and data) that really needs to know about
59 * hardware differences. That includes root hub registers, i/o queues,
60 * and so on ... but as little else as possible.
61 *
62 * Shared code includes most of the "root hub" code (these are emulated,
63 * though each HC's hardware works differently) and PCI glue, plus request
64 * tracking overhead. The HCD code should only block on spinlocks or on
65 * hardware handshaking; blocking on software events (such as other kernel
66 * threads releasing resources, or completing actions) is all generic.
67 *
68 * Happens the USB 2.0 spec says this would be invisible inside the "USBD",
69 * and includes mostly a "HCDI" (HCD Interface) along with some APIs used
70 * only by the hub driver ... and that neither should be seen or used by
71 * usb client device drivers.
72 *
73 * Contributors of ideas or unattributed patches include: David Brownell,
74 * Roman Weissgaerber, Rory Bolt, Greg Kroah-Hartman, ...
75 *
76 * HISTORY:
77 * 2002-02-21 Pull in most of the usb_bus support from usb.c; some
78 * associated cleanup. "usb_hcd" still != "usb_bus".
79 * 2001-12-12 Initial patch version for Linux 2.5.1 kernel.
80 */
81
82/*-------------------------------------------------------------------------*/
83
9beeee65
AS		 84/* Keep track of which host controller drivers are loaded */
85unsigned long usb_hcds_loaded;
86EXPORT_SYMBOL_GPL(usb_hcds_loaded);
87
1da177e4
LT		 88/* host controllers we manage */
89LIST_HEAD (usb_bus_list);
90EXPORT_SYMBOL_GPL (usb_bus_list);
91
92/* used when allocating bus numbers */
93#define USB_MAXBUS 64
94struct usb_busmap {
95 unsigned long busmap [USB_MAXBUS / (8*sizeof (unsigned long))];
96};
97static struct usb_busmap busmap;
98
99/* used when updating list of hcds */
4186ecf8 100DEFINE_MUTEX(usb_bus_list_lock); /* exported only for usbfs */
1da177e4
LT		 101EXPORT_SYMBOL_GPL (usb_bus_list_lock);
102
103/* used for controlling access to virtual root hubs */
104static DEFINE_SPINLOCK(hcd_root_hub_lock);
105
809a58b8
AS		 106/* used when updating an endpoint's URB list */
107static DEFINE_SPINLOCK(hcd_urb_list_lock);
1da177e4 108
cde217a5
AS		 109/* used to protect against unlinking URBs after the device is gone */
110static DEFINE_SPINLOCK(hcd_urb_unlink_lock);
111
1da177e4
LT		 112/* wait queue for synchronous unlinks */
113DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);
114
809a58b8
AS		 115static inline int is_root_hub(struct usb_device *udev)
116{
117 return (udev->parent == NULL);
118}
119
1da177e4
LT		 120/*-------------------------------------------------------------------------*/
121
122/*
123 * Sharable chunks of root hub code.
124 */
125
126/*-------------------------------------------------------------------------*/
127
128#define KERNEL_REL ((LINUX_VERSION_CODE >> 16) & 0x0ff)
129#define KERNEL_VER ((LINUX_VERSION_CODE >> 8) & 0x0ff)
130
d2e9b4d6
SS		 131/* usb 3.0 root hub device descriptor */
132static const u8 usb3_rh_dev_descriptor[18] = {
133 0x12, /* __u8 bLength; */
134 0x01, /* __u8 bDescriptorType; Device */
135 0x00, 0x03, /* __le16 bcdUSB; v3.0 */
136
137 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
138 0x00, /* __u8 bDeviceSubClass; */
139 0x03, /* __u8 bDeviceProtocol; USB 3.0 hub */
140 0x09, /* __u8 bMaxPacketSize0; 2^9 = 512 Bytes */
141
142 0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */
cd780694 143 0x03, 0x00, /* __le16 idProduct; device 0x0003 */
d2e9b4d6
SS		 144 KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */
145
146 0x03, /* __u8 iManufacturer; */
147 0x02, /* __u8 iProduct; */
148 0x01, /* __u8 iSerialNumber; */
149 0x01 /* __u8 bNumConfigurations; */
150};
151
1da177e4
LT		 152/* usb 2.0 root hub device descriptor */
153static const u8 usb2_rh_dev_descriptor [18] = {
154 0x12, /* __u8 bLength; */
155 0x01, /* __u8 bDescriptorType; Device */
156 0x00, 0x02, /* __le16 bcdUSB; v2.0 */
157
158 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
159 0x00, /* __u8 bDeviceSubClass; */
7329e211 160 0x00, /* __u8 bDeviceProtocol; [ usb 2.0 no TT ] */
16f16d11 161 0x40, /* __u8 bMaxPacketSize0; 64 Bytes */
1da177e4 162
667d691e
GKH		 163 0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */
164 0x02, 0x00, /* __le16 idProduct; device 0x0002 */
1da177e4
LT		 165 KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */
166
167 0x03, /* __u8 iManufacturer; */
168 0x02, /* __u8 iProduct; */
169 0x01, /* __u8 iSerialNumber; */
170 0x01 /* __u8 bNumConfigurations; */
171};
172
173/* no usb 2.0 root hub "device qualifier" descriptor: one speed only */
174
175/* usb 1.1 root hub device descriptor */
176static const u8 usb11_rh_dev_descriptor [18] = {
177 0x12, /* __u8 bLength; */
178 0x01, /* __u8 bDescriptorType; Device */
179 0x10, 0x01, /* __le16 bcdUSB; v1.1 */
180
181 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
182 0x00, /* __u8 bDeviceSubClass; */
183 0x00, /* __u8 bDeviceProtocol; [ low/full speeds only ] */
16f16d11 184 0x40, /* __u8 bMaxPacketSize0; 64 Bytes */
1da177e4 185
667d691e
GKH		 186 0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */
187 0x01, 0x00, /* __le16 idProduct; device 0x0001 */
1da177e4
LT		 188 KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */
189
190 0x03, /* __u8 iManufacturer; */
191 0x02, /* __u8 iProduct; */
192 0x01, /* __u8 iSerialNumber; */
193 0x01 /* __u8 bNumConfigurations; */
194};
195
196
197/*-------------------------------------------------------------------------*/
198
199/* Configuration descriptors for our root hubs */
200
201static const u8 fs_rh_config_descriptor [] = {
202
203 /* one configuration */
204 0x09, /* __u8 bLength; */
205 0x02, /* __u8 bDescriptorType; Configuration */
206 0x19, 0x00, /* __le16 wTotalLength; */
207 0x01, /* __u8 bNumInterfaces; (1) */
208 0x01, /* __u8 bConfigurationValue; */
209 0x00, /* __u8 iConfiguration; */
210 0xc0, /* __u8 bmAttributes;
211 Bit 7: must be set,
212 6: Self-powered,
213 5: Remote wakeup,
214 4..0: resvd */
215 0x00, /* __u8 MaxPower; */
216
217 /* USB 1.1:
218 * USB 2.0, single TT organization (mandatory):
219 * one interface, protocol 0
220 *
221 * USB 2.0, multiple TT organization (optional):
222 * two interfaces, protocols 1 (like single TT)
223 * and 2 (multiple TT mode) ... config is
224 * sometimes settable
225 * NOT IMPLEMENTED
226 */
227
228 /* one interface */
229 0x09, /* __u8 if_bLength; */
230 0x04, /* __u8 if_bDescriptorType; Interface */
231 0x00, /* __u8 if_bInterfaceNumber; */
232 0x00, /* __u8 if_bAlternateSetting; */
233 0x01, /* __u8 if_bNumEndpoints; */
234 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
235 0x00, /* __u8 if_bInterfaceSubClass; */
236 0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
237 0x00, /* __u8 if_iInterface; */
238
239 /* one endpoint (status change endpoint) */
240 0x07, /* __u8 ep_bLength; */
241 0x05, /* __u8 ep_bDescriptorType; Endpoint */
242 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
243 0x03, /* __u8 ep_bmAttributes; Interrupt */
244 0x02, 0x00, /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
245 0xff /* __u8 ep_bInterval; (255ms -- usb 2.0 spec) */
246};
247
248static const u8 hs_rh_config_descriptor [] = {
249
250 /* one configuration */
251 0x09, /* __u8 bLength; */
252 0x02, /* __u8 bDescriptorType; Configuration */
253 0x19, 0x00, /* __le16 wTotalLength; */
254 0x01, /* __u8 bNumInterfaces; (1) */
255 0x01, /* __u8 bConfigurationValue; */
256 0x00, /* __u8 iConfiguration; */
257 0xc0, /* __u8 bmAttributes;
258 Bit 7: must be set,
259 6: Self-powered,
260 5: Remote wakeup,
261 4..0: resvd */
262 0x00, /* __u8 MaxPower; */
263
264 /* USB 1.1:
265 * USB 2.0, single TT organization (mandatory):
266 * one interface, protocol 0
267 *
268 * USB 2.0, multiple TT organization (optional):
269 * two interfaces, protocols 1 (like single TT)
270 * and 2 (multiple TT mode) ... config is
271 * sometimes settable
272 * NOT IMPLEMENTED
273 */
274
275 /* one interface */
276 0x09, /* __u8 if_bLength; */
277 0x04, /* __u8 if_bDescriptorType; Interface */
278 0x00, /* __u8 if_bInterfaceNumber; */
279 0x00, /* __u8 if_bAlternateSetting; */
280 0x01, /* __u8 if_bNumEndpoints; */
281 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
282 0x00, /* __u8 if_bInterfaceSubClass; */
283 0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
284 0x00, /* __u8 if_iInterface; */
285
286 /* one endpoint (status change endpoint) */
287 0x07, /* __u8 ep_bLength; */
288 0x05, /* __u8 ep_bDescriptorType; Endpoint */
289 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
290 0x03, /* __u8 ep_bmAttributes; Interrupt */
88fafff9 291 /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
292 * see hub.c:hub_configure() for details. */
293 (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
1da177e4
LT		 294 0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */
295};
296
d2e9b4d6
SS		 297static const u8 ss_rh_config_descriptor[] = {
298 /* one configuration */
299 0x09, /* __u8 bLength; */
300 0x02, /* __u8 bDescriptorType; Configuration */
301 0x19, 0x00, /* __le16 wTotalLength; FIXME */
302 0x01, /* __u8 bNumInterfaces; (1) */
303 0x01, /* __u8 bConfigurationValue; */
304 0x00, /* __u8 iConfiguration; */
305 0xc0, /* __u8 bmAttributes;
306 Bit 7: must be set,
307 6: Self-powered,
308 5: Remote wakeup,
309 4..0: resvd */
310 0x00, /* __u8 MaxPower; */
311
312 /* one interface */
313 0x09, /* __u8 if_bLength; */
314 0x04, /* __u8 if_bDescriptorType; Interface */
315 0x00, /* __u8 if_bInterfaceNumber; */
316 0x00, /* __u8 if_bAlternateSetting; */
317 0x01, /* __u8 if_bNumEndpoints; */
318 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
319 0x00, /* __u8 if_bInterfaceSubClass; */
320 0x00, /* __u8 if_bInterfaceProtocol; */
321 0x00, /* __u8 if_iInterface; */
322
323 /* one endpoint (status change endpoint) */
324 0x07, /* __u8 ep_bLength; */
325 0x05, /* __u8 ep_bDescriptorType; Endpoint */
326 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
327 0x03, /* __u8 ep_bmAttributes; Interrupt */
328 /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
329 * see hub.c:hub_configure() for details. */
330 (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
331 0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */
332 /*
333 * All 3.0 hubs should have an endpoint companion descriptor,
334 * but we're ignoring that for now. FIXME?
335 */
336};
337
1da177e4
LT		 338/*-------------------------------------------------------------------------*/
339
392ca68b
GS		 340/**
341 * ascii2desc() - Helper routine for producing UTF-16LE string descriptors
342 * @s: Null-terminated ASCII (actually ISO-8859-1) string
343 * @buf: Buffer for USB string descriptor (header + UTF-16LE)
344 * @len: Length (in bytes; may be odd) of descriptor buffer.
345 *
346 * The return value is the number of bytes filled in: 2 + 2*strlen(s) or
347 * buflen, whichever is less.
348 *
349 * USB String descriptors can contain at most 126 characters; input
350 * strings longer than that are truncated.
1da177e4 351 */
392ca68b
GS		 352static unsigned
353ascii2desc(char const *s, u8 *buf, unsigned len)
1da177e4 354{
392ca68b
GS		 355 unsigned n, t = 2 + 2*strlen(s);
356
357 if (t > 254)
358 t = 254; /* Longest possible UTF string descriptor */
359 if (len > t)
360 len = t;
361
362 t += USB_DT_STRING << 8; /* Now t is first 16 bits to store */
363
364 n = len;
365 while (n--) {
366 *buf++ = t;
367 if (!n--)
368 break;
369 *buf++ = t >> 8;
370 t = (unsigned char)*s++;
1da177e4 371 }
392ca68b 372 return len;
1da177e4
LT		 373}
374
392ca68b
GS		 375/**
376 * rh_string() - provides string descriptors for root hub
377 * @id: the string ID number (0: langids, 1: serial #, 2: product, 3: vendor)
1da177e4 378 * @hcd: the host controller for this root hub
392ca68b
GS		 379 * @data: buffer for output packet
380 * @len: length of the provided buffer
1da177e4
LT		 381 *
382 * Produces either a manufacturer, product or serial number string for the
383 * virtual root hub device.
392ca68b
GS		 384 * Returns the number of bytes filled in: the length of the descriptor or
385 * of the provided buffer, whichever is less.
1da177e4 386 */
392ca68b
GS		 387static unsigned
388rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len)
71d2718f 389{
392ca68b
GS		 390 char buf[100];
391 char const *s;
392 static char const langids[4] = {4, USB_DT_STRING, 0x09, 0x04};
1da177e4
LT		 393
394 // language ids
392ca68b
GS		 395 switch (id) {
396 case 0:
397 /* Array of LANGID codes (0x0409 is MSFT-speak for "en-us") */
398 /* See http://www.usb.org/developers/docs/USB_LANGIDs.pdf */
399 if (len > 4)
400 len = 4;
401 memcpy(data, langids, len);
1da177e4 402 return len;
392ca68b
GS		 403 case 1:
404 /* Serial number */
405 s = hcd->self.bus_name;
406 break;
407 case 2:
408 /* Product name */
409 s = hcd->product_desc;
410 break;
411 case 3:
412 /* Manufacturer */
96b644bd
SH		 413 snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname,
414 init_utsname()->release, hcd->driver->description);
392ca68b
GS		 415 s = buf;
416 break;
1da177e4 417 default:
392ca68b
GS		 418 /* Can't happen; caller guarantees it */
419 return 0;
1da177e4 420 }
392ca68b
GS		 421
422 return ascii2desc(s, data, len);
1da177e4
LT		 423}
424
425
426/* Root hub control transfers execute synchronously */
427static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
428{
429 struct usb_ctrlrequest *cmd;
430 u16 typeReq, wValue, wIndex, wLength;
431 u8 *ubuf = urb->transfer_buffer;
54bee6e1
MP		 432 u8 tbuf [sizeof (struct usb_hub_descriptor)]
433 __attribute__((aligned(4)));
1da177e4 434 const u8 *bufp = tbuf;
71d2718f 435 unsigned len = 0;
e9df41c5 436 int status;
7329e211
AS		 437 u8 patch_wakeup = 0;
438 u8 patch_protocol = 0;
1da177e4 439
9439eb94
AS		 440 might_sleep();
441
e9df41c5
AS		 442 spin_lock_irq(&hcd_root_hub_lock);
443 status = usb_hcd_link_urb_to_ep(hcd, urb);
444 spin_unlock_irq(&hcd_root_hub_lock);
445 if (status)
446 return status;
b0d9efba 447 urb->hcpriv = hcd; /* Indicate it's queued */
e9df41c5 448
1da177e4
LT		 449 cmd = (struct usb_ctrlrequest *) urb->setup_packet;
450 typeReq = (cmd->bRequestType << 8) | cmd->bRequest;
451 wValue = le16_to_cpu (cmd->wValue);
452 wIndex = le16_to_cpu (cmd->wIndex);
453 wLength = le16_to_cpu (cmd->wLength);
454
455 if (wLength > urb->transfer_buffer_length)
456 goto error;
457
458 urb->actual_length = 0;
459 switch (typeReq) {
460
461 /* DEVICE REQUESTS */
462
fb669cc0
DB		 463 /* The root hub's remote wakeup enable bit is implemented using
464 * driver model wakeup flags. If this system supports wakeup
465 * through USB, userspace may change the default "allow wakeup"
466 * policy through sysfs or these calls.
467 *
468 * Most root hubs support wakeup from downstream devices, for
469 * runtime power management (disabling USB clocks and reducing
470 * VBUS power usage). However, not all of them do so; silicon,
471 * board, and BIOS bugs here are not uncommon, so these can't
472 * be treated quite like external hubs.
473 *
474 * Likewise, not all root hubs will pass wakeup events upstream,
475 * to wake up the whole system. So don't assume root hub and
476 * controller capabilities are identical.
477 */
478
1da177e4 479 case DeviceRequest | USB_REQ_GET_STATUS:
fb669cc0
DB		 480 tbuf [0] = (device_may_wakeup(&hcd->self.root_hub->dev)
481 << USB_DEVICE_REMOTE_WAKEUP)
1da177e4
LT		 482 | (1 << USB_DEVICE_SELF_POWERED);
483 tbuf [1] = 0;
484 len = 2;
485 break;
486 case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
487 if (wValue == USB_DEVICE_REMOTE_WAKEUP)
fb669cc0 488 device_set_wakeup_enable(&hcd->self.root_hub->dev, 0);
1da177e4
LT		 489 else
490 goto error;
491 break;
492 case DeviceOutRequest | USB_REQ_SET_FEATURE:
fb669cc0
DB		 493 if (device_can_wakeup(&hcd->self.root_hub->dev)
494 && wValue == USB_DEVICE_REMOTE_WAKEUP)
495 device_set_wakeup_enable(&hcd->self.root_hub->dev, 1);
1da177e4
LT		 496 else
497 goto error;
498 break;
499 case DeviceRequest | USB_REQ_GET_CONFIGURATION:
500 tbuf [0] = 1;
501 len = 1;
502 /* FALLTHROUGH */
503 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
504 break;
505 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
506 switch (wValue & 0xff00) {
507 case USB_DT_DEVICE << 8:
7dd19e69
VM		 508 switch (hcd->driver->flags & HCD_MASK) {
509 case HCD_USB3:
d2e9b4d6 510 bufp = usb3_rh_dev_descriptor;
7dd19e69
VM		 511 break;
512 case HCD_USB2:
1da177e4 513 bufp = usb2_rh_dev_descriptor;
7dd19e69
VM		 514 break;
515 case HCD_USB11:
1da177e4 516 bufp = usb11_rh_dev_descriptor;
7dd19e69
VM		 517 break;
518 default:
1da177e4 519 goto error;
7dd19e69 520 }
1da177e4 521 len = 18;
7329e211
AS		 522 if (hcd->has_tt)
523 patch_protocol = 1;
1da177e4
LT		 524 break;
525 case USB_DT_CONFIG << 8:
7dd19e69
VM		 526 switch (hcd->driver->flags & HCD_MASK) {
527 case HCD_USB3:
d2e9b4d6
SS		 528 bufp = ss_rh_config_descriptor;
529 len = sizeof ss_rh_config_descriptor;
7dd19e69
VM		 530 break;
531 case HCD_USB2:
1da177e4
LT		 532 bufp = hs_rh_config_descriptor;
533 len = sizeof hs_rh_config_descriptor;
7dd19e69
VM		 534 break;
535 case HCD_USB11:
1da177e4
LT		 536 bufp = fs_rh_config_descriptor;
537 len = sizeof fs_rh_config_descriptor;
7dd19e69
VM		 538 break;
539 default:
540 goto error;
1da177e4 541 }
fb669cc0 542 if (device_can_wakeup(&hcd->self.root_hub->dev))
1da177e4
LT		 543 patch_wakeup = 1;
544 break;
545 case USB_DT_STRING << 8:
71d2718f
RK		 546 if ((wValue & 0xff) < 4)
547 urb->actual_length = rh_string(wValue & 0xff,
548 hcd, ubuf, wLength);
549 else /* unsupported IDs --> "protocol stall" */
1da177e4 550 goto error;
1da177e4
LT		 551 break;
552 default:
553 goto error;
554 }
555 break;
556 case DeviceRequest | USB_REQ_GET_INTERFACE:
557 tbuf [0] = 0;
558 len = 1;
559 /* FALLTHROUGH */
560 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
561 break;
562 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
563 // wValue == urb->dev->devaddr
564 dev_dbg (hcd->self.controller, "root hub device address %d\n",
565 wValue);
566 break;
567
568 /* INTERFACE REQUESTS (no defined feature/status flags) */
569
570 /* ENDPOINT REQUESTS */
571
572 case EndpointRequest | USB_REQ_GET_STATUS:
573 // ENDPOINT_HALT flag
574 tbuf [0] = 0;
575 tbuf [1] = 0;
576 len = 2;
577 /* FALLTHROUGH */
578 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
579 case EndpointOutRequest | USB_REQ_SET_FEATURE:
580 dev_dbg (hcd->self.controller, "no endpoint features yet\n");
581 break;
582
583 /* CLASS REQUESTS (and errors) */
584
585 default:
586 /* non-generic request */
b13296c6
DB		 587 switch (typeReq) {
588 case GetHubStatus:
589 case GetPortStatus:
590 len = 4;
591 break;
592 case GetHubDescriptor:
593 len = sizeof (struct usb_hub_descriptor);
594 break;
1da177e4 595 }
b13296c6
DB		 596 status = hcd->driver->hub_control (hcd,
597 typeReq, wValue, wIndex,
598 tbuf, wLength);
1da177e4
LT		 599 break;
600error:
601 /* "protocol stall" on error */
602 status = -EPIPE;
603 }
604
605 if (status) {
606 len = 0;
607 if (status != -EPIPE) {
608 dev_dbg (hcd->self.controller,
609 "CTRL: TypeReq=0x%x val=0x%x "
610 "idx=0x%x len=%d ==> %d\n",
611 typeReq, wValue, wIndex,
b13296c6 612 wLength, status);
1da177e4
LT		 613 }
614 }
615 if (len) {
616 if (urb->transfer_buffer_length < len)
617 len = urb->transfer_buffer_length;
618 urb->actual_length = len;
619 // always USB_DIR_IN, toward host
620 memcpy (ubuf, bufp, len);
621
622 /* report whether RH hardware supports remote wakeup */
623 if (patch_wakeup &&
624 len > offsetof (struct usb_config_descriptor,
625 bmAttributes))
626 ((struct usb_config_descriptor *)ubuf)->bmAttributes
627 |= USB_CONFIG_ATT_WAKEUP;
7329e211
AS		 628
629 /* report whether RH hardware has an integrated TT */
630 if (patch_protocol &&
631 len > offsetof(struct usb_device_descriptor,
632 bDeviceProtocol))
633 ((struct usb_device_descriptor *) ubuf)->
634 bDeviceProtocol = 1;
1da177e4
LT		 635 }
636
637 /* any errors get returned through the urb completion */
9439eb94 638 spin_lock_irq(&hcd_root_hub_lock);
e9df41c5 639 usb_hcd_unlink_urb_from_ep(hcd, urb);
9439eb94
AS		 640
641 /* This peculiar use of spinlocks echoes what real HC drivers do.
642 * Avoiding calls to local_irq_disable/enable makes the code
643 * RT-friendly.
644 */
645 spin_unlock(&hcd_root_hub_lock);
4a00027d 646 usb_hcd_giveback_urb(hcd, urb, status);
9439eb94
AS		 647 spin_lock(&hcd_root_hub_lock);
648
649 spin_unlock_irq(&hcd_root_hub_lock);
1da177e4
LT		 650 return 0;
651}
652
653/*-------------------------------------------------------------------------*/
654
655/*
d5926ae7
AS		 656 * Root Hub interrupt transfers are polled using a timer if the
657 * driver requests it; otherwise the driver is responsible for
658 * calling usb_hcd_poll_rh_status() when an event occurs.
1da177e4 659 *
d5926ae7
AS		 660 * Completions are called in_interrupt(), but they may or may not
661 * be in_irq().
1da177e4 662 */
d5926ae7
AS		 663void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
664{
665 struct urb *urb;
666 int length;
667 unsigned long flags;
ad361c98 668 char buffer[6]; /* Any root hubs with > 31 ports? */
1da177e4 669
1b42ae6d
AS		 670 if (unlikely(!hcd->rh_registered))
671 return;
d5926ae7
AS		 672 if (!hcd->uses_new_polling && !hcd->status_urb)
673 return;
1da177e4 674
d5926ae7
AS		 675 length = hcd->driver->hub_status_data(hcd, buffer);
676 if (length > 0) {
1da177e4 677
d5926ae7 678 /* try to complete the status urb */
9439eb94 679 spin_lock_irqsave(&hcd_root_hub_lock, flags);
d5926ae7
AS		 680 urb = hcd->status_urb;
681 if (urb) {
e9df41c5
AS		 682 hcd->poll_pending = 0;
683 hcd->status_urb = NULL;
e9df41c5
AS		 684 urb->actual_length = length;
685 memcpy(urb->transfer_buffer, buffer, length);
9439eb94 686
e9df41c5 687 usb_hcd_unlink_urb_from_ep(hcd, urb);
9439eb94 688 spin_unlock(&hcd_root_hub_lock);
4a00027d 689 usb_hcd_giveback_urb(hcd, urb, 0);
9439eb94 690 spin_lock(&hcd_root_hub_lock);
e9df41c5 691 } else {
d5926ae7 692 length = 0;
d5926ae7 693 hcd->poll_pending = 1;
e9df41c5 694 }
9439eb94 695 spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
1da177e4
LT		 696 }
697
d5926ae7 698 /* The USB 2.0 spec says 256 ms. This is close enough and won't
01cd0819
AV		 699 * exceed that limit if HZ is 100. The math is more clunky than
700 * maybe expected, this is to make sure that all timers for USB devices
701 * fire at the same time to give the CPU a break inbetween */
d5926ae7
AS		 702 if (hcd->uses_new_polling ? hcd->poll_rh :
703 (length == 0 && hcd->status_urb != NULL))
01cd0819 704 mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
1da177e4 705}
d5926ae7 706EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status);
1da177e4
LT		 707
708/* timer callback */
d5926ae7
AS		 709static void rh_timer_func (unsigned long _hcd)
710{
711 usb_hcd_poll_rh_status((struct usb_hcd *) _hcd);
712}
713
714/*-------------------------------------------------------------------------*/
1da177e4 715
d5926ae7 716static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
1da177e4 717{
d5926ae7 718 int retval;
1da177e4 719 unsigned long flags;
71d2718f 720 unsigned len = 1 + (urb->dev->maxchild / 8);
1da177e4 721
d5926ae7 722 spin_lock_irqsave (&hcd_root_hub_lock, flags);
e9df41c5 723 if (hcd->status_urb || urb->transfer_buffer_length < len) {
d5926ae7
AS		 724 dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
725 retval = -EINVAL;
e9df41c5
AS		 726 goto done;
727 }
1da177e4 728
e9df41c5
AS		 729 retval = usb_hcd_link_urb_to_ep(hcd, urb);
730 if (retval)
731 goto done;
1da177e4 732
e9df41c5
AS		 733 hcd->status_urb = urb;
734 urb->hcpriv = hcd; /* indicate it's queued */
735 if (!hcd->uses_new_polling)
736 mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
737
738 /* If a status change has already occurred, report it ASAP */
739 else if (hcd->poll_pending)
740 mod_timer(&hcd->rh_timer, jiffies);
741 retval = 0;
742 done:
d5926ae7
AS		 743 spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
744 return retval;
1da177e4
LT		 745}
746
1da177e4
LT		 747static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
748{
5e60a161 749 if (usb_endpoint_xfer_int(&urb->ep->desc))
d5926ae7 750 return rh_queue_status (hcd, urb);
5e60a161 751 if (usb_endpoint_xfer_control(&urb->ep->desc))
1da177e4 752 return rh_call_control (hcd, urb);
d5926ae7 753 return -EINVAL;
1da177e4
LT		 754}
755
756/*-------------------------------------------------------------------------*/
757
455b25fb
AS		 758/* Unlinks of root-hub control URBs are legal, but they don't do anything
759 * since these URBs always execute synchronously.
d5926ae7 760 */
e9df41c5 761static int usb_rh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1da177e4 762{
455b25fb 763 unsigned long flags;
e9df41c5 764 int rc;
1da177e4 765
9439eb94 766 spin_lock_irqsave(&hcd_root_hub_lock, flags);
e9df41c5
AS		 767 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
768 if (rc)
769 goto done;
770
5e60a161 771 if (usb_endpoint_num(&urb->ep->desc) == 0) { /* Control URB */
455b25fb 772 ; /* Do nothing */
d5926ae7
AS		 773
774 } else { /* Status URB */
775 if (!hcd->uses_new_polling)
455b25fb 776 del_timer (&hcd->rh_timer);
d5926ae7
AS		 777 if (urb == hcd->status_urb) {
778 hcd->status_urb = NULL;
e9df41c5 779 usb_hcd_unlink_urb_from_ep(hcd, urb);
1da177e4 780
9439eb94 781 spin_unlock(&hcd_root_hub_lock);
4a00027d 782 usb_hcd_giveback_urb(hcd, urb, status);
9439eb94
AS		 783 spin_lock(&hcd_root_hub_lock);
784 }
785 }
e9df41c5 786 done:
9439eb94 787 spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
e9df41c5 788 return rc;
1da177e4
LT		 789}
790
5234ce1b
IPG		 791
792
793/*
794 * Show & store the current value of authorized_default
795 */
796static ssize_t usb_host_authorized_default_show(struct device *dev,
797 struct device_attribute *attr,
798 char *buf)
799{
800 struct usb_device *rh_usb_dev = to_usb_device(dev);
801 struct usb_bus *usb_bus = rh_usb_dev->bus;
802 struct usb_hcd *usb_hcd;
803
804 if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
805 return -ENODEV;
806 usb_hcd = bus_to_hcd(usb_bus);
807 return snprintf(buf, PAGE_SIZE, "%u\n", usb_hcd->authorized_default);
808}
809
810static ssize_t usb_host_authorized_default_store(struct device *dev,
811 struct device_attribute *attr,
812 const char *buf, size_t size)
813{
814 ssize_t result;
815 unsigned val;
816 struct usb_device *rh_usb_dev = to_usb_device(dev);
817 struct usb_bus *usb_bus = rh_usb_dev->bus;
818 struct usb_hcd *usb_hcd;
819
820 if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
821 return -ENODEV;
822 usb_hcd = bus_to_hcd(usb_bus);
823 result = sscanf(buf, "%u\n", &val);
824 if (result == 1) {
825 usb_hcd->authorized_default = val? 1 : 0;
826 result = size;
827 }
828 else
829 result = -EINVAL;
830 return result;
831}
832
833static DEVICE_ATTR(authorized_default, 0644,
834 usb_host_authorized_default_show,
835 usb_host_authorized_default_store);
836
837
838/* Group all the USB bus attributes */
839static struct attribute *usb_bus_attrs[] = {
840 &dev_attr_authorized_default.attr,
841 NULL,
842};
843
844static struct attribute_group usb_bus_attr_group = {
845 .name = NULL, /* we want them in the same directory */
846 .attrs = usb_bus_attrs,
847};
848
849
850
1da177e4
LT		 851/*-------------------------------------------------------------------------*/
852
1da177e4
LT		 853/**
854 * usb_bus_init - shared initialization code
855 * @bus: the bus structure being initialized
856 *
857 * This code is used to initialize a usb_bus structure, memory for which is
858 * separately managed.
859 */
860static void usb_bus_init (struct usb_bus *bus)
861{
862 memset (&bus->devmap, 0, sizeof(struct usb_devmap));
863
864 bus->devnum_next = 1;
865
866 bus->root_hub = NULL;
1da177e4
LT		 867 bus->busnum = -1;
868 bus->bandwidth_allocated = 0;
869 bus->bandwidth_int_reqs = 0;
870 bus->bandwidth_isoc_reqs = 0;
871
872 INIT_LIST_HEAD (&bus->bus_list);
1da177e4
LT		 873}
874
1da177e4
LT		 875/*-------------------------------------------------------------------------*/
876
877/**
878 * usb_register_bus - registers the USB host controller with the usb core
879 * @bus: pointer to the bus to register
880 * Context: !in_interrupt()
881 *
882 * Assigns a bus number, and links the controller into usbcore data
883 * structures so that it can be seen by scanning the bus list.
884 */
885static int usb_register_bus(struct usb_bus *bus)
886{
eb579f58 887 int result = -E2BIG;
1da177e4 888 int busnum;
1da177e4 889
4186ecf8 890 mutex_lock(&usb_bus_list_lock);
1da177e4 891 busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
eb579f58 892 if (busnum >= USB_MAXBUS) {
1da177e4 893 printk (KERN_ERR "%s: too many buses\n", usbcore_name);
eb579f58 894 goto error_find_busnum;
1da177e4 895 }
eb579f58
IPG		 896 set_bit (busnum, busmap.busmap);
897 bus->busnum = busnum;
5a3201b2 898
1da177e4
LT		 899 /* Add it to the local list of buses */
900 list_add (&bus->bus_list, &usb_bus_list);
4186ecf8 901 mutex_unlock(&usb_bus_list_lock);
1da177e4 902
3099e75a 903 usb_notify_add_bus(bus);
1da177e4 904
eb579f58
IPG		 905 dev_info (bus->controller, "new USB bus registered, assigned bus "
906 "number %d\n", bus->busnum);
1da177e4 907 return 0;
eb579f58 908
eb579f58
IPG		 909error_find_busnum:
910 mutex_unlock(&usb_bus_list_lock);
911 return result;
1da177e4
LT		 912}
913
914/**
915 * usb_deregister_bus - deregisters the USB host controller
916 * @bus: pointer to the bus to deregister
917 * Context: !in_interrupt()
918 *
919 * Recycles the bus number, and unlinks the controller from usbcore data
920 * structures so that it won't be seen by scanning the bus list.
921 */
922static void usb_deregister_bus (struct usb_bus *bus)
923{
924 dev_info (bus->controller, "USB bus %d deregistered\n", bus->busnum);
925
926 /*
927 * NOTE: make sure that all the devices are removed by the
928 * controller code, as well as having it call this when cleaning
929 * itself up
930 */
4186ecf8 931 mutex_lock(&usb_bus_list_lock);
1da177e4 932 list_del (&bus->bus_list);
4186ecf8 933 mutex_unlock(&usb_bus_list_lock);
1da177e4 934
3099e75a 935 usb_notify_remove_bus(bus);
1da177e4
LT		 936
937 clear_bit (bus->busnum, busmap.busmap);
1da177e4
LT		 938}
939
940/**
8ec8d20b 941 * register_root_hub - called by usb_add_hcd() to register a root hub
1da177e4
LT		 942 * @hcd: host controller for this root hub
943 *
8ec8d20b 944 * This function registers the root hub with the USB subsystem. It sets up
b1e8f0a6
DB		 945 * the device properly in the device tree and then calls usb_new_device()
946 * to register the usb device. It also assigns the root hub's USB address
947 * (always 1).
1da177e4 948 */
b1e8f0a6 949static int register_root_hub(struct usb_hcd *hcd)
1da177e4
LT		 950{
951 struct device *parent_dev = hcd->self.controller;
b1e8f0a6 952 struct usb_device *usb_dev = hcd->self.root_hub;
1da177e4
LT		 953 const int devnum = 1;
954 int retval;
955
1da177e4
LT		 956 usb_dev->devnum = devnum;
957 usb_dev->bus->devnum_next = devnum + 1;
958 memset (&usb_dev->bus->devmap.devicemap, 0,
959 sizeof usb_dev->bus->devmap.devicemap);
960 set_bit (devnum, usb_dev->bus->devmap.devicemap);
961 usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
962
4186ecf8 963 mutex_lock(&usb_bus_list_lock);
1da177e4 964
551509d2 965 usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
1da177e4
LT		 966 retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
967 if (retval != sizeof usb_dev->descriptor) {
4186ecf8 968 mutex_unlock(&usb_bus_list_lock);
1da177e4 969 dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
7071a3ce 970 dev_name(&usb_dev->dev), retval);
1da177e4
LT		 971 return (retval < 0) ? retval : -EMSGSIZE;
972 }
973
1da177e4 974 retval = usb_new_device (usb_dev);
1da177e4 975 if (retval) {
1da177e4 976 dev_err (parent_dev, "can't register root hub for %s, %d\n",
7071a3ce 977 dev_name(&usb_dev->dev), retval);
1da177e4 978 }
4186ecf8 979 mutex_unlock(&usb_bus_list_lock);
1da177e4
LT		 980
981 if (retval == 0) {
982 spin_lock_irq (&hcd_root_hub_lock);
983 hcd->rh_registered = 1;
984 spin_unlock_irq (&hcd_root_hub_lock);
985
986 /* Did the HC die before the root hub was registered? */
987 if (hcd->state == HC_STATE_HALT)
988 usb_hc_died (hcd); /* This time clean up */
989 }
990
991 return retval;
992}
1da177e4
LT		 993
994
995/*-------------------------------------------------------------------------*/
996
997/**
998 * usb_calc_bus_time - approximate periodic transaction time in nanoseconds
999 * @speed: from dev->speed; USB_SPEED_{LOW,FULL,HIGH}
1000 * @is_input: true iff the transaction sends data to the host
1001 * @isoc: true for isochronous transactions, false for interrupt ones
1002 * @bytecount: how many bytes in the transaction.
1003 *
1004 * Returns approximate bus time in nanoseconds for a periodic transaction.
1005 * See USB 2.0 spec section 5.11.3; only periodic transfers need to be
1006 * scheduled in software, this function is only used for such scheduling.
1007 */
1008long usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)
1009{
1010 unsigned long tmp;
1011
1012 switch (speed) {
1013 case USB_SPEED_LOW: /* INTR only */
1014 if (is_input) {
1015 tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
1016 return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
1017 } else {
1018 tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
1019 return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
1020 }
1021 case USB_SPEED_FULL: /* ISOC or INTR */
1022 if (isoc) {
1023 tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
1024 return (((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);
1025 } else {
1026 tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
1027 return (9107L + BW_HOST_DELAY + tmp);
1028 }
1029 case USB_SPEED_HIGH: /* ISOC or INTR */
1030 // FIXME adjust for input vs output
1031 if (isoc)
498f78e6 1032 tmp = HS_NSECS_ISO (bytecount);
1da177e4 1033 else
498f78e6 1034 tmp = HS_NSECS (bytecount);
1da177e4
LT		 1035 return tmp;
1036 default:
1037 pr_debug ("%s: bogus device speed!\n", usbcore_name);
1038 return -1;
1039 }
1040}
782e70c6 1041EXPORT_SYMBOL_GPL(usb_calc_bus_time);
1da177e4 1042
1da177e4
LT		 1043
1044/*-------------------------------------------------------------------------*/
1045
1046/*
1047 * Generic HC operations.
1048 */
1049
1050/*-------------------------------------------------------------------------*/
1051
e9df41c5
AS		 1052/**
1053 * usb_hcd_link_urb_to_ep - add an URB to its endpoint queue
1054 * @hcd: host controller to which @urb was submitted
1055 * @urb: URB being submitted
1056 *
1057 * Host controller drivers should call this routine in their enqueue()
1058 * method. The HCD's private spinlock must be held and interrupts must
1059 * be disabled. The actions carried out here are required for URB
1060 * submission, as well as for endpoint shutdown and for usb_kill_urb.
1061 *
1062 * Returns 0 for no error, otherwise a negative error code (in which case
1063 * the enqueue() method must fail). If no error occurs but enqueue() fails
1064 * anyway, it must call usb_hcd_unlink_urb_from_ep() before releasing
1065 * the private spinlock and returning.
1066 */
1067int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
1da177e4 1068{
9a9bf406 1069 int rc = 0;
1da177e4 1070
e9df41c5 1071 spin_lock(&hcd_urb_list_lock);
1da177e4 1072
9a9bf406 1073 /* Check that the URB isn't being killed */
49367d8f 1074 if (unlikely(atomic_read(&urb->reject))) {
9a9bf406
AS		 1075 rc = -EPERM;
1076 goto done;
9f6a93f7 1077 }
1da177e4 1078
9a9bf406
AS		 1079 if (unlikely(!urb->ep->enabled)) {
1080 rc = -ENOENT;
1081 goto done;
1082 }
1da177e4 1083
6840d255
AS		 1084 if (unlikely(!urb->dev->can_submit)) {
1085 rc = -EHOSTUNREACH;
1086 goto done;
1087 }
1088
1da177e4 1089 /*
9a9bf406
AS		 1090 * Check the host controller's state and add the URB to the
1091 * endpoint's queue.
1da177e4 1092 */
9a9bf406 1093 switch (hcd->state) {
1da177e4
LT		 1094 case HC_STATE_RUNNING:
1095 case HC_STATE_RESUMING:
eb231054 1096 urb->unlinked = 0;
9a9bf406 1097 list_add_tail(&urb->urb_list, &urb->ep->urb_list);
1da177e4
LT		 1098 break;
1099 default:
9a9bf406
AS		 1100 rc = -ESHUTDOWN;
1101 goto done;
1da177e4 1102 }
9a9bf406 1103 done:
e9df41c5 1104 spin_unlock(&hcd_urb_list_lock);
9a9bf406
AS		 1105 return rc;
1106}
e9df41c5 1107EXPORT_SYMBOL_GPL(usb_hcd_link_urb_to_ep);
9a9bf406 1108
e9df41c5
AS		 1109/**
1110 * usb_hcd_check_unlink_urb - check whether an URB may be unlinked
1111 * @hcd: host controller to which @urb was submitted
1112 * @urb: URB being checked for unlinkability
1113 * @status: error code to store in @urb if the unlink succeeds
1114 *
1115 * Host controller drivers should call this routine in their dequeue()
1116 * method. The HCD's private spinlock must be held and interrupts must
1117 * be disabled. The actions carried out here are required for making
1118 * sure than an unlink is valid.
1119 *
1120 * Returns 0 for no error, otherwise a negative error code (in which case
1121 * the dequeue() method must fail). The possible error codes are:
1122 *
1123 * -EIDRM: @urb was not submitted or has already completed.
1124 * The completion function may not have been called yet.
1125 *
1126 * -EBUSY: @urb has already been unlinked.
1127 */
1128int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
9a9bf406
AS		 1129 int status)
1130{
9a9bf406 1131 struct list_head *tmp;
9a9bf406
AS		 1132
1133 /* insist the urb is still queued */
1134 list_for_each(tmp, &urb->ep->urb_list) {
1135 if (tmp == &urb->urb_list)
1136 break;
1137 }
e9df41c5
AS		 1138 if (tmp != &urb->urb_list)
1139 return -EIDRM;
1da177e4 1140
9a9bf406
AS		 1141 /* Any status except -EINPROGRESS means something already started to
1142 * unlink this URB from the hardware. So there's no more work to do.
1da177e4 1143 */
eb231054 1144 if (urb->unlinked)
e9df41c5 1145 return -EBUSY;
eb231054 1146 urb->unlinked = status;
1da177e4 1147
9a9bf406
AS		 1148 /* IRQ setup can easily be broken so that USB controllers
1149 * never get completion IRQs ... maybe even the ones we need to
1150 * finish unlinking the initial failed usb_set_address()
1151 * or device descriptor fetch.
1152 */
1153 if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags) &&
1154 !is_root_hub(urb->dev)) {
1155 dev_warn(hcd->self.controller, "Unlink after no-IRQ? "
1156 "Controller is probably using the wrong IRQ.\n");
1157 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
1158 }
1159
e9df41c5 1160 return 0;
9a9bf406 1161}
e9df41c5 1162EXPORT_SYMBOL_GPL(usb_hcd_check_unlink_urb);
9a9bf406 1163
e9df41c5
AS		 1164/**
1165 * usb_hcd_unlink_urb_from_ep - remove an URB from its endpoint queue
1166 * @hcd: host controller to which @urb was submitted
1167 * @urb: URB being unlinked
1168 *
1169 * Host controller drivers should call this routine before calling
1170 * usb_hcd_giveback_urb(). The HCD's private spinlock must be held and
1171 * interrupts must be disabled. The actions carried out here are required
1172 * for URB completion.
1173 */
1174void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb)
9a9bf406 1175{
9a9bf406 1176 /* clear all state linking urb to this dev (and hcd) */
e9df41c5 1177 spin_lock(&hcd_urb_list_lock);
9a9bf406 1178 list_del_init(&urb->urb_list);
e9df41c5 1179 spin_unlock(&hcd_urb_list_lock);
9a9bf406 1180}
e9df41c5 1181EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep);
9a9bf406 1182
b3476675
MD		 1183/*
1184 * Some usb host controllers can only perform dma using a small SRAM area.
1185 * The usb core itself is however optimized for host controllers that can dma
1186 * using regular system memory - like pci devices doing bus mastering.
1187 *
1188 * To support host controllers with limited dma capabilites we provide dma
1189 * bounce buffers. This feature can be enabled using the HCD_LOCAL_MEM flag.
1190 * For this to work properly the host controller code must first use the
1191 * function dma_declare_coherent_memory() to point out which memory area
1192 * that should be used for dma allocations.
1193 *
1194 * The HCD_LOCAL_MEM flag then tells the usb code to allocate all data for
1195 * dma using dma_alloc_coherent() which in turn allocates from the memory
1196 * area pointed out with dma_declare_coherent_memory().
1197 *
1198 * So, to summarize...
1199 *
1200 * - We need "local" memory, canonical example being
1201 * a small SRAM on a discrete controller being the
1202 * only memory that the controller can read ...
1203 * (a) "normal" kernel memory is no good, and
1204 * (b) there's not enough to share
1205 *
1206 * - The only *portable* hook for such stuff in the
1207 * DMA framework is dma_declare_coherent_memory()
1208 *
1209 * - So we use that, even though the primary requirement
1210 * is that the memory be "local" (hence addressible
1211 * by that device), not "coherent".
1212 *
1213 */
1214
1215static int hcd_alloc_coherent(struct usb_bus *bus,
1216 gfp_t mem_flags, dma_addr_t *dma_handle,
1217 void **vaddr_handle, size_t size,
1218 enum dma_data_direction dir)
1219{
1220 unsigned char *vaddr;
1221
1222 vaddr = hcd_buffer_alloc(bus, size + sizeof(vaddr),
1223 mem_flags, dma_handle);
1224 if (!vaddr)
1225 return -ENOMEM;
1226
1227 /*
1228 * Store the virtual address of the buffer at the end
1229 * of the allocated dma buffer. The size of the buffer
1230 * may be uneven so use unaligned functions instead
1231 * of just rounding up. It makes sense to optimize for
1232 * memory footprint over access speed since the amount
1233 * of memory available for dma may be limited.
1234 */
1235 put_unaligned((unsigned long)*vaddr_handle,
1236 (unsigned long *)(vaddr + size));
1237
1238 if (dir == DMA_TO_DEVICE)
1239 memcpy(vaddr, *vaddr_handle, size);
1240
1241 *vaddr_handle = vaddr;
1242 return 0;
1243}
1244
1245static void hcd_free_coherent(struct usb_bus *bus, dma_addr_t *dma_handle,
1246 void **vaddr_handle, size_t size,
1247 enum dma_data_direction dir)
1248{
1249 unsigned char *vaddr = *vaddr_handle;
1250
1251 vaddr = (void *)get_unaligned((unsigned long *)(vaddr + size));
1252
1253 if (dir == DMA_FROM_DEVICE)
1254 memcpy(vaddr, *vaddr_handle, size);
1255
1256 hcd_buffer_free(bus, size + sizeof(vaddr), *vaddr_handle, *dma_handle);
1257
1258 *vaddr_handle = vaddr;
1259 *dma_handle = 0;
1260}
1261
ff9c895f
AS		 1262static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1263{
1264 enum dma_data_direction dir;
1265
1266 if (urb->transfer_flags & URB_SETUP_MAP_SINGLE)
1267 dma_unmap_single(hcd->self.controller,
1268 urb->setup_dma,
1269 sizeof(struct usb_ctrlrequest),
1270 DMA_TO_DEVICE);
1271 else if (urb->transfer_flags & URB_SETUP_MAP_LOCAL)
1272 hcd_free_coherent(urb->dev->bus,
1273 &urb->setup_dma,
1274 (void **) &urb->setup_packet,
1275 sizeof(struct usb_ctrlrequest),
1276 DMA_TO_DEVICE);
1277
1278 dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1279 if (urb->transfer_flags & URB_DMA_MAP_SG)
1280 dma_unmap_sg(hcd->self.controller,
910f8d0c 1281 urb->sg,
ff9c895f
AS		 1282 urb->num_sgs,
1283 dir);
1284 else if (urb->transfer_flags & URB_DMA_MAP_PAGE)
1285 dma_unmap_page(hcd->self.controller,
1286 urb->transfer_dma,
1287 urb->transfer_buffer_length,
1288 dir);
1289 else if (urb->transfer_flags & URB_DMA_MAP_SINGLE)
1290 dma_unmap_single(hcd->self.controller,
1291 urb->transfer_dma,
1292 urb->transfer_buffer_length,
1293 dir);
1294 else if (urb->transfer_flags & URB_MAP_LOCAL)
1295 hcd_free_coherent(urb->dev->bus,
1296 &urb->transfer_dma,
1297 &urb->transfer_buffer,
1298 urb->transfer_buffer_length,
1299 dir);
1300
1301 /* Make it safe to call this routine more than once */
1302 urb->transfer_flags &= ~(URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL |
1303 URB_DMA_MAP_SG | URB_DMA_MAP_PAGE |
1304 URB_DMA_MAP_SINGLE | URB_MAP_LOCAL);
1305}
1306
b3476675
MD		 1307static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
1308 gfp_t mem_flags)
9a9bf406 1309{
b3476675
MD		 1310 enum dma_data_direction dir;
1311 int ret = 0;
1312
9a9bf406
AS		 1313 /* Map the URB's buffers for DMA access.
1314 * Lower level HCD code should use *_dma exclusively,
e04748e3
SS		 1315 * unless it uses pio or talks to another transport,
1316 * or uses the provided scatter gather list for bulk.
1da177e4 1317 */
b3476675 1318
85bcb5ee 1319 if (usb_endpoint_xfer_control(&urb->ep->desc)) {
85e034fd 1320 if (hcd->self.uses_dma) {
b3476675 1321 urb->setup_dma = dma_map_single(
1da177e4
LT		 1322 hcd->self.controller,
1323 urb->setup_packet,
b3476675 1324 sizeof(struct usb_ctrlrequest),
1da177e4 1325 DMA_TO_DEVICE);
85e034fd
LF		 1326 if (dma_mapping_error(hcd->self.controller,
1327 urb->setup_dma))
1328 return -EAGAIN;
ff9c895f 1329 urb->transfer_flags |= URB_SETUP_MAP_SINGLE;
85e034fd 1330 } else if (hcd->driver->flags & HCD_LOCAL_MEM)
b3476675
MD		 1331 ret = hcd_alloc_coherent(
1332 urb->dev->bus, mem_flags,
1333 &urb->setup_dma,
1334 (void **)&urb->setup_packet,
1335 sizeof(struct usb_ctrlrequest),
1336 DMA_TO_DEVICE);
ff9c895f
AS		 1337 if (ret)
1338 return ret;
1339 urb->transfer_flags |= URB_SETUP_MAP_LOCAL;
b3476675
MD		 1340 }
1341
1342 dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
ff9c895f 1343 if (urb->transfer_buffer_length != 0
b3476675 1344 && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
85e034fd 1345 if (hcd->self.uses_dma) {
ff9c895f
AS		 1346 if (urb->num_sgs) {
1347 int n = dma_map_sg(
1348 hcd->self.controller,
910f8d0c 1349 urb->sg,
ff9c895f
AS		 1350 urb->num_sgs,
1351 dir);
1352 if (n <= 0)
1353 ret = -EAGAIN;
1354 else
1355 urb->transfer_flags |= URB_DMA_MAP_SG;
1356 if (n != urb->num_sgs) {
1357 urb->num_sgs = n;
1358 urb->transfer_flags |=
1359 URB_DMA_SG_COMBINED;
1360 }
1361 } else if (urb->sg) {
910f8d0c 1362 struct scatterlist *sg = urb->sg;
ff9c895f
AS		 1363 urb->transfer_dma = dma_map_page(
1364 hcd->self.controller,
1365 sg_page(sg),
1366 sg->offset,
1367 urb->transfer_buffer_length,
1368 dir);
1369 if (dma_mapping_error(hcd->self.controller,
85e034fd 1370 urb->transfer_dma))
ff9c895f
AS		 1371 ret = -EAGAIN;
1372 else
1373 urb->transfer_flags |= URB_DMA_MAP_PAGE;
1374 } else {
1375 urb->transfer_dma = dma_map_single(
1376 hcd->self.controller,
1377 urb->transfer_buffer,
1378 urb->transfer_buffer_length,
1379 dir);
1380 if (dma_mapping_error(hcd->self.controller,
1381 urb->transfer_dma))
1382 ret = -EAGAIN;
1383 else
1384 urb->transfer_flags |= URB_DMA_MAP_SINGLE;
1385 }
85e034fd 1386 } else if (hcd->driver->flags & HCD_LOCAL_MEM) {
b3476675
MD		 1387 ret = hcd_alloc_coherent(
1388 urb->dev->bus, mem_flags,
1389 &urb->transfer_dma,
1390 &urb->transfer_buffer,
1391 urb->transfer_buffer_length,
1392 dir);
ff9c895f
AS		 1393 if (ret == 0)
1394 urb->transfer_flags |= URB_MAP_LOCAL;
b3476675 1395 }
ff9c895f
AS		 1396 if (ret && (urb->transfer_flags & (URB_SETUP_MAP_SINGLE |
1397 URB_SETUP_MAP_LOCAL)))
1398 unmap_urb_for_dma(hcd, urb);
1da177e4 1399 }
b3476675 1400 return ret;
9a9bf406 1401}
1da177e4 1402
9a9bf406
AS		 1403/*-------------------------------------------------------------------------*/
1404
1405/* may be called in any context with a valid urb->dev usecount
1406 * caller surrenders "ownership" of urb
1407 * expects usb_submit_urb() to have sanity checked and conditioned all
1408 * inputs in the urb
1409 */
1410int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
1411{
1412 int status;
1413 struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus);
1414
1415 /* increment urb's reference count as part of giving it to the HCD
1416 * (which will control it). HCD guarantees that it either returns
1417 * an error or calls giveback(), but not both.
1418 */
1419 usb_get_urb(urb);
1420 atomic_inc(&urb->use_count);
4d59d8a1 1421 atomic_inc(&urb->dev->urbnum);
9a9bf406
AS		 1422 usbmon_urb_submit(&hcd->self, urb);
1423
1424 /* NOTE requirements on root-hub callers (usbfs and the hub
1425 * driver, for now): URBs' urb->transfer_buffer must be
1426 * valid and usb_buffer_{sync,unmap}() not be needed, since
1427 * they could clobber root hub response data. Also, control
1428 * URBs must be submitted in process context with interrupts
1429 * enabled.
1430 */
b3476675 1431
ff9c895f 1432 if (is_root_hub(urb->dev)) {
e9df41c5 1433 status = rh_urb_enqueue(hcd, urb);
ff9c895f
AS		 1434 } else {
1435 status = map_urb_for_dma(hcd, urb, mem_flags);
1436 if (likely(status == 0)) {
1437 status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
1438 if (unlikely(status))
1439 unmap_urb_for_dma(hcd, urb);
1440 }
1441 }
9a9bf406
AS		 1442
1443 if (unlikely(status)) {
1da177e4 1444 usbmon_urb_submit_error(&hcd->self, urb, status);
b0d9efba 1445 urb->hcpriv = NULL;
9a9bf406
AS		 1446 INIT_LIST_HEAD(&urb->urb_list);
1447 atomic_dec(&urb->use_count);
4d59d8a1 1448 atomic_dec(&urb->dev->urbnum);
49367d8f 1449 if (atomic_read(&urb->reject))
9a9bf406
AS		 1450 wake_up(&usb_kill_urb_queue);
1451 usb_put_urb(urb);
1da177e4
LT		 1452 }
1453 return status;
1454}
1455
1456/*-------------------------------------------------------------------------*/
1457
1da177e4
LT		 1458/* this makes the hcd giveback() the urb more quickly, by kicking it
1459 * off hardware queues (which may take a while) and returning it as
1460 * soon as practical. we've already set up the urb's return status,
1461 * but we can't know if the callback completed already.
1462 */
e9df41c5 1463static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status)
1da177e4
LT		 1464{
1465 int value;
1466
809a58b8 1467 if (is_root_hub(urb->dev))
e9df41c5 1468 value = usb_rh_urb_dequeue(hcd, urb, status);
1da177e4
LT		 1469 else {
1470
1471 /* The only reason an HCD might fail this call is if
1472 * it has not yet fully queued the urb to begin with.
1473 * Such failures should be harmless. */
e9df41c5 1474 value = hcd->driver->urb_dequeue(hcd, urb, status);
1da177e4 1475 }
1da177e4
LT		 1476 return value;
1477}
1478
1479/*
1480 * called in any context
1481 *
1482 * caller guarantees urb won't be recycled till both unlink()
1483 * and the urb's completion function return
1484 */
a6d2bb9f 1485int usb_hcd_unlink_urb (struct urb *urb, int status)
1da177e4 1486{
9a9bf406 1487 struct usb_hcd *hcd;
cde217a5
AS		 1488 int retval = -EIDRM;
1489 unsigned long flags;
1da177e4 1490
cde217a5
AS		 1491 /* Prevent the device and bus from going away while
1492 * the unlink is carried out. If they are already gone
1493 * then urb->use_count must be 0, since disconnected
1494 * devices can't have any active URBs.
1495 */
1496 spin_lock_irqsave(&hcd_urb_unlink_lock, flags);
1497 if (atomic_read(&urb->use_count) > 0) {
1498 retval = 0;
1499 usb_get_dev(urb->dev);
1500 }
1501 spin_unlock_irqrestore(&hcd_urb_unlink_lock, flags);
1502 if (retval == 0) {
1503 hcd = bus_to_hcd(urb->dev->bus);
1504 retval = unlink1(hcd, urb, status);
1505 usb_put_dev(urb->dev);
1506 }
1da177e4 1507
1da177e4
LT		 1508 if (retval == 0)
1509 retval = -EINPROGRESS;
e9df41c5 1510 else if (retval != -EIDRM && retval != -EBUSY)
9a9bf406
AS		 1511 dev_dbg(&urb->dev->dev, "hcd_unlink_urb %p fail %d\n",
1512 urb, retval);
1da177e4
LT		 1513 return retval;
1514}
1515
1516/*-------------------------------------------------------------------------*/
1517
32aca560
AS		 1518/**
1519 * usb_hcd_giveback_urb - return URB from HCD to device driver
1520 * @hcd: host controller returning the URB
1521 * @urb: urb being returned to the USB device driver.
4a00027d 1522 * @status: completion status code for the URB.
32aca560
AS		 1523 * Context: in_interrupt()
1524 *
1525 * This hands the URB from HCD to its USB device driver, using its
1526 * completion function. The HCD has freed all per-urb resources
1527 * (and is done using urb->hcpriv). It also released all HCD locks;
1528 * the device driver won't cause problems if it frees, modifies,
1529 * or resubmits this URB.
eb231054 1530 *
4a00027d 1531 * If @urb was unlinked, the value of @status will be overridden by
eb231054
AS		 1532 * @urb->unlinked. Erroneous short transfers are detected in case
1533 * the HCD hasn't checked for them.
32aca560 1534 */
4a00027d 1535void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
32aca560 1536{
b0d9efba 1537 urb->hcpriv = NULL;
eb231054 1538 if (unlikely(urb->unlinked))
4a00027d 1539 status = urb->unlinked;
eb231054 1540 else if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
b0d9efba 1541 urb->actual_length < urb->transfer_buffer_length &&
4a00027d
AS		 1542 !status))
1543 status = -EREMOTEIO;
32aca560 1544
1f5a3d0f 1545 unmap_urb_for_dma(hcd, urb);
4a00027d 1546 usbmon_urb_complete(&hcd->self, urb, status);
1f5a3d0f
AS		 1547 usb_unanchor_urb(urb);
1548
32aca560 1549 /* pass ownership to the completion handler */
4a00027d 1550 urb->status = status;
32aca560
AS		 1551 urb->complete (urb);
1552 atomic_dec (&urb->use_count);
49367d8f 1553 if (unlikely(atomic_read(&urb->reject)))
32aca560
AS		 1554 wake_up (&usb_kill_urb_queue);
1555 usb_put_urb (urb);
1556}
782e70c6 1557EXPORT_SYMBOL_GPL(usb_hcd_giveback_urb);
32aca560
AS		 1558
1559/*-------------------------------------------------------------------------*/
1560
95cf82f9
AS		 1561/* Cancel all URBs pending on this endpoint and wait for the endpoint's
1562 * queue to drain completely. The caller must first insure that no more
1563 * URBs can be submitted for this endpoint.
1da177e4 1564 */
95cf82f9 1565void usb_hcd_flush_endpoint(struct usb_device *udev,
a6d2bb9f 1566 struct usb_host_endpoint *ep)
1da177e4
LT		 1567{
1568 struct usb_hcd *hcd;
1569 struct urb *urb;
1570
95cf82f9
AS		 1571 if (!ep)
1572 return;
9a9bf406 1573 might_sleep();
17200583 1574 hcd = bus_to_hcd(udev->bus);
1da177e4 1575
95cf82f9 1576 /* No more submits can occur */
9a9bf406 1577 spin_lock_irq(&hcd_urb_list_lock);
ddc1fd6a 1578rescan:
1da177e4 1579 list_for_each_entry (urb, &ep->urb_list, urb_list) {
5e60a161 1580 int is_in;
1da177e4 1581
eb231054 1582 if (urb->unlinked)
1da177e4
LT		 1583 continue;
1584 usb_get_urb (urb);
5e60a161 1585 is_in = usb_urb_dir_in(urb);
809a58b8 1586 spin_unlock(&hcd_urb_list_lock);
1da177e4 1587
e9df41c5
AS		 1588 /* kick hcd */
1589 unlink1(hcd, urb, -ESHUTDOWN);
1590 dev_dbg (hcd->self.controller,
1591 "shutdown urb %p ep%d%s%s\n",
1592 urb, usb_endpoint_num(&ep->desc),
1593 is_in ? "in" : "out",
1594 ({ char *s;
1595
1596 switch (usb_endpoint_type(&ep->desc)) {
1597 case USB_ENDPOINT_XFER_CONTROL:
1598 s = ""; break;
1599 case USB_ENDPOINT_XFER_BULK:
1600 s = "-bulk"; break;
1601 case USB_ENDPOINT_XFER_INT:
1602 s = "-intr"; break;
1603 default:
1604 s = "-iso"; break;
1605 };
1606 s;
1607 }));
1da177e4
LT		 1608 usb_put_urb (urb);
1609
1610 /* list contents may have changed */
ddc1fd6a 1611 spin_lock(&hcd_urb_list_lock);
1da177e4
LT		 1612 goto rescan;
1613 }
9a9bf406 1614 spin_unlock_irq(&hcd_urb_list_lock);
1da177e4 1615
95cf82f9 1616 /* Wait until the endpoint queue is completely empty */
455b25fb 1617 while (!list_empty (&ep->urb_list)) {
809a58b8 1618 spin_lock_irq(&hcd_urb_list_lock);
455b25fb
AS		 1619
1620 /* The list may have changed while we acquired the spinlock */
1621 urb = NULL;
1622 if (!list_empty (&ep->urb_list)) {
1623 urb = list_entry (ep->urb_list.prev, struct urb,
1624 urb_list);
1625 usb_get_urb (urb);
1626 }
809a58b8 1627 spin_unlock_irq(&hcd_urb_list_lock);
455b25fb
AS		 1628
1629 if (urb) {
1630 usb_kill_urb (urb);
1631 usb_put_urb (urb);
1632 }
1633 }
1da177e4
LT		 1634}
1635
3f0479e0 1636/**
70445ae6
RD		 1637 * usb_hcd_alloc_bandwidth - check whether a new bandwidth setting exceeds
1638 * the bus bandwidth
1639 * @udev: target &usb_device
3f0479e0
SS		 1640 * @new_config: new configuration to install
1641 * @cur_alt: the current alternate interface setting
1642 * @new_alt: alternate interface setting that is being installed
1643 *
1644 * To change configurations, pass in the new configuration in new_config,
1645 * and pass NULL for cur_alt and new_alt.
1646 *
1647 * To reset a device's configuration (put the device in the ADDRESSED state),
1648 * pass in NULL for new_config, cur_alt, and new_alt.
1649 *
1650 * To change alternate interface settings, pass in NULL for new_config,
1651 * pass in the current alternate interface setting in cur_alt,
1652 * and pass in the new alternate interface setting in new_alt.
1653 *
1654 * Returns an error if the requested bandwidth change exceeds the
1655 * bus bandwidth or host controller internal resources.
79abb1ab 1656 */
3f0479e0 1657int usb_hcd_alloc_bandwidth(struct usb_device *udev,
79abb1ab 1658 struct usb_host_config *new_config,
3f0479e0
SS		 1659 struct usb_host_interface *cur_alt,
1660 struct usb_host_interface *new_alt)
79abb1ab
SS		 1661{
1662 int num_intfs, i, j;
576a362a 1663 struct usb_host_interface *alt = NULL;
79abb1ab
SS		 1664 int ret = 0;
1665 struct usb_hcd *hcd;
1666 struct usb_host_endpoint *ep;
1667
1668 hcd = bus_to_hcd(udev->bus);
1669 if (!hcd->driver->check_bandwidth)
1670 return 0;
1671
1672 /* Configuration is being removed - set configuration 0 */
3f0479e0 1673 if (!new_config && !cur_alt) {
79abb1ab
SS		 1674 for (i = 1; i < 16; ++i) {
1675 ep = udev->ep_out[i];
1676 if (ep)
1677 hcd->driver->drop_endpoint(hcd, udev, ep);
1678 ep = udev->ep_in[i];
1679 if (ep)
1680 hcd->driver->drop_endpoint(hcd, udev, ep);
1681 }
1682 hcd->driver->check_bandwidth(hcd, udev);
1683 return 0;
1684 }
1685 /* Check if the HCD says there's enough bandwidth. Enable all endpoints
1686 * each interface's alt setting 0 and ask the HCD to check the bandwidth
1687 * of the bus. There will always be bandwidth for endpoint 0, so it's
1688 * ok to exclude it.
1689 */
1690 if (new_config) {
1691 num_intfs = new_config->desc.bNumInterfaces;
1692 /* Remove endpoints (except endpoint 0, which is always on the
1693 * schedule) from the old config from the schedule
1694 */
1695 for (i = 1; i < 16; ++i) {
1696 ep = udev->ep_out[i];
1697 if (ep) {
1698 ret = hcd->driver->drop_endpoint(hcd, udev, ep);
1699 if (ret < 0)
1700 goto reset;
1701 }
1702 ep = udev->ep_in[i];
1703 if (ep) {
1704 ret = hcd->driver->drop_endpoint(hcd, udev, ep);
1705 if (ret < 0)
1706 goto reset;
1707 }
1708 }
1709 for (i = 0; i < num_intfs; ++i) {
d837e219
SS		 1710 struct usb_host_interface *first_alt;
1711 int iface_num;
1712
1713 first_alt = &new_config->intf_cache[i]->altsetting[0];
1714 iface_num = first_alt->desc.bInterfaceNumber;
91017f9c 1715 /* Set up endpoints for alternate interface setting 0 */
d837e219 1716 alt = usb_find_alt_setting(new_config, iface_num, 0);
3f0479e0
SS		 1717 if (!alt)
1718 /* No alt setting 0? Pick the first setting. */
d837e219 1719 alt = first_alt;
3f0479e0 1720
79abb1ab
SS		 1721 for (j = 0; j < alt->desc.bNumEndpoints; j++) {
1722 ret = hcd->driver->add_endpoint(hcd, udev, &alt->endpoint[j]);
1723 if (ret < 0)
1724 goto reset;
1725 }
1726 }
1727 }
3f0479e0 1728 if (cur_alt && new_alt) {
04a723ea
SS		 1729 struct usb_interface *iface = usb_ifnum_to_if(udev,
1730 cur_alt->desc.bInterfaceNumber);
1731
1732 if (iface->resetting_device) {
1733 /*
1734 * The USB core just reset the device, so the xHCI host
1735 * and the device will think alt setting 0 is installed.
1736 * However, the USB core will pass in the alternate
1737 * setting installed before the reset as cur_alt. Dig
1738 * out the alternate setting 0 structure, or the first
1739 * alternate setting if a broken device doesn't have alt
1740 * setting 0.
1741 */
1742 cur_alt = usb_altnum_to_altsetting(iface, 0);
1743 if (!cur_alt)
1744 cur_alt = &iface->altsetting[0];
1745 }
1746
3f0479e0
SS		 1747 /* Drop all the endpoints in the current alt setting */
1748 for (i = 0; i < cur_alt->desc.bNumEndpoints; i++) {
1749 ret = hcd->driver->drop_endpoint(hcd, udev,
1750 &cur_alt->endpoint[i]);
1751 if (ret < 0)
1752 goto reset;
1753 }
1754 /* Add all the endpoints in the new alt setting */
1755 for (i = 0; i < new_alt->desc.bNumEndpoints; i++) {
1756 ret = hcd->driver->add_endpoint(hcd, udev,
1757 &new_alt->endpoint[i]);
1758 if (ret < 0)
1759 goto reset;
1760 }
1761 }
79abb1ab
SS		 1762 ret = hcd->driver->check_bandwidth(hcd, udev);
1763reset:
1764 if (ret < 0)
1765 hcd->driver->reset_bandwidth(hcd, udev);
1766 return ret;
1767}
1768
95cf82f9
AS		 1769/* Disables the endpoint: synchronizes with the hcd to make sure all
1770 * endpoint state is gone from hardware. usb_hcd_flush_endpoint() must
1771 * have been called previously. Use for set_configuration, set_interface,
1772 * driver removal, physical disconnect.
1773 *
1774 * example: a qh stored in ep->hcpriv, holding state related to endpoint
1775 * type, maxpacket size, toggle, halt status, and scheduling.
1776 */
1777void usb_hcd_disable_endpoint(struct usb_device *udev,
1778 struct usb_host_endpoint *ep)
1779{
1780 struct usb_hcd *hcd;
1781
1782 might_sleep();
1783 hcd = bus_to_hcd(udev->bus);
1784 if (hcd->driver->endpoint_disable)
1785 hcd->driver->endpoint_disable(hcd, ep);
1786}
1787
3444b26a
DV		 1788/**
1789 * usb_hcd_reset_endpoint - reset host endpoint state
1790 * @udev: USB device.
1791 * @ep: the endpoint to reset.
1792 *
1793 * Resets any host endpoint state such as the toggle bit, sequence
1794 * number and current window.
1795 */
1796void usb_hcd_reset_endpoint(struct usb_device *udev,
1797 struct usb_host_endpoint *ep)
1798{
1799 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
1800
1801 if (hcd->driver->endpoint_reset)
1802 hcd->driver->endpoint_reset(hcd, ep);
1803 else {
1804 int epnum = usb_endpoint_num(&ep->desc);
1805 int is_out = usb_endpoint_dir_out(&ep->desc);
1806 int is_control = usb_endpoint_xfer_control(&ep->desc);
1807
1808 usb_settoggle(udev, epnum, is_out, 0);
1809 if (is_control)
1810 usb_settoggle(udev, epnum, !is_out, 0);
1811 }
1812}
1813
eab1cafc
SS		 1814/**
1815 * usb_alloc_streams - allocate bulk endpoint stream IDs.
1816 * @interface: alternate setting that includes all endpoints.
1817 * @eps: array of endpoints that need streams.
1818 * @num_eps: number of endpoints in the array.
1819 * @num_streams: number of streams to allocate.
1820 * @mem_flags: flags hcd should use to allocate memory.
1821 *
1822 * Sets up a group of bulk endpoints to have num_streams stream IDs available.
1823 * Drivers may queue multiple transfers to different stream IDs, which may
1824 * complete in a different order than they were queued.
1825 */
1826int usb_alloc_streams(struct usb_interface *interface,
1827 struct usb_host_endpoint **eps, unsigned int num_eps,
1828 unsigned int num_streams, gfp_t mem_flags)
1829{
1830 struct usb_hcd *hcd;
1831 struct usb_device *dev;
1832 int i;
1833
1834 dev = interface_to_usbdev(interface);
1835 hcd = bus_to_hcd(dev->bus);
1836 if (!hcd->driver->alloc_streams || !hcd->driver->free_streams)
1837 return -EINVAL;
1838 if (dev->speed != USB_SPEED_SUPER)
1839 return -EINVAL;
1840
1841 /* Streams only apply to bulk endpoints. */
1842 for (i = 0; i < num_eps; i++)
1843 if (!usb_endpoint_xfer_bulk(&eps[i]->desc))
1844 return -EINVAL;
1845
1846 return hcd->driver->alloc_streams(hcd, dev, eps, num_eps,
1847 num_streams, mem_flags);
1848}
1849EXPORT_SYMBOL_GPL(usb_alloc_streams);
1850
1851/**
1852 * usb_free_streams - free bulk endpoint stream IDs.
1853 * @interface: alternate setting that includes all endpoints.
1854 * @eps: array of endpoints to remove streams from.
1855 * @num_eps: number of endpoints in the array.
1856 * @mem_flags: flags hcd should use to allocate memory.
1857 *
1858 * Reverts a group of bulk endpoints back to not using stream IDs.
1859 * Can fail if we are given bad arguments, or HCD is broken.
1860 */
1861void usb_free_streams(struct usb_interface *interface,
1862 struct usb_host_endpoint **eps, unsigned int num_eps,
1863 gfp_t mem_flags)
1864{
1865 struct usb_hcd *hcd;
1866 struct usb_device *dev;
1867 int i;
1868
1869 dev = interface_to_usbdev(interface);
1870 hcd = bus_to_hcd(dev->bus);
1871 if (dev->speed != USB_SPEED_SUPER)
1872 return;
1873
1874 /* Streams only apply to bulk endpoints. */
1875 for (i = 0; i < num_eps; i++)
1876 if (!usb_endpoint_xfer_bulk(&eps[i]->desc))
1877 return;
1878
1879 hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
1880}
1881EXPORT_SYMBOL_GPL(usb_free_streams);
1882
cde217a5
AS		 1883/* Protect against drivers that try to unlink URBs after the device
1884 * is gone, by waiting until all unlinks for @udev are finished.
1885 * Since we don't currently track URBs by device, simply wait until
1886 * nothing is running in the locked region of usb_hcd_unlink_urb().
1887 */
1888void usb_hcd_synchronize_unlinks(struct usb_device *udev)
1889{
1890 spin_lock_irq(&hcd_urb_unlink_lock);
1891 spin_unlock_irq(&hcd_urb_unlink_lock);
1892}
1893
1da177e4
LT		 1894/*-------------------------------------------------------------------------*/
1895
32aca560
AS		 1896/* called in any context */
1897int usb_hcd_get_frame_number (struct usb_device *udev)
1898{
1899 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
1900
1901 if (!HC_IS_RUNNING (hcd->state))
1902 return -ESHUTDOWN;
1903 return hcd->driver->get_frame_number (hcd);
1904}
1905
1906/*-------------------------------------------------------------------------*/
1907
9293677a 1908#ifdef CONFIG_PM
1da177e4 1909
65bfd296 1910int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg)
1da177e4 1911{
686314cf
AS		 1912 struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
1913 int status;
1914 int old_state = hcd->state;
1da177e4 1915
686314cf 1916 dev_dbg(&rhdev->dev, "bus %s%s\n",
65bfd296 1917 (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "suspend");
686314cf
AS		 1918 if (!hcd->driver->bus_suspend) {
1919 status = -ENOENT;
1920 } else {
1921 hcd->state = HC_STATE_QUIESCING;
1922 status = hcd->driver->bus_suspend(hcd);
1923 }
1924 if (status == 0) {
1925 usb_set_device_state(rhdev, USB_STATE_SUSPENDED);
9293677a 1926 hcd->state = HC_STATE_SUSPENDED;
686314cf
AS		 1927 } else {
1928 hcd->state = old_state;
1929 dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
9293677a 1930 "suspend", status);
686314cf 1931 }
9293677a 1932 return status;
1da177e4
LT		 1933}
1934
65bfd296 1935int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg)
1da177e4 1936{
686314cf
AS		 1937 struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
1938 int status;
cfa59dab 1939 int old_state = hcd->state;
1da177e4 1940
686314cf 1941 dev_dbg(&rhdev->dev, "usb %s%s\n",
65bfd296 1942 (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "resume");
0c0382e3 1943 if (!hcd->driver->bus_resume)
9293677a 1944 return -ENOENT;
979d5199
DB		 1945 if (hcd->state == HC_STATE_RUNNING)
1946 return 0;
686314cf 1947
9293677a 1948 hcd->state = HC_STATE_RESUMING;
686314cf
AS		 1949 status = hcd->driver->bus_resume(hcd);
1950 if (status == 0) {
1951 /* TRSMRCY = 10 msec */
1952 msleep(10);
1953 usb_set_device_state(rhdev, rhdev->actconfig
1954 ? USB_STATE_CONFIGURED
1955 : USB_STATE_ADDRESS);
9293677a 1956 hcd->state = HC_STATE_RUNNING;
686314cf 1957 } else {
cfa59dab 1958 hcd->state = old_state;
686314cf 1959 dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
9293677a 1960 "resume", status);
cfa59dab
AS		 1961 if (status != -ESHUTDOWN)
1962 usb_hc_died(hcd);
9293677a
DB		 1963 }
1964 return status;
1da177e4
LT		 1965}
1966
9bbdf1e0
AS		 1967#endif /* CONFIG_PM */
1968
1969#ifdef CONFIG_USB_SUSPEND
1970
6b157c9b
AS		 1971/* Workqueue routine for root-hub remote wakeup */
1972static void hcd_resume_work(struct work_struct *work)
1973{
1974 struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
1975 struct usb_device *udev = hcd->self.root_hub;
1976
1977 usb_lock_device(udev);
0534d468 1978 usb_remote_wakeup(udev);
6b157c9b
AS		 1979 usb_unlock_device(udev);
1980}
1981
1da177e4
LT		 1982/**
1983 * usb_hcd_resume_root_hub - called by HCD to resume its root hub
1984 * @hcd: host controller for this root hub
1985 *
1986 * The USB host controller calls this function when its root hub is
1987 * suspended (with the remote wakeup feature enabled) and a remote
6b157c9b
AS		 1988 * wakeup request is received. The routine submits a workqueue request
1989 * to resume the root hub (that is, manage its downstream ports again).
1da177e4
LT		 1990 */
1991void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
1992{
1993 unsigned long flags;
1994
1995 spin_lock_irqsave (&hcd_root_hub_lock, flags);
1996 if (hcd->rh_registered)
9bbdf1e0 1997 queue_work(pm_wq, &hcd->wakeup_work);
1da177e4
LT		 1998 spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
1999}
9293677a 2000EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
1da177e4 2001
9bbdf1e0 2002#endif /* CONFIG_USB_SUSPEND */
1da177e4
LT		 2003
2004/*-------------------------------------------------------------------------*/
2005
2006#ifdef CONFIG_USB_OTG
2007
2008/**
2009 * usb_bus_start_enum - start immediate enumeration (for OTG)
2010 * @bus: the bus (must use hcd framework)
2011 * @port_num: 1-based number of port; usually bus->otg_port
2012 * Context: in_interrupt()
2013 *
2014 * Starts enumeration, with an immediate reset followed later by
2015 * khubd identifying and possibly configuring the device.
2016 * This is needed by OTG controller drivers, where it helps meet
2017 * HNP protocol timing requirements for starting a port reset.
2018 */
2019int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num)
2020{
2021 struct usb_hcd *hcd;
2022 int status = -EOPNOTSUPP;
2023
2024 /* NOTE: since HNP can't start by grabbing the bus's address0_sem,
2025 * boards with root hubs hooked up to internal devices (instead of
2026 * just the OTG port) may need more attention to resetting...
2027 */
2028 hcd = container_of (bus, struct usb_hcd, self);
2029 if (port_num && hcd->driver->start_port_reset)
2030 status = hcd->driver->start_port_reset(hcd, port_num);
2031
2032 /* run khubd shortly after (first) root port reset finishes;
2033 * it may issue others, until at least 50 msecs have passed.
2034 */
2035 if (status == 0)
2036 mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(10));
2037 return status;
2038}
782e70c6 2039EXPORT_SYMBOL_GPL(usb_bus_start_enum);
1da177e4
LT		 2040
2041#endif
2042
2043/*-------------------------------------------------------------------------*/
2044
1da177e4
LT		 2045/**
2046 * usb_hcd_irq - hook IRQs to HCD framework (bus glue)
2047 * @irq: the IRQ being raised
2048 * @__hcd: pointer to the HCD whose IRQ is being signaled
1da177e4
LT		 2049 *
2050 * If the controller isn't HALTed, calls the driver's irq handler.
2051 * Checks whether the controller is now dead.
2052 */
7d12e780 2053irqreturn_t usb_hcd_irq (int irq, void *__hcd)
1da177e4
LT		 2054{
2055 struct usb_hcd *hcd = __hcd;
de85422b
SB		 2056 unsigned long flags;
2057 irqreturn_t rc;
1da177e4 2058
de85422b
SB		 2059 /* IRQF_DISABLED doesn't work correctly with shared IRQs
2060 * when the first handler doesn't use it. So let's just
2061 * assume it's never used.
2062 */
2063 local_irq_save(flags);
1da177e4 2064
de85422b
SB		 2065 if (unlikely(hcd->state == HC_STATE_HALT ||
2066 !test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) {
2067 rc = IRQ_NONE;
2068 } else if (hcd->driver->irq(hcd) == IRQ_NONE) {
2069 rc = IRQ_NONE;
2070 } else {
2071 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
8de98402 2072
de85422b
SB		 2073 if (unlikely(hcd->state == HC_STATE_HALT))
2074 usb_hc_died(hcd);
2075 rc = IRQ_HANDLED;
2076 }
2077
2078 local_irq_restore(flags);
2079 return rc;
1da177e4
LT		 2080}
2081
2082/*-------------------------------------------------------------------------*/
2083
2084/**
2085 * usb_hc_died - report abnormal shutdown of a host controller (bus glue)
2086 * @hcd: pointer to the HCD representing the controller
2087 *
2088 * This is called by bus glue to report a USB host controller that died
2089 * while operations may still have been pending. It's called automatically
2090 * by the PCI glue, so only glue for non-PCI busses should need to call it.
2091 */
2092void usb_hc_died (struct usb_hcd *hcd)
2093{
2094 unsigned long flags;
2095
2096 dev_err (hcd->self.controller, "HC died; cleaning up\n");
2097
2098 spin_lock_irqsave (&hcd_root_hub_lock, flags);
2099 if (hcd->rh_registered) {
d5926ae7 2100 hcd->poll_rh = 0;
1da177e4
LT		 2101
2102 /* make khubd clean up old urbs and devices */
2103 usb_set_device_state (hcd->self.root_hub,
2104 USB_STATE_NOTATTACHED);
2105 usb_kick_khubd (hcd->self.root_hub);
2106 }
2107 spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
2108}
2109EXPORT_SYMBOL_GPL (usb_hc_died);
2110
2111/*-------------------------------------------------------------------------*/
2112
1da177e4
LT		 2113/**
2114 * usb_create_hcd - create and initialize an HCD structure
2115 * @driver: HC driver that will use this hcd
2116 * @dev: device for this HC, stored in hcd->self.controller
2117 * @bus_name: value to store in hcd->self.bus_name
2118 * Context: !in_interrupt()
2119 *
2120 * Allocate a struct usb_hcd, with extra space at the end for the
2121 * HC driver's private data. Initialize the generic members of the
2122 * hcd structure.
2123 *
2124 * If memory is unavailable, returns NULL.
2125 */
2126struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
1b26da15 2127 struct device *dev, const char *bus_name)
1da177e4
LT		 2128{
2129 struct usb_hcd *hcd;
2130
7b842b6e 2131 hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
1da177e4
LT		 2132 if (!hcd) {
2133 dev_dbg (dev, "hcd alloc failed\n");
2134 return NULL;
2135 }
2136 dev_set_drvdata(dev, hcd);
17200583 2137 kref_init(&hcd->kref);
1da177e4
LT		 2138
2139 usb_bus_init(&hcd->self);
1da177e4
LT		 2140 hcd->self.controller = dev;
2141 hcd->self.bus_name = bus_name;
dd990f16 2142 hcd->self.uses_dma = (dev->dma_mask != NULL);
1da177e4
LT		 2143
2144 init_timer(&hcd->rh_timer);
d5926ae7
AS		 2145 hcd->rh_timer.function = rh_timer_func;
2146 hcd->rh_timer.data = (unsigned long) hcd;
9bbdf1e0 2147#ifdef CONFIG_USB_SUSPEND
6b157c9b
AS		 2148 INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
2149#endif
3f0479e0 2150 mutex_init(&hcd->bandwidth_mutex);
1da177e4
LT		 2151
2152 hcd->driver = driver;
2153 hcd->product_desc = (driver->product_desc) ? driver->product_desc :
2154 "USB Host Controller";
1da177e4
LT		 2155 return hcd;
2156}
782e70c6 2157EXPORT_SYMBOL_GPL(usb_create_hcd);
1da177e4 2158
17200583
AS		 2159static void hcd_release (struct kref *kref)
2160{
2161 struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);
2162
2163 kfree(hcd);
2164}
2165
2166struct usb_hcd *usb_get_hcd (struct usb_hcd *hcd)
2167{
2168 if (hcd)
2169 kref_get (&hcd->kref);
2170 return hcd;
2171}
782e70c6 2172EXPORT_SYMBOL_GPL(usb_get_hcd);
17200583 2173
1da177e4
LT		 2174void usb_put_hcd (struct usb_hcd *hcd)
2175{
17200583
AS		 2176 if (hcd)
2177 kref_put (&hcd->kref, hcd_release);
1da177e4 2178}
782e70c6 2179EXPORT_SYMBOL_GPL(usb_put_hcd);
1da177e4
LT		 2180
2181/**
2182 * usb_add_hcd - finish generic HCD structure initialization and register
2183 * @hcd: the usb_hcd structure to initialize
2184 * @irqnum: Interrupt line to allocate
2185 * @irqflags: Interrupt type flags
2186 *
2187 * Finish the remaining parts of generic HCD initialization: allocate the
2188 * buffers of consistent memory, register the bus, request the IRQ line,
2189 * and call the driver's reset() and start() routines.
2190 */
2191int usb_add_hcd(struct usb_hcd *hcd,
2192 unsigned int irqnum, unsigned long irqflags)
2193{
8ec8d20b
AS		 2194 int retval;
2195 struct usb_device *rhdev;
1da177e4
LT		 2196
2197 dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
2198
5234ce1b 2199 hcd->authorized_default = hcd->wireless? 0 : 1;
8de98402
BH		 2200 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2201
b1e8f0a6
DB		 2202 /* HC is in reset state, but accessible. Now do the one-time init,
2203 * bottom up so that hcds can customize the root hubs before khubd
2204 * starts talking to them. (Note, bus id is assigned early too.)
2205 */
1da177e4
LT		 2206 if ((retval = hcd_buffer_create(hcd)) != 0) {
2207 dev_dbg(hcd->self.controller, "pool alloc failed\n");
2208 return retval;
2209 }
2210
2211 if ((retval = usb_register_bus(&hcd->self)) < 0)
8ec8d20b 2212 goto err_register_bus;
1da177e4 2213
b1e8f0a6
DB		 2214 if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) {
2215 dev_err(hcd->self.controller, "unable to allocate root hub\n");
2216 retval = -ENOMEM;
2217 goto err_allocate_root_hub;
2218 }
6b403b02
SS		 2219
2220 switch (hcd->driver->flags & HCD_MASK) {
2221 case HCD_USB11:
2222 rhdev->speed = USB_SPEED_FULL;
2223 break;
2224 case HCD_USB2:
2225 rhdev->speed = USB_SPEED_HIGH;
2226 break;
2227 case HCD_USB3:
2228 rhdev->speed = USB_SPEED_SUPER;
2229 break;
2230 default:
2231 goto err_allocate_root_hub;
2232 }
b1e8f0a6
DB		 2233 hcd->self.root_hub = rhdev;
2234
db4cefaa
DB		 2235 /* wakeup flag init defaults to "everything works" for root hubs,
2236 * but drivers can override it in reset() if needed, along with
2237 * recording the overall controller's system wakeup capability.
2238 */
2239 device_init_wakeup(&rhdev->dev, 1);
2240
b1e8f0a6
DB		 2241 /* "reset" is misnamed; its role is now one-time init. the controller
2242 * should already have been reset (and boot firmware kicked off etc).
2243 */
2244 if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {
2245 dev_err(hcd->self.controller, "can't setup\n");
2246 goto err_hcd_driver_setup;
2247 }
2248
fb669cc0
DB		 2249 /* NOTE: root hub and controller capabilities may not be the same */
2250 if (device_can_wakeup(hcd->self.controller)
2251 && device_can_wakeup(&hcd->self.root_hub->dev))
b1e8f0a6 2252 dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
b1e8f0a6
DB		 2253
2254 /* enable irqs just before we start the controller */
1da177e4 2255 if (hcd->driver->irq) {
de85422b
SB		 2256
2257 /* IRQF_DISABLED doesn't work as advertised when used together
2258 * with IRQF_SHARED. As usb_hcd_irq() will always disable
2259 * interrupts we can remove it here.
2260 */
83a79820
GL		 2261 if (irqflags & IRQF_SHARED)
2262 irqflags &= ~IRQF_DISABLED;
de85422b 2263
1da177e4
LT		 2264 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
2265 hcd->driver->description, hcd->self.busnum);
2266 if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
2267 hcd->irq_descr, hcd)) != 0) {
2268 dev_err(hcd->self.controller,
c6387a48 2269 "request interrupt %d failed\n", irqnum);
8ec8d20b 2270 goto err_request_irq;
1da177e4
LT		 2271 }
2272 hcd->irq = irqnum;
c6387a48 2273 dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
1da177e4
LT		 2274 (hcd->driver->flags & HCD_MEMORY) ?
2275 "io mem" : "io base",
2276 (unsigned long long)hcd->rsrc_start);
2277 } else {
2278 hcd->irq = -1;
2279 if (hcd->rsrc_start)
2280 dev_info(hcd->self.controller, "%s 0x%08llx\n",
2281 (hcd->driver->flags & HCD_MEMORY) ?
2282 "io mem" : "io base",
2283 (unsigned long long)hcd->rsrc_start);
2284 }
2285
2286 if ((retval = hcd->driver->start(hcd)) < 0) {
2287 dev_err(hcd->self.controller, "startup error %d\n", retval);
8ec8d20b 2288 goto err_hcd_driver_start;
1da177e4
LT		 2289 }
2290
b1e8f0a6 2291 /* starting here, usbcore will pay attention to this root hub */
55c52718 2292 rhdev->bus_mA = min(500u, hcd->power_budget);
b1e8f0a6 2293 if ((retval = register_root_hub(hcd)) != 0)
8ec8d20b
AS		 2294 goto err_register_root_hub;
2295
5234ce1b
IPG		 2296 retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
2297 if (retval < 0) {
2298 printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
2299 retval);
2300 goto error_create_attr_group;
2301 }
d5926ae7
AS		 2302 if (hcd->uses_new_polling && hcd->poll_rh)
2303 usb_hcd_poll_rh_status(hcd);
1da177e4
LT		 2304 return retval;
2305
5234ce1b
IPG		 2306error_create_attr_group:
2307 mutex_lock(&usb_bus_list_lock);
2308 usb_disconnect(&hcd->self.root_hub);
2309 mutex_unlock(&usb_bus_list_lock);
b1e8f0a6 2310err_register_root_hub:
8ec8d20b 2311 hcd->driver->stop(hcd);
b1e8f0a6 2312err_hcd_driver_start:
1da177e4
LT		 2313 if (hcd->irq >= 0)
2314 free_irq(irqnum, hcd);
b1e8f0a6
DB		 2315err_request_irq:
2316err_hcd_driver_setup:
2317 hcd->self.root_hub = NULL;
2318 usb_put_dev(rhdev);
2319err_allocate_root_hub:
1da177e4 2320 usb_deregister_bus(&hcd->self);
b1e8f0a6 2321err_register_bus:
1da177e4
LT		 2322 hcd_buffer_destroy(hcd);
2323 return retval;
2324}
782e70c6 2325EXPORT_SYMBOL_GPL(usb_add_hcd);
1da177e4
LT		 2326
2327/**
2328 * usb_remove_hcd - shutdown processing for generic HCDs
2329 * @hcd: the usb_hcd structure to remove
2330 * Context: !in_interrupt()
2331 *
2332 * Disconnects the root hub, then reverses the effects of usb_add_hcd(),
2333 * invoking the HCD's stop() method.
2334 */
2335void usb_remove_hcd(struct usb_hcd *hcd)
2336{
2337 dev_info(hcd->self.controller, "remove, state %x\n", hcd->state);
2338
2339 if (HC_IS_RUNNING (hcd->state))
2340 hcd->state = HC_STATE_QUIESCING;
2341
2342 dev_dbg(hcd->self.controller, "roothub graceful disconnect\n");
2343 spin_lock_irq (&hcd_root_hub_lock);
2344 hcd->rh_registered = 0;
2345 spin_unlock_irq (&hcd_root_hub_lock);
9ad3d6cc 2346
9bbdf1e0 2347#ifdef CONFIG_USB_SUSPEND
d5d4db70 2348 cancel_work_sync(&hcd->wakeup_work);
6b157c9b
AS		 2349#endif
2350
5234ce1b 2351 sysfs_remove_group(&hcd->self.root_hub->dev.kobj, &usb_bus_attr_group);
4186ecf8 2352 mutex_lock(&usb_bus_list_lock);
1da177e4 2353 usb_disconnect(&hcd->self.root_hub);
4186ecf8 2354 mutex_unlock(&usb_bus_list_lock);
1da177e4
LT		 2355
2356 hcd->driver->stop(hcd);
2357 hcd->state = HC_STATE_HALT;
2358
1b42ae6d
AS		 2359 hcd->poll_rh = 0;
2360 del_timer_sync(&hcd->rh_timer);
2361
1da177e4
LT		 2362 if (hcd->irq >= 0)
2363 free_irq(hcd->irq, hcd);
2364 usb_deregister_bus(&hcd->self);
2365 hcd_buffer_destroy(hcd);
2366}
782e70c6 2367EXPORT_SYMBOL_GPL(usb_remove_hcd);
1da177e4 2368
64a21d02
AG		 2369void
2370usb_hcd_platform_shutdown(struct platform_device* dev)
2371{
2372 struct usb_hcd *hcd = platform_get_drvdata(dev);
2373
2374 if (hcd->driver->shutdown)
2375 hcd->driver->shutdown(hcd);
2376}
782e70c6 2377EXPORT_SYMBOL_GPL(usb_hcd_platform_shutdown);
64a21d02 2378
1da177e4
LT		 2379/*-------------------------------------------------------------------------*/
2380
f150fa1a 2381#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
1da177e4
LT		 2382
2383struct usb_mon_operations *mon_ops;
2384
2385/*
2386 * The registration is unlocked.
2387 * We do it this way because we do not want to lock in hot paths.
2388 *
2389 * Notice that the code is minimally error-proof. Because usbmon needs
2390 * symbols from usbcore, usbcore gets referenced and cannot be unloaded first.
2391 */
2392
2393int usb_mon_register (struct usb_mon_operations *ops)
2394{
2395
2396 if (mon_ops)
2397 return -EBUSY;
2398
2399 mon_ops = ops;
2400 mb();
2401 return 0;
2402}
2403EXPORT_SYMBOL_GPL (usb_mon_register);
2404
2405void usb_mon_deregister (void)
2406{
2407
2408 if (mon_ops == NULL) {
2409 printk(KERN_ERR "USB: monitor was not registered\n");
2410 return;
2411 }
2412 mon_ops = NULL;
2413 mb();
2414}
2415EXPORT_SYMBOL_GPL (usb_mon_deregister);
2416
f150fa1a 2417#endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */
Linux kernel - Deliverables
This page took 0.732911 seconds and 5 git commands to generate.