projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[adm5120] disable unsupported boards in the LED driver by default
[openwrt.git] / target / linux / adm5120 / files / drivers / usb / host / adm5120-hub.c
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
12 /*
13 * OHCI Root Hub ... the nonsharable stuff
14 */
15
16 #define dbg_port(hc,label,num,value) \
17 admhc_dbg(hc, \
18 "%s port%d " \
19 "= 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
20 label, num, temp, \
21 (temp & ADMHC_PS_PRSC) ? " PRSC" : "", \
22 (temp & ADMHC_PS_OCIC) ? " OCIC" : "", \
23 (temp & ADMHC_PS_PSSC) ? " PSSC" : "", \
24 (temp & ADMHC_PS_PESC) ? " PESC" : "", \
25 (temp & ADMHC_PS_CSC) ? " CSC" : "", \
26 \
27 (temp & ADMHC_PS_LSDA) ? " LSDA" : "", \
28 (temp & ADMHC_PS_PPS) ? " PPS" : "", \
29 (temp & ADMHC_PS_PRS) ? " PRS" : "", \
30 (temp & ADMHC_PS_POCI) ? " POCI" : "", \
31 (temp & ADMHC_PS_PSS) ? " PSS" : "", \
32 \
33 (temp & ADMHC_PS_PES) ? " PES" : "", \
34 (temp & ADMHC_PS_CCS) ? " CCS" : "" \
35 );
36
37 #define dbg_port_write(hc,label,num,value) \
38 admhc_dbg(hc, \
39 "%s port%d " \
40 "= 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
41 label, num, temp, \
42 (temp & ADMHC_PS_PRSC) ? " PRSC" : "", \
43 (temp & ADMHC_PS_OCIC) ? " OCIC" : "", \
44 (temp & ADMHC_PS_PSSC) ? " PSSC" : "", \
45 (temp & ADMHC_PS_PESC) ? " PESC" : "", \
46 (temp & ADMHC_PS_CSC) ? " CSC" : "", \
47 \
48 (temp & ADMHC_PS_CPP) ? " CPP" : "", \
49 (temp & ADMHC_PS_SPP) ? " SPP" : "", \
50 (temp & ADMHC_PS_SPR) ? " SPR" : "", \
51 (temp & ADMHC_PS_CPS) ? " CPS" : "", \
52 (temp & ADMHC_PS_SPS) ? " SPS" : "", \
53 \
54 (temp & ADMHC_PS_SPE) ? " SPE" : "", \
55 (temp & ADMHC_PS_CPE) ? " CPE" : "" \
56 );
57
58 /*-------------------------------------------------------------------------*/
59
60 /* hcd->hub_irq_enable() */
61 static void admhc_rhsc_enable(struct usb_hcd *hcd)
62 {
63 struct admhcd *ahcd = hcd_to_admhcd(hcd);
64
65 spin_lock_irq(&ahcd->lock);
66 if (!ahcd->autostop)
67 del_timer(&hcd->rh_timer); /* Prevent next poll */
68 admhc_intr_enable(ahcd, ADMHC_INTR_INSM);
69 spin_unlock_irq(&ahcd->lock);
70 }
71
72 #define OHCI_SCHED_ENABLES \
73 (OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
74
75 #ifdef CONFIG_PM
76 static int admhc_restart(struct admhcd *ahcd);
77
78 static int admhc_rh_suspend(struct admhcd *ahcd, int autostop)
79 __releases(ahcd->lock)
80 __acquires(ahcd->lock)
81 {
82 int status = 0;
83
84 ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
85 switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
86 case OHCI_USB_RESUME:
87 admhc_dbg(ahcd, "resume/suspend?\n");
88 ahcd->hc_control &= ~OHCI_CTRL_HCFS;
89 ahcd->hc_control |= OHCI_USB_RESET;
90 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
91 (void) admhc_readl(ahcd, &ahcd->regs->control);
92 /* FALL THROUGH */
93 case OHCI_USB_RESET:
94 status = -EBUSY;
95 admhc_dbg(ahcd, "needs reinit!\n");
96 goto done;
97 case OHCI_USB_SUSPEND:
98 if (!ahcd->autostop) {
99 admhc_dbg(ahcd, "already suspended\n");
100 goto done;
101 }
102 }
103 admhc_dbg(ahcd, "%s root hub\n",
104 autostop ? "auto-stop" : "suspend");
105
106 /* First stop any processing */
107 if (!autostop && (ahcd->hc_control & OHCI_SCHED_ENABLES)) {
108 ahcd->hc_control &= ~OHCI_SCHED_ENABLES;
109 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
110 ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
111 admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->intrstatus);
112
113 /* sched disables take effect on the next frame,
114 * then the last WDH could take 6+ msec
115 */
116 admhc_dbg(ahcd, "stopping schedules ...\n");
117 ahcd->autostop = 0;
118 spin_unlock_irq (&ahcd->lock);
119 msleep (8);
120 spin_lock_irq (&ahcd->lock);
121 }
122 dl_done_list (ahcd);
123 finish_unlinks (ahcd, admhc_frame_no(ahcd));
124
125 /* maybe resume can wake root hub */
126 if (device_may_wakeup(&admhcd_to_hcd(ahcd)->self.root_hub->dev) ||
127 autostop)
128 ahcd->hc_control |= OHCI_CTRL_RWE;
129 else {
130 admhc_writel(ahcd, OHCI_INTR_RHSC, &ahcd->regs->intrdisable);
131 ahcd->hc_control &= ~OHCI_CTRL_RWE;
132 }
133
134 /* Suspend hub ... this is the "global (to this bus) suspend" mode,
135 * which doesn't imply ports will first be individually suspended.
136 */
137 ahcd->hc_control &= ~OHCI_CTRL_HCFS;
138 ahcd->hc_control |= OHCI_USB_SUSPEND;
139 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
140 (void) admhc_readl(ahcd, &ahcd->regs->control);
141
142 /* no resumes until devices finish suspending */
143 if (!autostop) {
144 ahcd->next_statechange = jiffies + msecs_to_jiffies (5);
145 ahcd->autostop = 0;
146 }
147
148 done:
149 return status;
150 }
151
152 static inline struct ed *find_head(struct ed *ed)
153 {
154 /* for bulk and control lists */
155 while (ed->ed_prev)
156 ed = ed->ed_prev;
157 return ed;
158 }
159
160 /* caller has locked the root hub */
161 static int admhc_rh_resume(struct admhcd *ahcd)
162 __releases(ahcd->lock)
163 __acquires(ahcd->lock)
164 {
165 struct usb_hcd *hcd = admhcd_to_hcd (ahcd);
166 u32 temp, enables;
167 int status = -EINPROGRESS;
168 int autostopped = ahcd->autostop;
169
170 ahcd->autostop = 0;
171 ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control);
172
173 if (ahcd->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
174 /* this can happen after resuming a swsusp snapshot */
175 if (hcd->state == HC_STATE_RESUMING) {
176 admhc_dbg(ahcd, "BIOS/SMM active, control %03x\n",
177 ahcd->hc_control);
178 status = -EBUSY;
179 /* this happens when pmcore resumes HC then root */
180 } else {
181 admhc_dbg(ahcd, "duplicate resume\n");
182 status = 0;
183 }
184 } else switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
185 case OHCI_USB_SUSPEND:
186 ahcd->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES);
187 ahcd->hc_control |= OHCI_USB_RESUME;
188 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
189 (void) admhc_readl(ahcd, &ahcd->regs->control);
190 admhc_dbg(ahcd, "%s root hub\n",
191 autostopped ? "auto-start" : "resume");
192 break;
193 case OHCI_USB_RESUME:
194 /* HCFS changes sometime after INTR_RD */
195 admhc_dbg(ahcd, "%swakeup root hub\n",
196 autostopped ? "auto-" : "");
197 break;
198 case OHCI_USB_OPER:
199 /* this can happen after resuming a swsusp snapshot */
200 admhc_dbg(ahcd, "snapshot resume? reinit\n");
201 status = -EBUSY;
202 break;
203 default: /* RESET, we lost power */
204 admhc_dbg(ahcd, "lost power\n");
205 status = -EBUSY;
206 }
207 if (status == -EBUSY) {
208 if (!autostopped) {
209 spin_unlock_irq (&ahcd->lock);
210 (void) ahcd_init (ahcd);
211 status = admhc_restart (ahcd);
212 spin_lock_irq (&ahcd->lock);
213 }
214 return status;
215 }
216 if (status != -EINPROGRESS)
217 return status;
218 if (autostopped)
219 goto skip_resume;
220 spin_unlock_irq (&ahcd->lock);
221
222 /* Some controllers (lucent erratum) need extra-long delays */
223 msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);
224
225 temp = admhc_readl(ahcd, &ahcd->regs->control);
226 temp &= OHCI_CTRL_HCFS;
227 if (temp != OHCI_USB_RESUME) {
228 admhc_err (ahcd, "controller won't resume\n");
229 spin_lock_irq(&ahcd->lock);
230 return -EBUSY;
231 }
232
233 /* disable old schedule state, reinit from scratch */
234 admhc_writel(ahcd, 0, &ahcd->regs->ed_controlhead);
235 admhc_writel(ahcd, 0, &ahcd->regs->ed_controlcurrent);
236 admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkhead);
237 admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkcurrent);
238 admhc_writel(ahcd, 0, &ahcd->regs->ed_periodcurrent);
239 admhc_writel(ahcd, (u32) ahcd->hcca_dma, &ahcd->ahcd->regs->hcca);
240
241 /* Sometimes PCI D3 suspend trashes frame timings ... */
242 periodic_reinit(ahcd);
243
244 /* the following code is executed with ahcd->lock held and
245 * irqs disabled if and only if autostopped is true
246 */
247
248 skip_resume:
249 /* interrupts might have been disabled */
250 admhc_writel(ahcd, OHCI_INTR_INIT, &ahcd->regs->int_enable);
251 if (ahcd->ed_rm_list)
252 admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->int_enable);
253
254 /* Then re-enable operations */
255 admhc_writel(ahcd, OHCI_USB_OPER, &ahcd->regs->control);
256 (void) admhc_readl(ahcd, &ahcd->regs->control);
257 if (!autostopped)
258 msleep (3);
259
260 temp = ahcd->hc_control;
261 temp &= OHCI_CTRL_RWC;
262 temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
263 ahcd->hc_control = temp;
264 admhc_writel(ahcd, temp, &ahcd->regs->control);
265 (void) admhc_readl(ahcd, &ahcd->regs->control);
266
267 /* TRSMRCY */
268 if (!autostopped) {
269 msleep (10);
270 spin_lock_irq (&ahcd->lock);
271 }
272 /* now ahcd->lock is always held and irqs are always disabled */
273
274 /* keep it alive for more than ~5x suspend + resume costs */
275 ahcd->next_statechange = jiffies + STATECHANGE_DELAY;
276
277 /* maybe turn schedules back on */
278 enables = 0;
279 temp = 0;
280 if (!ahcd->ed_rm_list) {
281 if (ahcd->ed_controltail) {
282 admhc_writel(ahcd,
283 find_head (ahcd->ed_controltail)->dma,
284 &ahcd->regs->ed_controlhead);
285 enables |= OHCI_CTRL_CLE;
286 temp |= OHCI_CLF;
287 }
288 if (ahcd->ed_bulktail) {
289 admhc_writel(ahcd, find_head (ahcd->ed_bulktail)->dma,
290 &ahcd->regs->ed_bulkhead);
291 enables |= OHCI_CTRL_BLE;
292 temp |= OHCI_BLF;
293 }
294 }
295 if (hcd->self.bandwidth_isoc_reqs || hcd->self.bandwidth_int_reqs)
296 enables |= OHCI_CTRL_PLE|OHCI_CTRL_IE;
297 if (enables) {
298 admhc_dbg(ahcd, "restarting schedules ... %08x\n", enables);
299 ahcd->hc_control |= enables;
300 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control);
301 if (temp)
302 admhc_writel(ahcd, temp, &ahcd->regs->cmdstatus);
303 (void) admhc_readl(ahcd, &ahcd->regs->control);
304 }
305
306 return 0;
307 }
308
309 static int admhc_bus_suspend(struct usb_hcd *hcd)
310 {
311 struct admhcd *ahcd = hcd_to_admhcd(hcd);
312 int rc;
313
314 spin_lock_irq(&ahcd->lock);
315
316 if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
317 rc = -ESHUTDOWN;
318 else
319 rc = admhc_rh_suspend (ahcd, 0);
320 spin_unlock_irq(&ahcd->lock);
321 return rc;
322 }
323
324 static int admhc_bus_resume(struct usb_hcd *hcd)
325 {
326 struct admhcd *ahcd = hcd_to_admhcd(hcd);
327 int rc;
328
329 if (time_before(jiffies, ahcd->next_statechange))
330 msleep(5);
331
332 spin_lock_irq (&ahcd->lock);
333
334 if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
335 rc = -ESHUTDOWN;
336 else
337 rc = admhc_rh_resume (ahcd);
338 spin_unlock_irq(&ahcd->lock);
339
340 /* poll until we know a device is connected or we autostop */
341 if (rc == 0)
342 usb_hcd_poll_rh_status(hcd);
343 return rc;
344 }
345
346 /* Carry out polling-, autostop-, and autoresume-related state changes */
347 static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed,
348 int any_connected)
349 {
350 int poll_rh = 1;
351
352 switch (ahcd->hc_control & OHCI_CTRL_HCFS) {
353
354 case OHCI_USB_OPER:
355 /* keep on polling until we know a device is connected
356 * and RHSC is enabled */
357 if (!ahcd->autostop) {
358 if (any_connected ||
359 !device_may_wakeup(&admhcd_to_hcd(ahcd)
360 ->self.root_hub->dev)) {
361 if (admhc_readl(ahcd, &ahcd->regs->int_enable) &
362 OHCI_INTR_RHSC)
363 poll_rh = 0;
364 } else {
365 ahcd->autostop = 1;
366 ahcd->next_statechange = jiffies + HZ;
367 }
368
369 /* if no devices have been attached for one second, autostop */
370 } else {
371 if (changed || any_connected) {
372 ahcd->autostop = 0;
373 ahcd->next_statechange = jiffies +
374 STATECHANGE_DELAY;
375 } else if (time_after_eq(jiffies,
376 ahcd->next_statechange)
377 && !ahcd->ed_rm_list
378 && !(ahcd->hc_control &
379 OHCI_SCHED_ENABLES)) {
380 ahcd_rh_suspend(ahcd, 1);
381 }
382 }
383 break;
384
385 /* if there is a port change, autostart or ask to be resumed */
386 case OHCI_USB_SUSPEND:
387 case OHCI_USB_RESUME:
388 if (changed) {
389 if (ahcd->autostop)
390 admhc_rh_resume(ahcd);
391 else
392 usb_hcd_resume_root_hub(admhcd_to_hcd(ahcd));
393 } else {
394 /* everything is idle, no need for polling */
395 poll_rh = 0;
396 }
397 break;
398 }
399 return poll_rh;
400 }
401
402 #else /* CONFIG_PM */
403
404 static inline int admhc_rh_resume(struct admhcd *ahcd)
405 {
406 return 0;
407 }
408
409 /* Carry out polling-related state changes.
410 * autostop isn't used when CONFIG_PM is turned off.
411 */
412 static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed,
413 int any_connected)
414 {
415 int poll_rh = 1;
416
417 /* keep on polling until RHSC is enabled */
418 if (admhc_readl(ahcd, &ahcd->regs->int_enable) & ADMHC_INTR_INSM)
419 poll_rh = 0;
420
421 return poll_rh;
422 }
423
424 #endif /* CONFIG_PM */
425
426 /*-------------------------------------------------------------------------*/
427
428 /* build "status change" packet (one or two bytes) from HC registers */
429
430 static int
431 admhc_hub_status_data(struct usb_hcd *hcd, char *buf)
432 {
433 struct admhcd *ahcd = hcd_to_admhcd(hcd);
434 int i, changed = 0, length = 1;
435 int any_connected = 0;
436 unsigned long flags;
437 u32 status;
438
439 spin_lock_irqsave(&ahcd->lock, flags);
440 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
441 goto done;
442
443 /* init status */
444 status = admhc_get_rhdesc(ahcd);
445 if (status & (ADMHC_RH_LPSC | ADMHC_RH_OCIC))
446 buf [0] = changed = 1;
447 else
448 buf [0] = 0;
449 if (ahcd->num_ports > 7) {
450 buf [1] = 0;
451 length++;
452 }
453
454 /* look at each port */
455 for (i = 0; i < ahcd->num_ports; i++) {
456 status = admhc_get_portstatus(ahcd, i);
457
458 /* can't autostop if ports are connected */
459 any_connected |= (status & ADMHC_PS_CCS);
460
461 if (status & (ADMHC_PS_CSC | ADMHC_PS_PESC | ADMHC_PS_PSSC
462 | ADMHC_PS_OCIC | ADMHC_PS_PRSC)) {
463 changed = 1;
464 if (i < 7)
465 buf [0] |= 1 << (i + 1);
466 else
467 buf [1] |= 1 << (i - 7);
468 }
469 }
470
471 hcd->poll_rh = admhc_root_hub_state_changes(ahcd, changed,
472 any_connected);
473
474 done:
475 spin_unlock_irqrestore(&ahcd->lock, flags);
476
477 return changed ? length : 0;
478 }
479
480 /*-------------------------------------------------------------------------*/
481
482 static void admhc_hub_descriptor(struct admhcd *ahcd,
483 struct usb_hub_descriptor *desc)
484 {
485 u32 rh = admhc_get_rhdesc(ahcd);
486 u16 temp;
487
488 desc->bDescriptorType = USB_DT_HUB; /* Hub-descriptor */
489 desc->bPwrOn2PwrGood = ADMHC_POTPGT/2; /* use default value */
490 desc->bHubContrCurrent = 0x00; /* 0mA */
491
492 desc->bNbrPorts = ahcd->num_ports;
493 temp = 1 + (ahcd->num_ports / 8);
494 desc->bDescLength = USB_DT_HUB_NONVAR_SIZE + 2 * temp;
495
496 /* FIXME */
497 temp = 0;
498 if (rh & ADMHC_RH_NPS) /* no power switching? */
499 temp |= 0x0002;
500 if (rh & ADMHC_RH_PSM) /* per-port power switching? */
501 temp |= 0x0001;
502 if (rh & ADMHC_RH_NOCP) /* no overcurrent reporting? */
503 temp |= 0x0010;
504 else if (rh & ADMHC_RH_OCPM) /* per-port overcurrent reporting? */
505 temp |= 0x0008;
506 desc->wHubCharacteristics = (__force __u16)cpu_to_hc16(ahcd, temp);
507
508 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
509 desc->bitmap [0] = 0;
510 desc->bitmap [0] = ~0;
511 }
512
513 /*-------------------------------------------------------------------------*/
514
515 #ifdef CONFIG_USB_OTG
516
517 static int admhc_start_port_reset(struct usb_hcd *hcd, unsigned port)
518 {
519 struct admhcd *ahcd = hcd_to_admhcd(hcd);
520 u32 status;
521
522 if (!port)
523 return -EINVAL;
524 port--;
525
526 /* start port reset before HNP protocol times out */
527 status = admhc_readl(ahcd, &ahcd->regs->portstatus[port]);
528 if (!(status & ADMHC_PS_CCS))
529 return -ENODEV;
530
531 /* khubd will finish the reset later */
532 admhc_writel(ahcd, ADMHC_PS_PRS, &ahcd->regs->portstatus[port]);
533 return 0;
534 }
535
536 static void start_hnp(struct admhcd *ahcd);
537
538 #else
539
540 #define admhc_start_port_reset NULL
541
542 #endif
543
544 /*-------------------------------------------------------------------------*/
545
546
547 /* See usb 7.1.7.5: root hubs must issue at least 50 msec reset signaling,
548 * not necessarily continuous ... to guard against resume signaling.
549 * The short timeout is safe for non-root hubs, and is backward-compatible
550 * with earlier Linux hosts.
551 */
552 #ifdef CONFIG_USB_SUSPEND
553 #define PORT_RESET_MSEC 50
554 #else
555 #define PORT_RESET_MSEC 10
556 #endif
557
558 /* this timer value might be vendor-specific ... */
559 #define PORT_RESET_HW_MSEC 10
560
561 /* wrap-aware logic morphed from <linux/jiffies.h> */
562 #define tick_before(t1,t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
563
564 /* called from some task, normally khubd */
565 static inline int root_port_reset(struct admhcd *ahcd, unsigned port)
566 {
567 #if 0
568 /* FIXME: revert to this when frame numbers are updated */
569 __hc32 __iomem *portstat = &ahcd->regs->portstatus[port];
570 u32 temp;
571 u16 now = admhc_readl(ahcd, &ahcd->regs->fmnumber);
572 u16 reset_done = now + PORT_RESET_MSEC;
573
574 /* build a "continuous enough" reset signal, with up to
575 * 3msec gap between pulses. scheduler HZ==100 must work;
576 * this might need to be deadline-scheduled.
577 */
578 do {
579 /* spin until any current reset finishes */
580 for (;;) {
581 temp = admhc_readl(ahcd, portstat);
582 /* handle e.g. CardBus eject */
583 if (temp == ~(u32)0)
584 return -ESHUTDOWN;
585 if (!(temp & ADMHC_PS_PRS))
586 break;
587 udelay (500);
588 }
589
590 if (!(temp & ADMHC_PS_CCS))
591 break;
592 if (temp & ADMHC_PS_PRSC)
593 admhc_writel(ahcd, ADMHC_PS_PRSC, portstat);
594
595 /* start the next reset, sleep till it's probably done */
596 admhc_writel(ahcd, ADMHC_PS_PRS, portstat);
597 msleep(PORT_RESET_HW_MSEC);
598 now = admhc_readl(ahcd, &ahcd->regs->fmnumber);
599 } while (tick_before(now, reset_done));
600 /* caller synchronizes using PRSC */
601 #else
602 __hc32 __iomem *portstat = &ahcd->regs->portstatus[port];
603 u32 temp;
604 unsigned long reset_done = jiffies + msecs_to_jiffies(PORT_RESET_MSEC);
605
606 /* build a "continuous enough" reset signal, with up to
607 * 3msec gap between pulses. scheduler HZ==100 must work;
608 * this might need to be deadline-scheduled.
609 */
610 do {
611 /* spin until any current reset finishes */
612 for (;;) {
613 temp = admhc_readl(ahcd, portstat);
614 /* handle e.g. CardBus eject */
615 if (temp == ~(u32)0)
616 return -ESHUTDOWN;
617 if (!(temp & ADMHC_PS_PRS))
618 break;
619 udelay (500);
620 }
621
622 if (!(temp & ADMHC_PS_CCS))
623 break;
624
625 if (temp & ADMHC_PS_PRSC)
626 admhc_writel(ahcd, ADMHC_PS_PRSC, portstat);
627
628 /* start the next reset, sleep till it's probably done */
629 admhc_writel(ahcd, ADMHC_PS_PRS, portstat);
630 msleep(PORT_RESET_HW_MSEC);
631 } while (time_before(jiffies, reset_done));
632
633 admhc_writel(ahcd, ADMHC_PS_SPE | ADMHC_PS_CSC, portstat);
634 msleep(100);
635 #endif
636 return 0;
637 }
638
639 static int admhc_hub_control (
640 struct usb_hcd *hcd,
641 u16 typeReq,
642 u16 wValue,
643 u16 wIndex,
644 char *buf,
645 u16 wLength
646 ) {
647 struct admhcd *ahcd = hcd_to_admhcd(hcd);
648 int ports = hcd_to_bus (hcd)->root_hub->maxchild;
649 u32 temp;
650 int retval = 0;
651
652 if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
653 return -ESHUTDOWN;
654
655 switch (typeReq) {
656 case ClearHubFeature:
657 switch (wValue) {
658 case C_HUB_OVER_CURRENT:
659 #if 0 /* FIXME */
660 admhc_writel(ahcd, ADMHC_RH_OCIC,
661 &ahcd->regs->roothub.status);
662 #endif
663 case C_HUB_LOCAL_POWER:
664 break;
665 default:
666 goto error;
667 }
668 break;
669 case ClearPortFeature:
670 if (!wIndex || wIndex > ports)
671 goto error;
672 wIndex--;
673
674 switch (wValue) {
675 case USB_PORT_FEAT_ENABLE:
676 temp = ADMHC_PS_CPE;
677 break;
678 case USB_PORT_FEAT_SUSPEND:
679 temp = ADMHC_PS_CPS;
680 break;
681 case USB_PORT_FEAT_POWER:
682 temp = ADMHC_PS_CPP;
683 break;
684 case USB_PORT_FEAT_C_CONNECTION:
685 temp = ADMHC_PS_CSC;
686 break;
687 case USB_PORT_FEAT_C_ENABLE:
688 temp = ADMHC_PS_PESC;
689 break;
690 case USB_PORT_FEAT_C_SUSPEND:
691 temp = ADMHC_PS_PSSC;
692 break;
693 case USB_PORT_FEAT_C_OVER_CURRENT:
694 temp = ADMHC_PS_OCIC;
695 break;
696 case USB_PORT_FEAT_C_RESET:
697 temp = ADMHC_PS_PRSC;
698 break;
699 default:
700 goto error;
701 }
702 admhc_writel(ahcd, temp, &ahcd->regs->portstatus[wIndex]);
703 break;
704 case GetHubDescriptor:
705 admhc_hub_descriptor(ahcd, (struct usb_hub_descriptor *) buf);
706 break;
707 case GetHubStatus:
708 temp = admhc_get_rhdesc(ahcd);
709 temp &= ~(ADMHC_RH_CRWE | ADMHC_RH_DRWE);
710 put_unaligned(cpu_to_le32 (temp), (__le32 *) buf);
711 break;
712 case GetPortStatus:
713 if (!wIndex || wIndex > ports)
714 goto error;
715 wIndex--;
716 temp = admhc_get_portstatus(ahcd, wIndex);
717 put_unaligned(cpu_to_le32 (temp), (__le32 *) buf);
718
719 dbg_port(ahcd, "GetPortStatus", wIndex, temp);
720 break;
721 case SetHubFeature:
722 switch (wValue) {
723 case C_HUB_OVER_CURRENT:
724 // FIXME: this can be cleared, yes?
725 case C_HUB_LOCAL_POWER:
726 break;
727 default:
728 goto error;
729 }
730 break;
731 case SetPortFeature:
732 if (!wIndex || wIndex > ports)
733 goto error;
734 wIndex--;
735
736 switch (wValue) {
737 case USB_PORT_FEAT_ENABLE:
738 admhc_writel(ahcd, ADMHC_PS_SPE,
739 &ahcd->regs->portstatus[wIndex]);
740 break;
741 case USB_PORT_FEAT_SUSPEND:
742 #ifdef CONFIG_USB_OTG
743 if (hcd->self.otg_port == (wIndex + 1)
744 && hcd->self.b_hnp_enable)
745 start_hnp(ahcd);
746 else
747 #endif
748 admhc_writel(ahcd, ADMHC_PS_SPS,
749 &ahcd->regs->portstatus[wIndex]);
750 break;
751 case USB_PORT_FEAT_POWER:
752 admhc_writel(ahcd, ADMHC_PS_SPP,
753 &ahcd->regs->portstatus[wIndex]);
754 break;
755 case USB_PORT_FEAT_RESET:
756 retval = root_port_reset(ahcd, wIndex);
757 break;
758 default:
759 goto error;
760 }
761 break;
762
763 default:
764 error:
765 /* "protocol stall" on error */
766 retval = -EPIPE;
767 }
768 return retval;
769 }
770
Personal OpenWRT clone
This page took 0.08238 seconds and 5 git commands to generate.