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

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

Linux/Unix编程

开发平台：

Unix_Linux

hub.c：源码内容
  1. /*
  2.  * USB hub driver.
  3.  *
  4.  * (C) Copyright 1999 Linus Torvalds
  5.  * (C) Copyright 1999 Johannes Erdfelt
  6.  * (C) Copyright 1999 Gregory P. Smith
  7.  * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
  8.  *
  9.  */
  11. #include <linux/config.h>
  12. #include <linux/kernel.h>
  13. #include <linux/module.h>
  14. #include <linux/completion.h>
  15. #include <linux/sched.h>
  16. #include <linux/list.h>
  17. #include <linux/slab.h>
  18. #include <linux/smp_lock.h>
  19. #ifdef CONFIG_USB_DEBUG
  20. #define DEBUG
  21. #else
  22. #undef DEBUG
  23. #endif
  24. #include <linux/usb.h>
  25. #include <linux/usbdevice_fs.h>
  27. #include <asm/semaphore.h>
  28. #include <asm/uaccess.h>
  29. #include <asm/byteorder.h>
  31. #include "hub.h"
  33. /* Wakes up khubd */
  34. static spinlock_t hub_event_lock = SPIN_LOCK_UNLOCKED;
  35. static DECLARE_MUTEX(usb_address0_sem);
  37. static LIST_HEAD(hub_event_list); /* List of hubs needing servicing */
  38. static LIST_HEAD(hub_list); /* List containing all of the hubs (for cleanup) */
  40. static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
  41. static int khubd_pid = 0; /* PID of khubd */
  42. static DECLARE_COMPLETION(khubd_exited);
  44. #ifdef DEBUG
  45. static inline char *portspeed (int portstatus)
  46. {
  47. if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))
  48.      return "480 Mb/s";
  49. else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED))
  50. return "1.5 Mb/s";
  51. else
  52. return "12 Mb/s";
  53. }
  54. #endif
  56. /* USB 2.0 spec Section 11.24.4.5 */
  57. static int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size)
  58. {
  59. return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  60. USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
  61. USB_DT_HUB << 8, 0, data, size, HZ);
  62. }
  64. /*
  65.  * USB 2.0 spec Section 11.24.2.1
  66.  */
  67. static int usb_clear_hub_feature(struct usb_device *dev, int feature)
  68. {
  69. return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  70. USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, HZ);
  71. }
  73. /*
  74.  * USB 2.0 spec Section 11.24.2.2
  75.  * BUG: doesn't handle port indicator selector in high byte of wIndex
  76.  */
  77. static int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
  78. {
  79. return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  80. USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port, NULL, 0, HZ);
  81. }
  83. /*
  84.  * USB 2.0 spec Section 11.24.2.13
  85.  * BUG: doesn't handle port indicator selector in high byte of wIndex
  86.  */
  87. static int usb_set_port_feature(struct usb_device *dev, int port, int feature)
  88. {
  89. return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  90. USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port, NULL, 0, HZ);
  91. }
  93. /*
  94.  * USB 2.0 spec Section 11.24.2.6
  95.  */
  96. static int usb_get_hub_status(struct usb_device *dev, void *data)
  97. {
  98. return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  99. USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
  100. data, sizeof(struct usb_hub_status), HZ);
  101. }
  103. /*
  104.  * USB 2.0 spec Section 11.24.2.7
  105.  */
  106. static int usb_get_port_status(struct usb_device *dev, int port, void *data)
  107. {
  108. return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  109. USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,
  110. data, sizeof(struct usb_hub_status), HZ);
  111. }
  113. static void hub_irq(struct urb *urb)
  114. {
  115. struct usb_hub *hub = (struct usb_hub *)urb->context;
  116. unsigned long flags;
  118. /* Cause a hub reset after 10 consecutive errors */
  119. if (urb->status) {
  120. if (urb->status == -ENOENT)
  121. return;
  123. dbg("nonzero status in irq %d", urb->status);
  125. if ((++hub->nerrors < 10) || hub->error)
  126. return;
  128. hub->error = urb->status;
  129. }
  131. hub->nerrors = 0;
  133. /* Something happened, let khubd figure it out */
  134. spin_lock_irqsave(&hub_event_lock, flags);
  135. if (list_empty(&hub->event_list)) {
  136. list_add(&hub->event_list, &hub_event_list);
  137. wake_up(&khubd_wait);
  138. }
  139. spin_unlock_irqrestore(&hub_event_lock, flags);
  140. }
  142. static void usb_hub_power_on(struct usb_hub *hub)
  143. {
  144. int i;
  146. /* Enable power to the ports */
  147. dbg("enabling power on all ports");
  148. for (i = 0; i < hub->descriptor->bNbrPorts; i++)
  149. usb_set_port_feature(hub->dev, i + 1, USB_PORT_FEAT_POWER);
  151. /* Wait for power to be enabled */
  152. wait_ms(hub->descriptor->bPwrOn2PwrGood * 2);
  153. }
  155. static int usb_hub_configure(struct usb_hub *hub, struct usb_endpoint_descriptor *endpoint)
  156. {
  157. struct usb_device *dev = hub->dev;
  158. struct usb_hub_status *hubstatus;
  159. char portstr[USB_MAXCHILDREN + 1];
  160. unsigned int pipe;
  161. int i, maxp, ret;
  163. hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
  164. if (!hub->descriptor) {
  165. err("Unable to kmalloc %Zd bytes for hub descriptor", sizeof(*hub->descriptor));
  166. return -1;
  167. }
  169. /* Request the entire hub descriptor. */
  170. ret = usb_get_hub_descriptor(dev, hub->descriptor, sizeof(*hub->descriptor));
  171. /* <hub->descriptor> is large enough for a hub with 127 ports;
  172.  * the hub can/will return fewer bytes here. */
  173. if (ret < 0) {
  174. err("Unable to get hub descriptor (err = %d)", ret);
  175. kfree(hub->descriptor);
  176. return -1;
  177. }
  179. dev->maxchild = hub->descriptor->bNbrPorts;
  180. info("%d port%s detected", hub->descriptor->bNbrPorts, (hub->descriptor->bNbrPorts == 1) ? "" : "s");
  182. le16_to_cpus(&hub->descriptor->wHubCharacteristics);
  184. if (hub->descriptor->wHubCharacteristics & HUB_CHAR_COMPOUND)
  185. dbg("part of a compound device");
  186. else
  187. dbg("standalone hub");
  189. switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) {
  190. case 0x00:
  191. dbg("ganged power switching");
  192. break;
  193. case 0x01:
  194. dbg("individual port power switching");
  195. break;
  196. case 0x02:
  197. case 0x03:
  198. dbg("unknown reserved power switching mode");
  199. break;
  200. }
  202. switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) {
  203. case 0x00:
  204. dbg("global over-current protection");
  205. break;
  206. case 0x08:
  207. dbg("individual port over-current protection");
  208. break;
  209. case 0x10:
  210. case 0x18:
  211. dbg("no over-current protection");
  212.                         break;
  213. }
  215. switch (dev->descriptor.bDeviceProtocol) {
  216. case 0:
  217. break;
  218. case 1:
  219. dbg("Single TT");
  220. hub->tt.hub = dev;
  221. break;
  222. case 2:
  223. dbg("TT per port");
  224. hub->tt.hub = dev;
  225. hub->tt.multi = 1;
  226. break;
  227. default:
  228. dbg("Unrecognized hub protocol %d",
  229. dev->descriptor.bDeviceProtocol);
  230. break;
  231. }
  233. switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_TTTT) {
  234. case 0x00:
  235. if (dev->descriptor.bDeviceProtocol != 0)
  236. dbg("TT requires at most 8 FS bit times");
  237. break;
  238. case 0x20:
  239. dbg("TT requires at most 16 FS bit times");
  240. break;
  241. case 0x40:
  242. dbg("TT requires at most 24 FS bit times");
  243. break;
  244. case 0x60:
  245. dbg("TT requires at most 32 FS bit times");
  246. break;
  247. }
  249. dbg("Port indicators are %s supported", 
  250.     (hub->descriptor->wHubCharacteristics & HUB_CHAR_PORTIND) ? "" : "not");
  252. dbg("power on to power good time: %dms", hub->descriptor->bPwrOn2PwrGood * 2);
  253. dbg("hub controller current requirement: %dmA", hub->descriptor->bHubContrCurrent);
  255. for (i = 0; i < dev->maxchild; i++)
  256. portstr[i] = hub->descriptor->DeviceRemovable[((i + 1) / 8)] & (1 << ((i + 1) % 8)) ? 'F' : 'R';
  257. portstr[dev->maxchild] = 0;
  259. dbg("port removable status: %s", portstr);
  261. hubstatus = kmalloc(sizeof *hubstatus, GFP_KERNEL);
  262. if (!hubstatus) {
  263. err("Unable to allocate hubstatus");
  264. kfree(hub->descriptor);
  265. return -1;
  266. }
  267. ret = usb_get_hub_status(dev, hubstatus);
  268. if (ret < 0) {
  269. err("Unable to get hub status (err = %d)", ret);
  270. kfree(hubstatus);
  271. kfree(hub->descriptor);
  272. return -1;
  273. }
  275. le16_to_cpus(&hubstatus->wHubStatus);
  277. dbg("local power source is %s",
  278. (hubstatus->wHubStatus & HUB_STATUS_LOCAL_POWER) ? "lost (inactive)" : "good");
  280. dbg("%sover-current condition exists",
  281. (hubstatus->wHubStatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
  283. kfree(hubstatus);
  285. /* Start the interrupt endpoint */
  286. pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
  287. maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
  289. if (maxp > sizeof(hub->buffer))
  290. maxp = sizeof(hub->buffer);
  292. hub->urb = usb_alloc_urb(0);
  293. if (!hub->urb) {
  294. err("couldn't allocate interrupt urb");
  295. kfree(hub->descriptor);
  296. return -1;
  297. }
  299. FILL_INT_URB(hub->urb, dev, pipe, hub->buffer, maxp, hub_irq, hub,
  300. /* NOTE:  in 2.5 fill_int_urb() converts the encoding */
  301. (dev->speed == USB_SPEED_HIGH)
  302. ? 1 << (endpoint->bInterval - 1)
  303. : endpoint->bInterval);
  304. ret = usb_submit_urb(hub->urb);
  305. if (ret) {
  306. err("usb_submit_urb failed (%d)", ret);
  307. kfree(hub->descriptor);
  308. return -1;
  309. }
  311. /* Wake up khubd */
  312. wake_up(&khubd_wait);
  314. usb_hub_power_on(hub);
  316. return 0;
  317. }
  319. static void *hub_probe(struct usb_device *dev, unsigned int i,
  320.        const struct usb_device_id *id)
  321. {
  322. struct usb_interface_descriptor *interface;
  323. struct usb_endpoint_descriptor *endpoint;
  324. struct usb_hub *hub;
  325. unsigned long flags;
  327. interface = &dev->actconfig->interface[i].altsetting[0];
  329. /* Some hubs have a subclass of 1, which AFAICT according to the */
  330. /*  specs is not defined, but it works */
  331. if ((interface->bInterfaceSubClass != 0) &&
  332.     (interface->bInterfaceSubClass != 1)) {
  333. err("invalid subclass (%d) for USB hub device #%d",
  334. interface->bInterfaceSubClass, dev->devnum);
  335. return NULL;
  336. }
  338. /* Multiple endpoints? What kind of mutant ninja-hub is this? */
  339. if (interface->bNumEndpoints != 1) {
  340. err("invalid bNumEndpoints (%d) for USB hub device #%d",
  341. interface->bNumEndpoints, dev->devnum);
  342. return NULL;
  343. }
  345. endpoint = &interface->endpoint[0];
  347. /* Output endpoint? Curiousier and curiousier.. */
  348. if (!(endpoint->bEndpointAddress & USB_DIR_IN)) {
  349. err("Device #%d is hub class, but has output endpoint?",
  350. dev->devnum);
  351. return NULL;
  352. }
  354. /* If it's not an interrupt endpoint, we'd better punt! */
  355. if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT) {
  356. err("Device #%d is hub class, but has endpoint other than interrupt?",
  357. dev->devnum);
  358. return NULL;
  359. }
  361. /* We found a hub */
  362. info("USB hub found");
  364. hub = kmalloc(sizeof(*hub), GFP_KERNEL);
  365. if (!hub) {
  366. err("couldn't kmalloc hub struct");
  367. return NULL;
  368. }
  370. memset(hub, 0, sizeof(*hub));
  372. INIT_LIST_HEAD(&hub->event_list);
  373. hub->dev = dev;
  374. init_MUTEX(&hub->khubd_sem);
  376. /* Record the new hub's existence */
  377. spin_lock_irqsave(&hub_event_lock, flags);
  378. INIT_LIST_HEAD(&hub->hub_list);
  379. list_add(&hub->hub_list, &hub_list);
  380. spin_unlock_irqrestore(&hub_event_lock, flags);
  382. if (usb_hub_configure(hub, endpoint) >= 0)
  383. return hub;
  385. err("hub configuration failed for device #%d", dev->devnum);
  387. /* free hub, but first clean up its list. */
  388. spin_lock_irqsave(&hub_event_lock, flags);
  390. /* Delete it and then reset it */
  391. list_del(&hub->event_list);
  392. INIT_LIST_HEAD(&hub->event_list);
  393. list_del(&hub->hub_list);
  394. INIT_LIST_HEAD(&hub->hub_list);
  396. spin_unlock_irqrestore(&hub_event_lock, flags);
  398. kfree(hub);
  400. return NULL;
  401. }
  403. static void hub_disconnect(struct usb_device *dev, void *ptr)
  404. {
  405. struct usb_hub *hub = (struct usb_hub *)ptr;
  406. unsigned long flags;
  408. spin_lock_irqsave(&hub_event_lock, flags);
  410. /* Delete it and then reset it */
  411. list_del(&hub->event_list);
  412. INIT_LIST_HEAD(&hub->event_list);
  413. list_del(&hub->hub_list);
  414. INIT_LIST_HEAD(&hub->hub_list);
  416. spin_unlock_irqrestore(&hub_event_lock, flags);
  418. down(&hub->khubd_sem); /* Wait for khubd to leave this hub alone. */
  419. up(&hub->khubd_sem);
  421. if (hub->urb) {
  422. usb_unlink_urb(hub->urb);
  423. usb_free_urb(hub->urb);
  424. hub->urb = NULL;
  425. }
  427. if (hub->descriptor) {
  428. kfree(hub->descriptor);
  429. hub->descriptor = NULL;
  430. }
  432. /* Free the memory */
  433. kfree(hub);
  434. }
  436. static int hub_ioctl(struct usb_device *hub, unsigned int code, void *user_data)
  437. {
  438. /* assert ifno == 0 (part of hub spec) */
  439. switch (code) {
  440. case USBDEVFS_HUB_PORTINFO: {
  441. struct usbdevfs_hub_portinfo *info = user_data;
  442. unsigned long flags;
  443. int i;
  445. spin_lock_irqsave(&hub_event_lock, flags);
  446. if (hub->devnum <= 0)
  447. info->nports = 0;
  448. else {
  449. info->nports = hub->maxchild;
  450. for (i = 0; i < info->nports; i++) {
  451. if (hub->children[i] == NULL)
  452. info->port[i] = 0;
  453. else
  454. info->port[i] = hub->children[i]->devnum;
  455. }
  456. }
  457. spin_unlock_irqrestore(&hub_event_lock, flags);
  459. return info->nports + 1;
  460. }
  462. default:
  463. return -ENOSYS;
  464. }
  465. }
  467. static int usb_hub_reset(struct usb_hub *hub)
  468. {
  469. struct usb_device *dev = hub->dev;
  470. int i;
  472. /* Disconnect any attached devices */
  473. for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
  474. if (dev->children[i])
  475. usb_disconnect(&dev->children[i]);
  476. }
  478. /* Attempt to reset the hub */
  479. if (hub->urb)
  480. usb_unlink_urb(hub->urb);
  481. else
  482. return -1;
  484. if (usb_reset_device(dev))
  485. return -1;
  487. hub->urb->dev = dev;                                                    
  488. if (usb_submit_urb(hub->urb))
  489. return -1;
  491. usb_hub_power_on(hub);
  493. return 0;
  494. }
  496. static void usb_hub_disconnect(struct usb_device *dev)
  497. {
  498. struct usb_device *parent = dev->parent;
  499. int i;
  501. /* Find the device pointer to disconnect */
  502. if (parent) {
  503. for (i = 0; i < parent->maxchild; i++) {
  504. if (parent->children[i] == dev) {
  505. usb_disconnect(&parent->children[i]);
  506. return;
  507. }
  508. }
  509. }
  511. err("cannot disconnect hub %d", dev->devnum);
  512. }
  514. static int usb_hub_port_status(struct usb_device *hub, int port,
  515.        u16 *status, u16 *change)
  516. {
  517. struct usb_port_status *portsts;
  518. int ret = -ENOMEM;
  520. portsts = kmalloc(sizeof(*portsts), GFP_KERNEL);
  521. if (portsts) {
  522. ret = usb_get_port_status(hub, port + 1, portsts);
  523. if (ret < 0)
  524. err("%s (%d) failed (err = %d)", __FUNCTION__, hub->devnum, ret);
  525. else {
  526. *status = le16_to_cpu(portsts->wPortStatus);
  527. *change = le16_to_cpu(portsts->wPortChange); 
  528. dbg("port %d, portstatus %x, change %x, %s", port + 1,
  529. *status, *change, portspeed(*status));
  530. ret = 0;
  531. }
  532. kfree(portsts);
  533. }
  534. return ret;
  535. }
  537. #define HUB_RESET_TRIES 5
  538. #define HUB_PROBE_TRIES 2
  539. #define HUB_SHORT_RESET_TIME 10
  540. #define HUB_LONG_RESET_TIME 200
  541. #define HUB_RESET_TIMEOUT 500
  543. /* return: -1 on error, 0 on success, 1 on disconnect.  */
  544. static int usb_hub_port_wait_reset(struct usb_device *hub, int port,
  545. struct usb_device *dev, unsigned int delay)
  546. {
  547. int delay_time, ret;
  548. u16 portstatus;
  549. u16 portchange;
  551. for (delay_time = 0; delay_time < HUB_RESET_TIMEOUT; delay_time += delay) {
  552. /* wait to give the device a chance to reset */
  553. wait_ms(delay);
  555. /* read and decode port status */
  556. ret = usb_hub_port_status(hub, port, &portstatus, &portchange);
  557. if (ret < 0) {
  558. return -1;
  559. }
  561. /* Device went away? */
  562. if (!(portstatus & USB_PORT_STAT_CONNECTION))
  563. return 1;
  565. /* bomb out completely if something weird happened */
  566. if ((portchange & USB_PORT_STAT_C_CONNECTION))
  567. return -1;
  569. /* if we`ve finished resetting, then break out of the loop */
  570. if (!(portstatus & USB_PORT_STAT_RESET) &&
  571.     (portstatus & USB_PORT_STAT_ENABLE)) {
  572. if (portstatus & USB_PORT_STAT_HIGH_SPEED)
  573. dev->speed = USB_SPEED_HIGH;
  574. else if (portstatus & USB_PORT_STAT_LOW_SPEED)
  575. dev->speed = USB_SPEED_LOW;
  576. else
  577. dev->speed = USB_SPEED_FULL;
  578. return 0;
  579. }
  581. /* switch to the long delay after two short delay failures */
  582. if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
  583. delay = HUB_LONG_RESET_TIME;
  585. dbg("port %d of hub %d not reset yet, waiting %dms", port + 1,
  586. hub->devnum, delay);
  587. }
  589. return -1;
  590. }
  592. /* return: -1 on error, 0 on success, 1 on disconnect.  */
  593. static int usb_hub_port_reset(struct usb_device *hub, int port,
  594. struct usb_device *dev, unsigned int delay)
  595. {
  596. int i, status;
  598. /* Reset the port */
  599. for (i = 0; i < HUB_RESET_TRIES; i++) {
  600. usb_set_port_feature(hub, port + 1, USB_PORT_FEAT_RESET);
  602. /* return on disconnect or reset */
  603. status = usb_hub_port_wait_reset(hub, port, dev, delay);
  604. if (status != -1) {
  605. usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_C_RESET);
  606. return status;
  607. }
  609. dbg("port %d of hub %d not enabled, trying reset again...",
  610. port + 1, hub->devnum);
  611. delay = HUB_LONG_RESET_TIME;
  612. }
  614. err("Cannot enable port %i of hub %d, disabling port.",
  615. port + 1, hub->devnum);
  616. err("Maybe the USB cable is bad?");
  618. return -1;
  619. }
  621. void usb_hub_port_disable(struct usb_device *hub, int port)
  622. {
  623. int ret;
  625. ret = usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_ENABLE);
  626. if (ret)
  627. err("cannot disable port %d of hub %d (err = %d)",
  628. port + 1, hub->devnum, ret);
  629. }
  631. /* USB 2.0 spec, 7.1.7.3 / fig 7-29:
  632.  *
  633.  * Between connect detection and reset signaling there must be a delay
  634.  * of 100ms at least for debounce and power-settling. The corresponding
  635.  * timer shall restart whenever the downstream port detects a disconnect.
  636.  * 
  637.  * Apparently there are some bluetooth and irda-dongles and a number
  638.  * of low-speed devices which require longer delays of about 200-400ms.
  639.  * Not covered by the spec - but easy to deal with.
  640.  *
  641.  * This implementation uses 400ms minimum debounce timeout and checks
  642.  * every 100ms for transient disconnects to restart the delay.
  643.  */
  645. #define HUB_DEBOUNCE_TIMEOUT 400
  646. #define HUB_DEBOUNCE_STEP 100
  648. /* return: -1 on error, 0 on success, 1 on disconnect.  */
  649. static int usb_hub_port_debounce(struct usb_device *hub, int port)
  650. {
  651. int ret;
  652. unsigned delay_time;
  653. u16 portchange, portstatus;
  655. for (delay_time = 0; delay_time < HUB_DEBOUNCE_TIMEOUT; /* empty */ ) {
  657. /* wait debounce step increment */
  658. wait_ms(HUB_DEBOUNCE_STEP);
  660. ret = usb_hub_port_status(hub, port, &portstatus, &portchange);
  661. if (ret < 0)
  662. return -1;
  664. if ((portchange & USB_PORT_STAT_C_CONNECTION)) {
  665. usb_clear_port_feature(hub, port+1, USB_PORT_FEAT_C_CONNECTION);
  666. delay_time = 0;
  667. }
  668. else
  669. delay_time += HUB_DEBOUNCE_STEP;
  670. }
  671. return ((portstatus&USB_PORT_STAT_CONNECTION)) ? 0 : 1;
  672. }
  674. static void usb_hub_port_connect_change(struct usb_hub *hubstate, int port,
  675. u16 portstatus, u16 portchange)
  676. {
  677. struct usb_device *hub = hubstate->dev;
  678. struct usb_device *dev;
  679. unsigned int delay = HUB_SHORT_RESET_TIME;
  680. int i;
  682. dbg("port %d, portstatus %x, change %x, %s",
  683. port + 1, portstatus, portchange, portspeed (portstatus));
  685. /* Clear the connection change status */
  686. usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_C_CONNECTION);
  688. /* Disconnect any existing devices under this port */
  689. if (hub->children[port])
  690. usb_disconnect(&hub->children[port]);
  692. /* Return now if nothing is connected */
  693. if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
  694. if (portstatus & USB_PORT_STAT_ENABLE)
  695. usb_hub_port_disable(hub, port);
  697. return;
  698. }
  700. if (usb_hub_port_debounce(hub, port)) {
  701. err("connect-debounce failed, port %d disabled", port+1);
  702. usb_hub_port_disable(hub, port);
  703. return;
  704. }
  706. down(&usb_address0_sem);
  708. for (i = 0; i < HUB_PROBE_TRIES; i++) {
  709. struct usb_device *pdev;
  710. int len;
  712. /* Allocate a new device struct */
  713. dev = usb_alloc_dev(hub, hub->bus);
  714. if (!dev) {
  715. err("couldn't allocate usb_device");
  716. break;
  717. }
  719. hub->children[port] = dev;
  721. /* Reset the device */
  722. if (usb_hub_port_reset(hub, port, dev, delay)) {
  723. usb_free_dev(dev);
  724. break;
  725. }
  727. /* Find a new device ID for it */
  728. usb_connect(dev);
  730. /* Set up TT records, if needed  */
  731. if (hub->tt) {
  732. dev->tt = hub->tt;
  733. dev->ttport = hub->ttport;
  734. } else if (dev->speed != USB_SPEED_HIGH
  735. && hub->speed == USB_SPEED_HIGH) {
  736. dev->tt = &hubstate->tt;
  737. dev->ttport = port + 1;
  738. }
  740. /* Save readable and stable topology id, distinguishing
  741.  * devices by location for diagnostics, tools, etc.  The
  742.  * string is a path along hub ports, from the root.  Each
  743.  * device's id will be stable until USB is re-cabled, and
  744.  * hubs are often labeled with these port numbers.
  745.  *
  746.  * Initial size: ".NN" times five hubs + NUL = 16 bytes max
  747.  * (quite rare, since most hubs have 4-6 ports).
  748.  */
  749. pdev = dev->parent;
  750. if (pdev->devpath [0] != '0') /* parent not root? */
  751. len = snprintf (dev->devpath, sizeof dev->devpath,
  752. "%s.%d", pdev->devpath, port + 1);
  753. /* root == "0", root port 2 == "2", port 3 that hub "2.3" */
  754. else
  755. len = snprintf (dev->devpath, sizeof dev->devpath,
  756. "%d", port + 1);
  757. if (len == sizeof dev->devpath)
  758. warn ("devpath size! usb/%03d/%03d path %s",
  759. dev->bus->busnum, dev->devnum, dev->devpath);
  760. info("new USB device %s-%s, assigned address %d",
  761. dev->bus->bus_name, dev->devpath, dev->devnum);
  763. /* Run it through the hoops (find a driver, etc) */
  764. if (!usb_new_device(dev))
  765. goto done;
  767. /* Free the configuration if there was an error */
  768. usb_free_dev(dev);
  770. /* Switch to a long reset time */
  771. delay = HUB_LONG_RESET_TIME;
  772. }
  774. hub->children[port] = NULL;
  775. usb_hub_port_disable(hub, port);
  776. done:
  777. up(&usb_address0_sem);
  778. }
  780. static void usb_hub_events(void)
  781. {
  782. unsigned long flags;
  783. struct list_head *tmp;
  784. struct usb_device *dev;
  785. struct usb_hub *hub;
  786. struct usb_hub_status *hubsts;
  787. u16 hubstatus;
  788. u16 hubchange;
  789. u16 portstatus;
  790. u16 portchange;
  791. int i, ret;
  793. /*
  794.  *  We restart the list everytime to avoid a deadlock with
  795.  * deleting hubs downstream from this one. This should be
  796.  * safe since we delete the hub from the event list.
  797.  * Not the most efficient, but avoids deadlocks.
  798.  */
  799. while (1) {
  800. spin_lock_irqsave(&hub_event_lock, flags);
  802. if (list_empty(&hub_event_list))
  803. break;
  805. /* Grab the next entry from the beginning of the list */
  806. tmp = hub_event_list.next;
  808. hub = list_entry(tmp, struct usb_hub, event_list);
  809. dev = hub->dev;
  811. list_del(tmp);
  812. INIT_LIST_HEAD(tmp);
  814. down(&hub->khubd_sem); /* never blocks, we were on list */
  815. spin_unlock_irqrestore(&hub_event_lock, flags);
  817. if (hub->error) {
  818. dbg("resetting hub %d for error %d", dev->devnum, hub->error);
  820. if (usb_hub_reset(hub)) {
  821. err("error resetting hub %d - disconnecting", dev->devnum);
  822. up(&hub->khubd_sem);
  823. usb_hub_disconnect(dev);
  824. continue;
  825. }
  827. hub->nerrors = 0;
  828. hub->error = 0;
  829. }
  831. for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
  832. ret = usb_hub_port_status(dev, i, &portstatus, &portchange);
  833. if (ret < 0) {
  834. continue;
  835. }
  837. if (portchange & USB_PORT_STAT_C_CONNECTION) {
  838. dbg("port %d connection change", i + 1);
  840. usb_hub_port_connect_change(hub, i, portstatus, portchange);
  841. } else if (portchange & USB_PORT_STAT_C_ENABLE) {
  842. dbg("port %d enable change, status %x", i + 1, portstatus);
  843. usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_ENABLE);
  845. /*
  846.  * EM interference sometimes causes bad shielded USB devices to 
  847.  * be shutdown by the hub, this hack enables them again.
  848.  * Works at least with mouse driver. 
  849.  */
  850. if (!(portstatus & USB_PORT_STAT_ENABLE) && 
  851.     (portstatus & USB_PORT_STAT_CONNECTION) && (dev->children[i])) {
  852. err("already running port %i disabled by hub (EMI?), re-enabling...",
  853. i + 1);
  854. usb_hub_port_connect_change(hub, i, portstatus, portchange);
  855. }
  856. }
  858. if (portchange & USB_PORT_STAT_C_SUSPEND) {
  859. dbg("port %d suspend change", i + 1);
  860. usb_clear_port_feature(dev, i + 1,  USB_PORT_FEAT_C_SUSPEND);
  861. }
  863. if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
  864. err("port %d over-current change", i + 1);
  865. usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_OVER_CURRENT);
  866. usb_hub_power_on(hub);
  867. }
  869. if (portchange & USB_PORT_STAT_C_RESET) {
  870. dbg("port %d reset change", i + 1);
  871. usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_RESET);
  872. }
  873. } /* end for i */
  875. /* deal with hub status changes */
  876. hubsts = kmalloc(sizeof *hubsts, GFP_KERNEL);
  877. if (!hubsts) {
  878. err("couldn't allocate hubsts");
  879. } else {
  880. if (usb_get_hub_status(dev, hubsts) < 0)
  881. err("get_hub_status failed");
  882. else {
  883. hubstatus = le16_to_cpup(&hubsts->wHubStatus);
  884. hubchange = le16_to_cpup(&hubsts->wHubChange);
  885. if (hubchange & HUB_CHANGE_LOCAL_POWER) {
  886. dbg("hub power change");
  887. usb_clear_hub_feature(dev, C_HUB_LOCAL_POWER);
  888. }
  889. if (hubchange & HUB_CHANGE_OVERCURRENT) {
  890. dbg("hub overcurrent change");
  891. wait_ms(500); /* Cool down */
  892. usb_clear_hub_feature(dev, C_HUB_OVER_CURRENT);
  893. usb_hub_power_on(hub);
  894. }
  895. }
  896. kfree(hubsts);
  897. }
  898. up(&hub->khubd_sem);
  899.         } /* end while (1) */
  901. spin_unlock_irqrestore(&hub_event_lock, flags);
  902. }
  904. static int usb_hub_thread(void *__hub)
  905. {
  906. lock_kernel();
  908. /*
  909.  * This thread doesn't need any user-level access,
  910.  * so get rid of all our resources
  911.  */
  913. daemonize();
  914. reparent_to_init();
  916. /* Setup a nice name */
  917. strcpy(current->comm, "khubd");
  919. /* Send me a signal to get me die (for debugging) */
  920. do {
  921. usb_hub_events();
  922. wait_event_interruptible(khubd_wait, !list_empty(&hub_event_list)); 
  923. } while (!signal_pending(current));
  925. dbg("usb_hub_thread exiting");
  927. unlock_kernel();
  928. complete_and_exit(&khubd_exited, 0);
  929. }
  931. static struct usb_device_id hub_id_table [] = {
  932.     { match_flags: USB_DEVICE_ID_MATCH_INT_CLASS,
  933.       bInterfaceClass: USB_CLASS_HUB},
  934.     { } /* Terminating entry */
  935. };
  937. MODULE_DEVICE_TABLE (usb, hub_id_table);
  939. static struct usb_driver hub_driver = {
  940. name: "hub",
  941. probe: hub_probe,
  942. ioctl: hub_ioctl,
  943. disconnect: hub_disconnect,
  944. id_table: hub_id_table,
  945. };
  947. /*
  948.  * This should be a separate module.
  949.  */
  950. int usb_hub_init(void)
  951. {
  952. int pid;
  954. if (usb_register(&hub_driver) < 0) {
  955. err("Unable to register USB hub driver");
  956. return -1;
  957. }
  959. pid = kernel_thread(usb_hub_thread, NULL,
  960. CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
  961. if (pid >= 0) {
  962. khubd_pid = pid;
  964. return 0;
  965. }
  967. /* Fall through if kernel_thread failed */
  968. usb_deregister(&hub_driver);
  969. err("failed to start usb_hub_thread");
  971. return -1;
  972. }
  974. void usb_hub_cleanup(void)
  975. {
  976. int ret;
  978. /* Kill the thread */
  979. ret = kill_proc(khubd_pid, SIGTERM, 1);
  981. wait_for_completion(&khubd_exited);
  983. /*
  984.  * Hub resources are freed for us by usb_deregister. It calls
  985.  * usb_driver_purge on every device which in turn calls that
  986.  * devices disconnect function if it is using this driver.
  987.  * The hub_disconnect function takes care of releasing the
  988.  * individual hub resources. -greg
  989.  */
  990. usb_deregister(&hub_driver);
  991. } /* usb_hub_cleanup() */
  993. /*
  994.  * WARNING - If a driver calls usb_reset_device, you should simulate a
  995.  * disconnect() and probe() for other interfaces you doesn't claim. This
  996.  * is left up to the driver writer right now. This insures other drivers
  997.  * have a chance to re-setup their interface.
  998.  *
  999.  * Take a look at proc_resetdevice in devio.c for some sample code to
  1000.  * do this.
  1001.  */
  1002. int usb_reset_device(struct usb_device *dev)
  1003. {
  1004. struct usb_device *parent = dev->parent;
  1005. struct usb_device_descriptor *descriptor;
  1006. int i, ret, port = -1;
  1008. if (!parent) {
  1009. err("attempting to reset root hub!");
  1010. return -EINVAL;
  1011. }
  1013. for (i = 0; i < parent->maxchild; i++)
  1014. if (parent->children[i] == dev) {
  1015. port = i;
  1016. break;
  1017. }
  1019. if (port < 0)
  1020. return -ENOENT;
  1022. down(&usb_address0_sem);
  1024. /* Send a reset to the device */
  1025. if (usb_hub_port_reset(parent, port, dev, HUB_SHORT_RESET_TIME)) {
  1026. usb_hub_port_disable(parent, port);
  1027. up(&usb_address0_sem);
  1028. return(-ENODEV);
  1029. }
  1031. /* Reprogram the Address */
  1032. ret = usb_set_address(dev);
  1033. if (ret < 0) {
  1034. err("USB device not accepting new address (error=%d)", ret);
  1035. usb_hub_port_disable(parent, port);
  1036. up(&usb_address0_sem);
  1037. return ret;
  1038. }
  1040. /* Let the SET_ADDRESS settle */
  1041. wait_ms(10);
  1043. up(&usb_address0_sem);
  1045. /*
  1046.  * Now we fetch the configuration descriptors for the device and
  1047.  * see if anything has changed. If it has, we dump the current
  1048.  * parsed descriptors and reparse from scratch. Then we leave
  1049.  * the device alone for the caller to finish setting up.
  1050.  *
  1051.  * If nothing changed, we reprogram the configuration and then
  1052.  * the alternate settings.
  1053.  */
  1054. descriptor = kmalloc(sizeof *descriptor, GFP_NOIO);
  1055. if (!descriptor) {
  1056. return -ENOMEM;
  1057. }
  1058. ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, descriptor,
  1059. sizeof(*descriptor));
  1060. if (ret < 0)
  1061. return ret;
  1063. le16_to_cpus(&descriptor->bcdUSB);
  1064. le16_to_cpus(&descriptor->idVendor);
  1065. le16_to_cpus(&descriptor->idProduct);
  1066. le16_to_cpus(&descriptor->bcdDevice);
  1068. if (memcmp(&dev->descriptor, descriptor, sizeof(*descriptor))) {
  1069. kfree(descriptor);
  1070. usb_destroy_configuration(dev);
  1072. ret = usb_get_device_descriptor(dev);
  1073. if (ret < sizeof(dev->descriptor)) {
  1074. if (ret < 0)
  1075. err("unable to get device descriptor (error=%d)", ret);
  1076. else
  1077. err("USB device descriptor short read (expected %Zi, got %i)", sizeof(dev->descriptor), ret);
  1078.         
  1079. clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
  1080. dev->devnum = -1;
  1081. return -EIO;
  1082. }
  1084. ret = usb_get_configuration(dev);
  1085. if (ret < 0) {
  1086. err("unable to get configuration (error=%d)", ret);
  1087. usb_destroy_configuration(dev);
  1088. clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
  1089. dev->devnum = -1;
  1090. return 1;
  1091. }
  1093. dev->actconfig = dev->config;
  1094. usb_set_maxpacket(dev);
  1096. return 1;
  1097. }
  1099. kfree(descriptor);
  1101. ret = usb_set_configuration(dev, dev->actconfig->bConfigurationValue);
  1102. if (ret < 0) {
  1103. err("failed to set active configuration (error=%d)", ret);
  1104. return ret;
  1105. }
  1107. for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
  1108. struct usb_interface *intf = &dev->actconfig->interface[i];
  1109. struct usb_interface_descriptor *as = &intf->altsetting[intf->act_altsetting];
  1111. ret = usb_set_interface(dev, as->bInterfaceNumber, as->bAlternateSetting);
  1112. if (ret < 0) {
  1113. err("failed to set active alternate setting for interface %d (error=%d)", i, ret);
  1114. return ret;
  1115. }
  1116. }
  1118. return 0;
  1119. }