ohci-hub.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776
  1. /*
  2. * OHCI HCD (Host Controller Driver) for USB.
  3. *
  4. * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
  5. * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
  6. *
  7. * This file is licenced under GPL
  8. */
  9. /*-------------------------------------------------------------------------*/
  10. /*
  11. * OHCI Root Hub ... the nonsharable stuff
  12. */
  13. #define dbg_port(hc,label,num,value) \
  14. ohci_dbg (hc, \
  15. "%s roothub.portstatus [%d] " \
  16. "= 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
  17. label, num, temp, \
  18. (temp & RH_PS_PRSC) ? " PRSC" : "", \
  19. (temp & RH_PS_OCIC) ? " OCIC" : "", \
  20. (temp & RH_PS_PSSC) ? " PSSC" : "", \
  21. (temp & RH_PS_PESC) ? " PESC" : "", \
  22. (temp & RH_PS_CSC) ? " CSC" : "", \
  23. \
  24. (temp & RH_PS_LSDA) ? " LSDA" : "", \
  25. (temp & RH_PS_PPS) ? " PPS" : "", \
  26. (temp & RH_PS_PRS) ? " PRS" : "", \
  27. (temp & RH_PS_POCI) ? " POCI" : "", \
  28. (temp & RH_PS_PSS) ? " PSS" : "", \
  29. \
  30. (temp & RH_PS_PES) ? " PES" : "", \
  31. (temp & RH_PS_CCS) ? " CCS" : "" \
  32. );
  33. /*-------------------------------------------------------------------------*/
  34. #define OHCI_SCHED_ENABLES \
  35. (OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
  36. static void dl_done_list (struct ohci_hcd *);
  37. static void finish_unlinks (struct ohci_hcd *, u16);
  38. #ifdef CONFIG_PM
  39. static int ohci_rh_suspend (struct ohci_hcd *ohci, int autostop)
  40. __releases(ohci->lock)
  41. __acquires(ohci->lock)
  42. {
  43. int status = 0;
  44. ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
  45. switch (ohci->hc_control & OHCI_CTRL_HCFS) {
  46. case OHCI_USB_RESUME:
  47. ohci_dbg (ohci, "resume/suspend?\n");
  48. ohci->hc_control &= ~OHCI_CTRL_HCFS;
  49. ohci->hc_control |= OHCI_USB_RESET;
  50. ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
  51. (void) ohci_readl (ohci, &ohci->regs->control);
  52. /* FALL THROUGH */
  53. case OHCI_USB_RESET:
  54. status = -EBUSY;
  55. ohci_dbg (ohci, "needs reinit!\n");
  56. goto done;
  57. case OHCI_USB_SUSPEND:
  58. if (!ohci->autostop) {
  59. ohci_dbg (ohci, "already suspended\n");
  60. goto done;
  61. }
  62. }
  63. ohci_dbg (ohci, "%s root hub\n",
  64. autostop ? "auto-stop" : "suspend");
  65. /* First stop any processing */
  66. if (!autostop && (ohci->hc_control & OHCI_SCHED_ENABLES)) {
  67. ohci->hc_control &= ~OHCI_SCHED_ENABLES;
  68. ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
  69. ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
  70. ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrstatus);
  71. /* sched disables take effect on the next frame,
  72. * then the last WDH could take 6+ msec
  73. */
  74. ohci_dbg (ohci, "stopping schedules ...\n");
  75. ohci->autostop = 0;
  76. spin_unlock_irq (&ohci->lock);
  77. msleep (8);
  78. spin_lock_irq (&ohci->lock);
  79. }
  80. dl_done_list (ohci);
  81. finish_unlinks (ohci, ohci_frame_no(ohci));
  82. /* maybe resume can wake root hub */
  83. if (ohci_to_hcd(ohci)->self.root_hub->do_remote_wakeup || autostop) {
  84. ohci->hc_control |= OHCI_CTRL_RWE;
  85. } else {
  86. ohci_writel(ohci, OHCI_INTR_RHSC | OHCI_INTR_RD,
  87. &ohci->regs->intrdisable);
  88. ohci->hc_control &= ~OHCI_CTRL_RWE;
  89. }
  90. /* Suspend hub ... this is the "global (to this bus) suspend" mode,
  91. * which doesn't imply ports will first be individually suspended.
  92. */
  93. ohci->hc_control &= ~OHCI_CTRL_HCFS;
  94. ohci->hc_control |= OHCI_USB_SUSPEND;
  95. ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
  96. (void) ohci_readl (ohci, &ohci->regs->control);
  97. /* no resumes until devices finish suspending */
  98. if (!autostop) {
  99. ohci->next_statechange = jiffies + msecs_to_jiffies (5);
  100. ohci->autostop = 0;
  101. ohci->rh_state = OHCI_RH_SUSPENDED;
  102. }
  103. done:
  104. return status;
  105. }
  106. static inline struct ed *find_head (struct ed *ed)
  107. {
  108. /* for bulk and control lists */
  109. while (ed->ed_prev)
  110. ed = ed->ed_prev;
  111. return ed;
  112. }
  113. /* caller has locked the root hub */
  114. static int ohci_rh_resume (struct ohci_hcd *ohci)
  115. __releases(ohci->lock)
  116. __acquires(ohci->lock)
  117. {
  118. struct usb_hcd *hcd = ohci_to_hcd (ohci);
  119. u32 temp, enables;
  120. int status = -EINPROGRESS;
  121. int autostopped = ohci->autostop;
  122. ohci->autostop = 0;
  123. ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
  124. if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
  125. /* this can happen after resuming a swsusp snapshot */
  126. if (ohci->rh_state != OHCI_RH_RUNNING) {
  127. ohci_dbg (ohci, "BIOS/SMM active, control %03x\n",
  128. ohci->hc_control);
  129. status = -EBUSY;
  130. /* this happens when pmcore resumes HC then root */
  131. } else {
  132. ohci_dbg (ohci, "duplicate resume\n");
  133. status = 0;
  134. }
  135. } else switch (ohci->hc_control & OHCI_CTRL_HCFS) {
  136. case OHCI_USB_SUSPEND:
  137. ohci->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES);
  138. ohci->hc_control |= OHCI_USB_RESUME;
  139. ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
  140. (void) ohci_readl (ohci, &ohci->regs->control);
  141. ohci_dbg (ohci, "%s root hub\n",
  142. autostopped ? "auto-start" : "resume");
  143. break;
  144. case OHCI_USB_RESUME:
  145. /* HCFS changes sometime after INTR_RD */
  146. ohci_dbg(ohci, "%swakeup root hub\n",
  147. autostopped ? "auto-" : "");
  148. break;
  149. case OHCI_USB_OPER:
  150. /* this can happen after resuming a swsusp snapshot */
  151. ohci_dbg (ohci, "snapshot resume? reinit\n");
  152. status = -EBUSY;
  153. break;
  154. default: /* RESET, we lost power */
  155. ohci_dbg (ohci, "lost power\n");
  156. status = -EBUSY;
  157. }
  158. if (status == -EBUSY) {
  159. if (!autostopped) {
  160. spin_unlock_irq (&ohci->lock);
  161. status = ohci_restart (ohci);
  162. usb_root_hub_lost_power(hcd->self.root_hub);
  163. spin_lock_irq (&ohci->lock);
  164. }
  165. return status;
  166. }
  167. if (status != -EINPROGRESS)
  168. return status;
  169. if (autostopped)
  170. goto skip_resume;
  171. spin_unlock_irq (&ohci->lock);
  172. /* Some controllers (lucent erratum) need extra-long delays */
  173. msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);
  174. temp = ohci_readl (ohci, &ohci->regs->control);
  175. temp &= OHCI_CTRL_HCFS;
  176. if (temp != OHCI_USB_RESUME) {
  177. ohci_err (ohci, "controller won't resume\n");
  178. spin_lock_irq(&ohci->lock);
  179. return -EBUSY;
  180. }
  181. /* disable old schedule state, reinit from scratch */
  182. ohci_writel (ohci, 0, &ohci->regs->ed_controlhead);
  183. ohci_writel (ohci, 0, &ohci->regs->ed_controlcurrent);
  184. ohci_writel (ohci, 0, &ohci->regs->ed_bulkhead);
  185. ohci_writel (ohci, 0, &ohci->regs->ed_bulkcurrent);
  186. ohci_writel (ohci, 0, &ohci->regs->ed_periodcurrent);
  187. ohci_writel (ohci, (u32) ohci->hcca_dma, &ohci->regs->hcca);
  188. /* Sometimes PCI D3 suspend trashes frame timings ... */
  189. periodic_reinit (ohci);
  190. /* the following code is executed with ohci->lock held and
  191. * irqs disabled if and only if autostopped is true
  192. */
  193. skip_resume:
  194. /* interrupts might have been disabled */
  195. ohci_writel (ohci, OHCI_INTR_INIT, &ohci->regs->intrenable);
  196. if (ohci->ed_rm_list)
  197. ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrenable);
  198. /* Then re-enable operations */
  199. ohci_writel (ohci, OHCI_USB_OPER, &ohci->regs->control);
  200. (void) ohci_readl (ohci, &ohci->regs->control);
  201. if (!autostopped)
  202. msleep (3);
  203. temp = ohci->hc_control;
  204. temp &= OHCI_CTRL_RWC;
  205. temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
  206. ohci->hc_control = temp;
  207. ohci_writel (ohci, temp, &ohci->regs->control);
  208. (void) ohci_readl (ohci, &ohci->regs->control);
  209. /* TRSMRCY */
  210. if (!autostopped) {
  211. msleep (10);
  212. spin_lock_irq (&ohci->lock);
  213. }
  214. /* now ohci->lock is always held and irqs are always disabled */
  215. /* keep it alive for more than ~5x suspend + resume costs */
  216. ohci->next_statechange = jiffies + STATECHANGE_DELAY;
  217. /* maybe turn schedules back on */
  218. enables = 0;
  219. temp = 0;
  220. if (!ohci->ed_rm_list) {
  221. if (ohci->ed_controltail) {
  222. ohci_writel (ohci,
  223. find_head (ohci->ed_controltail)->dma,
  224. &ohci->regs->ed_controlhead);
  225. enables |= OHCI_CTRL_CLE;
  226. temp |= OHCI_CLF;
  227. }
  228. if (ohci->ed_bulktail) {
  229. ohci_writel (ohci, find_head (ohci->ed_bulktail)->dma,
  230. &ohci->regs->ed_bulkhead);
  231. enables |= OHCI_CTRL_BLE;
  232. temp |= OHCI_BLF;
  233. }
  234. }
  235. if (hcd->self.bandwidth_isoc_reqs || hcd->self.bandwidth_int_reqs)
  236. enables |= OHCI_CTRL_PLE|OHCI_CTRL_IE;
  237. if (enables) {
  238. ohci_dbg (ohci, "restarting schedules ... %08x\n", enables);
  239. ohci->hc_control |= enables;
  240. ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
  241. if (temp)
  242. ohci_writel (ohci, temp, &ohci->regs->cmdstatus);
  243. (void) ohci_readl (ohci, &ohci->regs->control);
  244. }
  245. ohci->rh_state = OHCI_RH_RUNNING;
  246. return 0;
  247. }
  248. static int ohci_bus_suspend (struct usb_hcd *hcd)
  249. {
  250. struct ohci_hcd *ohci = hcd_to_ohci (hcd);
  251. int rc;
  252. spin_lock_irq (&ohci->lock);
  253. if (unlikely(!HCD_HW_ACCESSIBLE(hcd)))
  254. rc = -ESHUTDOWN;
  255. else
  256. rc = ohci_rh_suspend (ohci, 0);
  257. spin_unlock_irq (&ohci->lock);
  258. return rc;
  259. }
  260. static int ohci_bus_resume (struct usb_hcd *hcd)
  261. {
  262. struct ohci_hcd *ohci = hcd_to_ohci (hcd);
  263. int rc;
  264. if (time_before (jiffies, ohci->next_statechange))
  265. msleep(5);
  266. spin_lock_irq (&ohci->lock);
  267. if (unlikely(!HCD_HW_ACCESSIBLE(hcd)))
  268. rc = -ESHUTDOWN;
  269. else
  270. rc = ohci_rh_resume (ohci);
  271. spin_unlock_irq (&ohci->lock);
  272. /* poll until we know a device is connected or we autostop */
  273. if (rc == 0)
  274. usb_hcd_poll_rh_status(hcd);
  275. return rc;
  276. }
  277. /* Carry out polling-, autostop-, and autoresume-related state changes */
  278. static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
  279. int any_connected, int rhsc_status)
  280. {
  281. int poll_rh = 1;
  282. int rhsc_enable;
  283. /* Some broken controllers never turn off RHSC in the interrupt
  284. * status register. For their sake we won't re-enable RHSC
  285. * interrupts if the interrupt bit is already active.
  286. */
  287. rhsc_enable = ohci_readl(ohci, &ohci->regs->intrenable) &
  288. OHCI_INTR_RHSC;
  289. switch (ohci->hc_control & OHCI_CTRL_HCFS) {
  290. case OHCI_USB_OPER:
  291. /* If no status changes are pending, enable RHSC interrupts. */
  292. if (!rhsc_enable && !rhsc_status && !changed) {
  293. rhsc_enable = OHCI_INTR_RHSC;
  294. ohci_writel(ohci, rhsc_enable, &ohci->regs->intrenable);
  295. }
  296. /* Keep on polling until we know a device is connected
  297. * and RHSC is enabled, or until we autostop.
  298. */
  299. if (!ohci->autostop) {
  300. if (any_connected ||
  301. !device_may_wakeup(&ohci_to_hcd(ohci)
  302. ->self.root_hub->dev)) {
  303. if (rhsc_enable)
  304. poll_rh = 0;
  305. } else {
  306. ohci->autostop = 1;
  307. ohci->next_statechange = jiffies + HZ;
  308. }
  309. /* if no devices have been attached for one second, autostop */
  310. } else {
  311. if (changed || any_connected) {
  312. ohci->autostop = 0;
  313. ohci->next_statechange = jiffies +
  314. STATECHANGE_DELAY;
  315. } else if (time_after_eq(jiffies,
  316. ohci->next_statechange)
  317. && !ohci->ed_rm_list
  318. && !(ohci->hc_control &
  319. OHCI_SCHED_ENABLES)) {
  320. ohci_rh_suspend(ohci, 1);
  321. if (rhsc_enable)
  322. poll_rh = 0;
  323. }
  324. }
  325. break;
  326. case OHCI_USB_SUSPEND:
  327. case OHCI_USB_RESUME:
  328. /* if there is a port change, autostart or ask to be resumed */
  329. if (changed) {
  330. if (ohci->autostop)
  331. ohci_rh_resume(ohci);
  332. else
  333. usb_hcd_resume_root_hub(ohci_to_hcd(ohci));
  334. /* If remote wakeup is disabled, stop polling */
  335. } else if (!ohci->autostop &&
  336. !ohci_to_hcd(ohci)->self.root_hub->
  337. do_remote_wakeup) {
  338. poll_rh = 0;
  339. } else {
  340. /* If no status changes are pending,
  341. * enable RHSC interrupts
  342. */
  343. if (!rhsc_enable && !rhsc_status) {
  344. rhsc_enable = OHCI_INTR_RHSC;
  345. ohci_writel(ohci, rhsc_enable,
  346. &ohci->regs->intrenable);
  347. }
  348. /* Keep polling until RHSC is enabled */
  349. if (rhsc_enable)
  350. poll_rh = 0;
  351. }
  352. break;
  353. }
  354. return poll_rh;
  355. }
  356. #else /* CONFIG_PM */
  357. static inline int ohci_rh_resume(struct ohci_hcd *ohci)
  358. {
  359. return 0;
  360. }
  361. /* Carry out polling-related state changes.
  362. * autostop isn't used when CONFIG_PM is turned off.
  363. */
  364. static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
  365. int any_connected, int rhsc_status)
  366. {
  367. /* If RHSC is enabled, don't poll */
  368. if (ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC)
  369. return 0;
  370. /* If status changes are pending, continue polling.
  371. * Conversely, if no status changes are pending but the RHSC
  372. * status bit was set, then RHSC may be broken so continue polling.
  373. */
  374. if (changed || rhsc_status)
  375. return 1;
  376. /* It's safe to re-enable RHSC interrupts */
  377. ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable);
  378. return 0;
  379. }
  380. #endif /* CONFIG_PM */
  381. /*-------------------------------------------------------------------------*/
  382. /* build "status change" packet (one or two bytes) from HC registers */
  383. static int
  384. ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
  385. {
  386. struct ohci_hcd *ohci = hcd_to_ohci (hcd);
  387. int i, changed = 0, length = 1;
  388. int any_connected = 0;
  389. int rhsc_status;
  390. unsigned long flags;
  391. spin_lock_irqsave (&ohci->lock, flags);
  392. if (!HCD_HW_ACCESSIBLE(hcd))
  393. goto done;
  394. /* undocumented erratum seen on at least rev D */
  395. if ((ohci->flags & OHCI_QUIRK_AMD756)
  396. && (roothub_a (ohci) & RH_A_NDP) > MAX_ROOT_PORTS) {
  397. ohci_warn (ohci, "bogus NDP, rereads as NDP=%d\n",
  398. ohci_readl (ohci, &ohci->regs->roothub.a) & RH_A_NDP);
  399. /* retry later; "should not happen" */
  400. goto done;
  401. }
  402. /* init status */
  403. if (roothub_status (ohci) & (RH_HS_LPSC | RH_HS_OCIC))
  404. buf [0] = changed = 1;
  405. else
  406. buf [0] = 0;
  407. if (ohci->num_ports > 7) {
  408. buf [1] = 0;
  409. length++;
  410. }
  411. /* Clear the RHSC status flag before reading the port statuses */
  412. ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrstatus);
  413. rhsc_status = ohci_readl(ohci, &ohci->regs->intrstatus) &
  414. OHCI_INTR_RHSC;
  415. /* look at each port */
  416. for (i = 0; i < ohci->num_ports; i++) {
  417. u32 status = roothub_portstatus (ohci, i);
  418. /* can't autostop if ports are connected */
  419. any_connected |= (status & RH_PS_CCS);
  420. if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
  421. | RH_PS_OCIC | RH_PS_PRSC)) {
  422. changed = 1;
  423. if (i < 7)
  424. buf [0] |= 1 << (i + 1);
  425. else
  426. buf [1] |= 1 << (i - 7);
  427. }
  428. }
  429. if (ohci_root_hub_state_changes(ohci, changed,
  430. any_connected, rhsc_status))
  431. set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
  432. else
  433. clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
  434. done:
  435. spin_unlock_irqrestore (&ohci->lock, flags);
  436. return changed ? length : 0;
  437. }
  438. /*-------------------------------------------------------------------------*/
  439. static void
  440. ohci_hub_descriptor (
  441. struct ohci_hcd *ohci,
  442. struct usb_hub_descriptor *desc
  443. ) {
  444. u32 rh = roothub_a (ohci);
  445. u16 temp;
  446. desc->bDescriptorType = 0x29;
  447. desc->bPwrOn2PwrGood = (rh & RH_A_POTPGT) >> 24;
  448. desc->bHubContrCurrent = 0;
  449. desc->bNbrPorts = ohci->num_ports;
  450. temp = 1 + (ohci->num_ports / 8);
  451. desc->bDescLength = 7 + 2 * temp;
  452. temp = 0;
  453. if (rh & RH_A_NPS) /* no power switching? */
  454. temp |= 0x0002;
  455. if (rh & RH_A_PSM) /* per-port power switching? */
  456. temp |= 0x0001;
  457. if (rh & RH_A_NOCP) /* no overcurrent reporting? */
  458. temp |= 0x0010;
  459. else if (rh & RH_A_OCPM) /* per-port overcurrent reporting? */
  460. temp |= 0x0008;
  461. desc->wHubCharacteristics = (__force __u16)cpu_to_hc16(ohci, temp);
  462. /* ports removable, and usb 1.0 legacy PortPwrCtrlMask */
  463. rh = roothub_b (ohci);
  464. memset(desc->u.hs.DeviceRemovable, 0xff,
  465. sizeof(desc->u.hs.DeviceRemovable));
  466. desc->u.hs.DeviceRemovable[0] = rh & RH_B_DR;
  467. if (ohci->num_ports > 7) {
  468. desc->u.hs.DeviceRemovable[1] = (rh & RH_B_DR) >> 8;
  469. desc->u.hs.DeviceRemovable[2] = 0xff;
  470. } else
  471. desc->u.hs.DeviceRemovable[1] = 0xff;
  472. }
  473. /*-------------------------------------------------------------------------*/
  474. #ifdef CONFIG_USB_OTG
  475. static int ohci_start_port_reset (struct usb_hcd *hcd, unsigned port)
  476. {
  477. struct ohci_hcd *ohci = hcd_to_ohci (hcd);
  478. u32 status;
  479. if (!port)
  480. return -EINVAL;
  481. port--;
  482. /* start port reset before HNP protocol times out */
  483. status = ohci_readl(ohci, &ohci->regs->roothub.portstatus [port]);
  484. if (!(status & RH_PS_CCS))
  485. return -ENODEV;
  486. /* khubd will finish the reset later */
  487. ohci_writel(ohci, RH_PS_PRS, &ohci->regs->roothub.portstatus [port]);
  488. return 0;
  489. }
  490. #else
  491. #define ohci_start_port_reset NULL
  492. #endif
  493. /*-------------------------------------------------------------------------*/
  494. /* See usb 7.1.7.5: root hubs must issue at least 50 msec reset signaling,
  495. * not necessarily continuous ... to guard against resume signaling.
  496. */
  497. #define PORT_RESET_MSEC 50
  498. /* this timer value might be vendor-specific ... */
  499. #define PORT_RESET_HW_MSEC 10
  500. /* wrap-aware logic morphed from <linux/jiffies.h> */
  501. #define tick_before(t1,t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
  502. /* called from some task, normally khubd */
  503. static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port)
  504. {
  505. __hc32 __iomem *portstat = &ohci->regs->roothub.portstatus [port];
  506. u32 temp = 0;
  507. u16 now = ohci_readl(ohci, &ohci->regs->fmnumber);
  508. u16 reset_done = now + PORT_RESET_MSEC;
  509. int limit_1 = DIV_ROUND_UP(PORT_RESET_MSEC, PORT_RESET_HW_MSEC);
  510. /* build a "continuous enough" reset signal, with up to
  511. * 3msec gap between pulses. scheduler HZ==100 must work;
  512. * this might need to be deadline-scheduled.
  513. */
  514. do {
  515. int limit_2;
  516. /* spin until any current reset finishes */
  517. limit_2 = PORT_RESET_HW_MSEC * 2;
  518. while (--limit_2 >= 0) {
  519. temp = ohci_readl (ohci, portstat);
  520. /* handle e.g. CardBus eject */
  521. if (temp == ~(u32)0)
  522. return -ESHUTDOWN;
  523. if (!(temp & RH_PS_PRS))
  524. break;
  525. udelay (500);
  526. }
  527. /* timeout (a hardware error) has been observed when
  528. * EHCI sets CF while this driver is resetting a port;
  529. * presumably other disconnect paths might do it too.
  530. */
  531. if (limit_2 < 0) {
  532. ohci_dbg(ohci,
  533. "port[%d] reset timeout, stat %08x\n",
  534. port, temp);
  535. break;
  536. }
  537. if (!(temp & RH_PS_CCS))
  538. break;
  539. if (temp & RH_PS_PRSC)
  540. ohci_writel (ohci, RH_PS_PRSC, portstat);
  541. /* start the next reset, sleep till it's probably done */
  542. ohci_writel (ohci, RH_PS_PRS, portstat);
  543. msleep(PORT_RESET_HW_MSEC);
  544. now = ohci_readl(ohci, &ohci->regs->fmnumber);
  545. } while (tick_before(now, reset_done) && --limit_1 >= 0);
  546. /* caller synchronizes using PRSC ... and handles PRS
  547. * still being set when this returns.
  548. */
  549. return 0;
  550. }
  551. static int ohci_hub_control (
  552. struct usb_hcd *hcd,
  553. u16 typeReq,
  554. u16 wValue,
  555. u16 wIndex,
  556. char *buf,
  557. u16 wLength
  558. ) {
  559. struct ohci_hcd *ohci = hcd_to_ohci (hcd);
  560. int ports = ohci->num_ports;
  561. u32 temp;
  562. int retval = 0;
  563. if (unlikely(!HCD_HW_ACCESSIBLE(hcd)))
  564. return -ESHUTDOWN;
  565. switch (typeReq) {
  566. case ClearHubFeature:
  567. switch (wValue) {
  568. case C_HUB_OVER_CURRENT:
  569. ohci_writel (ohci, RH_HS_OCIC,
  570. &ohci->regs->roothub.status);
  571. case C_HUB_LOCAL_POWER:
  572. break;
  573. default:
  574. goto error;
  575. }
  576. break;
  577. case ClearPortFeature:
  578. if (!wIndex || wIndex > ports)
  579. goto error;
  580. wIndex--;
  581. switch (wValue) {
  582. case USB_PORT_FEAT_ENABLE:
  583. temp = RH_PS_CCS;
  584. break;
  585. case USB_PORT_FEAT_C_ENABLE:
  586. temp = RH_PS_PESC;
  587. break;
  588. case USB_PORT_FEAT_SUSPEND:
  589. temp = RH_PS_POCI;
  590. break;
  591. case USB_PORT_FEAT_C_SUSPEND:
  592. temp = RH_PS_PSSC;
  593. break;
  594. case USB_PORT_FEAT_POWER:
  595. temp = RH_PS_LSDA;
  596. break;
  597. case USB_PORT_FEAT_C_CONNECTION:
  598. temp = RH_PS_CSC;
  599. break;
  600. case USB_PORT_FEAT_C_OVER_CURRENT:
  601. temp = RH_PS_OCIC;
  602. break;
  603. case USB_PORT_FEAT_C_RESET:
  604. temp = RH_PS_PRSC;
  605. break;
  606. default:
  607. goto error;
  608. }
  609. ohci_writel (ohci, temp,
  610. &ohci->regs->roothub.portstatus [wIndex]);
  611. // ohci_readl (ohci, &ohci->regs->roothub.portstatus [wIndex]);
  612. break;
  613. case GetHubDescriptor:
  614. ohci_hub_descriptor (ohci, (struct usb_hub_descriptor *) buf);
  615. break;
  616. case GetHubStatus:
  617. temp = roothub_status (ohci) & ~(RH_HS_CRWE | RH_HS_DRWE);
  618. put_unaligned_le32(temp, buf);
  619. break;
  620. case GetPortStatus:
  621. if (!wIndex || wIndex > ports)
  622. goto error;
  623. wIndex--;
  624. temp = roothub_portstatus (ohci, wIndex);
  625. put_unaligned_le32(temp, buf);
  626. #ifndef OHCI_VERBOSE_DEBUG
  627. if (*(u16*)(buf+2)) /* only if wPortChange is interesting */
  628. #endif
  629. dbg_port (ohci, "GetStatus", wIndex, temp);
  630. break;
  631. case SetHubFeature:
  632. switch (wValue) {
  633. case C_HUB_OVER_CURRENT:
  634. // FIXME: this can be cleared, yes?
  635. case C_HUB_LOCAL_POWER:
  636. break;
  637. default:
  638. goto error;
  639. }
  640. break;
  641. case SetPortFeature:
  642. if (!wIndex || wIndex > ports)
  643. goto error;
  644. wIndex--;
  645. switch (wValue) {
  646. case USB_PORT_FEAT_SUSPEND:
  647. #ifdef CONFIG_USB_OTG
  648. if (hcd->self.otg_port == (wIndex + 1)
  649. && hcd->self.b_hnp_enable)
  650. ohci->start_hnp(ohci);
  651. else
  652. #endif
  653. ohci_writel (ohci, RH_PS_PSS,
  654. &ohci->regs->roothub.portstatus [wIndex]);
  655. break;
  656. case USB_PORT_FEAT_POWER:
  657. ohci_writel (ohci, RH_PS_PPS,
  658. &ohci->regs->roothub.portstatus [wIndex]);
  659. break;
  660. case USB_PORT_FEAT_RESET:
  661. retval = root_port_reset (ohci, wIndex);
  662. break;
  663. default:
  664. goto error;
  665. }
  666. break;
  667. default:
  668. error:
  669. /* "protocol stall" on error */
  670. retval = -EPIPE;
  671. }
  672. return retval;
  673. }