开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
hcd.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：40k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

hcd.c：源码内容
  1. /*
  2.  * Copyright (c) 2001-2002 by David Brownell
  3.  * 
  4.  * This program is free software; you can redistribute it and/or modify it
  5.  * under the terms of the GNU General Public License as published by the
  6.  * Free Software Foundation; either version 2 of the License, or (at your
  7.  * option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful, but
  10.  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11.  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12.  * for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software Foundation,
  16.  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  */
  19. #include <linux/config.h>
  20. #include <linux/module.h>
  21. #include <linux/pci.h>
  22. #include <linux/kernel.h>
  23. #include <linux/delay.h>
  24. #include <linux/ioport.h>
  25. #include <linux/sched.h>
  26. #include <linux/slab.h>
  27. #include <linux/smp_lock.h>
  28. #include <linux/errno.h>
  29. #include <linux/kmod.h>
  30. #include <linux/init.h>
  31. #include <linux/timer.h>
  32. #include <linux/list.h>
  33. #include <linux/interrupt.h>
  34. #include <linux/completion.h>
  35. #include <linux/uts.h> /* for UTS_SYSNAME */
  38. #ifdef CONFIG_USB_DEBUG
  39. #define DEBUG
  40. #else
  41. #undef DEBUG
  42. #endif
  44. #include <linux/usb.h>
  45. #include "hcd.h"
  47. #include <asm/io.h>
  48. #include <asm/irq.h>
  49. #include <asm/system.h>
  50. #include <asm/unaligned.h>
  53. /*-------------------------------------------------------------------------*/
  55. /*
  56.  * USB Host Controller Driver framework
  57.  *
  58.  * Plugs into usbcore (usb_bus) and lets HCDs share code, minimizing
  59.  * HCD-specific behaviors/bugs.  Think of it as the "upper level" of
  60.  * some drivers, where the "lower level" is hardware-specific.
  61.  *
  62.  * This does error checks, tracks devices and urbs, and delegates to a
  63.  * "hc_driver" only for code (and data) that really needs to know about
  64.  * hardware differences.  That includes root hub registers, i/o queues,
  65.  * and so on ... but as little else as possible.
  66.  *
  67.  * Shared code includes most of the "root hub" code (these are emulated,
  68.  * though each HC's hardware works differently) and PCI glue, plus request
  69.  * tracking overhead.  The HCD code should only block on spinlocks or on
  70.  * hardware handshaking; blocking on software events (such as other kernel
  71.  * threads releasing resources, or completing actions) is all generic.
  72.  *
  73.  * Happens the USB 2.0 spec says this would be invisible inside the "USBD",
  74.  * and includes mostly a "HCDI" (HCD Interface) along with some APIs used
  75.  * only by the hub driver ... and that neither should be seen or used by
  76.  * usb client device drivers.
  77.  *
  78.  * Contributors of ideas or unattributed patches include: David Brownell,
  79.  * Roman Weissgaerber, Rory Bolt, ...
  80.  *
  81.  * HISTORY:
  82.  * 2002-sept Merge some 2.5 updates so we can share hardware level HCD
  83.  *  code between the 2.4.20+ and 2.5 trees.
  84.  * 2002-feb merge to 2.4.19
  85.  * 2001-12-12 Initial patch version for Linux 2.5.1 kernel.
  86.  */
  88. /*-------------------------------------------------------------------------*/
  90. /* host controllers we manage */
  91. static LIST_HEAD (hcd_list);
  93. /* used when updating list of hcds */
  94. static DECLARE_MUTEX (hcd_list_lock);
  96. /* used when updating hcd data */
  97. static spinlock_t hcd_data_lock = SPIN_LOCK_UNLOCKED;
  99. static struct usb_operations hcd_operations;
  101. /*-------------------------------------------------------------------------*/
  103. /*
  104.  * Sharable chunks of root hub code.
  105.  */
  107. /*-------------------------------------------------------------------------*/
  109. #define KERNEL_REL ((LINUX_VERSION_CODE >> 16) & 0x0ff)
  110. #define KERNEL_VER ((LINUX_VERSION_CODE >> 8) & 0x0ff)
  112. /* usb 2.0 root hub device descriptor */
  113. static const u8 usb2_rh_dev_descriptor [18] = {
  114. 0x12,       /*  __u8  bLength; */
  115. 0x01,       /*  __u8  bDescriptorType; Device */
  116. 0x00, 0x02, /*  __u16 bcdUSB; v2.0 */
  118. 0x09,     /*  __u8  bDeviceClass; HUB_CLASSCODE */
  119. 0x00,     /*  __u8  bDeviceSubClass; */
  120. 0x01,       /*  __u8  bDeviceProtocol; [ usb 2.0 single TT ]*/
  121. 0x08,       /*  __u8  bMaxPacketSize0; 8 Bytes */
  123. 0x00, 0x00, /*  __u16 idVendor; */
  124.   0x00, 0x00, /*  __u16 idProduct; */
  125. KERNEL_VER, KERNEL_REL, /*  __u16 bcdDevice */
  127. 0x03,       /*  __u8  iManufacturer; */
  128. 0x02,       /*  __u8  iProduct; */
  129. 0x01,       /*  __u8  iSerialNumber; */
  130. 0x01        /*  __u8  bNumConfigurations; */
  131. };
  133. /* no usb 2.0 root hub "device qualifier" descriptor: one speed only */
  135. /* usb 1.1 root hub device descriptor */
  136. static const u8 usb11_rh_dev_descriptor [18] = {
  137. 0x12,       /*  __u8  bLength; */
  138. 0x01,       /*  __u8  bDescriptorType; Device */
  139. 0x10, 0x01, /*  __u16 bcdUSB; v1.1 */
  141. 0x09,     /*  __u8  bDeviceClass; HUB_CLASSCODE */
  142. 0x00,     /*  __u8  bDeviceSubClass; */
  143. 0x00,       /*  __u8  bDeviceProtocol; [ low/full speeds only ] */
  144. 0x08,       /*  __u8  bMaxPacketSize0; 8 Bytes */
  146. 0x00, 0x00, /*  __u16 idVendor; */
  147.   0x00, 0x00, /*  __u16 idProduct; */
  148. KERNEL_VER, KERNEL_REL, /*  __u16 bcdDevice */
  150. 0x03,       /*  __u8  iManufacturer; */
  151. 0x02,       /*  __u8  iProduct; */
  152. 0x01,       /*  __u8  iSerialNumber; */
  153. 0x01        /*  __u8  bNumConfigurations; */
  154. };
  157. /*-------------------------------------------------------------------------*/
  159. /* Configuration descriptors for our root hubs */
  161. static const u8 fs_rh_config_descriptor [] = {
  163. /* one configuration */
  164. 0x09,       /*  __u8  bLength; */
  165. 0x02,       /*  __u8  bDescriptorType; Configuration */
  166. 0x19, 0x00, /*  __u16 wTotalLength; */
  167. 0x01,       /*  __u8  bNumInterfaces; (1) */
  168. 0x01,       /*  __u8  bConfigurationValue; */
  169. 0x00,       /*  __u8  iConfiguration; */
  170. 0x40,       /*  __u8  bmAttributes; 
  171.  Bit 7: Bus-powered,
  172.      6: Self-powered,
  173.      5 Remote-wakwup,
  174.      4..0: resvd */
  175. 0x00,       /*  __u8  MaxPower; */
  176.       
  177. /* USB 1.1:
  178.  * USB 2.0, single TT organization (mandatory):
  179.  * one interface, protocol 0
  180.  *
  181.  * USB 2.0, multiple TT organization (optional):
  182.  * two interfaces, protocols 1 (like single TT)
  183.  * and 2 (multiple TT mode) ... config is
  184.  * sometimes settable
  185.  * NOT IMPLEMENTED
  186.  */
  188. /* one interface */
  189. 0x09,       /*  __u8  if_bLength; */
  190. 0x04,       /*  __u8  if_bDescriptorType; Interface */
  191. 0x00,       /*  __u8  if_bInterfaceNumber; */
  192. 0x00,       /*  __u8  if_bAlternateSetting; */
  193. 0x01,       /*  __u8  if_bNumEndpoints; */
  194. 0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
  195. 0x00,       /*  __u8  if_bInterfaceSubClass; */
  196. 0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
  197. 0x00,       /*  __u8  if_iInterface; */
  198.      
  199. /* one endpoint (status change endpoint) */
  200. 0x07,       /*  __u8  ep_bLength; */
  201. 0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
  202. 0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
  203.   0x03,       /*  __u8  ep_bmAttributes; Interrupt */
  204.   0x02, 0x00, /*  __u16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
  205. 0xff        /*  __u8  ep_bInterval; (255ms -- usb 2.0 spec) */
  206. };
  208. static const u8 hs_rh_config_descriptor [] = {
  210. /* one configuration */
  211. 0x09,       /*  __u8  bLength; */
  212. 0x02,       /*  __u8  bDescriptorType; Configuration */
  213. 0x19, 0x00, /*  __u16 wTotalLength; */
  214. 0x01,       /*  __u8  bNumInterfaces; (1) */
  215. 0x01,       /*  __u8  bConfigurationValue; */
  216. 0x00,       /*  __u8  iConfiguration; */
  217. 0x40,       /*  __u8  bmAttributes; 
  218.  Bit 7: Bus-powered,
  219.      6: Self-powered,
  220.      5 Remote-wakwup,
  221.      4..0: resvd */
  222. 0x00,       /*  __u8  MaxPower; */
  223.       
  224. /* USB 1.1:
  225.  * USB 2.0, single TT organization (mandatory):
  226.  * one interface, protocol 0
  227.  *
  228.  * USB 2.0, multiple TT organization (optional):
  229.  * two interfaces, protocols 1 (like single TT)
  230.  * and 2 (multiple TT mode) ... config is
  231.  * sometimes settable
  232.  * NOT IMPLEMENTED
  233.  */
  235. /* one interface */
  236. 0x09,       /*  __u8  if_bLength; */
  237. 0x04,       /*  __u8  if_bDescriptorType; Interface */
  238. 0x00,       /*  __u8  if_bInterfaceNumber; */
  239. 0x00,       /*  __u8  if_bAlternateSetting; */
  240. 0x01,       /*  __u8  if_bNumEndpoints; */
  241. 0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
  242. 0x00,       /*  __u8  if_bInterfaceSubClass; */
  243. 0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
  244. 0x00,       /*  __u8  if_iInterface; */
  245.      
  246. /* one endpoint (status change endpoint) */
  247. 0x07,       /*  __u8  ep_bLength; */
  248. 0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
  249. 0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
  250.   0x03,       /*  __u8  ep_bmAttributes; Interrupt */
  251.   0x02, 0x00, /*  __u16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
  252. 0x0c        /*  __u8  ep_bInterval; (256ms -- usb 2.0 spec) */
  253. };
  255. /*-------------------------------------------------------------------------*/
  257. /*
  258.  * helper routine for returning string descriptors in UTF-16LE
  259.  * input can actually be ISO-8859-1; ASCII is its 7-bit subset
  260.  */
  261. static int ascii2utf (char *s, u8 *utf, int utfmax)
  262. {
  263. int retval;
  265. for (retval = 0; *s && utfmax > 1; utfmax -= 2, retval += 2) {
  266. *utf++ = *s++;
  267. *utf++ = 0;
  268. }
  269. return retval;
  270. }
  272. /*
  273.  * rh_string - provides manufacturer, product and serial strings for root hub
  274.  * @id: the string ID number (1: serial number, 2: product, 3: vendor)
  275.  * @pci_desc: PCI device descriptor for the relevant HC
  276.  * @type: string describing our driver 
  277.  * @data: return packet in UTF-16 LE
  278.  * @len: length of the return packet
  279.  *
  280.  * Produces either a manufacturer, product or serial number string for the
  281.  * virtual root hub device.
  282.  */
  283. static int rh_string (
  284. int id,
  285. struct usb_hcd *hcd,
  286. u8 *data,
  287. int len
  288. ) {
  289. char buf [100];
  291. // language ids
  292. if (id == 0) {
  293. *data++ = 4; *data++ = 3; /* 4 bytes string data */
  294. *data++ = 0; *data++ = 0; /* some language id */
  295. return 4;
  297. // serial number
  298. } else if (id == 1) {
  299. strcpy (buf, hcd->bus_name);
  301. // product description
  302. } else if (id == 2) {
  303.                 strcpy (buf, hcd->product_desc);
  305.   // id 3 == vendor description
  306. } else if (id == 3) {
  307.                 sprintf (buf, "%s %s %s", UTS_SYSNAME, UTS_RELEASE,
  308. hcd->description);
  310. // unsupported IDs --> "protocol stall"
  311. } else
  312.     return 0;
  314. data [0] = 2 + ascii2utf (buf, data + 2, len - 2);
  315. data [1] = 3; /* type == string */
  316. return data [0];
  317. }
  320. /* Root hub control transfers execute synchronously */
  321. static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
  322. {
  323. struct usb_ctrlrequest *cmd = (struct usb_ctrlrequest *) urb->setup_packet;
  324.   u16 typeReq, wValue, wIndex, wLength;
  325. const u8 *bufp = 0;
  326. u8 *ubuf = urb->transfer_buffer;
  327. int len = 0;
  329. typeReq  = (cmd->bRequestType << 8) | cmd->bRequest;
  330. wValue   = le16_to_cpu (cmd->wValue);
  331. wIndex   = le16_to_cpu (cmd->wIndex);
  332. wLength  = le16_to_cpu (cmd->wLength);
  334. if (wLength > urb->transfer_buffer_length)
  335. goto error;
  337. /* set up for success */
  338. urb->status = 0;
  339. urb->actual_length = wLength;
  340. switch (typeReq) {
  342. /* DEVICE REQUESTS */
  344. case DeviceRequest | USB_REQ_GET_STATUS:
  345. // DEVICE_REMOTE_WAKEUP
  346. ubuf [0] = 1; // selfpowered
  347. ubuf [1] = 0;
  348. /* FALLTHROUGH */
  349. case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
  350. case DeviceOutRequest | USB_REQ_SET_FEATURE:
  351. dbg ("no device features yet yet");
  352. break;
  353. case DeviceRequest | USB_REQ_GET_CONFIGURATION:
  354. ubuf [0] = 1;
  355. /* FALLTHROUGH */
  356. case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
  357. break;
  358. case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
  359. switch (wValue & 0xff00) {
  360. case USB_DT_DEVICE << 8:
  361. if (hcd->driver->flags & HCD_USB2)
  362. bufp = usb2_rh_dev_descriptor;
  363. else if (hcd->driver->flags & HCD_USB11)
  364. bufp = usb11_rh_dev_descriptor;
  365. else
  366. goto error;
  367. len = 18;
  368. break;
  369. case USB_DT_CONFIG << 8:
  370. if (hcd->driver->flags & HCD_USB2) {
  371. bufp = hs_rh_config_descriptor;
  372. len = sizeof hs_rh_config_descriptor;
  373. } else {
  374. bufp = fs_rh_config_descriptor;
  375. len = sizeof fs_rh_config_descriptor;
  376. }
  377. break;
  378. case USB_DT_STRING << 8:
  379. urb->actual_length = rh_string (
  380. wValue & 0xff, hcd,
  381. ubuf, wLength);
  382. break;
  383. default:
  384. goto error;
  385. }
  386. break;
  387. case DeviceRequest | USB_REQ_GET_INTERFACE:
  388. ubuf [0] = 0;
  389. /* FALLTHROUGH */
  390. case DeviceOutRequest | USB_REQ_SET_INTERFACE:
  391. break;
  392. case DeviceOutRequest | USB_REQ_SET_ADDRESS:
  393. // wValue == urb->dev->devaddr
  394. dbg ("%s root hub device address %d",
  395. hcd->bus_name, wValue);
  396. break;
  398. /* INTERFACE REQUESTS (no defined feature/status flags) */
  400. /* ENDPOINT REQUESTS */
  402. case EndpointRequest | USB_REQ_GET_STATUS:
  403. // ENDPOINT_HALT flag
  404. ubuf [0] = 0;
  405. ubuf [1] = 0;
  406. /* FALLTHROUGH */
  407. case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
  408. case EndpointOutRequest | USB_REQ_SET_FEATURE:
  409. dbg ("no endpoint features yet");
  410. break;
  412. /* CLASS REQUESTS (and errors) */
  414. default:
  415. /* non-generic request */
  416. urb->status = hcd->driver->hub_control (hcd,
  417. typeReq, wValue, wIndex,
  418. ubuf, wLength);
  419. break;
  420. error:
  421. /* "protocol stall" on error */
  422. urb->status = -EPIPE;
  423. dbg ("unsupported hub control message (maxchild %d)",
  424. urb->dev->maxchild);
  425. }
  426. if (urb->status) {
  427. urb->actual_length = 0;
  428. dbg ("CTRL: TypeReq=0x%x val=0x%x idx=0x%x len=%d ==> %d",
  429. typeReq, wValue, wIndex, wLength, urb->status);
  430. }
  431. if (bufp) {
  432. if (urb->transfer_buffer_length < len)
  433. len = urb->transfer_buffer_length;
  434. urb->actual_length = len;
  435. // always USB_DIR_IN, toward host
  436. memcpy (ubuf, bufp, len);
  437. }
  439. /* any errors get returned through the urb completion */
  440. usb_hcd_giveback_urb (hcd, urb);
  441. return 0;
  442. }
  444. /*-------------------------------------------------------------------------*/
  446. /*
  447.  * Root Hub interrupt transfers are synthesized with a timer.
  448.  * Completions are called in_interrupt() but not in_irq().
  449.  */
  451. static void rh_report_status (unsigned long ptr);
  453. static int rh_status_urb (struct usb_hcd *hcd, struct urb *urb) 
  454. {
  455. int len = 1 + (urb->dev->maxchild / 8);
  457. /* rh_timer protected by hcd_data_lock */
  458. if (timer_pending (&hcd->rh_timer)
  459. || urb->status != -EINPROGRESS
  460. || !HCD_IS_RUNNING (hcd->state)
  461. || urb->transfer_buffer_length < len) {
  462. dbg ("not queuing status urb, stat %d", urb->status);
  463. return -EINVAL;
  464. }
  466. urb->hcpriv = hcd; /* nonzero to indicate it's queued */
  467. init_timer (&hcd->rh_timer);
  468. hcd->rh_timer.function = rh_report_status;
  469. hcd->rh_timer.data = (unsigned long) urb;
  470. /* USB 2.0 spec says 256msec; this is close enough */
  471. hcd->rh_timer.expires = jiffies + HZ/4;
  472. add_timer (&hcd->rh_timer);
  473. return 0;
  474. }
  476. /* timer callback */
  478. static void rh_report_status (unsigned long ptr)
  479. {
  480. struct urb *urb;
  481. struct usb_hcd *hcd;
  482. int length;
  483. unsigned long flags;
  485. urb = (struct urb *) ptr;
  486. spin_lock_irqsave (&urb->lock, flags);
  487. if (!urb->dev) {
  488. spin_unlock_irqrestore (&urb->lock, flags);
  489. return;
  490. }
  492. hcd = urb->dev->bus->hcpriv;
  493. if (urb->status == -EINPROGRESS) {
  494. if (HCD_IS_RUNNING (hcd->state)) {
  495. length = hcd->driver->hub_status_data (hcd,
  496. urb->transfer_buffer);
  497. spin_unlock_irqrestore (&urb->lock, flags);
  498. if (length > 0) {
  499. urb->actual_length = length;
  500. urb->status = 0;
  501. urb->complete (urb);
  502. }
  503. spin_lock_irqsave (&hcd_data_lock, flags);
  504. urb->status = -EINPROGRESS;
  505. if (HCD_IS_RUNNING (hcd->state)
  506. && rh_status_urb (hcd, urb) != 0) {
  507. /* another driver snuck in? */
  508. dbg ("%s, can't resubmit roothub status urb?",
  509. hcd->bus_name);
  510. spin_unlock_irqrestore (&hcd_data_lock, flags);
  511. BUG ();
  512. }
  513. spin_unlock_irqrestore (&hcd_data_lock, flags);
  514. } else
  515. spin_unlock_irqrestore (&urb->lock, flags);
  516. } else {
  517. /* this urb's been unlinked */
  518. urb->hcpriv = 0;
  519. spin_unlock_irqrestore (&urb->lock, flags);
  521. usb_hcd_giveback_urb (hcd, urb);
  522. }
  523. }
  525. /*-------------------------------------------------------------------------*/
  527. static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
  528. {
  529. if (usb_pipeint (urb->pipe)) {
  530. int retval;
  531. unsigned long flags;
  533. spin_lock_irqsave (&hcd_data_lock, flags);
  534. retval = rh_status_urb (hcd, urb);
  535. spin_unlock_irqrestore (&hcd_data_lock, flags);
  536. return retval;
  537. }
  538. if (usb_pipecontrol (urb->pipe))
  539. return rh_call_control (hcd, urb);
  540. else
  541. return -EINVAL;
  542. }
  544. /*-------------------------------------------------------------------------*/
  546. static void rh_status_dequeue (struct usb_hcd *hcd, struct urb *urb)
  547. {
  548. unsigned long flags;
  550. spin_lock_irqsave (&hcd_data_lock, flags);
  551. del_timer_sync (&hcd->rh_timer);
  552. hcd->rh_timer.data = 0;
  553. spin_unlock_irqrestore (&hcd_data_lock, flags);
  555. /* we rely on RH callback code not unlinking its URB! */
  556. usb_hcd_giveback_urb (hcd, urb);
  557. }
  559. /*-------------------------------------------------------------------------*/
  561. #ifdef CONFIG_PCI
  563. /* PCI-based HCs are normal, but custom bus glue should be ok */
  565. static void hcd_irq (int irq, void *__hcd, struct pt_regs *r);
  566. static void hc_died (struct usb_hcd *hcd);
  568. /*-------------------------------------------------------------------------*/
  570. /* configure so an HC device and id are always provided */
  571. /* always called with process context; sleeping is OK */
  573. /**
  574.  * usb_hcd_pci_probe - initialize PCI-based HCDs
  575.  * @dev: USB Host Controller being probed
  576.  * @id: pci hotplug id connecting controller to HCD framework
  577.  * Context: !in_interrupt()
  578.  *
  579.  * Allocates basic PCI resources for this USB host controller, and
  580.  * then invokes the start() method for the HCD associated with it
  581.  * through the hotplug entry's driver_data.
  582.  *
  583.  * Store this function in the HCD's struct pci_driver as probe().
  584.  */
  585. int usb_hcd_pci_probe (struct pci_dev *dev, const struct pci_device_id *id)
  586. {
  587. struct hc_driver *driver;
  588. unsigned long resource, len;
  589. void *base;
  590. struct usb_bus *bus;
  591. struct usb_hcd *hcd;
  592. int retval, region;
  593. char buf [8], *bufp = buf;
  595. if (!id || !(driver = (struct hc_driver *) id->driver_data))
  596. return -EINVAL;
  598. if (pci_enable_device (dev) < 0)
  599. return -ENODEV;
  601.         if (!dev->irq) {
  602.          err ("Found HC with no IRQ.  Check BIOS/PCI %s setup!",
  603. dev->slot_name);
  604.             return -ENODEV;
  605.         }
  607. if (driver->flags & HCD_MEMORY) { // EHCI, OHCI
  608. region = 0;
  609. resource = pci_resource_start (dev, 0);
  610. len = pci_resource_len (dev, 0);
  611. if (!request_mem_region (resource, len, driver->description)) {
  612. dbg ("controller already in use");
  613. return -EBUSY;
  614. }
  615. base = ioremap_nocache (resource, len);
  616. if (base == NULL) {
  617. dbg ("error mapping memory");
  618. retval = -EFAULT;
  619. clean_1:
  620. release_mem_region (resource, len);
  621. err ("init %s fail, %d", dev->slot_name, retval);
  622. return retval;
  623. }
  625. } else {  // UHCI
  626. resource = len = 0;
  627. for (region = 0; region < PCI_ROM_RESOURCE; region++) {
  628. if (!(pci_resource_flags (dev, region) & IORESOURCE_IO))
  629. continue;
  631. resource = pci_resource_start (dev, region);
  632. len = pci_resource_len (dev, region);
  633. if (request_region (resource, len,
  634. driver->description))
  635. break;
  636. }
  637. if (region == PCI_ROM_RESOURCE) {
  638. dbg ("no i/o regions available");
  639. return -EBUSY;
  640. }
  641. base = (void *) resource;
  642. }
  644. // driver->start(), later on, will transfer device from
  645. // control by SMM/BIOS to control by Linux (if needed)
  647. pci_set_master (dev);
  648. hcd = driver->hcd_alloc ();
  649. if (hcd == NULL){
  650. dbg ("hcd alloc fail");
  651. retval = -ENOMEM;
  652. clean_2:
  653. if (driver->flags & HCD_MEMORY) {
  654. iounmap (base);
  655. goto clean_1;
  656. } else {
  657. release_region (resource, len);
  658. err ("init %s fail, %d", dev->slot_name, retval);
  659. return retval;
  660. }
  661. }
  662. pci_set_drvdata(dev, hcd);
  663. hcd->driver = driver;
  664. hcd->description = driver->description;
  665. hcd->pdev = dev;
  666. info ("%s @ %s, %s", hcd->description,  dev->slot_name, dev->name);
  668. #ifndef __sparc__
  669. sprintf (buf, "%d", dev->irq);
  670. #else
  671. bufp = __irq_itoa(dev->irq);
  672. #endif
  673. if (request_irq (dev->irq, hcd_irq, SA_SHIRQ, hcd->description, hcd)
  674. != 0) {
  675. err ("request interrupt %s failed", bufp);
  676. retval = -EBUSY;
  677. clean_3:
  678. driver->hcd_free (hcd);
  679. goto clean_2;
  680. }
  681. hcd->irq = dev->irq;
  683. hcd->regs = base;
  684. hcd->region = region;
  685. info ("irq %s, %s %p", bufp,
  686. (driver->flags & HCD_MEMORY) ? "pci mem" : "io base",
  687. base);
  689. // FIXME simpler: make "bus" be that data, not pointer to it.
  690. bus = usb_alloc_bus (&hcd_operations);
  691. if (bus == NULL) {
  692. dbg ("usb_alloc_bus fail");
  693. retval = -ENOMEM;
  694. free_irq (dev->irq, hcd);
  695. goto clean_3;
  696. }
  697. hcd->bus = bus;
  698. hcd->bus_name = dev->slot_name; /* prefer bus->bus_name */
  699. bus->bus_name = dev->slot_name;
  700. hcd->product_desc = dev->name;
  701. bus->hcpriv = (void *) hcd;
  703. INIT_LIST_HEAD (&hcd->dev_list);
  704. INIT_LIST_HEAD (&hcd->hcd_list);
  706. down (&hcd_list_lock);
  707. list_add (&hcd->hcd_list, &hcd_list);
  708. up (&hcd_list_lock);
  710. usb_register_bus (bus);
  712. if ((retval = driver->start (hcd)) < 0)
  713. usb_hcd_pci_remove (dev);
  715. return retval;
  716. } 
  717. EXPORT_SYMBOL (usb_hcd_pci_probe);
  720. /* may be called without controller electrically present */
  721. /* may be called with controller, bus, and devices active */
  723. /**
  724.  * usb_hcd_pci_remove - shutdown processing for PCI-based HCDs
  725.  * @dev: USB Host Controller being removed
  726.  * Context: !in_interrupt()
  727.  *
  728.  * Reverses the effect of usb_hcd_pci_probe(), first invoking
  729.  * the HCD's stop() method.  It is always called from a thread
  730.  * context, normally "rmmod", "apmd", or something similar.
  731.  *
  732.  * Store this function in the HCD's struct pci_driver as remove().
  733.  */
  734. void usb_hcd_pci_remove (struct pci_dev *dev)
  735. {
  736. struct usb_hcd *hcd;
  737. struct usb_device *hub;
  739. hcd = pci_get_drvdata(dev);
  740. if (!hcd)
  741. return;
  742. info ("remove: %s, state %x", hcd->bus_name, hcd->state);
  744. if (in_interrupt ()) BUG ();
  746. hub = hcd->bus->root_hub;
  747. hcd->state = USB_STATE_QUIESCING;
  749. dbg ("%s: roothub graceful disconnect", hcd->bus_name);
  750. usb_disconnect (&hub);
  751. // usb_disconnect (&hcd->bus->root_hub);
  753. hcd->driver->stop (hcd);
  754. hcd->state = USB_STATE_HALT;
  756. free_irq (hcd->irq, hcd);
  757. if (hcd->driver->flags & HCD_MEMORY) {
  758. iounmap (hcd->regs);
  759. release_mem_region (pci_resource_start (dev, 0),
  760. pci_resource_len (dev, 0));
  761. } else {
  762. release_region (pci_resource_start (dev, hcd->region),
  763. pci_resource_len (dev, hcd->region));
  764. }
  766. down (&hcd_list_lock);
  767. list_del (&hcd->hcd_list);
  768. up (&hcd_list_lock);
  770. usb_deregister_bus (hcd->bus);
  771. usb_free_bus (hcd->bus);
  772. hcd->bus = NULL;
  774. hcd->driver->hcd_free (hcd);
  775. }
  776. EXPORT_SYMBOL (usb_hcd_pci_remove);
  779. #ifdef CONFIG_PM
  781. /*
  782.  * Some "sleep" power levels imply updating struct usb_driver
  783.  * to include a callback asking hcds to do their bit by checking
  784.  * if all the drivers can suspend.  Gets involved with remote wakeup.
  785.  *
  786.  * If there are pending urbs, then HCs will need to access memory,
  787.  * causing extra power drain.  New sleep()/wakeup() PM calls might
  788.  * be needed, beyond PCI suspend()/resume().  The root hub timer
  789.  * still be accessing memory though ...
  790.  *
  791.  * FIXME:  USB should have some power budgeting support working with
  792.  * all kinds of hubs.
  793.  *
  794.  * FIXME:  This assumes only D0->D3 suspend and D3->D0 resume.
  795.  * D1 and D2 states should do something, yes?
  796.  *
  797.  * FIXME:  Should provide generic enable_wake(), calling pci_enable_wake()
  798.  * for all supported states, so that USB remote wakeup can work for any
  799.  * devices that support it (and are connected via powered hubs).
  800.  *
  801.  * FIXME:  resume doesn't seem to work right any more...
  802.  */
  805. // 2.4 kernels have issued concurrent resumes (w/APM)
  806. // we defend against that error; PCI doesn't yet.
  808. /**
  809.  * usb_hcd_pci_suspend - power management suspend of a PCI-based HCD
  810.  * @dev: USB Host Controller being suspended
  811.  *
  812.  * Store this function in the HCD's struct pci_driver as suspend().
  813.  */
  814. int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state)
  815. {
  816. struct usb_hcd *hcd;
  817. int retval;
  819. hcd = pci_get_drvdata(dev);
  820. info ("suspend %s to state %d", hcd->bus_name, state);
  822. pci_save_state (dev, hcd->pci_state);
  824. // FIXME for all connected devices, leaf-to-root:
  825. // driver->suspend()
  826. // proposed "new 2.5 driver model" will automate that
  828. /* driver may want to disable DMA etc */
  829. retval = hcd->driver->suspend (hcd, state);
  830. hcd->state = USB_STATE_SUSPENDED;
  832.   pci_set_power_state (dev, state);
  833. return retval;
  834. }
  835. EXPORT_SYMBOL (usb_hcd_pci_suspend);
  837. /**
  838.  * usb_hcd_pci_resume - power management resume of a PCI-based HCD
  839.  * @dev: USB Host Controller being resumed
  840.  *
  841.  * Store this function in the HCD's struct pci_driver as resume().
  842.  */
  843. int usb_hcd_pci_resume (struct pci_dev *dev)
  844. {
  845. struct usb_hcd *hcd;
  846. int retval;
  848. hcd = pci_get_drvdata(dev);
  849. info ("resume %s", hcd->bus_name);
  851. /* guard against multiple resumes (APM bug?) */
  852. atomic_inc (&hcd->resume_count);
  853. if (atomic_read (&hcd->resume_count) != 1) {
  854. err ("concurrent PCI resumes for %s", hcd->bus_name);
  855. retval = 0;
  856. goto done;
  857. }
  859. retval = -EBUSY;
  860. if (hcd->state != USB_STATE_SUSPENDED) {
  861. dbg ("can't resume, not suspended!");
  862. goto done;
  863. }
  864. hcd->state = USB_STATE_RESUMING;
  866. pci_set_power_state (dev, 0);
  867. pci_restore_state (dev, hcd->pci_state);
  869. retval = hcd->driver->resume (hcd);
  870. if (!HCD_IS_RUNNING (hcd->state)) {
  871. dbg ("resume %s failure, retval %d", hcd->bus_name, retval);
  872. hc_died (hcd);
  873. // FIXME:  recover, reset etc.
  874. } else {
  875. // FIXME for all connected devices, root-to-leaf:
  876. // driver->resume ();
  877. // proposed "new 2.5 driver model" will automate that
  878. }
  880. done:
  881. atomic_dec (&hcd->resume_count);
  882. return retval;
  883. }
  884. EXPORT_SYMBOL (usb_hcd_pci_resume);
  886. #endif /* CONFIG_PM */
  888. #endif
  890. /*-------------------------------------------------------------------------*/
  892. /*
  893.  * Generic HC operations.
  894.  */
  896. /*-------------------------------------------------------------------------*/
  898. /* called from khubd, or root hub init threads for hcd-private init */
  899. static int hcd_alloc_dev (struct usb_device *udev)
  900. {
  901. struct hcd_dev *dev;
  902. struct usb_hcd *hcd;
  903. unsigned long flags;
  905. if (!udev || udev->hcpriv)
  906. return -EINVAL;
  907. if (!udev->bus || !udev->bus->hcpriv)
  908. return -ENODEV;
  909. hcd = udev->bus->hcpriv;
  910. if (hcd->state == USB_STATE_QUIESCING)
  911. return -ENOLINK;
  913. dev = (struct hcd_dev *) kmalloc (sizeof *dev, GFP_KERNEL);
  914. if (dev == NULL)
  915. return -ENOMEM;
  916. memset (dev, 0, sizeof *dev);
  918. INIT_LIST_HEAD (&dev->dev_list);
  919. INIT_LIST_HEAD (&dev->urb_list);
  921. spin_lock_irqsave (&hcd_data_lock, flags);
  922. list_add (&dev->dev_list, &hcd->dev_list);
  923. // refcount is implicit
  924. udev->hcpriv = dev;
  925. spin_unlock_irqrestore (&hcd_data_lock, flags);
  927. return 0;
  928. }
  930. /*-------------------------------------------------------------------------*/
  932. static void hc_died (struct usb_hcd *hcd)
  933. {
  934. struct list_head *devlist, *urblist;
  935. struct hcd_dev *dev;
  936. struct urb *urb;
  937. unsigned long flags;
  939. /* flag every pending urb as done */
  940. spin_lock_irqsave (&hcd_data_lock, flags);
  941. list_for_each (devlist, &hcd->dev_list) {
  942. dev = list_entry (devlist, struct hcd_dev, dev_list);
  943. list_for_each (urblist, &dev->urb_list) {
  944. urb = list_entry (urblist, struct urb, urb_list);
  945. dbg ("shutdown %s urb %p pipe %x, current status %d",
  946. hcd->bus_name, urb, urb->pipe, urb->status);
  947. if (urb->status == -EINPROGRESS)
  948. urb->status = -ESHUTDOWN;
  949. }
  950. }
  951. urb = (struct urb *) hcd->rh_timer.data;
  952. if (urb)
  953. urb->status = -ESHUTDOWN;
  954. spin_unlock_irqrestore (&hcd_data_lock, flags);
  956. if (urb)
  957. rh_status_dequeue (hcd, urb);
  958. hcd->driver->stop (hcd);
  959. }
  961. /*-------------------------------------------------------------------------*/
  963. static void urb_unlink (struct urb *urb)
  964. {
  965. unsigned long flags;
  966. struct usb_device *dev;
  968. /* Release any periodic transfer bandwidth */
  969. if (urb->bandwidth)
  970. usb_release_bandwidth (urb->dev, urb,
  971. usb_pipeisoc (urb->pipe));
  973. /* clear all state linking urb to this dev (and hcd) */
  975. spin_lock_irqsave (&hcd_data_lock, flags);
  976. list_del_init (&urb->urb_list);
  977. dev = urb->dev;
  978. urb->dev = NULL;
  979. usb_dec_dev_use (dev);
  980. spin_unlock_irqrestore (&hcd_data_lock, flags);
  981. }
  984. /* may be called in any context with a valid urb->dev usecount */
  985. /* caller surrenders "ownership" of urb */
  987. static int hcd_submit_urb (struct urb *urb)
  988. {
  989. int status;
  990. struct usb_hcd *hcd;
  991. struct hcd_dev *dev;
  992. unsigned long flags;
  993. int pipe, temp, max;
  994. int mem_flags;
  996. if (!urb || urb->hcpriv || !urb->complete)
  997. return -EINVAL;
  999. urb->status = -EINPROGRESS;
  1000. urb->actual_length = 0;
  1001. urb->bandwidth = 0;
  1002. INIT_LIST_HEAD (&urb->urb_list);
  1004. if (!urb->dev || !urb->dev->bus || urb->dev->devnum <= 0)
  1005. return -ENODEV;
  1006. hcd = urb->dev->bus->hcpriv;
  1007. dev = urb->dev->hcpriv;
  1008. if (!hcd || !dev)
  1009. return -ENODEV;
  1011. /* can't submit new urbs when quiescing, halted, ... */
  1012. if (hcd->state == USB_STATE_QUIESCING || !HCD_IS_RUNNING (hcd->state))
  1013. return -ESHUTDOWN;
  1014. pipe = urb->pipe;
  1015. temp = usb_pipetype (urb->pipe);
  1016. if (usb_endpoint_halted (urb->dev, usb_pipeendpoint (pipe),
  1017. usb_pipeout (pipe)))
  1018. return -EPIPE;
  1020. /* NOTE: 2.5 passes this value explicitly in submit() */
  1021. mem_flags = in_interrupt () ? GFP_ATOMIC : GFP_KERNEL;
  1023. /* FIXME there should be a sharable lock protecting us against
  1024.  * config/altsetting changes and disconnects, kicking in here.
  1025.  */
  1027. /* Sanity check, so HCDs can rely on clean data */
  1028. max = usb_maxpacket (urb->dev, pipe, usb_pipeout (pipe));
  1029. if (max <= 0) {
  1030. err ("bogus endpoint (bad maxpacket)");
  1031. return -EINVAL;
  1032. }
  1034. /* "high bandwidth" mode, 1-3 packets/uframe? */
  1035. if (urb->dev->speed == USB_SPEED_HIGH) {
  1036. int mult;
  1037. switch (temp) {
  1038. case PIPE_ISOCHRONOUS:
  1039. case PIPE_INTERRUPT:
  1040. mult = 1 + ((max >> 11) & 0x03);
  1041. max &= 0x03ff;
  1042. max *= mult;
  1043. }
  1044. }
  1046. /* periodic transfers limit size per frame/uframe */
  1047. switch (temp) {
  1048. case PIPE_ISOCHRONOUS: {
  1049. int n, len;
  1051. if (urb->number_of_packets <= 0)     
  1052. return -EINVAL;
  1053. for (n = 0; n < urb->number_of_packets; n++) {
  1054. len = urb->iso_frame_desc [n].length;
  1055. if (len < 0 || len > max) 
  1056. return -EINVAL;
  1057. }
  1059. }
  1060. break;
  1061. case PIPE_INTERRUPT:
  1062. if (urb->transfer_buffer_length > max)
  1063. return -EINVAL;
  1064. }
  1066. /* the I/O buffer must usually be mapped/unmapped */
  1067. if (urb->transfer_buffer_length < 0)
  1068. return -EINVAL;
  1070. // FIXME set urb->transfer_dma and/or setup_dma 
  1072. if (urb->next) {
  1073. warn ("use explicit queuing not urb->next");
  1074. return -EINVAL;
  1075. }
  1077. #ifdef DEBUG
  1078. /* stuff that drivers shouldn't do, but which shouldn't
  1079.  * cause problems in HCDs if they get it wrong.
  1080.  */
  1081. {
  1082. unsigned int orig_flags = urb->transfer_flags;
  1083. unsigned int allowed;
  1085. /* enforce simple/standard policy */
  1086. allowed = USB_ASYNC_UNLINK; // affects later unlinks
  1087. allowed |= USB_NO_FSBR; // only affects UHCI
  1088. switch (temp) {
  1089. case PIPE_CONTROL:
  1090. allowed |= USB_DISABLE_SPD;
  1091. break;
  1092. case PIPE_BULK:
  1093. allowed |= USB_DISABLE_SPD | USB_QUEUE_BULK
  1094. | USB_ZERO_PACKET | URB_NO_INTERRUPT;
  1095. break;
  1096. case PIPE_INTERRUPT:
  1097. allowed |= USB_DISABLE_SPD;
  1098. break;
  1099. case PIPE_ISOCHRONOUS:
  1100. allowed |= USB_ISO_ASAP;
  1101. break;
  1102. }
  1103. urb->transfer_flags &= allowed;
  1105. /* fail if submitter gave bogus flags */
  1106. if (urb->transfer_flags != orig_flags) {
  1107. err ("BOGUS urb flags, %x --> %x",
  1108. orig_flags, urb->transfer_flags);
  1109. return -EINVAL;
  1110. }
  1111. }
  1112. #endif
  1113. /*
  1114.  * Force periodic transfer intervals to be legal values that are
  1115.  * a power of two (so HCDs don't need to).
  1116.  *
  1117.  * FIXME want bus->{intr,iso}_sched_horizon values here.  Each HC
  1118.  * supports different values... this uses EHCI/UHCI defaults (and
  1119.  * EHCI can use smaller non-default values).
  1120.  */
  1121. switch (temp) {
  1122. case PIPE_ISOCHRONOUS:
  1123. case PIPE_INTERRUPT:
  1124. /* too small? */
  1125. if (urb->interval <= 0)
  1126. return -EINVAL;
  1127. /* too big? */
  1128. switch (urb->dev->speed) {
  1129. case USB_SPEED_HIGH: /* units are microframes */
  1130. // NOTE usb handles 2^15
  1131. if (urb->interval > (1024 * 8))
  1132. urb->interval = 1024 * 8;
  1133. temp = 1024 * 8;
  1134. break;
  1135. case USB_SPEED_FULL: /* units are frames/msec */
  1136. case USB_SPEED_LOW:
  1137. if (temp == PIPE_INTERRUPT) {
  1138. if (urb->interval > 255)
  1139. return -EINVAL;
  1140. // NOTE ohci only handles up to 32
  1141. temp = 128;
  1142. } else {
  1143. if (urb->interval > 1024)
  1144. urb->interval = 1024;
  1145. // NOTE usb and ohci handle up to 2^15
  1146. temp = 1024;
  1147. }
  1148. break;
  1149. default:
  1150. return -EINVAL;
  1151. }
  1152. /* power of two? */
  1153. while (temp > urb->interval)
  1154. temp >>= 1;
  1155. urb->interval = temp;
  1156. }
  1159. /*
  1160.  * FIXME:  make urb timeouts be generic, keeping the HCD cores
  1161.  * as simple as possible.
  1162.  */
  1164. // NOTE:  a generic device/urb monitoring hook would go here.
  1165. // hcd_monitor_hook(MONITOR_URB_SUBMIT, urb)
  1166. // It would catch submission paths for all urbs.
  1168. /*
  1169.  * Atomically queue the urb,  first to our records, then to the HCD.
  1170.  * Access to urb->status is controlled by urb->lock ... changes on
  1171.  * i/o completion (normal or fault) or unlinking.
  1172.  */
  1174. // FIXME:  verify that quiescing hc works right (RH cleans up)
  1176. spin_lock_irqsave (&hcd_data_lock, flags);
  1177. if (HCD_IS_RUNNING (hcd->state) && hcd->state != USB_STATE_QUIESCING) {
  1178. usb_inc_dev_use (urb->dev);
  1179. list_add (&urb->urb_list, &dev->urb_list);
  1180. status = 0;
  1181. } else {
  1182. INIT_LIST_HEAD (&urb->urb_list);
  1183. status = -ESHUTDOWN;
  1184. }
  1185. spin_unlock_irqrestore (&hcd_data_lock, flags);
  1186. if (status)
  1187. return status;
  1189. if (urb->dev == hcd->bus->root_hub)
  1190. status = rh_urb_enqueue (hcd, urb);
  1191. else
  1192. status = hcd->driver->urb_enqueue (hcd, urb, mem_flags);
  1193. /* urb->dev got nulled if hcd called giveback for us
  1194.  * NOTE: ref to urb->dev is a race without (2.5) refcounting,
  1195.  * unless driver only returns status when it didn't giveback 
  1196.  */
  1197. if (status && urb->dev)
  1198. urb_unlink (urb);
  1199. return status;
  1200. }
  1202. /*-------------------------------------------------------------------------*/
  1204. /* called in any context */
  1205. static int hcd_get_frame_number (struct usb_device *udev)
  1206. {
  1207. struct usb_hcd *hcd = (struct usb_hcd *)udev->bus->hcpriv;
  1208. return hcd->driver->get_frame_number (hcd);
  1209. }
  1211. /*-------------------------------------------------------------------------*/
  1213. struct completion_splice { // modified urb context:
  1214. /* did we complete? */
  1215. struct completion done;
  1217. /* original urb data */
  1218. void (*complete)(struct urb *);
  1219. void *context;
  1220. };
  1222. static void unlink_complete (struct urb *urb)
  1223. {
  1224. struct completion_splice *splice;
  1226. splice = (struct completion_splice *) urb->context;
  1228. /* issue original completion call */
  1229. urb->complete = splice->complete;
  1230. urb->context = splice->context;
  1231. urb->complete (urb);
  1233. /* then let the synchronous unlink call complete */
  1234. complete (&splice->done);
  1235. }
  1237. /*
  1238.  * called in any context; note ASYNC_UNLINK restrictions
  1239.  *
  1240.  * caller guarantees urb won't be recycled till both unlink()
  1241.  * and the urb's completion function return
  1242.  */
  1243. static int hcd_unlink_urb (struct urb *urb)
  1244. {
  1245. struct hcd_dev *dev;
  1246. struct usb_hcd *hcd = 0;
  1247. unsigned long flags;
  1248. struct completion_splice splice;
  1249. int retval;
  1251. if (!urb)
  1252. return -EINVAL;
  1254. /*
  1255.  * we contend for urb->status with the hcd core,
  1256.  * which changes it while returning the urb.
  1257.  *
  1258.  * Caller guaranteed that the urb pointer hasn't been freed, and
  1259.  * that it was submitted.  But as a rule it can't know whether or
  1260.  * not it's already been unlinked ... so we respect the reversed
  1261.  * lock sequence needed for the usb_hcd_giveback_urb() code paths
  1262.  * (urb lock, then hcd_data_lock) in case some other CPU is now
  1263.  * unlinking it.
  1264.  */
  1265. spin_lock_irqsave (&urb->lock, flags);
  1266. spin_lock (&hcd_data_lock);
  1267. if (!urb->hcpriv || urb->transfer_flags & USB_TIMEOUT_KILLED) {
  1268. retval = -EINVAL;
  1269. goto done;
  1270. }
  1272. if (!urb->dev || !urb->dev->bus) {
  1273. retval = -ENODEV;
  1274. goto done;
  1275. }
  1277. /* giveback clears dev; non-null means it's linked at this level */
  1278. dev = urb->dev->hcpriv;
  1279. hcd = urb->dev->bus->hcpriv;
  1280. if (!dev || !hcd) {
  1281. retval = -ENODEV;
  1282. goto done;
  1283. }
  1285. /* For non-periodic transfers, any status except -EINPROGRESS means
  1286.  * the HCD has already started to unlink this URB from the hardware.
  1287.  * In that case, there's no more work to do.
  1288.  *
  1289.  * For periodic transfers, this is the only way to trigger unlinking
  1290.  * from the hardware.  Since we (currently) overload urb->status to
  1291.  * tell the driver to unlink, error status might get clobbered ...
  1292.  * unless that transfer hasn't yet restarted.  One such case is when
  1293.  * the URB gets unlinked from its completion handler.
  1294.  *
  1295.  * FIXME use an URB_UNLINKED flag to match URB_TIMEOUT_KILLED
  1296.  */
  1297. switch (usb_pipetype (urb->pipe)) {
  1298. case PIPE_CONTROL:
  1299. case PIPE_BULK:
  1300. if (urb->status != -EINPROGRESS) {
  1301. retval = -EINVAL;
  1302. goto done;
  1303. }
  1304. }
  1306. /* maybe set up to block on completion notification */
  1307. if ((urb->transfer_flags & USB_TIMEOUT_KILLED))
  1308. urb->status = -ETIMEDOUT;
  1309. else if (!(urb->transfer_flags & USB_ASYNC_UNLINK)) {
  1310. if (in_interrupt ()) {
  1311. dbg ("non-async unlink in_interrupt");
  1312. retval = -EWOULDBLOCK;
  1313. goto done;
  1314. }
  1315. /* synchronous unlink: block till we see the completion */
  1316. init_completion (&splice.done);
  1317. splice.complete = urb->complete;
  1318. splice.context = urb->context;
  1319. urb->complete = unlink_complete;
  1320. urb->context = &splice;
  1321. urb->status = -ENOENT;
  1322. } else {
  1323. /* asynchronous unlink */
  1324. urb->status = -ECONNRESET;
  1325. }
  1326. spin_unlock (&hcd_data_lock);
  1327. spin_unlock_irqrestore (&urb->lock, flags);
  1329. if (urb == (struct urb *) hcd->rh_timer.data) {
  1330. rh_status_dequeue (hcd, urb);
  1331. retval = 0;
  1332. } else {
  1333. retval = hcd->driver->urb_dequeue (hcd, urb);
  1334. // FIXME:  if retval and we tried to splice, whoa!!
  1335. if (retval && urb->status == -ENOENT) err ("whoa! retval %d", retval);
  1336. }
  1338.      /* block till giveback, if needed */
  1339. if (!(urb->transfer_flags & (USB_ASYNC_UNLINK|USB_TIMEOUT_KILLED))
  1340. && HCD_IS_RUNNING (hcd->state)
  1341. && !retval) {
  1342. dbg ("%s: wait for giveback urb %p",
  1343. hcd->bus_name, urb);
  1344. wait_for_completion (&splice.done);
  1345. } else if ((urb->transfer_flags & USB_ASYNC_UNLINK) && retval == 0) {
  1346. return -EINPROGRESS;
  1347. }
  1348. goto bye;
  1349. done:
  1350. spin_unlock (&hcd_data_lock);
  1351. spin_unlock_irqrestore (&urb->lock, flags);
  1352. bye:
  1353. if (retval)
  1354. dbg ("%s: hcd_unlink_urb fail %d",
  1355.     hcd ? hcd->bus_name : "(no bus?)",
  1356.     retval);
  1357. return retval;
  1358. }
  1360. /*-------------------------------------------------------------------------*/
  1362. /* called by khubd, rmmod, apmd, or other thread for hcd-private cleanup */
  1364. // FIXME:  likely best to have explicit per-setting (config+alt)
  1365. // setup primitives in the usbcore-to-hcd driver API, so nothing
  1366. // is implicit.  kernel 2.5 needs a bunch of config cleanup...
  1368. static int hcd_free_dev (struct usb_device *udev)
  1369. {
  1370. struct hcd_dev *dev;
  1371. struct usb_hcd *hcd;
  1372. unsigned long flags;
  1374. if (!udev || !udev->hcpriv)
  1375. return -EINVAL;
  1377. if (!udev->bus || !udev->bus->hcpriv)
  1378. return -ENODEV;
  1380. // should udev->devnum == -1 ??
  1382. dev = udev->hcpriv;
  1383. hcd = udev->bus->hcpriv;
  1385. /* device driver problem with refcounts? */
  1386. if (!list_empty (&dev->urb_list)) {
  1387. dbg ("free busy dev, %s devnum %d (bug!)",
  1388. hcd->bus_name, udev->devnum);
  1389. return -EINVAL;
  1390. }
  1392. hcd->driver->free_config (hcd, udev);
  1394. spin_lock_irqsave (&hcd_data_lock, flags);
  1395. list_del (&dev->dev_list);
  1396. udev->hcpriv = NULL;
  1397. spin_unlock_irqrestore (&hcd_data_lock, flags);
  1399. kfree (dev);
  1400. return 0;
  1401. }
  1403. static struct usb_operations hcd_operations = {
  1404. allocate: hcd_alloc_dev,
  1405. get_frame_number: hcd_get_frame_number,
  1406. submit_urb: hcd_submit_urb,
  1407. unlink_urb: hcd_unlink_urb,
  1408. deallocate: hcd_free_dev,
  1409. };
  1411. /*-------------------------------------------------------------------------*/
  1413. static void hcd_irq (int irq, void *__hcd, struct pt_regs * r)
  1414. {
  1415. struct usb_hcd *hcd = __hcd;
  1416. int start = hcd->state;
  1418. if (unlikely (hcd->state == USB_STATE_HALT)) /* irq sharing? */
  1419. return;
  1421. hcd->driver->irq (hcd);
  1422. if (hcd->state != start && hcd->state == USB_STATE_HALT)
  1423. hc_died (hcd);
  1424. }
  1426. /*-------------------------------------------------------------------------*/
  1428. /**
  1429.  * usb_hcd_giveback_urb - return URB from HCD to device driver
  1430.  * @hcd: host controller returning the URB
  1431.  * @urb: urb being returned to the USB device driver.
  1432.  * Context: in_interrupt()
  1433.  *
  1434.  * This hands the URB from HCD to its USB device driver, using its
  1435.  * completion function.  The HCD has freed all per-urb resources
  1436.  * (and is done using urb->hcpriv).  It also released all HCD locks;
  1437.  * the device driver won't cause deadlocks if it resubmits this URB,
  1438.  * and won't confuse things by modifying and resubmitting this one.
  1439.  * Bandwidth and other resources will be deallocated.
  1440.  *
  1441.  * HCDs must not use this for periodic URBs that are still scheduled
  1442.  * and will be reissued.  They should just call their completion handlers
  1443.  * until the urb is returned to the device driver by unlinking.
  1444.  *
  1445.  * NOTE that no urb->next processing is done, even for isochronous URBs.
  1446.  * ISO streaming functionality can be achieved by having completion handlers
  1447.  * re-queue URBs.  Such explicit queuing doesn't discard error reports.
  1448.  */
  1449. void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb)
  1450. {
  1451. urb_unlink (urb);
  1453. // NOTE:  a generic device/urb monitoring hook would go here.
  1454. // hcd_monitor_hook(MONITOR_URB_FINISH, urb, dev)
  1455. // It would catch exit/unlink paths for all urbs, but non-exit
  1456. // completions for periodic urbs need hooks inside the HCD.
  1457. // hcd_monitor_hook(MONITOR_URB_UPDATE, urb, dev)
  1459. if (urb->status)
  1460. dbg ("giveback urb %p status %d len %d",
  1461. urb, urb->status, urb->actual_length);
  1463. // FIXME unmap urb->transfer_dma and/or setup_dma 
  1465. /* pass ownership to the completion handler */
  1466. urb->complete (urb);
  1467. }
  1468. EXPORT_SYMBOL (usb_hcd_giveback_urb);