hcd.c 53 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857
  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. #include <linux/module.h>
  25. #include <linux/version.h>
  26. #include <linux/kernel.h>
  27. #include <linux/slab.h>
  28. #include <linux/completion.h>
  29. #include <linux/utsname.h>
  30. #include <linux/mm.h>
  31. #include <asm/io.h>
  32. #include <asm/scatterlist.h>
  33. #include <linux/device.h>
  34. #include <linux/dma-mapping.h>
  35. #include <linux/mutex.h>
  36. #include <asm/irq.h>
  37. #include <asm/byteorder.h>
  38. #include <linux/platform_device.h>
  39. #include <linux/workqueue.h>
  40. #include <linux/usb.h>
  41. #include "usb.h"
  42. #include "hcd.h"
  43. #include "hub.h"
  44. /*-------------------------------------------------------------------------*/
  45. /*
  46. * USB Host Controller Driver framework
  47. *
  48. * Plugs into usbcore (usb_bus) and lets HCDs share code, minimizing
  49. * HCD-specific behaviors/bugs.
  50. *
  51. * This does error checks, tracks devices and urbs, and delegates to a
  52. * "hc_driver" only for code (and data) that really needs to know about
  53. * hardware differences. That includes root hub registers, i/o queues,
  54. * and so on ... but as little else as possible.
  55. *
  56. * Shared code includes most of the "root hub" code (these are emulated,
  57. * though each HC's hardware works differently) and PCI glue, plus request
  58. * tracking overhead. The HCD code should only block on spinlocks or on
  59. * hardware handshaking; blocking on software events (such as other kernel
  60. * threads releasing resources, or completing actions) is all generic.
  61. *
  62. * Happens the USB 2.0 spec says this would be invisible inside the "USBD",
  63. * and includes mostly a "HCDI" (HCD Interface) along with some APIs used
  64. * only by the hub driver ... and that neither should be seen or used by
  65. * usb client device drivers.
  66. *
  67. * Contributors of ideas or unattributed patches include: David Brownell,
  68. * Roman Weissgaerber, Rory Bolt, Greg Kroah-Hartman, ...
  69. *
  70. * HISTORY:
  71. * 2002-02-21 Pull in most of the usb_bus support from usb.c; some
  72. * associated cleanup. "usb_hcd" still != "usb_bus".
  73. * 2001-12-12 Initial patch version for Linux 2.5.1 kernel.
  74. */
  75. /*-------------------------------------------------------------------------*/
  76. /* host controllers we manage */
  77. LIST_HEAD (usb_bus_list);
  78. EXPORT_SYMBOL_GPL (usb_bus_list);
  79. /* used when allocating bus numbers */
  80. #define USB_MAXBUS 64
  81. struct usb_busmap {
  82. unsigned long busmap [USB_MAXBUS / (8*sizeof (unsigned long))];
  83. };
  84. static struct usb_busmap busmap;
  85. /* used when updating list of hcds */
  86. DEFINE_MUTEX(usb_bus_list_lock); /* exported only for usbfs */
  87. EXPORT_SYMBOL_GPL (usb_bus_list_lock);
  88. /* used for controlling access to virtual root hubs */
  89. static DEFINE_SPINLOCK(hcd_root_hub_lock);
  90. /* used when updating an endpoint's URB list */
  91. static DEFINE_SPINLOCK(hcd_urb_list_lock);
  92. /* wait queue for synchronous unlinks */
  93. DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);
  94. static inline int is_root_hub(struct usb_device *udev)
  95. {
  96. return (udev->parent == NULL);
  97. }
  98. /*-------------------------------------------------------------------------*/
  99. /*
  100. * Sharable chunks of root hub code.
  101. */
  102. /*-------------------------------------------------------------------------*/
  103. #define KERNEL_REL ((LINUX_VERSION_CODE >> 16) & 0x0ff)
  104. #define KERNEL_VER ((LINUX_VERSION_CODE >> 8) & 0x0ff)
  105. /* usb 2.0 root hub device descriptor */
  106. static const u8 usb2_rh_dev_descriptor [18] = {
  107. 0x12, /* __u8 bLength; */
  108. 0x01, /* __u8 bDescriptorType; Device */
  109. 0x00, 0x02, /* __le16 bcdUSB; v2.0 */
  110. 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
  111. 0x00, /* __u8 bDeviceSubClass; */
  112. 0x01, /* __u8 bDeviceProtocol; [ usb 2.0 single TT ]*/
  113. 0x40, /* __u8 bMaxPacketSize0; 64 Bytes */
  114. 0x00, 0x00, /* __le16 idVendor; */
  115. 0x00, 0x00, /* __le16 idProduct; */
  116. KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */
  117. 0x03, /* __u8 iManufacturer; */
  118. 0x02, /* __u8 iProduct; */
  119. 0x01, /* __u8 iSerialNumber; */
  120. 0x01 /* __u8 bNumConfigurations; */
  121. };
  122. /* no usb 2.0 root hub "device qualifier" descriptor: one speed only */
  123. /* usb 1.1 root hub device descriptor */
  124. static const u8 usb11_rh_dev_descriptor [18] = {
  125. 0x12, /* __u8 bLength; */
  126. 0x01, /* __u8 bDescriptorType; Device */
  127. 0x10, 0x01, /* __le16 bcdUSB; v1.1 */
  128. 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
  129. 0x00, /* __u8 bDeviceSubClass; */
  130. 0x00, /* __u8 bDeviceProtocol; [ low/full speeds only ] */
  131. 0x40, /* __u8 bMaxPacketSize0; 64 Bytes */
  132. 0x00, 0x00, /* __le16 idVendor; */
  133. 0x00, 0x00, /* __le16 idProduct; */
  134. KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */
  135. 0x03, /* __u8 iManufacturer; */
  136. 0x02, /* __u8 iProduct; */
  137. 0x01, /* __u8 iSerialNumber; */
  138. 0x01 /* __u8 bNumConfigurations; */
  139. };
  140. /*-------------------------------------------------------------------------*/
  141. /* Configuration descriptors for our root hubs */
  142. static const u8 fs_rh_config_descriptor [] = {
  143. /* one configuration */
  144. 0x09, /* __u8 bLength; */
  145. 0x02, /* __u8 bDescriptorType; Configuration */
  146. 0x19, 0x00, /* __le16 wTotalLength; */
  147. 0x01, /* __u8 bNumInterfaces; (1) */
  148. 0x01, /* __u8 bConfigurationValue; */
  149. 0x00, /* __u8 iConfiguration; */
  150. 0xc0, /* __u8 bmAttributes;
  151. Bit 7: must be set,
  152. 6: Self-powered,
  153. 5: Remote wakeup,
  154. 4..0: resvd */
  155. 0x00, /* __u8 MaxPower; */
  156. /* USB 1.1:
  157. * USB 2.0, single TT organization (mandatory):
  158. * one interface, protocol 0
  159. *
  160. * USB 2.0, multiple TT organization (optional):
  161. * two interfaces, protocols 1 (like single TT)
  162. * and 2 (multiple TT mode) ... config is
  163. * sometimes settable
  164. * NOT IMPLEMENTED
  165. */
  166. /* one interface */
  167. 0x09, /* __u8 if_bLength; */
  168. 0x04, /* __u8 if_bDescriptorType; Interface */
  169. 0x00, /* __u8 if_bInterfaceNumber; */
  170. 0x00, /* __u8 if_bAlternateSetting; */
  171. 0x01, /* __u8 if_bNumEndpoints; */
  172. 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
  173. 0x00, /* __u8 if_bInterfaceSubClass; */
  174. 0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
  175. 0x00, /* __u8 if_iInterface; */
  176. /* one endpoint (status change endpoint) */
  177. 0x07, /* __u8 ep_bLength; */
  178. 0x05, /* __u8 ep_bDescriptorType; Endpoint */
  179. 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
  180. 0x03, /* __u8 ep_bmAttributes; Interrupt */
  181. 0x02, 0x00, /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
  182. 0xff /* __u8 ep_bInterval; (255ms -- usb 2.0 spec) */
  183. };
  184. static const u8 hs_rh_config_descriptor [] = {
  185. /* one configuration */
  186. 0x09, /* __u8 bLength; */
  187. 0x02, /* __u8 bDescriptorType; Configuration */
  188. 0x19, 0x00, /* __le16 wTotalLength; */
  189. 0x01, /* __u8 bNumInterfaces; (1) */
  190. 0x01, /* __u8 bConfigurationValue; */
  191. 0x00, /* __u8 iConfiguration; */
  192. 0xc0, /* __u8 bmAttributes;
  193. Bit 7: must be set,
  194. 6: Self-powered,
  195. 5: Remote wakeup,
  196. 4..0: resvd */
  197. 0x00, /* __u8 MaxPower; */
  198. /* USB 1.1:
  199. * USB 2.0, single TT organization (mandatory):
  200. * one interface, protocol 0
  201. *
  202. * USB 2.0, multiple TT organization (optional):
  203. * two interfaces, protocols 1 (like single TT)
  204. * and 2 (multiple TT mode) ... config is
  205. * sometimes settable
  206. * NOT IMPLEMENTED
  207. */
  208. /* one interface */
  209. 0x09, /* __u8 if_bLength; */
  210. 0x04, /* __u8 if_bDescriptorType; Interface */
  211. 0x00, /* __u8 if_bInterfaceNumber; */
  212. 0x00, /* __u8 if_bAlternateSetting; */
  213. 0x01, /* __u8 if_bNumEndpoints; */
  214. 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
  215. 0x00, /* __u8 if_bInterfaceSubClass; */
  216. 0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
  217. 0x00, /* __u8 if_iInterface; */
  218. /* one endpoint (status change endpoint) */
  219. 0x07, /* __u8 ep_bLength; */
  220. 0x05, /* __u8 ep_bDescriptorType; Endpoint */
  221. 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
  222. 0x03, /* __u8 ep_bmAttributes; Interrupt */
  223. /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
  224. * see hub.c:hub_configure() for details. */
  225. (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
  226. 0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */
  227. };
  228. /*-------------------------------------------------------------------------*/
  229. /*
  230. * helper routine for returning string descriptors in UTF-16LE
  231. * input can actually be ISO-8859-1; ASCII is its 7-bit subset
  232. */
  233. static int ascii2utf (char *s, u8 *utf, int utfmax)
  234. {
  235. int retval;
  236. for (retval = 0; *s && utfmax > 1; utfmax -= 2, retval += 2) {
  237. *utf++ = *s++;
  238. *utf++ = 0;
  239. }
  240. if (utfmax > 0) {
  241. *utf = *s;
  242. ++retval;
  243. }
  244. return retval;
  245. }
  246. /*
  247. * rh_string - provides manufacturer, product and serial strings for root hub
  248. * @id: the string ID number (1: serial number, 2: product, 3: vendor)
  249. * @hcd: the host controller for this root hub
  250. * @type: string describing our driver
  251. * @data: return packet in UTF-16 LE
  252. * @len: length of the return packet
  253. *
  254. * Produces either a manufacturer, product or serial number string for the
  255. * virtual root hub device.
  256. */
  257. static int rh_string (
  258. int id,
  259. struct usb_hcd *hcd,
  260. u8 *data,
  261. int len
  262. ) {
  263. char buf [100];
  264. // language ids
  265. if (id == 0) {
  266. buf[0] = 4; buf[1] = 3; /* 4 bytes string data */
  267. buf[2] = 0x09; buf[3] = 0x04; /* MSFT-speak for "en-us" */
  268. len = min (len, 4);
  269. memcpy (data, buf, len);
  270. return len;
  271. // serial number
  272. } else if (id == 1) {
  273. strlcpy (buf, hcd->self.bus_name, sizeof buf);
  274. // product description
  275. } else if (id == 2) {
  276. strlcpy (buf, hcd->product_desc, sizeof buf);
  277. // id 3 == vendor description
  278. } else if (id == 3) {
  279. snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname,
  280. init_utsname()->release, hcd->driver->description);
  281. // unsupported IDs --> "protocol stall"
  282. } else
  283. return -EPIPE;
  284. switch (len) { /* All cases fall through */
  285. default:
  286. len = 2 + ascii2utf (buf, data + 2, len - 2);
  287. case 2:
  288. data [1] = 3; /* type == string */
  289. case 1:
  290. data [0] = 2 * (strlen (buf) + 1);
  291. case 0:
  292. ; /* Compiler wants a statement here */
  293. }
  294. return len;
  295. }
  296. /* Root hub control transfers execute synchronously */
  297. static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
  298. {
  299. struct usb_ctrlrequest *cmd;
  300. u16 typeReq, wValue, wIndex, wLength;
  301. u8 *ubuf = urb->transfer_buffer;
  302. u8 tbuf [sizeof (struct usb_hub_descriptor)]
  303. __attribute__((aligned(4)));
  304. const u8 *bufp = tbuf;
  305. int len = 0;
  306. int patch_wakeup = 0;
  307. int status;
  308. int n;
  309. might_sleep();
  310. spin_lock_irq(&hcd_root_hub_lock);
  311. status = usb_hcd_link_urb_to_ep(hcd, urb);
  312. spin_unlock_irq(&hcd_root_hub_lock);
  313. if (status)
  314. return status;
  315. cmd = (struct usb_ctrlrequest *) urb->setup_packet;
  316. typeReq = (cmd->bRequestType << 8) | cmd->bRequest;
  317. wValue = le16_to_cpu (cmd->wValue);
  318. wIndex = le16_to_cpu (cmd->wIndex);
  319. wLength = le16_to_cpu (cmd->wLength);
  320. if (wLength > urb->transfer_buffer_length)
  321. goto error;
  322. urb->actual_length = 0;
  323. switch (typeReq) {
  324. /* DEVICE REQUESTS */
  325. /* The root hub's remote wakeup enable bit is implemented using
  326. * driver model wakeup flags. If this system supports wakeup
  327. * through USB, userspace may change the default "allow wakeup"
  328. * policy through sysfs or these calls.
  329. *
  330. * Most root hubs support wakeup from downstream devices, for
  331. * runtime power management (disabling USB clocks and reducing
  332. * VBUS power usage). However, not all of them do so; silicon,
  333. * board, and BIOS bugs here are not uncommon, so these can't
  334. * be treated quite like external hubs.
  335. *
  336. * Likewise, not all root hubs will pass wakeup events upstream,
  337. * to wake up the whole system. So don't assume root hub and
  338. * controller capabilities are identical.
  339. */
  340. case DeviceRequest | USB_REQ_GET_STATUS:
  341. tbuf [0] = (device_may_wakeup(&hcd->self.root_hub->dev)
  342. << USB_DEVICE_REMOTE_WAKEUP)
  343. | (1 << USB_DEVICE_SELF_POWERED);
  344. tbuf [1] = 0;
  345. len = 2;
  346. break;
  347. case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
  348. if (wValue == USB_DEVICE_REMOTE_WAKEUP)
  349. device_set_wakeup_enable(&hcd->self.root_hub->dev, 0);
  350. else
  351. goto error;
  352. break;
  353. case DeviceOutRequest | USB_REQ_SET_FEATURE:
  354. if (device_can_wakeup(&hcd->self.root_hub->dev)
  355. && wValue == USB_DEVICE_REMOTE_WAKEUP)
  356. device_set_wakeup_enable(&hcd->self.root_hub->dev, 1);
  357. else
  358. goto error;
  359. break;
  360. case DeviceRequest | USB_REQ_GET_CONFIGURATION:
  361. tbuf [0] = 1;
  362. len = 1;
  363. /* FALLTHROUGH */
  364. case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
  365. break;
  366. case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
  367. switch (wValue & 0xff00) {
  368. case USB_DT_DEVICE << 8:
  369. if (hcd->driver->flags & HCD_USB2)
  370. bufp = usb2_rh_dev_descriptor;
  371. else if (hcd->driver->flags & HCD_USB11)
  372. bufp = usb11_rh_dev_descriptor;
  373. else
  374. goto error;
  375. len = 18;
  376. break;
  377. case USB_DT_CONFIG << 8:
  378. if (hcd->driver->flags & HCD_USB2) {
  379. bufp = hs_rh_config_descriptor;
  380. len = sizeof hs_rh_config_descriptor;
  381. } else {
  382. bufp = fs_rh_config_descriptor;
  383. len = sizeof fs_rh_config_descriptor;
  384. }
  385. if (device_can_wakeup(&hcd->self.root_hub->dev))
  386. patch_wakeup = 1;
  387. break;
  388. case USB_DT_STRING << 8:
  389. n = rh_string (wValue & 0xff, hcd, ubuf, wLength);
  390. if (n < 0)
  391. goto error;
  392. urb->actual_length = n;
  393. break;
  394. default:
  395. goto error;
  396. }
  397. break;
  398. case DeviceRequest | USB_REQ_GET_INTERFACE:
  399. tbuf [0] = 0;
  400. len = 1;
  401. /* FALLTHROUGH */
  402. case DeviceOutRequest | USB_REQ_SET_INTERFACE:
  403. break;
  404. case DeviceOutRequest | USB_REQ_SET_ADDRESS:
  405. // wValue == urb->dev->devaddr
  406. dev_dbg (hcd->self.controller, "root hub device address %d\n",
  407. wValue);
  408. break;
  409. /* INTERFACE REQUESTS (no defined feature/status flags) */
  410. /* ENDPOINT REQUESTS */
  411. case EndpointRequest | USB_REQ_GET_STATUS:
  412. // ENDPOINT_HALT flag
  413. tbuf [0] = 0;
  414. tbuf [1] = 0;
  415. len = 2;
  416. /* FALLTHROUGH */
  417. case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
  418. case EndpointOutRequest | USB_REQ_SET_FEATURE:
  419. dev_dbg (hcd->self.controller, "no endpoint features yet\n");
  420. break;
  421. /* CLASS REQUESTS (and errors) */
  422. default:
  423. /* non-generic request */
  424. switch (typeReq) {
  425. case GetHubStatus:
  426. case GetPortStatus:
  427. len = 4;
  428. break;
  429. case GetHubDescriptor:
  430. len = sizeof (struct usb_hub_descriptor);
  431. break;
  432. }
  433. status = hcd->driver->hub_control (hcd,
  434. typeReq, wValue, wIndex,
  435. tbuf, wLength);
  436. break;
  437. error:
  438. /* "protocol stall" on error */
  439. status = -EPIPE;
  440. }
  441. if (status) {
  442. len = 0;
  443. if (status != -EPIPE) {
  444. dev_dbg (hcd->self.controller,
  445. "CTRL: TypeReq=0x%x val=0x%x "
  446. "idx=0x%x len=%d ==> %d\n",
  447. typeReq, wValue, wIndex,
  448. wLength, status);
  449. }
  450. }
  451. if (len) {
  452. if (urb->transfer_buffer_length < len)
  453. len = urb->transfer_buffer_length;
  454. urb->actual_length = len;
  455. // always USB_DIR_IN, toward host
  456. memcpy (ubuf, bufp, len);
  457. /* report whether RH hardware supports remote wakeup */
  458. if (patch_wakeup &&
  459. len > offsetof (struct usb_config_descriptor,
  460. bmAttributes))
  461. ((struct usb_config_descriptor *)ubuf)->bmAttributes
  462. |= USB_CONFIG_ATT_WAKEUP;
  463. }
  464. /* any errors get returned through the urb completion */
  465. spin_lock_irq(&hcd_root_hub_lock);
  466. if (urb->status == -EINPROGRESS)
  467. urb->status = status;
  468. usb_hcd_unlink_urb_from_ep(hcd, urb);
  469. /* This peculiar use of spinlocks echoes what real HC drivers do.
  470. * Avoiding calls to local_irq_disable/enable makes the code
  471. * RT-friendly.
  472. */
  473. spin_unlock(&hcd_root_hub_lock);
  474. usb_hcd_giveback_urb(hcd, urb);
  475. spin_lock(&hcd_root_hub_lock);
  476. spin_unlock_irq(&hcd_root_hub_lock);
  477. return 0;
  478. }
  479. /*-------------------------------------------------------------------------*/
  480. /*
  481. * Root Hub interrupt transfers are polled using a timer if the
  482. * driver requests it; otherwise the driver is responsible for
  483. * calling usb_hcd_poll_rh_status() when an event occurs.
  484. *
  485. * Completions are called in_interrupt(), but they may or may not
  486. * be in_irq().
  487. */
  488. void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
  489. {
  490. struct urb *urb;
  491. int length;
  492. unsigned long flags;
  493. char buffer[4]; /* Any root hubs with > 31 ports? */
  494. if (unlikely(!hcd->rh_registered))
  495. return;
  496. if (!hcd->uses_new_polling && !hcd->status_urb)
  497. return;
  498. length = hcd->driver->hub_status_data(hcd, buffer);
  499. if (length > 0) {
  500. /* try to complete the status urb */
  501. spin_lock_irqsave(&hcd_root_hub_lock, flags);
  502. urb = hcd->status_urb;
  503. if (urb) {
  504. hcd->poll_pending = 0;
  505. hcd->status_urb = NULL;
  506. urb->status = 0;
  507. urb->hcpriv = NULL;
  508. urb->actual_length = length;
  509. memcpy(urb->transfer_buffer, buffer, length);
  510. usb_hcd_unlink_urb_from_ep(hcd, urb);
  511. spin_unlock(&hcd_root_hub_lock);
  512. usb_hcd_giveback_urb(hcd, urb);
  513. spin_lock(&hcd_root_hub_lock);
  514. } else {
  515. length = 0;
  516. hcd->poll_pending = 1;
  517. }
  518. spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
  519. }
  520. /* The USB 2.0 spec says 256 ms. This is close enough and won't
  521. * exceed that limit if HZ is 100. The math is more clunky than
  522. * maybe expected, this is to make sure that all timers for USB devices
  523. * fire at the same time to give the CPU a break inbetween */
  524. if (hcd->uses_new_polling ? hcd->poll_rh :
  525. (length == 0 && hcd->status_urb != NULL))
  526. mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
  527. }
  528. EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status);
  529. /* timer callback */
  530. static void rh_timer_func (unsigned long _hcd)
  531. {
  532. usb_hcd_poll_rh_status((struct usb_hcd *) _hcd);
  533. }
  534. /*-------------------------------------------------------------------------*/
  535. static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
  536. {
  537. int retval;
  538. unsigned long flags;
  539. int len = 1 + (urb->dev->maxchild / 8);
  540. spin_lock_irqsave (&hcd_root_hub_lock, flags);
  541. if (hcd->status_urb || urb->transfer_buffer_length < len) {
  542. dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
  543. retval = -EINVAL;
  544. goto done;
  545. }
  546. retval = usb_hcd_link_urb_to_ep(hcd, urb);
  547. if (retval)
  548. goto done;
  549. hcd->status_urb = urb;
  550. urb->hcpriv = hcd; /* indicate it's queued */
  551. if (!hcd->uses_new_polling)
  552. mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
  553. /* If a status change has already occurred, report it ASAP */
  554. else if (hcd->poll_pending)
  555. mod_timer(&hcd->rh_timer, jiffies);
  556. retval = 0;
  557. done:
  558. spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
  559. return retval;
  560. }
  561. static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
  562. {
  563. if (usb_endpoint_xfer_int(&urb->ep->desc))
  564. return rh_queue_status (hcd, urb);
  565. if (usb_endpoint_xfer_control(&urb->ep->desc))
  566. return rh_call_control (hcd, urb);
  567. return -EINVAL;
  568. }
  569. /*-------------------------------------------------------------------------*/
  570. /* Unlinks of root-hub control URBs are legal, but they don't do anything
  571. * since these URBs always execute synchronously.
  572. */
  573. static int usb_rh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
  574. {
  575. unsigned long flags;
  576. int rc;
  577. spin_lock_irqsave(&hcd_root_hub_lock, flags);
  578. rc = usb_hcd_check_unlink_urb(hcd, urb, status);
  579. if (rc)
  580. goto done;
  581. if (usb_endpoint_num(&urb->ep->desc) == 0) { /* Control URB */
  582. ; /* Do nothing */
  583. } else { /* Status URB */
  584. if (!hcd->uses_new_polling)
  585. del_timer (&hcd->rh_timer);
  586. if (urb == hcd->status_urb) {
  587. hcd->status_urb = NULL;
  588. urb->hcpriv = NULL;
  589. usb_hcd_unlink_urb_from_ep(hcd, urb);
  590. spin_unlock(&hcd_root_hub_lock);
  591. usb_hcd_giveback_urb(hcd, urb);
  592. spin_lock(&hcd_root_hub_lock);
  593. }
  594. }
  595. done:
  596. spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
  597. return rc;
  598. }
  599. /*
  600. * Show & store the current value of authorized_default
  601. */
  602. static ssize_t usb_host_authorized_default_show(struct device *dev,
  603. struct device_attribute *attr,
  604. char *buf)
  605. {
  606. struct usb_device *rh_usb_dev = to_usb_device(dev);
  607. struct usb_bus *usb_bus = rh_usb_dev->bus;
  608. struct usb_hcd *usb_hcd;
  609. if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
  610. return -ENODEV;
  611. usb_hcd = bus_to_hcd(usb_bus);
  612. return snprintf(buf, PAGE_SIZE, "%u\n", usb_hcd->authorized_default);
  613. }
  614. static ssize_t usb_host_authorized_default_store(struct device *dev,
  615. struct device_attribute *attr,
  616. const char *buf, size_t size)
  617. {
  618. ssize_t result;
  619. unsigned val;
  620. struct usb_device *rh_usb_dev = to_usb_device(dev);
  621. struct usb_bus *usb_bus = rh_usb_dev->bus;
  622. struct usb_hcd *usb_hcd;
  623. if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
  624. return -ENODEV;
  625. usb_hcd = bus_to_hcd(usb_bus);
  626. result = sscanf(buf, "%u\n", &val);
  627. if (result == 1) {
  628. usb_hcd->authorized_default = val? 1 : 0;
  629. result = size;
  630. }
  631. else
  632. result = -EINVAL;
  633. return result;
  634. }
  635. static DEVICE_ATTR(authorized_default, 0644,
  636. usb_host_authorized_default_show,
  637. usb_host_authorized_default_store);
  638. /* Group all the USB bus attributes */
  639. static struct attribute *usb_bus_attrs[] = {
  640. &dev_attr_authorized_default.attr,
  641. NULL,
  642. };
  643. static struct attribute_group usb_bus_attr_group = {
  644. .name = NULL, /* we want them in the same directory */
  645. .attrs = usb_bus_attrs,
  646. };
  647. /*-------------------------------------------------------------------------*/
  648. static struct class *usb_host_class;
  649. int usb_host_init(void)
  650. {
  651. int retval = 0;
  652. usb_host_class = class_create(THIS_MODULE, "usb_host");
  653. if (IS_ERR(usb_host_class))
  654. retval = PTR_ERR(usb_host_class);
  655. return retval;
  656. }
  657. void usb_host_cleanup(void)
  658. {
  659. class_destroy(usb_host_class);
  660. }
  661. /**
  662. * usb_bus_init - shared initialization code
  663. * @bus: the bus structure being initialized
  664. *
  665. * This code is used to initialize a usb_bus structure, memory for which is
  666. * separately managed.
  667. */
  668. static void usb_bus_init (struct usb_bus *bus)
  669. {
  670. memset (&bus->devmap, 0, sizeof(struct usb_devmap));
  671. bus->devnum_next = 1;
  672. bus->root_hub = NULL;
  673. bus->busnum = -1;
  674. bus->bandwidth_allocated = 0;
  675. bus->bandwidth_int_reqs = 0;
  676. bus->bandwidth_isoc_reqs = 0;
  677. INIT_LIST_HEAD (&bus->bus_list);
  678. }
  679. /*-------------------------------------------------------------------------*/
  680. /**
  681. * usb_register_bus - registers the USB host controller with the usb core
  682. * @bus: pointer to the bus to register
  683. * Context: !in_interrupt()
  684. *
  685. * Assigns a bus number, and links the controller into usbcore data
  686. * structures so that it can be seen by scanning the bus list.
  687. */
  688. static int usb_register_bus(struct usb_bus *bus)
  689. {
  690. int result = -E2BIG;
  691. int busnum;
  692. mutex_lock(&usb_bus_list_lock);
  693. busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
  694. if (busnum >= USB_MAXBUS) {
  695. printk (KERN_ERR "%s: too many buses\n", usbcore_name);
  696. goto error_find_busnum;
  697. }
  698. set_bit (busnum, busmap.busmap);
  699. bus->busnum = busnum;
  700. bus->class_dev = class_device_create(usb_host_class, NULL, MKDEV(0,0),
  701. bus->controller, "usb_host%d",
  702. busnum);
  703. result = PTR_ERR(bus->class_dev);
  704. if (IS_ERR(bus->class_dev))
  705. goto error_create_class_dev;
  706. class_set_devdata(bus->class_dev, bus);
  707. /* Add it to the local list of buses */
  708. list_add (&bus->bus_list, &usb_bus_list);
  709. mutex_unlock(&usb_bus_list_lock);
  710. usb_notify_add_bus(bus);
  711. dev_info (bus->controller, "new USB bus registered, assigned bus "
  712. "number %d\n", bus->busnum);
  713. return 0;
  714. error_create_class_dev:
  715. clear_bit(busnum, busmap.busmap);
  716. error_find_busnum:
  717. mutex_unlock(&usb_bus_list_lock);
  718. return result;
  719. }
  720. /**
  721. * usb_deregister_bus - deregisters the USB host controller
  722. * @bus: pointer to the bus to deregister
  723. * Context: !in_interrupt()
  724. *
  725. * Recycles the bus number, and unlinks the controller from usbcore data
  726. * structures so that it won't be seen by scanning the bus list.
  727. */
  728. static void usb_deregister_bus (struct usb_bus *bus)
  729. {
  730. dev_info (bus->controller, "USB bus %d deregistered\n", bus->busnum);
  731. /*
  732. * NOTE: make sure that all the devices are removed by the
  733. * controller code, as well as having it call this when cleaning
  734. * itself up
  735. */
  736. mutex_lock(&usb_bus_list_lock);
  737. list_del (&bus->bus_list);
  738. mutex_unlock(&usb_bus_list_lock);
  739. usb_notify_remove_bus(bus);
  740. clear_bit (bus->busnum, busmap.busmap);
  741. class_device_unregister(bus->class_dev);
  742. }
  743. /**
  744. * register_root_hub - called by usb_add_hcd() to register a root hub
  745. * @hcd: host controller for this root hub
  746. *
  747. * This function registers the root hub with the USB subsystem. It sets up
  748. * the device properly in the device tree and then calls usb_new_device()
  749. * to register the usb device. It also assigns the root hub's USB address
  750. * (always 1).
  751. */
  752. static int register_root_hub(struct usb_hcd *hcd)
  753. {
  754. struct device *parent_dev = hcd->self.controller;
  755. struct usb_device *usb_dev = hcd->self.root_hub;
  756. const int devnum = 1;
  757. int retval;
  758. usb_dev->devnum = devnum;
  759. usb_dev->bus->devnum_next = devnum + 1;
  760. memset (&usb_dev->bus->devmap.devicemap, 0,
  761. sizeof usb_dev->bus->devmap.devicemap);
  762. set_bit (devnum, usb_dev->bus->devmap.devicemap);
  763. usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
  764. mutex_lock(&usb_bus_list_lock);
  765. usb_dev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
  766. retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
  767. if (retval != sizeof usb_dev->descriptor) {
  768. mutex_unlock(&usb_bus_list_lock);
  769. dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
  770. usb_dev->dev.bus_id, retval);
  771. return (retval < 0) ? retval : -EMSGSIZE;
  772. }
  773. retval = usb_new_device (usb_dev);
  774. if (retval) {
  775. dev_err (parent_dev, "can't register root hub for %s, %d\n",
  776. usb_dev->dev.bus_id, retval);
  777. }
  778. mutex_unlock(&usb_bus_list_lock);
  779. if (retval == 0) {
  780. spin_lock_irq (&hcd_root_hub_lock);
  781. hcd->rh_registered = 1;
  782. spin_unlock_irq (&hcd_root_hub_lock);
  783. /* Did the HC die before the root hub was registered? */
  784. if (hcd->state == HC_STATE_HALT)
  785. usb_hc_died (hcd); /* This time clean up */
  786. }
  787. return retval;
  788. }
  789. void usb_enable_root_hub_irq (struct usb_bus *bus)
  790. {
  791. struct usb_hcd *hcd;
  792. hcd = container_of (bus, struct usb_hcd, self);
  793. if (hcd->driver->hub_irq_enable && hcd->state != HC_STATE_HALT)
  794. hcd->driver->hub_irq_enable (hcd);
  795. }
  796. /*-------------------------------------------------------------------------*/
  797. /**
  798. * usb_calc_bus_time - approximate periodic transaction time in nanoseconds
  799. * @speed: from dev->speed; USB_SPEED_{LOW,FULL,HIGH}
  800. * @is_input: true iff the transaction sends data to the host
  801. * @isoc: true for isochronous transactions, false for interrupt ones
  802. * @bytecount: how many bytes in the transaction.
  803. *
  804. * Returns approximate bus time in nanoseconds for a periodic transaction.
  805. * See USB 2.0 spec section 5.11.3; only periodic transfers need to be
  806. * scheduled in software, this function is only used for such scheduling.
  807. */
  808. long usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)
  809. {
  810. unsigned long tmp;
  811. switch (speed) {
  812. case USB_SPEED_LOW: /* INTR only */
  813. if (is_input) {
  814. tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
  815. return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
  816. } else {
  817. tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
  818. return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
  819. }
  820. case USB_SPEED_FULL: /* ISOC or INTR */
  821. if (isoc) {
  822. tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
  823. return (((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);
  824. } else {
  825. tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
  826. return (9107L + BW_HOST_DELAY + tmp);
  827. }
  828. case USB_SPEED_HIGH: /* ISOC or INTR */
  829. // FIXME adjust for input vs output
  830. if (isoc)
  831. tmp = HS_NSECS_ISO (bytecount);
  832. else
  833. tmp = HS_NSECS (bytecount);
  834. return tmp;
  835. default:
  836. pr_debug ("%s: bogus device speed!\n", usbcore_name);
  837. return -1;
  838. }
  839. }
  840. EXPORT_SYMBOL (usb_calc_bus_time);
  841. /*-------------------------------------------------------------------------*/
  842. /*
  843. * Generic HC operations.
  844. */
  845. /*-------------------------------------------------------------------------*/
  846. /**
  847. * usb_hcd_link_urb_to_ep - add an URB to its endpoint queue
  848. * @hcd: host controller to which @urb was submitted
  849. * @urb: URB being submitted
  850. *
  851. * Host controller drivers should call this routine in their enqueue()
  852. * method. The HCD's private spinlock must be held and interrupts must
  853. * be disabled. The actions carried out here are required for URB
  854. * submission, as well as for endpoint shutdown and for usb_kill_urb.
  855. *
  856. * Returns 0 for no error, otherwise a negative error code (in which case
  857. * the enqueue() method must fail). If no error occurs but enqueue() fails
  858. * anyway, it must call usb_hcd_unlink_urb_from_ep() before releasing
  859. * the private spinlock and returning.
  860. */
  861. int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
  862. {
  863. int rc = 0;
  864. spin_lock(&hcd_urb_list_lock);
  865. /* Check that the URB isn't being killed */
  866. if (unlikely(urb->reject)) {
  867. rc = -EPERM;
  868. goto done;
  869. }
  870. if (unlikely(!urb->ep->enabled)) {
  871. rc = -ENOENT;
  872. goto done;
  873. }
  874. /*
  875. * Check the host controller's state and add the URB to the
  876. * endpoint's queue.
  877. */
  878. switch (hcd->state) {
  879. case HC_STATE_RUNNING:
  880. case HC_STATE_RESUMING:
  881. list_add_tail(&urb->urb_list, &urb->ep->urb_list);
  882. break;
  883. default:
  884. rc = -ESHUTDOWN;
  885. goto done;
  886. }
  887. done:
  888. spin_unlock(&hcd_urb_list_lock);
  889. return rc;
  890. }
  891. EXPORT_SYMBOL_GPL(usb_hcd_link_urb_to_ep);
  892. /**
  893. * usb_hcd_check_unlink_urb - check whether an URB may be unlinked
  894. * @hcd: host controller to which @urb was submitted
  895. * @urb: URB being checked for unlinkability
  896. * @status: error code to store in @urb if the unlink succeeds
  897. *
  898. * Host controller drivers should call this routine in their dequeue()
  899. * method. The HCD's private spinlock must be held and interrupts must
  900. * be disabled. The actions carried out here are required for making
  901. * sure than an unlink is valid.
  902. *
  903. * Returns 0 for no error, otherwise a negative error code (in which case
  904. * the dequeue() method must fail). The possible error codes are:
  905. *
  906. * -EIDRM: @urb was not submitted or has already completed.
  907. * The completion function may not have been called yet.
  908. *
  909. * -EBUSY: @urb has already been unlinked.
  910. */
  911. int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
  912. int status)
  913. {
  914. struct list_head *tmp;
  915. /* insist the urb is still queued */
  916. list_for_each(tmp, &urb->ep->urb_list) {
  917. if (tmp == &urb->urb_list)
  918. break;
  919. }
  920. if (tmp != &urb->urb_list)
  921. return -EIDRM;
  922. /* Any status except -EINPROGRESS means something already started to
  923. * unlink this URB from the hardware. So there's no more work to do.
  924. */
  925. if (urb->status != -EINPROGRESS)
  926. return -EBUSY;
  927. urb->status = status;
  928. /* IRQ setup can easily be broken so that USB controllers
  929. * never get completion IRQs ... maybe even the ones we need to
  930. * finish unlinking the initial failed usb_set_address()
  931. * or device descriptor fetch.
  932. */
  933. if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags) &&
  934. !is_root_hub(urb->dev)) {
  935. dev_warn(hcd->self.controller, "Unlink after no-IRQ? "
  936. "Controller is probably using the wrong IRQ.\n");
  937. set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
  938. }
  939. return 0;
  940. }
  941. EXPORT_SYMBOL_GPL(usb_hcd_check_unlink_urb);
  942. /**
  943. * usb_hcd_unlink_urb_from_ep - remove an URB from its endpoint queue
  944. * @hcd: host controller to which @urb was submitted
  945. * @urb: URB being unlinked
  946. *
  947. * Host controller drivers should call this routine before calling
  948. * usb_hcd_giveback_urb(). The HCD's private spinlock must be held and
  949. * interrupts must be disabled. The actions carried out here are required
  950. * for URB completion.
  951. */
  952. void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb)
  953. {
  954. /* clear all state linking urb to this dev (and hcd) */
  955. spin_lock(&hcd_urb_list_lock);
  956. list_del_init(&urb->urb_list);
  957. spin_unlock(&hcd_urb_list_lock);
  958. }
  959. EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep);
  960. static void map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
  961. {
  962. /* Map the URB's buffers for DMA access.
  963. * Lower level HCD code should use *_dma exclusively,
  964. * unless it uses pio or talks to another transport.
  965. */
  966. if (hcd->self.uses_dma && !is_root_hub(urb->dev)) {
  967. if (usb_endpoint_xfer_control(&urb->ep->desc)
  968. && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
  969. urb->setup_dma = dma_map_single (
  970. hcd->self.controller,
  971. urb->setup_packet,
  972. sizeof (struct usb_ctrlrequest),
  973. DMA_TO_DEVICE);
  974. if (urb->transfer_buffer_length != 0
  975. && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
  976. urb->transfer_dma = dma_map_single (
  977. hcd->self.controller,
  978. urb->transfer_buffer,
  979. urb->transfer_buffer_length,
  980. usb_urb_dir_in(urb)
  981. ? DMA_FROM_DEVICE
  982. : DMA_TO_DEVICE);
  983. }
  984. }
  985. static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
  986. {
  987. if (hcd->self.uses_dma && !is_root_hub(urb->dev)) {
  988. if (usb_endpoint_xfer_control(&urb->ep->desc)
  989. && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
  990. dma_unmap_single(hcd->self.controller, urb->setup_dma,
  991. sizeof(struct usb_ctrlrequest),
  992. DMA_TO_DEVICE);
  993. if (urb->transfer_buffer_length != 0
  994. && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
  995. dma_unmap_single(hcd->self.controller,
  996. urb->transfer_dma,
  997. urb->transfer_buffer_length,
  998. usb_urb_dir_in(urb)
  999. ? DMA_FROM_DEVICE
  1000. : DMA_TO_DEVICE);
  1001. }
  1002. }
  1003. /*-------------------------------------------------------------------------*/
  1004. /* may be called in any context with a valid urb->dev usecount
  1005. * caller surrenders "ownership" of urb
  1006. * expects usb_submit_urb() to have sanity checked and conditioned all
  1007. * inputs in the urb
  1008. */
  1009. int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
  1010. {
  1011. int status;
  1012. struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus);
  1013. /* increment urb's reference count as part of giving it to the HCD
  1014. * (which will control it). HCD guarantees that it either returns
  1015. * an error or calls giveback(), but not both.
  1016. */
  1017. usb_get_urb(urb);
  1018. atomic_inc(&urb->use_count);
  1019. usbmon_urb_submit(&hcd->self, urb);
  1020. /* NOTE requirements on root-hub callers (usbfs and the hub
  1021. * driver, for now): URBs' urb->transfer_buffer must be
  1022. * valid and usb_buffer_{sync,unmap}() not be needed, since
  1023. * they could clobber root hub response data. Also, control
  1024. * URBs must be submitted in process context with interrupts
  1025. * enabled.
  1026. */
  1027. map_urb_for_dma(hcd, urb);
  1028. if (is_root_hub(urb->dev))
  1029. status = rh_urb_enqueue(hcd, urb);
  1030. else
  1031. status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
  1032. if (unlikely(status)) {
  1033. usbmon_urb_submit_error(&hcd->self, urb, status);
  1034. unmap_urb_for_dma(hcd, urb);
  1035. INIT_LIST_HEAD(&urb->urb_list);
  1036. atomic_dec(&urb->use_count);
  1037. if (urb->reject)
  1038. wake_up(&usb_kill_urb_queue);
  1039. usb_put_urb(urb);
  1040. }
  1041. return status;
  1042. }
  1043. /*-------------------------------------------------------------------------*/
  1044. /* this makes the hcd giveback() the urb more quickly, by kicking it
  1045. * off hardware queues (which may take a while) and returning it as
  1046. * soon as practical. we've already set up the urb's return status,
  1047. * but we can't know if the callback completed already.
  1048. */
  1049. static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status)
  1050. {
  1051. int value;
  1052. if (is_root_hub(urb->dev))
  1053. value = usb_rh_urb_dequeue(hcd, urb, status);
  1054. else {
  1055. /* The only reason an HCD might fail this call is if
  1056. * it has not yet fully queued the urb to begin with.
  1057. * Such failures should be harmless. */
  1058. value = hcd->driver->urb_dequeue(hcd, urb, status);
  1059. }
  1060. return value;
  1061. }
  1062. /*
  1063. * called in any context
  1064. *
  1065. * caller guarantees urb won't be recycled till both unlink()
  1066. * and the urb's completion function return
  1067. */
  1068. int usb_hcd_unlink_urb (struct urb *urb, int status)
  1069. {
  1070. struct usb_hcd *hcd;
  1071. int retval;
  1072. hcd = bus_to_hcd(urb->dev->bus);
  1073. retval = unlink1(hcd, urb, status);
  1074. if (retval == 0)
  1075. retval = -EINPROGRESS;
  1076. else if (retval != -EIDRM && retval != -EBUSY)
  1077. dev_dbg(&urb->dev->dev, "hcd_unlink_urb %p fail %d\n",
  1078. urb, retval);
  1079. return retval;
  1080. }
  1081. /*-------------------------------------------------------------------------*/
  1082. /**
  1083. * usb_hcd_giveback_urb - return URB from HCD to device driver
  1084. * @hcd: host controller returning the URB
  1085. * @urb: urb being returned to the USB device driver.
  1086. * Context: in_interrupt()
  1087. *
  1088. * This hands the URB from HCD to its USB device driver, using its
  1089. * completion function. The HCD has freed all per-urb resources
  1090. * (and is done using urb->hcpriv). It also released all HCD locks;
  1091. * the device driver won't cause problems if it frees, modifies,
  1092. * or resubmits this URB.
  1093. */
  1094. void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb)
  1095. {
  1096. unmap_urb_for_dma(hcd, urb);
  1097. usbmon_urb_complete (&hcd->self, urb);
  1098. usb_unanchor_urb(urb);
  1099. /* pass ownership to the completion handler */
  1100. urb->complete (urb);
  1101. atomic_dec (&urb->use_count);
  1102. if (unlikely (urb->reject))
  1103. wake_up (&usb_kill_urb_queue);
  1104. usb_put_urb (urb);
  1105. }
  1106. EXPORT_SYMBOL (usb_hcd_giveback_urb);
  1107. /*-------------------------------------------------------------------------*/
  1108. /* disables the endpoint: cancels any pending urbs, then synchronizes with
  1109. * the hcd to make sure all endpoint state is gone from hardware, and then
  1110. * waits until the endpoint's queue is completely drained. use for
  1111. * set_configuration, set_interface, driver removal, physical disconnect.
  1112. *
  1113. * example: a qh stored in ep->hcpriv, holding state related to endpoint
  1114. * type, maxpacket size, toggle, halt status, and scheduling.
  1115. */
  1116. void usb_hcd_endpoint_disable (struct usb_device *udev,
  1117. struct usb_host_endpoint *ep)
  1118. {
  1119. struct usb_hcd *hcd;
  1120. struct urb *urb;
  1121. might_sleep();
  1122. hcd = bus_to_hcd(udev->bus);
  1123. /* ep is already gone from udev->ep_{in,out}[]; no more submits */
  1124. rescan:
  1125. spin_lock_irq(&hcd_urb_list_lock);
  1126. list_for_each_entry (urb, &ep->urb_list, urb_list) {
  1127. int is_in;
  1128. /* the urb may already have been unlinked */
  1129. if (urb->status != -EINPROGRESS)
  1130. continue;
  1131. usb_get_urb (urb);
  1132. is_in = usb_urb_dir_in(urb);
  1133. spin_unlock(&hcd_urb_list_lock);
  1134. /* kick hcd */
  1135. unlink1(hcd, urb, -ESHUTDOWN);
  1136. dev_dbg (hcd->self.controller,
  1137. "shutdown urb %p ep%d%s%s\n",
  1138. urb, usb_endpoint_num(&ep->desc),
  1139. is_in ? "in" : "out",
  1140. ({ char *s;
  1141. switch (usb_endpoint_type(&ep->desc)) {
  1142. case USB_ENDPOINT_XFER_CONTROL:
  1143. s = ""; break;
  1144. case USB_ENDPOINT_XFER_BULK:
  1145. s = "-bulk"; break;
  1146. case USB_ENDPOINT_XFER_INT:
  1147. s = "-intr"; break;
  1148. default:
  1149. s = "-iso"; break;
  1150. };
  1151. s;
  1152. }));
  1153. usb_put_urb (urb);
  1154. /* list contents may have changed */
  1155. goto rescan;
  1156. }
  1157. spin_unlock_irq(&hcd_urb_list_lock);
  1158. /* synchronize with the hardware, so old configuration state
  1159. * clears out immediately (and will be freed).
  1160. */
  1161. if (hcd->driver->endpoint_disable)
  1162. hcd->driver->endpoint_disable (hcd, ep);
  1163. /* Wait until the endpoint queue is completely empty. Most HCDs
  1164. * will have done this already in their endpoint_disable method,
  1165. * but some might not. And there could be root-hub control URBs
  1166. * still pending since they aren't affected by the HCDs'
  1167. * endpoint_disable methods.
  1168. */
  1169. while (!list_empty (&ep->urb_list)) {
  1170. spin_lock_irq(&hcd_urb_list_lock);
  1171. /* The list may have changed while we acquired the spinlock */
  1172. urb = NULL;
  1173. if (!list_empty (&ep->urb_list)) {
  1174. urb = list_entry (ep->urb_list.prev, struct urb,
  1175. urb_list);
  1176. usb_get_urb (urb);
  1177. }
  1178. spin_unlock_irq(&hcd_urb_list_lock);
  1179. if (urb) {
  1180. usb_kill_urb (urb);
  1181. usb_put_urb (urb);
  1182. }
  1183. }
  1184. }
  1185. /*-------------------------------------------------------------------------*/
  1186. /* called in any context */
  1187. int usb_hcd_get_frame_number (struct usb_device *udev)
  1188. {
  1189. struct usb_hcd *hcd = bus_to_hcd(udev->bus);
  1190. if (!HC_IS_RUNNING (hcd->state))
  1191. return -ESHUTDOWN;
  1192. return hcd->driver->get_frame_number (hcd);
  1193. }
  1194. /*-------------------------------------------------------------------------*/
  1195. #ifdef CONFIG_PM
  1196. int hcd_bus_suspend(struct usb_device *rhdev)
  1197. {
  1198. struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
  1199. int status;
  1200. int old_state = hcd->state;
  1201. dev_dbg(&rhdev->dev, "bus %s%s\n",
  1202. rhdev->auto_pm ? "auto-" : "", "suspend");
  1203. if (!hcd->driver->bus_suspend) {
  1204. status = -ENOENT;
  1205. } else {
  1206. hcd->state = HC_STATE_QUIESCING;
  1207. status = hcd->driver->bus_suspend(hcd);
  1208. }
  1209. if (status == 0) {
  1210. usb_set_device_state(rhdev, USB_STATE_SUSPENDED);
  1211. hcd->state = HC_STATE_SUSPENDED;
  1212. } else {
  1213. hcd->state = old_state;
  1214. dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
  1215. "suspend", status);
  1216. }
  1217. return status;
  1218. }
  1219. int hcd_bus_resume(struct usb_device *rhdev)
  1220. {
  1221. struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
  1222. int status;
  1223. int old_state = hcd->state;
  1224. dev_dbg(&rhdev->dev, "usb %s%s\n",
  1225. rhdev->auto_pm ? "auto-" : "", "resume");
  1226. if (!hcd->driver->bus_resume)
  1227. return -ENOENT;
  1228. if (hcd->state == HC_STATE_RUNNING)
  1229. return 0;
  1230. hcd->state = HC_STATE_RESUMING;
  1231. status = hcd->driver->bus_resume(hcd);
  1232. if (status == 0) {
  1233. /* TRSMRCY = 10 msec */
  1234. msleep(10);
  1235. usb_set_device_state(rhdev, rhdev->actconfig
  1236. ? USB_STATE_CONFIGURED
  1237. : USB_STATE_ADDRESS);
  1238. hcd->state = HC_STATE_RUNNING;
  1239. } else {
  1240. hcd->state = old_state;
  1241. dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
  1242. "resume", status);
  1243. if (status != -ESHUTDOWN)
  1244. usb_hc_died(hcd);
  1245. }
  1246. return status;
  1247. }
  1248. /* Workqueue routine for root-hub remote wakeup */
  1249. static void hcd_resume_work(struct work_struct *work)
  1250. {
  1251. struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
  1252. struct usb_device *udev = hcd->self.root_hub;
  1253. usb_lock_device(udev);
  1254. usb_mark_last_busy(udev);
  1255. usb_external_resume_device(udev);
  1256. usb_unlock_device(udev);
  1257. }
  1258. /**
  1259. * usb_hcd_resume_root_hub - called by HCD to resume its root hub
  1260. * @hcd: host controller for this root hub
  1261. *
  1262. * The USB host controller calls this function when its root hub is
  1263. * suspended (with the remote wakeup feature enabled) and a remote
  1264. * wakeup request is received. The routine submits a workqueue request
  1265. * to resume the root hub (that is, manage its downstream ports again).
  1266. */
  1267. void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
  1268. {
  1269. unsigned long flags;
  1270. spin_lock_irqsave (&hcd_root_hub_lock, flags);
  1271. if (hcd->rh_registered)
  1272. queue_work(ksuspend_usb_wq, &hcd->wakeup_work);
  1273. spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
  1274. }
  1275. EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
  1276. #endif
  1277. /*-------------------------------------------------------------------------*/
  1278. #ifdef CONFIG_USB_OTG
  1279. /**
  1280. * usb_bus_start_enum - start immediate enumeration (for OTG)
  1281. * @bus: the bus (must use hcd framework)
  1282. * @port_num: 1-based number of port; usually bus->otg_port
  1283. * Context: in_interrupt()
  1284. *
  1285. * Starts enumeration, with an immediate reset followed later by
  1286. * khubd identifying and possibly configuring the device.
  1287. * This is needed by OTG controller drivers, where it helps meet
  1288. * HNP protocol timing requirements for starting a port reset.
  1289. */
  1290. int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num)
  1291. {
  1292. struct usb_hcd *hcd;
  1293. int status = -EOPNOTSUPP;
  1294. /* NOTE: since HNP can't start by grabbing the bus's address0_sem,
  1295. * boards with root hubs hooked up to internal devices (instead of
  1296. * just the OTG port) may need more attention to resetting...
  1297. */
  1298. hcd = container_of (bus, struct usb_hcd, self);
  1299. if (port_num && hcd->driver->start_port_reset)
  1300. status = hcd->driver->start_port_reset(hcd, port_num);
  1301. /* run khubd shortly after (first) root port reset finishes;
  1302. * it may issue others, until at least 50 msecs have passed.
  1303. */
  1304. if (status == 0)
  1305. mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(10));
  1306. return status;
  1307. }
  1308. EXPORT_SYMBOL (usb_bus_start_enum);
  1309. #endif
  1310. /*-------------------------------------------------------------------------*/
  1311. /**
  1312. * usb_hcd_irq - hook IRQs to HCD framework (bus glue)
  1313. * @irq: the IRQ being raised
  1314. * @__hcd: pointer to the HCD whose IRQ is being signaled
  1315. * @r: saved hardware registers
  1316. *
  1317. * If the controller isn't HALTed, calls the driver's irq handler.
  1318. * Checks whether the controller is now dead.
  1319. */
  1320. irqreturn_t usb_hcd_irq (int irq, void *__hcd)
  1321. {
  1322. struct usb_hcd *hcd = __hcd;
  1323. int start = hcd->state;
  1324. if (unlikely(start == HC_STATE_HALT ||
  1325. !test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
  1326. return IRQ_NONE;
  1327. if (hcd->driver->irq (hcd) == IRQ_NONE)
  1328. return IRQ_NONE;
  1329. set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
  1330. if (unlikely(hcd->state == HC_STATE_HALT))
  1331. usb_hc_died (hcd);
  1332. return IRQ_HANDLED;
  1333. }
  1334. /*-------------------------------------------------------------------------*/
  1335. /**
  1336. * usb_hc_died - report abnormal shutdown of a host controller (bus glue)
  1337. * @hcd: pointer to the HCD representing the controller
  1338. *
  1339. * This is called by bus glue to report a USB host controller that died
  1340. * while operations may still have been pending. It's called automatically
  1341. * by the PCI glue, so only glue for non-PCI busses should need to call it.
  1342. */
  1343. void usb_hc_died (struct usb_hcd *hcd)
  1344. {
  1345. unsigned long flags;
  1346. dev_err (hcd->self.controller, "HC died; cleaning up\n");
  1347. spin_lock_irqsave (&hcd_root_hub_lock, flags);
  1348. if (hcd->rh_registered) {
  1349. hcd->poll_rh = 0;
  1350. /* make khubd clean up old urbs and devices */
  1351. usb_set_device_state (hcd->self.root_hub,
  1352. USB_STATE_NOTATTACHED);
  1353. usb_kick_khubd (hcd->self.root_hub);
  1354. }
  1355. spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
  1356. }
  1357. EXPORT_SYMBOL_GPL (usb_hc_died);
  1358. /*-------------------------------------------------------------------------*/
  1359. /**
  1360. * usb_create_hcd - create and initialize an HCD structure
  1361. * @driver: HC driver that will use this hcd
  1362. * @dev: device for this HC, stored in hcd->self.controller
  1363. * @bus_name: value to store in hcd->self.bus_name
  1364. * Context: !in_interrupt()
  1365. *
  1366. * Allocate a struct usb_hcd, with extra space at the end for the
  1367. * HC driver's private data. Initialize the generic members of the
  1368. * hcd structure.
  1369. *
  1370. * If memory is unavailable, returns NULL.
  1371. */
  1372. struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
  1373. struct device *dev, char *bus_name)
  1374. {
  1375. struct usb_hcd *hcd;
  1376. hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
  1377. if (!hcd) {
  1378. dev_dbg (dev, "hcd alloc failed\n");
  1379. return NULL;
  1380. }
  1381. dev_set_drvdata(dev, hcd);
  1382. kref_init(&hcd->kref);
  1383. usb_bus_init(&hcd->self);
  1384. hcd->self.controller = dev;
  1385. hcd->self.bus_name = bus_name;
  1386. hcd->self.uses_dma = (dev->dma_mask != NULL);
  1387. init_timer(&hcd->rh_timer);
  1388. hcd->rh_timer.function = rh_timer_func;
  1389. hcd->rh_timer.data = (unsigned long) hcd;
  1390. #ifdef CONFIG_PM
  1391. INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
  1392. #endif
  1393. hcd->driver = driver;
  1394. hcd->product_desc = (driver->product_desc) ? driver->product_desc :
  1395. "USB Host Controller";
  1396. return hcd;
  1397. }
  1398. EXPORT_SYMBOL (usb_create_hcd);
  1399. static void hcd_release (struct kref *kref)
  1400. {
  1401. struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);
  1402. kfree(hcd);
  1403. }
  1404. struct usb_hcd *usb_get_hcd (struct usb_hcd *hcd)
  1405. {
  1406. if (hcd)
  1407. kref_get (&hcd->kref);
  1408. return hcd;
  1409. }
  1410. EXPORT_SYMBOL (usb_get_hcd);
  1411. void usb_put_hcd (struct usb_hcd *hcd)
  1412. {
  1413. if (hcd)
  1414. kref_put (&hcd->kref, hcd_release);
  1415. }
  1416. EXPORT_SYMBOL (usb_put_hcd);
  1417. /**
  1418. * usb_add_hcd - finish generic HCD structure initialization and register
  1419. * @hcd: the usb_hcd structure to initialize
  1420. * @irqnum: Interrupt line to allocate
  1421. * @irqflags: Interrupt type flags
  1422. *
  1423. * Finish the remaining parts of generic HCD initialization: allocate the
  1424. * buffers of consistent memory, register the bus, request the IRQ line,
  1425. * and call the driver's reset() and start() routines.
  1426. */
  1427. int usb_add_hcd(struct usb_hcd *hcd,
  1428. unsigned int irqnum, unsigned long irqflags)
  1429. {
  1430. int retval;
  1431. struct usb_device *rhdev;
  1432. dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
  1433. hcd->authorized_default = hcd->wireless? 0 : 1;
  1434. set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
  1435. /* HC is in reset state, but accessible. Now do the one-time init,
  1436. * bottom up so that hcds can customize the root hubs before khubd
  1437. * starts talking to them. (Note, bus id is assigned early too.)
  1438. */
  1439. if ((retval = hcd_buffer_create(hcd)) != 0) {
  1440. dev_dbg(hcd->self.controller, "pool alloc failed\n");
  1441. return retval;
  1442. }
  1443. if ((retval = usb_register_bus(&hcd->self)) < 0)
  1444. goto err_register_bus;
  1445. if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) {
  1446. dev_err(hcd->self.controller, "unable to allocate root hub\n");
  1447. retval = -ENOMEM;
  1448. goto err_allocate_root_hub;
  1449. }
  1450. rhdev->speed = (hcd->driver->flags & HCD_USB2) ? USB_SPEED_HIGH :
  1451. USB_SPEED_FULL;
  1452. hcd->self.root_hub = rhdev;
  1453. /* wakeup flag init defaults to "everything works" for root hubs,
  1454. * but drivers can override it in reset() if needed, along with
  1455. * recording the overall controller's system wakeup capability.
  1456. */
  1457. device_init_wakeup(&rhdev->dev, 1);
  1458. /* "reset" is misnamed; its role is now one-time init. the controller
  1459. * should already have been reset (and boot firmware kicked off etc).
  1460. */
  1461. if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {
  1462. dev_err(hcd->self.controller, "can't setup\n");
  1463. goto err_hcd_driver_setup;
  1464. }
  1465. /* NOTE: root hub and controller capabilities may not be the same */
  1466. if (device_can_wakeup(hcd->self.controller)
  1467. && device_can_wakeup(&hcd->self.root_hub->dev))
  1468. dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
  1469. /* enable irqs just before we start the controller */
  1470. if (hcd->driver->irq) {
  1471. snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
  1472. hcd->driver->description, hcd->self.busnum);
  1473. if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
  1474. hcd->irq_descr, hcd)) != 0) {
  1475. dev_err(hcd->self.controller,
  1476. "request interrupt %d failed\n", irqnum);
  1477. goto err_request_irq;
  1478. }
  1479. hcd->irq = irqnum;
  1480. dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
  1481. (hcd->driver->flags & HCD_MEMORY) ?
  1482. "io mem" : "io base",
  1483. (unsigned long long)hcd->rsrc_start);
  1484. } else {
  1485. hcd->irq = -1;
  1486. if (hcd->rsrc_start)
  1487. dev_info(hcd->self.controller, "%s 0x%08llx\n",
  1488. (hcd->driver->flags & HCD_MEMORY) ?
  1489. "io mem" : "io base",
  1490. (unsigned long long)hcd->rsrc_start);
  1491. }
  1492. if ((retval = hcd->driver->start(hcd)) < 0) {
  1493. dev_err(hcd->self.controller, "startup error %d\n", retval);
  1494. goto err_hcd_driver_start;
  1495. }
  1496. /* starting here, usbcore will pay attention to this root hub */
  1497. rhdev->bus_mA = min(500u, hcd->power_budget);
  1498. if ((retval = register_root_hub(hcd)) != 0)
  1499. goto err_register_root_hub;
  1500. retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
  1501. if (retval < 0) {
  1502. printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
  1503. retval);
  1504. goto error_create_attr_group;
  1505. }
  1506. if (hcd->uses_new_polling && hcd->poll_rh)
  1507. usb_hcd_poll_rh_status(hcd);
  1508. return retval;
  1509. error_create_attr_group:
  1510. mutex_lock(&usb_bus_list_lock);
  1511. usb_disconnect(&hcd->self.root_hub);
  1512. mutex_unlock(&usb_bus_list_lock);
  1513. err_register_root_hub:
  1514. hcd->driver->stop(hcd);
  1515. err_hcd_driver_start:
  1516. if (hcd->irq >= 0)
  1517. free_irq(irqnum, hcd);
  1518. err_request_irq:
  1519. err_hcd_driver_setup:
  1520. hcd->self.root_hub = NULL;
  1521. usb_put_dev(rhdev);
  1522. err_allocate_root_hub:
  1523. usb_deregister_bus(&hcd->self);
  1524. err_register_bus:
  1525. hcd_buffer_destroy(hcd);
  1526. return retval;
  1527. }
  1528. EXPORT_SYMBOL (usb_add_hcd);
  1529. /**
  1530. * usb_remove_hcd - shutdown processing for generic HCDs
  1531. * @hcd: the usb_hcd structure to remove
  1532. * Context: !in_interrupt()
  1533. *
  1534. * Disconnects the root hub, then reverses the effects of usb_add_hcd(),
  1535. * invoking the HCD's stop() method.
  1536. */
  1537. void usb_remove_hcd(struct usb_hcd *hcd)
  1538. {
  1539. dev_info(hcd->self.controller, "remove, state %x\n", hcd->state);
  1540. if (HC_IS_RUNNING (hcd->state))
  1541. hcd->state = HC_STATE_QUIESCING;
  1542. dev_dbg(hcd->self.controller, "roothub graceful disconnect\n");
  1543. spin_lock_irq (&hcd_root_hub_lock);
  1544. hcd->rh_registered = 0;
  1545. spin_unlock_irq (&hcd_root_hub_lock);
  1546. #ifdef CONFIG_PM
  1547. cancel_work_sync(&hcd->wakeup_work);
  1548. #endif
  1549. sysfs_remove_group(&hcd->self.root_hub->dev.kobj, &usb_bus_attr_group);
  1550. mutex_lock(&usb_bus_list_lock);
  1551. usb_disconnect(&hcd->self.root_hub);
  1552. mutex_unlock(&usb_bus_list_lock);
  1553. hcd->driver->stop(hcd);
  1554. hcd->state = HC_STATE_HALT;
  1555. hcd->poll_rh = 0;
  1556. del_timer_sync(&hcd->rh_timer);
  1557. if (hcd->irq >= 0)
  1558. free_irq(hcd->irq, hcd);
  1559. usb_deregister_bus(&hcd->self);
  1560. hcd_buffer_destroy(hcd);
  1561. }
  1562. EXPORT_SYMBOL (usb_remove_hcd);
  1563. void
  1564. usb_hcd_platform_shutdown(struct platform_device* dev)
  1565. {
  1566. struct usb_hcd *hcd = platform_get_drvdata(dev);
  1567. if (hcd->driver->shutdown)
  1568. hcd->driver->shutdown(hcd);
  1569. }
  1570. EXPORT_SYMBOL (usb_hcd_platform_shutdown);
  1571. /*-------------------------------------------------------------------------*/
  1572. #if defined(CONFIG_USB_MON)
  1573. struct usb_mon_operations *mon_ops;
  1574. /*
  1575. * The registration is unlocked.
  1576. * We do it this way because we do not want to lock in hot paths.
  1577. *
  1578. * Notice that the code is minimally error-proof. Because usbmon needs
  1579. * symbols from usbcore, usbcore gets referenced and cannot be unloaded first.
  1580. */
  1581. int usb_mon_register (struct usb_mon_operations *ops)
  1582. {
  1583. if (mon_ops)
  1584. return -EBUSY;
  1585. mon_ops = ops;
  1586. mb();
  1587. return 0;
  1588. }
  1589. EXPORT_SYMBOL_GPL (usb_mon_register);
  1590. void usb_mon_deregister (void)
  1591. {
  1592. if (mon_ops == NULL) {
  1593. printk(KERN_ERR "USB: monitor was not registered\n");
  1594. return;
  1595. }
  1596. mon_ops = NULL;
  1597. mb();
  1598. }
  1599. EXPORT_SYMBOL_GPL (usb_mon_deregister);
  1600. #endif /* CONFIG_USB_MON */