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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
hub.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：26k
源码类别：

嵌入式Linux

开发平台：

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. #if 0
  156. static void usb_hub_port_suspend(struct usb_hub *hub, int port)
  157. {
  158. usb_set_port_feature(hub->dev, port + 1, USB_PORT_FEAT_SUSPEND);
  159. }
  160. #endif
  162. static int usb_hub_configure(struct usb_hub *hub, struct usb_endpoint_descriptor *endpoint)
  163. {
  164. struct usb_device *dev = hub->dev;
  165. struct usb_hub_status hubstatus;
  166. char portstr[USB_MAXCHILDREN + 1];
  167. unsigned int pipe;
  168. int i, maxp, ret;
  170. hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
  171. if (!hub->descriptor) {
  172. err("Unable to kmalloc %Zd bytes for hub descriptor", sizeof(*hub->descriptor));
  173. return -1;
  174. }
  176. /* Request the entire hub descriptor. */
  177. ret = usb_get_hub_descriptor(dev, hub->descriptor, sizeof(*hub->descriptor));
  178. // BUSHI //
  179. #ifdef CONFIG_ARCH_S3C2410
  180. if ((dev->devnum == 1)  // Root Hub
  181. && hub->descriptor->bNbrPorts > CONFIG_MAX_ROOT_PORTS) {
  182. for (i=hub->descriptor->bNbrPorts-1; i>=0; i--) {
  183. printk("port #%d ", i);
  184. if (i > CONFIG_MAX_ROOT_PORTS-1) {
  185. // usb_hub_port_suspend(hub, i);
  186. printk("suspened!n");
  187. } else {
  188. printk("alived!n");
  189. }
  190. }
  191. hub->descriptor->bNbrPorts = CONFIG_MAX_ROOT_PORTS;
  192. }
  193. #endif
  194. /////////
  196. /* <hub->descriptor> is large enough for a hub with 127 ports;
  197.  * the hub can/will return fewer bytes here. */
  198. if (ret < 0) {
  199. err("Unable to get hub descriptor (err = %d)", ret);
  200. kfree(hub->descriptor);
  201. return -1;
  202. }
  204. dev->maxchild = hub->descriptor->bNbrPorts;
  205. info("%d port%s detected", hub->descriptor->bNbrPorts, (hub->descriptor->bNbrPorts == 1) ? "" : "s");
  207. le16_to_cpus(&hub->descriptor->wHubCharacteristics);
  209. if (hub->descriptor->wHubCharacteristics & HUB_CHAR_COMPOUND)
  210. dbg("part of a compound device");
  211. else
  212. dbg("standalone hub");
  214. switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) {
  215. case 0x00:
  216. dbg("ganged power switching");
  217. break;
  218. case 0x01:
  219. dbg("individual port power switching");
  220. break;
  221. case 0x02:
  222. case 0x03:
  223. dbg("unknown reserved power switching mode");
  224. break;
  225. }
  227. switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) {
  228. case 0x00:
  229. dbg("global over-current protection");
  230. break;
  231. case 0x08:
  232. dbg("individual port over-current protection");
  233. break;
  234. case 0x10:
  235. case 0x18:
  236. dbg("no over-current protection");
  237.                         break;
  238. }
  240. switch (dev->descriptor.bDeviceProtocol) {
  241. case 0:
  242. break;
  243. case 1:
  244. dbg("Single TT");
  245. break;
  246. case 2:
  247. dbg("Multiple TT");
  248. break;
  249. default:
  250. dbg("Unrecognized hub protocol %d",
  251. dev->descriptor.bDeviceProtocol);
  252. break;
  253. }
  255. switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_TTTT) {
  256. case 0x00:
  257. if (dev->descriptor.bDeviceProtocol != 0)
  258. dbg("TT requires at most 8 FS bit times");
  259. break;
  260. case 0x20:
  261. dbg("TT requires at most 16 FS bit times");
  262. break;
  263. case 0x40:
  264. dbg("TT requires at most 24 FS bit times");
  265. break;
  266. case 0x60:
  267. dbg("TT requires at most 32 FS bit times");
  268. break;
  269. }
  271. dbg("Port indicators are %s supported", 
  272.     (hub->descriptor->wHubCharacteristics & HUB_CHAR_PORTIND) ? "" : "not");
  274. dbg("power on to power good time: %dms", hub->descriptor->bPwrOn2PwrGood * 2);
  275. dbg("hub controller current requirement: %dmA", hub->descriptor->bHubContrCurrent);
  277. for (i = 0; i < dev->maxchild; i++)
  278. portstr[i] = hub->descriptor->DeviceRemovable[((i + 1) / 8)] & (1 << ((i + 1) % 8)) ? 'F' : 'R';
  279. portstr[dev->maxchild] = 0;
  281. dbg("port removable status: %s", portstr);
  283. ret = usb_get_hub_status(dev, &hubstatus);
  284. if (ret < 0) {
  285. err("Unable to get hub status (err = %d)", ret);
  286. kfree(hub->descriptor);
  287. return -1;
  288. }
  290. le16_to_cpus(&hubstatus.wHubStatus);
  292. dbg("local power source is %s",
  293. (hubstatus.wHubStatus & HUB_STATUS_LOCAL_POWER) ? "lost (inactive)" : "good");
  295. dbg("%sover-current condition exists",
  296. (hubstatus.wHubStatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
  298. /* Start the interrupt endpoint */
  299. pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
  300. maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
  302. if (maxp > sizeof(hub->buffer))
  303. maxp = sizeof(hub->buffer);
  305. hub->urb = usb_alloc_urb(0);
  306. if (!hub->urb) {
  307. err("couldn't allocate interrupt urb");
  308. kfree(hub->descriptor);
  309. return -1;
  310. }
  312. FILL_INT_URB(hub->urb, dev, pipe, hub->buffer, maxp, hub_irq,
  313. hub, endpoint->bInterval);
  314. ret = usb_submit_urb(hub->urb);
  315. if (ret) {
  316. err("usb_submit_urb failed (%d)", ret);
  317. kfree(hub->descriptor);
  318. return -1;
  319. }
  321. /* Wake up khubd */
  322. wake_up(&khubd_wait);
  324. usb_hub_power_on(hub);
  326. return 0;
  327. }
  329. static void *hub_probe(struct usb_device *dev, unsigned int i,
  330.        const struct usb_device_id *id)
  331. {
  332. struct usb_interface_descriptor *interface;
  333. struct usb_endpoint_descriptor *endpoint;
  334. struct usb_hub *hub;
  335. unsigned long flags;
  337. interface = &dev->actconfig->interface[i].altsetting[0];
  339. /* Some hubs have a subclass of 1, which AFAICT according to the */
  340. /*  specs is not defined, but it works */
  341. if ((interface->bInterfaceSubClass != 0) &&
  342.     (interface->bInterfaceSubClass != 1)) {
  343. err("invalid subclass (%d) for USB hub device #%d",
  344. interface->bInterfaceSubClass, dev->devnum);
  345. return NULL;
  346. }
  348. /* Multiple endpoints? What kind of mutant ninja-hub is this? */
  349. if (interface->bNumEndpoints != 1) {
  350. err("invalid bNumEndpoints (%d) for USB hub device #%d",
  351. interface->bNumEndpoints, dev->devnum);
  352. return NULL;
  353. }
  355. endpoint = &interface->endpoint[0];
  357. /* Output endpoint? Curiousier and curiousier.. */
  358. if (!(endpoint->bEndpointAddress & USB_DIR_IN)) {
  359. err("Device #%d is hub class, but has output endpoint?",
  360. dev->devnum);
  361. return NULL;
  362. }
  364. /* If it's not an interrupt endpoint, we'd better punt! */
  365. if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT) {
  366. err("Device #%d is hub class, but has endpoint other than interrupt?",
  367. dev->devnum);
  368. return NULL;
  369. }
  371. /* We found a hub */
  372. info("USB hub found");
  374. hub = kmalloc(sizeof(*hub), GFP_KERNEL);
  375. if (!hub) {
  376. err("couldn't kmalloc hub struct");
  377. return NULL;
  378. }
  380. memset(hub, 0, sizeof(*hub));
  382. INIT_LIST_HEAD(&hub->event_list);
  383. hub->dev = dev;
  384. init_MUTEX(&hub->khubd_sem);
  386. /* Record the new hub's existence */
  387. spin_lock_irqsave(&hub_event_lock, flags);
  388. INIT_LIST_HEAD(&hub->hub_list);
  389. list_add(&hub->hub_list, &hub_list);
  390. spin_unlock_irqrestore(&hub_event_lock, flags);
  392. if (usb_hub_configure(hub, endpoint) >= 0)
  393. return hub;
  395. err("hub configuration failed for device #%d", dev->devnum);
  397. /* free hub, but first clean up its list. */
  398. spin_lock_irqsave(&hub_event_lock, flags);
  400. /* Delete it and then reset it */
  401. list_del(&hub->event_list);
  402. INIT_LIST_HEAD(&hub->event_list);
  403. list_del(&hub->hub_list);
  404. INIT_LIST_HEAD(&hub->hub_list);
  406. spin_unlock_irqrestore(&hub_event_lock, flags);
  408. kfree(hub);
  410. return NULL;
  411. }
  413. static void hub_disconnect(struct usb_device *dev, void *ptr)
  414. {
  415. struct usb_hub *hub = (struct usb_hub *)ptr;
  416. unsigned long flags;
  418. spin_lock_irqsave(&hub_event_lock, flags);
  420. /* Delete it and then reset it */
  421. list_del(&hub->event_list);
  422. INIT_LIST_HEAD(&hub->event_list);
  423. list_del(&hub->hub_list);
  424. INIT_LIST_HEAD(&hub->hub_list);
  426. spin_unlock_irqrestore(&hub_event_lock, flags);
  428. down(&hub->khubd_sem); /* Wait for khubd to leave this hub alone. */
  429. up(&hub->khubd_sem);
  431. if (hub->urb) {
  432. usb_unlink_urb(hub->urb);
  433. usb_free_urb(hub->urb);
  434. hub->urb = NULL;
  435. }
  437. if (hub->descriptor) {
  438. kfree(hub->descriptor);
  439. hub->descriptor = NULL;
  440. }
  442. /* Free the memory */
  443. kfree(hub);
  444. }
  446. static int hub_ioctl(struct usb_device *hub, unsigned int code, void *user_data)
  447. {
  448. /* assert ifno == 0 (part of hub spec) */
  449. switch (code) {
  450. case USBDEVFS_HUB_PORTINFO: {
  451. struct usbdevfs_hub_portinfo *info = user_data;
  452. unsigned long flags;
  453. int i;
  455. spin_lock_irqsave(&hub_event_lock, flags);
  456. if (hub->devnum <= 0)
  457. info->nports = 0;
  458. else {
  459. info->nports = hub->maxchild;
  460. for (i = 0; i < info->nports; i++) {
  461. if (hub->children[i] == NULL)
  462. info->port[i] = 0;
  463. else
  464. info->port[i] = hub->children[i]->devnum;
  465. }
  466. }
  467. spin_unlock_irqrestore(&hub_event_lock, flags);
  469. return info->nports + 1;
  470. }
  472. default:
  473. return -ENOSYS;
  474. }
  475. }
  477. static int usb_hub_reset(struct usb_hub *hub)
  478. {
  479. struct usb_device *dev = hub->dev;
  480. int i;
  482. /* Disconnect any attached devices */
  483. for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
  484. if (dev->children[i])
  485. usb_disconnect(&dev->children[i]);
  486. }
  488. /* Attempt to reset the hub */
  489. if (hub->urb)
  490. usb_unlink_urb(hub->urb);
  491. else
  492. return -1;
  494. if (usb_reset_device(dev))
  495. return -1;
  497. hub->urb->dev = dev;                                                    
  498. if (usb_submit_urb(hub->urb))
  499. return -1;
  501. usb_hub_power_on(hub);
  503. return 0;
  504. }
  506. static void usb_hub_disconnect(struct usb_device *dev)
  507. {
  508. struct usb_device *parent = dev->parent;
  509. int i;
  511. /* Find the device pointer to disconnect */
  512. if (parent) {
  513. for (i = 0; i < parent->maxchild; i++) {
  514. if (parent->children[i] == dev) {
  515. usb_disconnect(&parent->children[i]);
  516. return;
  517. }
  518. }
  519. }
  521. err("cannot disconnect hub %d", dev->devnum);
  522. }
  524. #define HUB_RESET_TRIES 5
  525. #define HUB_PROBE_TRIES 2
  526. #define HUB_SHORT_RESET_TIME 10
  527. #define HUB_LONG_RESET_TIME 200
  528. #define HUB_RESET_TIMEOUT 500
  530. /* return: -1 on error, 0 on success, 1 on disconnect.  */
  531. static int usb_hub_port_wait_reset(struct usb_device *hub, int port,
  532. struct usb_device *dev, unsigned int delay)
  533. {
  534. int delay_time, ret;
  535. struct usb_port_status portsts;
  536. unsigned short portchange, portstatus;
  538. for (delay_time = 0; delay_time < HUB_RESET_TIMEOUT; delay_time += delay) {
  539. /* wait to give the device a chance to reset */
  540. wait_ms(delay);
  542. /* read and decode port status */
  543. ret = usb_get_port_status(hub, port + 1, &portsts);
  544. if (ret < 0) {
  545. err("get_port_status(%d) failed (err = %d)", port + 1, ret);
  546. return -1;
  547. }
  549. portstatus = le16_to_cpu(portsts.wPortStatus);
  550. portchange = le16_to_cpu(portsts.wPortChange);
  551. dbg("port %d, portstatus %x, change %x, %s", port + 1,
  552. portstatus, portchange, portspeed (portstatus));
  554. /* bomb out completely if something weird happened */
  555. if ((portchange & USB_PORT_STAT_C_CONNECTION))
  556. return -1;
  558. /* if we`ve finished resetting, then break out of the loop */
  559. if (!(portstatus & USB_PORT_STAT_RESET) &&
  560.     (portstatus & USB_PORT_STAT_ENABLE)) {
  561. if (portstatus & USB_PORT_STAT_HIGH_SPEED)
  562. dev->speed = USB_SPEED_HIGH;
  563. else if (portstatus & USB_PORT_STAT_LOW_SPEED)
  564. dev->speed = USB_SPEED_LOW;
  565. else
  566. dev->speed = USB_SPEED_FULL;
  567. return 0;
  568. }
  570. /* switch to the long delay after two short delay failures */
  571. if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
  572. delay = HUB_LONG_RESET_TIME;
  574. dbg("port %d of hub %d not reset yet, waiting %dms", port + 1,
  575. hub->devnum, delay);
  576. }
  578. return -1;
  579. }
  581. /* return: -1 on error, 0 on success, 1 on disconnect.  */
  582. static int usb_hub_port_reset(struct usb_device *hub, int port,
  583. struct usb_device *dev, unsigned int delay)
  584. {
  585. int i, status;
  587. /* Reset the port */
  588. for (i = 0; i < HUB_RESET_TRIES; i++) {
  589. usb_set_port_feature(hub, port + 1, USB_PORT_FEAT_RESET);
  591. /* return on disconnect or reset */
  592. status = usb_hub_port_wait_reset(hub, port, dev, delay);
  593. if (status != -1) {
  594. usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_C_RESET);
  595. return status;
  596. }
  598. dbg("port %d of hub %d not enabled, trying reset again...",
  599. port + 1, hub->devnum);
  600. delay = HUB_LONG_RESET_TIME;
  601. }
  603. err("Cannot enable port %i of hub %d, disabling port.",
  604. port + 1, hub->devnum);
  605. err("Maybe the USB cable is bad?");
  607. return -1;
  608. }
  610. void usb_hub_port_disable(struct usb_device *hub, int port)
  611. {
  612. int ret;
  614. ret = usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_ENABLE);
  615. if (ret)
  616. err("cannot disable port %d of hub %d (err = %d)",
  617. port + 1, hub->devnum, ret);
  618. }
  620. static void usb_hub_port_connect_change(struct usb_device *hub, int port,
  621. struct usb_port_status *portsts)
  622. {
  623. struct usb_device *dev;
  624. unsigned short portstatus, portchange;
  625. unsigned int delay = HUB_SHORT_RESET_TIME;
  626. int i;
  627. char *portstr, *tempstr;
  629. portstatus = le16_to_cpu(portsts->wPortStatus);
  630. portchange = le16_to_cpu(portsts->wPortChange);
  631. dbg("port %d, portstatus %x, change %x, %s",
  632. port + 1, portstatus, portchange, portspeed (portstatus));
  634. /* Clear the connection change status */
  635. usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_C_CONNECTION);
  637. /* Disconnect any existing devices under this port */
  638. if (hub->children[port])
  639. usb_disconnect(&hub->children[port]);
  641. /* Return now if nothing is connected */
  642. if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
  643. if (portstatus & USB_PORT_STAT_ENABLE)
  644. usb_hub_port_disable(hub, port);
  646. return;
  647. }
  649. /* Some low speed devices have problems with the quick delay, so */
  650. /*  be a bit pessimistic with those devices. RHbug #23670 */
  651. if (portstatus & USB_PORT_STAT_LOW_SPEED) {
  652. wait_ms(400);
  653. delay = HUB_LONG_RESET_TIME;
  654. }
  656. down(&usb_address0_sem);
  658. tempstr = kmalloc(1024, GFP_KERNEL);
  659. portstr = kmalloc(1024, GFP_KERNEL);
  661. for (i = 0; i < HUB_PROBE_TRIES; i++) {
  662. struct usb_device *pdev, *cdev;
  664. /* Allocate a new device struct */
  665. dev = usb_alloc_dev(hub, hub->bus);
  666. if (!dev) {
  667. err("couldn't allocate usb_device");
  668. break;
  669. }
  671. hub->children[port] = dev;
  673. /* Reset the device */
  674. if (usb_hub_port_reset(hub, port, dev, delay)) {
  675. usb_free_dev(dev);
  676. break;
  677. }
  679. /* Find a new device ID for it */
  680. usb_connect(dev);
  682. /* Create a readable topology string */
  683. cdev = dev;
  684. pdev = dev->parent;
  685. if (portstr && tempstr) {
  686. portstr[0] = 0;
  687. while (pdev) {
  688. int port;
  690. for (port = 0; port < pdev->maxchild; port++)
  691. if (pdev->children[port] == cdev)
  692. break;
  694. strcpy(tempstr, portstr);
  695. if (!strlen(tempstr))
  696. sprintf(portstr, "%d", port + 1);
  697. else
  698. sprintf(portstr, "%d/%s", port + 1, tempstr);
  700. cdev = pdev;
  701. pdev = pdev->parent;
  702. }
  703. info("USB new device connect on bus%d/%s, assigned device number %d",
  704. dev->bus->busnum, portstr, dev->devnum);
  705. } else
  706. info("USB new device connect on bus%d, assigned device number %d",
  707. dev->bus->busnum, dev->devnum);
  709. /* Run it through the hoops (find a driver, etc) */
  710. if (!usb_new_device(dev))
  711. goto done;
  713. /* Free the configuration if there was an error */
  714. usb_free_dev(dev);
  716. /* Switch to a long reset time */
  717. delay = HUB_LONG_RESET_TIME;
  718. }
  720. hub->children[port] = NULL;
  721. usb_hub_port_disable(hub, port);
  722. done:
  723. up(&usb_address0_sem);
  724. if (portstr)
  725. kfree(portstr);
  726. if (tempstr)
  727. kfree(tempstr);
  728. }
  730. static void usb_hub_events(void)
  731. {
  732. unsigned long flags;
  733. struct list_head *tmp;
  734. struct usb_device *dev;
  735. struct usb_hub *hub;
  736. struct usb_hub_status hubsts;
  737. unsigned short hubstatus, hubchange;
  738. int i, ret;
  740. /*
  741.  *  We restart the list everytime to avoid a deadlock with
  742.  * deleting hubs downstream from this one. This should be
  743.  * safe since we delete the hub from the event list.
  744.  * Not the most efficient, but avoids deadlocks.
  745.  */
  746. while (1) {
  747. spin_lock_irqsave(&hub_event_lock, flags);
  749. if (list_empty(&hub_event_list))
  750. break;
  752. /* Grab the next entry from the beginning of the list */
  753. tmp = hub_event_list.next;
  755. hub = list_entry(tmp, struct usb_hub, event_list);
  756. dev = hub->dev;
  758. list_del(tmp);
  759. INIT_LIST_HEAD(tmp);
  761. down(&hub->khubd_sem); /* never blocks, we were on list */
  762. spin_unlock_irqrestore(&hub_event_lock, flags);
  764. if (hub->error) {
  765. dbg("resetting hub %d for error %d", dev->devnum, hub->error);
  767. if (usb_hub_reset(hub)) {
  768. err("error resetting hub %d - disconnecting", dev->devnum);
  769. up(&hub->khubd_sem);
  770. usb_hub_disconnect(dev);
  771. continue;
  772. }
  774. hub->nerrors = 0;
  775. hub->error = 0;
  776. }
  778. for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
  779. struct usb_port_status portsts;
  780. unsigned short portstatus, portchange;
  782. ret = usb_get_port_status(dev, i + 1, &portsts);
  783. if (ret < 0) {
  784. err("get_port_status failed (err = %d)", ret);
  785. continue;
  786. }
  788. portstatus = le16_to_cpu(portsts.wPortStatus);
  789. portchange = le16_to_cpu(portsts.wPortChange);
  791. if (portchange & USB_PORT_STAT_C_CONNECTION) {
  792. dbg("port %d connection change", i + 1);
  794. usb_hub_port_connect_change(dev, i, &portsts);
  795. } else if (portchange & USB_PORT_STAT_C_ENABLE) {
  796. dbg("port %d enable change, status %x", i + 1, portstatus);
  797. usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_ENABLE);
  799. /*
  800.  * EM interference sometimes causes bad shielded USB devices to 
  801.  * be shutdown by the hub, this hack enables them again.
  802.  * Works at least with mouse driver. 
  803.  */
  804. if (!(portstatus & USB_PORT_STAT_ENABLE) && 
  805.     (portstatus & USB_PORT_STAT_CONNECTION) && (dev->children[i])) {
  806. err("already running port %i disabled by hub (EMI?), re-enabling...",
  807. i + 1);
  808. usb_hub_port_connect_change(dev, i, &portsts);
  809. }
  810. }
  812. if (portchange & USB_PORT_STAT_C_SUSPEND) {
  813. dbg("port %d suspend change", i + 1);
  814. usb_clear_port_feature(dev, i + 1,  USB_PORT_FEAT_C_SUSPEND);
  815. }
  817. if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
  818. err("port %d over-current change", i + 1);
  819. usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_OVER_CURRENT);
  820. usb_hub_power_on(hub);
  821. }
  823. if (portchange & USB_PORT_STAT_C_RESET) {
  824. dbg("port %d reset change", i + 1);
  825. usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_RESET);
  826. }
  827. } /* end for i */
  829. /* deal with hub status changes */
  830. if (usb_get_hub_status(dev, &hubsts) < 0)
  831. err("get_hub_status failed");
  832. else {
  833. hubstatus = le16_to_cpup(&hubsts.wHubStatus);
  834. hubchange = le16_to_cpup(&hubsts.wHubChange);
  835. if (hubchange & HUB_CHANGE_LOCAL_POWER) {
  836. dbg("hub power change");
  837. usb_clear_hub_feature(dev, C_HUB_LOCAL_POWER);
  838. }
  839. if (hubchange & HUB_CHANGE_OVERCURRENT) {
  840. dbg("hub overcurrent change");
  841. wait_ms(500); /* Cool down */
  842. usb_clear_hub_feature(dev, C_HUB_OVER_CURRENT);
  843.                          usb_hub_power_on(hub);
  844. }
  845. }
  846. up(&hub->khubd_sem);
  847.         } /* end while (1) */
  849. spin_unlock_irqrestore(&hub_event_lock, flags);
  850. }
  852. static int usb_hub_thread(void *__hub)
  853. {
  854. lock_kernel();
  856. /*
  857.  * This thread doesn't need any user-level access,
  858.  * so get rid of all our resources
  859.  */
  861. daemonize();
  863. /* Setup a nice name */
  864. strcpy(current->comm, "khubd");
  866. /* Send me a signal to get me die (for debugging) */
  867. do {
  868. usb_hub_events();
  869. interruptible_sleep_on(&khubd_wait);
  870. } while (!signal_pending(current));
  872. dbg("usb_hub_thread exiting");
  874. unlock_kernel();
  875. complete_and_exit(&khubd_exited, 0);
  876. }
  878. static struct usb_device_id hub_id_table [] = {
  879.     { match_flags: USB_DEVICE_ID_MATCH_INT_CLASS,
  880.       bInterfaceClass: USB_CLASS_HUB},
  881.     { } /* Terminating entry */
  882. };
  884. MODULE_DEVICE_TABLE (usb, hub_id_table);
  886. static struct usb_driver hub_driver = {
  887. name: "hub",
  888. probe: hub_probe,
  889. ioctl: hub_ioctl,
  890. disconnect: hub_disconnect,
  891. id_table: hub_id_table,
  892. };
  894. /*
  895.  * This should be a separate module.
  896.  */
  897. int usb_hub_init(void)
  898. {
  899. int pid;
  901. if (usb_register(&hub_driver) < 0) {
  902. err("Unable to register USB hub driver");
  903. return -1;
  904. }
  906. pid = kernel_thread(usb_hub_thread, NULL,
  907. CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
  908. if (pid >= 0) {
  909. khubd_pid = pid;
  911. return 0;
  912. }
  914. /* Fall through if kernel_thread failed */
  915. usb_deregister(&hub_driver);
  916. err("failed to start usb_hub_thread");
  918. return -1;
  919. }
  921. void usb_hub_cleanup(void)
  922. {
  923. int ret;
  925. /* Kill the thread */
  926. ret = kill_proc(khubd_pid, SIGTERM, 1);
  928. wait_for_completion(&khubd_exited);
  930. /*
  931.  * Hub resources are freed for us by usb_deregister. It calls
  932.  * usb_driver_purge on every device which in turn calls that
  933.  * devices disconnect function if it is using this driver.
  934.  * The hub_disconnect function takes care of releasing the
  935.  * individual hub resources. -greg
  936.  */
  937. usb_deregister(&hub_driver);
  938. } /* usb_hub_cleanup() */
  940. /*
  941.  * WARNING - If a driver calls usb_reset_device, you should simulate a
  942.  * disconnect() and probe() for other interfaces you doesn't claim. This
  943.  * is left up to the driver writer right now. This insures other drivers
  944.  * have a chance to re-setup their interface.
  945.  *
  946.  * Take a look at proc_resetdevice in devio.c for some sample code to
  947.  * do this.
  948.  */
  949. int usb_reset_device(struct usb_device *dev)
  950. {
  951. struct usb_device *parent = dev->parent;
  952. struct usb_device_descriptor descriptor;
  953. int i, ret, port = -1;
  955. if (!parent) {
  956. err("attempting to reset root hub!");
  957. return -EINVAL;
  958. }
  960. for (i = 0; i < parent->maxchild; i++)
  961. if (parent->children[i] == dev) {
  962. port = i;
  963. break;
  964. }
  966. if (port < 0)
  967. return -ENOENT;
  969. down(&usb_address0_sem);
  971. /* Send a reset to the device */
  972. if (usb_hub_port_reset(parent, port, dev, HUB_SHORT_RESET_TIME)) {
  973. usb_hub_port_disable(parent, port);
  974. up(&usb_address0_sem);
  975. return(-ENODEV);
  976. }
  978. /* Reprogram the Address */
  979. ret = usb_set_address(dev);
  980. if (ret < 0) {
  981. err("USB device not accepting new address (error=%d)", ret);
  982. usb_hub_port_disable(parent, port);
  983. up(&usb_address0_sem);
  984. return ret;
  985. }
  987. /* Let the SET_ADDRESS settle */
  988. wait_ms(10);
  990. up(&usb_address0_sem);
  992. /*
  993.  * Now we fetch the configuration descriptors for the device and
  994.  * see if anything has changed. If it has, we dump the current
  995.  * parsed descriptors and reparse from scratch. Then we leave
  996.  * the device alone for the caller to finish setting up.
  997.  *
  998.  * If nothing changed, we reprogram the configuration and then
  999.  * the alternate settings.
  1000.  */
  1001. ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &descriptor,
  1002. sizeof(descriptor));
  1003. if (ret < 0)
  1004. return ret;
  1006. le16_to_cpus(&descriptor.bcdUSB);
  1007. le16_to_cpus(&descriptor.idVendor);
  1008. le16_to_cpus(&descriptor.idProduct);
  1009. le16_to_cpus(&descriptor.bcdDevice);
  1011. if (memcmp(&dev->descriptor, &descriptor, sizeof(descriptor))) {
  1012. usb_destroy_configuration(dev);
  1014. ret = usb_get_device_descriptor(dev);
  1015. if (ret < sizeof(dev->descriptor)) {
  1016. if (ret < 0)
  1017. err("unable to get device descriptor (error=%d)", ret);
  1018. else
  1019. err("USB device descriptor short read (expected %Zi, got %i)", sizeof(dev->descriptor), ret);
  1020.         
  1021. clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
  1022. dev->devnum = -1;
  1023. return -EIO;
  1024. }
  1026. ret = usb_get_configuration(dev);
  1027. if (ret < 0) {
  1028. err("unable to get configuration (error=%d)", ret);
  1029. usb_destroy_configuration(dev);
  1030. clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
  1031. dev->devnum = -1;
  1032. return 1;
  1033. }
  1035. dev->actconfig = dev->config;
  1036. usb_set_maxpacket(dev);
  1038. return 1;
  1039. }
  1041. ret = usb_set_configuration(dev, dev->actconfig->bConfigurationValue);
  1042. if (ret < 0) {
  1043. err("failed to set active configuration (error=%d)", ret);
  1044. return ret;
  1045. }
  1047. for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
  1048. struct usb_interface *intf = &dev->actconfig->interface[i];
  1049. struct usb_interface_descriptor *as = &intf->altsetting[intf->act_altsetting];
  1051. ret = usb_set_interface(dev, as->bInterfaceNumber, as->bAlternateSetting);
  1052. if (ret < 0) {
  1053. err("failed to set active alternate setting for interface %d (error=%d)", i, ret);
  1054. return ret;
  1055. }
  1056. }
  1058. return 0;
  1059. }