1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48#define USE_PLATFORM_DELAY
49
50
51
52
53
54
55
56
57
58#include <linux/module.h>
59#include <linux/delay.h>
60#include <linux/debugfs.h>
61#include <linux/seq_file.h>
62#include <linux/errno.h>
63#include <linux/init.h>
64#include <linux/list.h>
65#include <linux/usb.h>
66#include <linux/usb/isp116x.h>
67#include <linux/platform_device.h>
68
69#include <asm/io.h>
70#include <asm/irq.h>
71#include <asm/system.h>
72#include <asm/byteorder.h>
73
74#include "../core/hcd.h"
75#include "isp116x.h"
76
77#define DRIVER_VERSION "03 Nov 2005"
78#define DRIVER_DESC "ISP116x USB Host Controller Driver"
79
80MODULE_DESCRIPTION(DRIVER_DESC);
81MODULE_LICENSE("GPL");
82
83static const char hcd_name[] = "isp116x-hcd";
84
85
86
87
88
89
90static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
91{
92 u8 *dp = (u8 *) buf;
93 u16 *dp2 = (u16 *) buf;
94 u16 w;
95 int quot = len % 4;
96
97
98
99
100
101 if ((unsigned long)dp2 & 1) {
102
103 for (; len > 1; len -= 2) {
104 w = *dp++;
105 w |= *dp++ << 8;
106 isp116x_raw_write_data16(isp116x, w);
107 }
108 if (len)
109 isp116x_write_data16(isp116x, (u16) * dp);
110 } else {
111
112 for (; len > 1; len -= 2) {
113
114 isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
115 }
116
117 if (len)
118 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
119 }
120 if (quot == 1 || quot == 2)
121 isp116x_raw_write_data16(isp116x, 0);
122}
123
124
125
126
127static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
128{
129 u8 *dp = (u8 *) buf;
130 u16 *dp2 = (u16 *) buf;
131 u16 w;
132 int quot = len % 4;
133
134
135
136
137
138 if ((unsigned long)dp2 & 1) {
139
140 for (; len > 1; len -= 2) {
141 w = isp116x_raw_read_data16(isp116x);
142 *dp++ = w & 0xff;
143 *dp++ = (w >> 8) & 0xff;
144 }
145
146 if (len)
147 *dp = 0xff & isp116x_read_data16(isp116x);
148 } else {
149
150 for (; len > 1; len -= 2) {
151
152 *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
153 }
154
155 if (len)
156 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
157 }
158 if (quot == 1 || quot == 2)
159 isp116x_raw_read_data16(isp116x);
160}
161
162
163
164
165
166static void pack_fifo(struct isp116x *isp116x)
167{
168 struct isp116x_ep *ep;
169 struct ptd *ptd;
170 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
171 ? isp116x->atl_bufshrt : isp116x->atl_buflen;
172
173 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
174 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
175 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
176 for (ep = isp116x->atl_active; ep; ep = ep->active) {
177 ptd = &ep->ptd;
178 dump_ptd(ptd);
179 dump_ptd_out_data(ptd, ep->data);
180 isp116x_write_data16(isp116x, ptd->count);
181 isp116x_write_data16(isp116x, ptd->mps);
182 isp116x_write_data16(isp116x, ptd->len);
183 isp116x_write_data16(isp116x, ptd->faddr);
184 buflen -= sizeof(struct ptd);
185
186 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
187 write_ptddata_to_fifo(isp116x, ep->data, ep->length);
188 buflen -= ALIGN(ep->length, 4);
189 }
190 }
191 BUG_ON(buflen);
192}
193
194
195
196
197
198static void unpack_fifo(struct isp116x *isp116x)
199{
200 struct isp116x_ep *ep;
201 struct ptd *ptd;
202 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
203 ? isp116x->atl_buflen : isp116x->atl_bufshrt;
204
205 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
206 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
207 isp116x_write_addr(isp116x, HCATLPORT);
208 for (ep = isp116x->atl_active; ep; ep = ep->active) {
209 ptd = &ep->ptd;
210 ptd->count = isp116x_read_data16(isp116x);
211 ptd->mps = isp116x_read_data16(isp116x);
212 ptd->len = isp116x_read_data16(isp116x);
213 ptd->faddr = isp116x_read_data16(isp116x);
214 buflen -= sizeof(struct ptd);
215
216 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
217 read_ptddata_from_fifo(isp116x, ep->data, ep->length);
218 buflen -= ALIGN(ep->length, 4);
219 }
220 dump_ptd(ptd);
221 dump_ptd_in_data(ptd, ep->data);
222 }
223 BUG_ON(buflen);
224}
225
226
227
228
229
230
231static void preproc_atl_queue(struct isp116x *isp116x)
232{
233 struct isp116x_ep *ep;
234 struct urb *urb;
235 struct ptd *ptd;
236 u16 len;
237
238 for (ep = isp116x->atl_active; ep; ep = ep->active) {
239 u16 toggle = 0, dir = PTD_DIR_SETUP;
240
241 BUG_ON(list_empty(&ep->hep->urb_list));
242 urb = container_of(ep->hep->urb_list.next,
243 struct urb, urb_list);
244 ptd = &ep->ptd;
245 len = ep->length;
246 ep->data = (unsigned char *)urb->transfer_buffer
247 + urb->actual_length;
248
249 switch (ep->nextpid) {
250 case USB_PID_IN:
251 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
252 dir = PTD_DIR_IN;
253 break;
254 case USB_PID_OUT:
255 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
256 dir = PTD_DIR_OUT;
257 break;
258 case USB_PID_SETUP:
259 len = sizeof(struct usb_ctrlrequest);
260 ep->data = urb->setup_packet;
261 break;
262 case USB_PID_ACK:
263 toggle = 1;
264 len = 0;
265 dir = (urb->transfer_buffer_length
266 && usb_pipein(urb->pipe))
267 ? PTD_DIR_OUT : PTD_DIR_IN;
268 break;
269 default:
270 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
271 ep->nextpid);
272 BUG();
273 }
274
275 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
276 ptd->mps = PTD_MPS(ep->maxpacket)
277 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
278 | PTD_EP(ep->epnum);
279 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
280 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
281 if (!ep->active) {
282 ptd->mps |= PTD_LAST_MSK;
283 isp116x->atl_last_dir = dir;
284 }
285 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
286 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
287 }
288}
289
290
291
292
293
294static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
295 struct urb *urb, int status)
296__releases(isp116x->lock) __acquires(isp116x->lock)
297{
298 unsigned i;
299
300 ep->error_count = 0;
301
302 if (usb_pipecontrol(urb->pipe))
303 ep->nextpid = USB_PID_SETUP;
304
305 urb_dbg(urb, "Finish");
306
307 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
308 spin_unlock(&isp116x->lock);
309 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
310 spin_lock(&isp116x->lock);
311
312
313 if (!list_empty(&ep->hep->urb_list))
314 return;
315
316
317 if (!list_empty(&ep->schedule)) {
318 list_del_init(&ep->schedule);
319 return;
320 }
321
322
323 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
324 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
325 struct isp116x_ep *temp;
326 struct isp116x_ep **prev = &isp116x->periodic[i];
327
328 while (*prev && ((temp = *prev) != ep))
329 prev = &temp->next;
330 if (*prev)
331 *prev = ep->next;
332 isp116x->load[i] -= ep->load;
333 }
334 ep->branch = PERIODIC_SIZE;
335 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
336 ep->load / ep->period;
337
338
339 if (!--isp116x->periodic_count) {
340 isp116x->irqenb &= ~HCuPINT_SOF;
341 isp116x->irqenb |= HCuPINT_ATL;
342 }
343}
344
345
346
347
348static void postproc_atl_queue(struct isp116x *isp116x)
349{
350 struct isp116x_ep *ep;
351 struct urb *urb;
352 struct usb_device *udev;
353 struct ptd *ptd;
354 int short_not_ok;
355 int status;
356 u8 cc;
357
358 for (ep = isp116x->atl_active; ep; ep = ep->active) {
359 BUG_ON(list_empty(&ep->hep->urb_list));
360 urb =
361 container_of(ep->hep->urb_list.next, struct urb, urb_list);
362 udev = urb->dev;
363 ptd = &ep->ptd;
364 cc = PTD_GET_CC(ptd);
365 short_not_ok = 1;
366 status = -EINPROGRESS;
367
368
369
370
371
372
373 if (cc == TD_DATAUNDERRUN) {
374 if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
375 usb_pipecontrol(urb->pipe)) {
376 DBG("Allowed or control data underrun\n");
377 cc = TD_CC_NOERROR;
378 short_not_ok = 0;
379 } else {
380 ep->error_count = 1;
381 usb_settoggle(udev, ep->epnum,
382 ep->nextpid == USB_PID_OUT,
383 PTD_GET_TOGGLE(ptd));
384 urb->actual_length += PTD_GET_COUNT(ptd);
385 status = cc_to_error[TD_DATAUNDERRUN];
386 goto done;
387 }
388 }
389
390 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
391 && (++ep->error_count >= 3 || cc == TD_CC_STALL
392 || cc == TD_DATAOVERRUN)) {
393 status = cc_to_error[cc];
394 if (ep->nextpid == USB_PID_ACK)
395 ep->nextpid = 0;
396 goto done;
397 }
398
399
400
401 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
402 status = 0;
403 goto done;
404 }
405
406
407
408 if (ep->error_count
409 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
410 ep->error_count = 0;
411
412
413
414 if (ep->nextpid == USB_PID_OUT)
415 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
416 ^ (ep->error_count > 0));
417 else if (ep->nextpid == USB_PID_IN)
418 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
419 ^ (ep->error_count > 0));
420
421 switch (ep->nextpid) {
422 case USB_PID_IN:
423 case USB_PID_OUT:
424 urb->actual_length += PTD_GET_COUNT(ptd);
425 if (PTD_GET_ACTIVE(ptd)
426 || (cc != TD_CC_NOERROR && cc < 0x0E))
427 break;
428 if (urb->transfer_buffer_length != urb->actual_length) {
429 if (short_not_ok)
430 break;
431 } else {
432 if (urb->transfer_flags & URB_ZERO_PACKET
433 && ep->nextpid == USB_PID_OUT
434 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
435 DBG("Zero packet requested\n");
436 break;
437 }
438 }
439
440 if (usb_pipecontrol(urb->pipe))
441 ep->nextpid = USB_PID_ACK;
442 else
443 status = 0;
444 break;
445 case USB_PID_SETUP:
446 if (PTD_GET_ACTIVE(ptd)
447 || (cc != TD_CC_NOERROR && cc < 0x0E))
448 break;
449 if (urb->transfer_buffer_length == urb->actual_length)
450 ep->nextpid = USB_PID_ACK;
451 else if (usb_pipeout(urb->pipe)) {
452 usb_settoggle(udev, 0, 1, 1);
453 ep->nextpid = USB_PID_OUT;
454 } else {
455 usb_settoggle(udev, 0, 0, 1);
456 ep->nextpid = USB_PID_IN;
457 }
458 break;
459 case USB_PID_ACK:
460 if (PTD_GET_ACTIVE(ptd)
461 || (cc != TD_CC_NOERROR && cc < 0x0E))
462 break;
463 status = 0;
464 ep->nextpid = 0;
465 break;
466 default:
467 BUG();
468 }
469
470 done:
471 if (status != -EINPROGRESS || urb->unlinked)
472 finish_request(isp116x, ep, urb, status);
473 }
474}
475
476
477
478
479
480static void start_atl_transfers(struct isp116x *isp116x)
481{
482 struct isp116x_ep *last_ep = NULL, *ep;
483 struct urb *urb;
484 u16 load = 0;
485 int len, index, speed, byte_time;
486
487 if (atomic_read(&isp116x->atl_finishing))
488 return;
489
490 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
491 return;
492
493
494 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
495 return;
496
497 isp116x->atl_active = NULL;
498 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
499
500
501 if (isp116x->periodic_count) {
502 isp116x->fmindex = index =
503 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
504 if ((load = isp116x->load[index])) {
505
506
507 isp116x->atl_active = last_ep =
508 isp116x->periodic[index];
509 while (last_ep->next)
510 last_ep = (last_ep->active = last_ep->next);
511 last_ep->active = NULL;
512 }
513 }
514
515
516 list_for_each_entry(ep, &isp116x->async, schedule) {
517 urb = container_of(ep->hep->urb_list.next,
518 struct urb, urb_list);
519 speed = urb->dev->speed;
520 byte_time = speed == USB_SPEED_LOW
521 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
522
523 if (ep->nextpid == USB_PID_SETUP) {
524 len = sizeof(struct usb_ctrlrequest);
525 } else if (ep->nextpid == USB_PID_ACK) {
526 len = 0;
527 } else {
528
529 len = (MAX_LOAD_LIMIT - load) / byte_time;
530
531
532 len = min(len, speed == USB_SPEED_LOW ?
533 MAX_TRANSFER_SIZE_LOWSPEED :
534 MAX_TRANSFER_SIZE_FULLSPEED);
535
536
537
538 if (len <
539 (urb->transfer_buffer_length -
540 urb->actual_length)) {
541 len -= len % ep->maxpacket;
542 if (!len)
543 continue;
544 } else
545 len = urb->transfer_buffer_length -
546 urb->actual_length;
547 BUG_ON(len < 0);
548 }
549
550 load += len * byte_time;
551 if (load > MAX_LOAD_LIMIT)
552 break;
553
554 ep->active = NULL;
555 ep->length = len;
556 if (last_ep)
557 last_ep->active = ep;
558 else
559 isp116x->atl_active = ep;
560 last_ep = ep;
561 }
562
563
564 if ((&isp116x->async)->next != (&isp116x->async)->prev)
565 list_move(&isp116x->async, (&isp116x->async)->next);
566
567 if (isp116x->atl_active) {
568 preproc_atl_queue(isp116x);
569 pack_fifo(isp116x);
570 }
571}
572
573
574
575
576static void finish_atl_transfers(struct isp116x *isp116x)
577{
578 if (!isp116x->atl_active)
579 return;
580
581 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
582 return;
583
584 atomic_inc(&isp116x->atl_finishing);
585 unpack_fifo(isp116x);
586 postproc_atl_queue(isp116x);
587 atomic_dec(&isp116x->atl_finishing);
588}
589
590static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
591{
592 struct isp116x *isp116x = hcd_to_isp116x(hcd);
593 u16 irqstat;
594 irqreturn_t ret = IRQ_NONE;
595
596 spin_lock(&isp116x->lock);
597 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
598 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
599 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
600
601 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
602 ret = IRQ_HANDLED;
603 finish_atl_transfers(isp116x);
604 }
605
606 if (irqstat & HCuPINT_OPR) {
607 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
608 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
609 if (intstat & HCINT_UE) {
610 ERR("Unrecoverable error, HC is dead!\n");
611
612
613 hcd->state = HC_STATE_HALT;
614 ret = IRQ_HANDLED;
615 goto done;
616 }
617 if (intstat & HCINT_RHSC)
618
619
620
621 mod_timer(&hcd->rh_timer, jiffies
622 + msecs_to_jiffies(20) + 1);
623 if (intstat & HCINT_RD) {
624 DBG("---- remote wakeup\n");
625 usb_hcd_resume_root_hub(hcd);
626 }
627 irqstat &= ~HCuPINT_OPR;
628 ret = IRQ_HANDLED;
629 }
630
631 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
632 start_atl_transfers(isp116x);
633 }
634
635 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
636 done:
637 spin_unlock(&isp116x->lock);
638 return ret;
639}
640
641
642
643
644
645
646
647
648
649#define MAX_PERIODIC_LOAD 600
650static int balance(struct isp116x *isp116x, u16 period, u16 load)
651{
652 int i, branch = -ENOSPC;
653
654
655
656 for (i = 0; i < period; i++) {
657 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
658 int j;
659
660 for (j = i; j < PERIODIC_SIZE; j += period) {
661 if ((isp116x->load[j] + load)
662 > MAX_PERIODIC_LOAD)
663 break;
664 }
665 if (j < PERIODIC_SIZE)
666 continue;
667 branch = i;
668 }
669 }
670 return branch;
671}
672
673
674
675
676
677
678
679static int isp116x_urb_enqueue(struct usb_hcd *hcd,
680 struct urb *urb,
681 gfp_t mem_flags)
682{
683 struct isp116x *isp116x = hcd_to_isp116x(hcd);
684 struct usb_device *udev = urb->dev;
685 unsigned int pipe = urb->pipe;
686 int is_out = !usb_pipein(pipe);
687 int type = usb_pipetype(pipe);
688 int epnum = usb_pipeendpoint(pipe);
689 struct usb_host_endpoint *hep = urb->ep;
690 struct isp116x_ep *ep = NULL;
691 unsigned long flags;
692 int i;
693 int ret = 0;
694
695 urb_dbg(urb, "Enqueue");
696
697 if (type == PIPE_ISOCHRONOUS) {
698 ERR("Isochronous transfers not supported\n");
699 urb_dbg(urb, "Refused to enqueue");
700 return -ENXIO;
701 }
702
703 if (!hep->hcpriv) {
704 ep = kzalloc(sizeof *ep, mem_flags);
705 if (!ep)
706 return -ENOMEM;
707 }
708
709 spin_lock_irqsave(&isp116x->lock, flags);
710 if (!HC_IS_RUNNING(hcd->state)) {
711 kfree(ep);
712 ret = -ENODEV;
713 goto fail_not_linked;
714 }
715 ret = usb_hcd_link_urb_to_ep(hcd, urb);
716 if (ret) {
717 kfree(ep);
718 goto fail_not_linked;
719 }
720
721 if (hep->hcpriv)
722 ep = hep->hcpriv;
723 else {
724 INIT_LIST_HEAD(&ep->schedule);
725 ep->udev = udev;
726 ep->epnum = epnum;
727 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
728 usb_settoggle(udev, epnum, is_out, 0);
729
730 if (type == PIPE_CONTROL) {
731 ep->nextpid = USB_PID_SETUP;
732 } else if (is_out) {
733 ep->nextpid = USB_PID_OUT;
734 } else {
735 ep->nextpid = USB_PID_IN;
736 }
737
738 if (urb->interval) {
739
740
741
742
743
744
745
746
747
748
749 if (urb->interval < 2)
750 urb->interval = 2;
751 if (urb->interval > 2 * PERIODIC_SIZE)
752 urb->interval = 2 * PERIODIC_SIZE;
753 ep->period = urb->interval >> 1;
754 ep->branch = PERIODIC_SIZE;
755 ep->load = usb_calc_bus_time(udev->speed,
756 !is_out,
757 (type == PIPE_ISOCHRONOUS),
758 usb_maxpacket(udev, pipe,
759 is_out)) /
760 1000;
761 }
762 hep->hcpriv = ep;
763 ep->hep = hep;
764 }
765
766
767 switch (type) {
768 case PIPE_CONTROL:
769 case PIPE_BULK:
770 if (list_empty(&ep->schedule))
771 list_add_tail(&ep->schedule, &isp116x->async);
772 break;
773 case PIPE_INTERRUPT:
774 urb->interval = ep->period;
775 ep->length = min_t(u32, ep->maxpacket,
776 urb->transfer_buffer_length);
777
778
779 if (ep->branch < PERIODIC_SIZE)
780 break;
781
782 ep->branch = ret = balance(isp116x, ep->period, ep->load);
783 if (ret < 0)
784 goto fail;
785 ret = 0;
786
787 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
788 + ep->branch;
789
790
791
792
793 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
794 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
795 struct isp116x_ep **prev = &isp116x->periodic[i];
796 struct isp116x_ep *here = *prev;
797
798 while (here && ep != here) {
799 if (ep->period > here->period)
800 break;
801 prev = &here->next;
802 here = *prev;
803 }
804 if (ep != here) {
805 ep->next = here;
806 *prev = ep;
807 }
808 isp116x->load[i] += ep->load;
809 }
810 hcd->self.bandwidth_allocated += ep->load / ep->period;
811
812
813 if (!isp116x->periodic_count++) {
814 isp116x->irqenb &= ~HCuPINT_ATL;
815 isp116x->irqenb |= HCuPINT_SOF;
816 isp116x_write_reg16(isp116x, HCuPINTENB,
817 isp116x->irqenb);
818 }
819 }
820
821 urb->hcpriv = hep;
822 start_atl_transfers(isp116x);
823
824 fail:
825 if (ret)
826 usb_hcd_unlink_urb_from_ep(hcd, urb);
827 fail_not_linked:
828 spin_unlock_irqrestore(&isp116x->lock, flags);
829 return ret;
830}
831
832
833
834
835static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
836 int status)
837{
838 struct isp116x *isp116x = hcd_to_isp116x(hcd);
839 struct usb_host_endpoint *hep;
840 struct isp116x_ep *ep, *ep_act;
841 unsigned long flags;
842 int rc;
843
844 spin_lock_irqsave(&isp116x->lock, flags);
845 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
846 if (rc)
847 goto done;
848
849 hep = urb->hcpriv;
850 ep = hep->hcpriv;
851 WARN_ON(hep != ep->hep);
852
853
854 if (ep->hep->urb_list.next == &urb->urb_list)
855
856 for (ep_act = isp116x->atl_active; ep_act;
857 ep_act = ep_act->active)
858 if (ep_act == ep) {
859 VDBG("dequeue, urb %p active; wait for irq\n",
860 urb);
861 urb = NULL;
862 break;
863 }
864
865 if (urb)
866 finish_request(isp116x, ep, urb, status);
867 done:
868 spin_unlock_irqrestore(&isp116x->lock, flags);
869 return rc;
870}
871
872static void isp116x_endpoint_disable(struct usb_hcd *hcd,
873 struct usb_host_endpoint *hep)
874{
875 int i;
876 struct isp116x_ep *ep = hep->hcpriv;
877
878 if (!ep)
879 return;
880
881
882 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
883 msleep(3);
884 if (!list_empty(&hep->urb_list))
885 WARNING("ep %p not empty?\n", ep);
886
887 kfree(ep);
888 hep->hcpriv = NULL;
889}
890
891static int isp116x_get_frame(struct usb_hcd *hcd)
892{
893 struct isp116x *isp116x = hcd_to_isp116x(hcd);
894 u32 fmnum;
895 unsigned long flags;
896
897 spin_lock_irqsave(&isp116x->lock, flags);
898 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
899 spin_unlock_irqrestore(&isp116x->lock, flags);
900 return (int)fmnum;
901}
902
903
904
905
906static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
907{
908 struct isp116x *isp116x = hcd_to_isp116x(hcd);
909 int ports, i, changed = 0;
910 unsigned long flags;
911
912 if (!HC_IS_RUNNING(hcd->state))
913 return -ESHUTDOWN;
914
915
916
917 if (timer_pending(&hcd->rh_timer))
918 return 0;
919
920 ports = isp116x->rhdesca & RH_A_NDP;
921 spin_lock_irqsave(&isp116x->lock, flags);
922 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
923 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
924 buf[0] = changed = 1;
925 else
926 buf[0] = 0;
927
928 for (i = 0; i < ports; i++) {
929 u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
930
931 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
932 | RH_PS_OCIC | RH_PS_PRSC)) {
933 changed = 1;
934 buf[0] |= 1 << (i + 1);
935 }
936 }
937 spin_unlock_irqrestore(&isp116x->lock, flags);
938 return changed;
939}
940
941static void isp116x_hub_descriptor(struct isp116x *isp116x,
942 struct usb_hub_descriptor *desc)
943{
944 u32 reg = isp116x->rhdesca;
945
946 desc->bDescriptorType = 0x29;
947 desc->bDescLength = 9;
948 desc->bHubContrCurrent = 0;
949 desc->bNbrPorts = (u8) (reg & 0x3);
950
951 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
952 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
953
954 desc->bitmap[0] = 0;
955 desc->bitmap[1] = ~0;
956}
957
958
959
960
961
962
963
964
965static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
966{
967 u32 tmp;
968 unsigned long flags, t;
969
970
971
972 t = jiffies + msecs_to_jiffies(100);
973
974 while (time_before(jiffies, t)) {
975 spin_lock_irqsave(&isp116x->lock, flags);
976
977 for (;;) {
978 tmp = isp116x_read_reg32(isp116x, port ?
979 HCRHPORT2 : HCRHPORT1);
980 if (!(tmp & RH_PS_PRS))
981 break;
982 udelay(500);
983 }
984
985 if (!(tmp & RH_PS_CCS)) {
986 spin_unlock_irqrestore(&isp116x->lock, flags);
987 break;
988 }
989
990 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
991 HCRHPORT1, (RH_PS_PRS));
992 spin_unlock_irqrestore(&isp116x->lock, flags);
993 msleep(10);
994 }
995}
996
997
998static int isp116x_hub_control(struct usb_hcd *hcd,
999 u16 typeReq,
1000 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1001{
1002 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1003 int ret = 0;
1004 unsigned long flags;
1005 int ports = isp116x->rhdesca & RH_A_NDP;
1006 u32 tmp = 0;
1007
1008 switch (typeReq) {
1009 case ClearHubFeature:
1010 DBG("ClearHubFeature: ");
1011 switch (wValue) {
1012 case C_HUB_OVER_CURRENT:
1013 DBG("C_HUB_OVER_CURRENT\n");
1014 spin_lock_irqsave(&isp116x->lock, flags);
1015 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1016 spin_unlock_irqrestore(&isp116x->lock, flags);
1017 case C_HUB_LOCAL_POWER:
1018 DBG("C_HUB_LOCAL_POWER\n");
1019 break;
1020 default:
1021 goto error;
1022 }
1023 break;
1024 case SetHubFeature:
1025 DBG("SetHubFeature: ");
1026 switch (wValue) {
1027 case C_HUB_OVER_CURRENT:
1028 case C_HUB_LOCAL_POWER:
1029 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1030 break;
1031 default:
1032 goto error;
1033 }
1034 break;
1035 case GetHubDescriptor:
1036 DBG("GetHubDescriptor\n");
1037 isp116x_hub_descriptor(isp116x,
1038 (struct usb_hub_descriptor *)buf);
1039 break;
1040 case GetHubStatus:
1041 DBG("GetHubStatus\n");
1042 *(__le32 *) buf = 0;
1043 break;
1044 case GetPortStatus:
1045 DBG("GetPortStatus\n");
1046 if (!wIndex || wIndex > ports)
1047 goto error;
1048 spin_lock_irqsave(&isp116x->lock, flags);
1049 tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1050 spin_unlock_irqrestore(&isp116x->lock, flags);
1051 *(__le32 *) buf = cpu_to_le32(tmp);
1052 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1053 break;
1054 case ClearPortFeature:
1055 DBG("ClearPortFeature: ");
1056 if (!wIndex || wIndex > ports)
1057 goto error;
1058 wIndex--;
1059
1060 switch (wValue) {
1061 case USB_PORT_FEAT_ENABLE:
1062 DBG("USB_PORT_FEAT_ENABLE\n");
1063 tmp = RH_PS_CCS;
1064 break;
1065 case USB_PORT_FEAT_C_ENABLE:
1066 DBG("USB_PORT_FEAT_C_ENABLE\n");
1067 tmp = RH_PS_PESC;
1068 break;
1069 case USB_PORT_FEAT_SUSPEND:
1070 DBG("USB_PORT_FEAT_SUSPEND\n");
1071 tmp = RH_PS_POCI;
1072 break;
1073 case USB_PORT_FEAT_C_SUSPEND:
1074 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1075 tmp = RH_PS_PSSC;
1076 break;
1077 case USB_PORT_FEAT_POWER:
1078 DBG("USB_PORT_FEAT_POWER\n");
1079 tmp = RH_PS_LSDA;
1080 break;
1081 case USB_PORT_FEAT_C_CONNECTION:
1082 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1083 tmp = RH_PS_CSC;
1084 break;
1085 case USB_PORT_FEAT_C_OVER_CURRENT:
1086 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1087 tmp = RH_PS_OCIC;
1088 break;
1089 case USB_PORT_FEAT_C_RESET:
1090 DBG("USB_PORT_FEAT_C_RESET\n");
1091 tmp = RH_PS_PRSC;
1092 break;
1093 default:
1094 goto error;
1095 }
1096 spin_lock_irqsave(&isp116x->lock, flags);
1097 isp116x_write_reg32(isp116x, wIndex
1098 ? HCRHPORT2 : HCRHPORT1, tmp);
1099 spin_unlock_irqrestore(&isp116x->lock, flags);
1100 break;
1101 case SetPortFeature:
1102 DBG("SetPortFeature: ");
1103 if (!wIndex || wIndex > ports)
1104 goto error;
1105 wIndex--;
1106 switch (wValue) {
1107 case USB_PORT_FEAT_SUSPEND:
1108 DBG("USB_PORT_FEAT_SUSPEND\n");
1109 spin_lock_irqsave(&isp116x->lock, flags);
1110 isp116x_write_reg32(isp116x, wIndex
1111 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1112 spin_unlock_irqrestore(&isp116x->lock, flags);
1113 break;
1114 case USB_PORT_FEAT_POWER:
1115 DBG("USB_PORT_FEAT_POWER\n");
1116 spin_lock_irqsave(&isp116x->lock, flags);
1117 isp116x_write_reg32(isp116x, wIndex
1118 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1119 spin_unlock_irqrestore(&isp116x->lock, flags);
1120 break;
1121 case USB_PORT_FEAT_RESET:
1122 DBG("USB_PORT_FEAT_RESET\n");
1123 root_port_reset(isp116x, wIndex);
1124 break;
1125 default:
1126 goto error;
1127 }
1128 break;
1129
1130 default:
1131 error:
1132
1133 DBG("PROTOCOL STALL\n");
1134 ret = -EPIPE;
1135 }
1136 return ret;
1137}
1138
1139
1140
1141#ifdef CONFIG_DEBUG_FS
1142
1143static void dump_irq(struct seq_file *s, char *label, u16 mask)
1144{
1145 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1146 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1147 mask & HCuPINT_SUSP ? " susp" : "",
1148 mask & HCuPINT_OPR ? " opr" : "",
1149 mask & HCuPINT_AIIEOT ? " eot" : "",
1150 mask & HCuPINT_ATL ? " atl" : "",
1151 mask & HCuPINT_SOF ? " sof" : "");
1152}
1153
1154static void dump_int(struct seq_file *s, char *label, u32 mask)
1155{
1156 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1157 mask & HCINT_MIE ? " MIE" : "",
1158 mask & HCINT_RHSC ? " rhsc" : "",
1159 mask & HCINT_FNO ? " fno" : "",
1160 mask & HCINT_UE ? " ue" : "",
1161 mask & HCINT_RD ? " rd" : "",
1162 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1163}
1164
1165static int isp116x_show_dbg(struct seq_file *s, void *unused)
1166{
1167 struct isp116x *isp116x = s->private;
1168
1169 seq_printf(s, "%s\n%s version %s\n",
1170 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1171 DRIVER_VERSION);
1172
1173 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1174 seq_printf(s, "HCD is suspended\n");
1175 return 0;
1176 }
1177 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1178 seq_printf(s, "HCD not running\n");
1179 return 0;
1180 }
1181
1182 spin_lock_irq(&isp116x->lock);
1183 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1184 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1185 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1186 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1187 isp116x_show_regs_seq(isp116x, s);
1188 spin_unlock_irq(&isp116x->lock);
1189 seq_printf(s, "\n");
1190
1191 return 0;
1192}
1193
1194static int isp116x_open_seq(struct inode *inode, struct file *file)
1195{
1196 return single_open(file, isp116x_show_dbg, inode->i_private);
1197}
1198
1199static const struct file_operations isp116x_debug_fops = {
1200 .open = isp116x_open_seq,
1201 .read = seq_read,
1202 .llseek = seq_lseek,
1203 .release = single_release,
1204};
1205
1206static int create_debug_file(struct isp116x *isp116x)
1207{
1208 isp116x->dentry = debugfs_create_file(hcd_name,
1209 S_IRUGO, NULL, isp116x,
1210 &isp116x_debug_fops);
1211 if (!isp116x->dentry)
1212 return -ENOMEM;
1213 return 0;
1214}
1215
1216static void remove_debug_file(struct isp116x *isp116x)
1217{
1218 debugfs_remove(isp116x->dentry);
1219}
1220
1221#else
1222
1223#define create_debug_file(d) 0
1224#define remove_debug_file(d) do{}while(0)
1225
1226#endif
1227
1228
1229
1230
1231
1232
1233static int isp116x_sw_reset(struct isp116x *isp116x)
1234{
1235 int retries = 15;
1236 unsigned long flags;
1237 int ret = 0;
1238
1239 spin_lock_irqsave(&isp116x->lock, flags);
1240 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1241 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1242 while (--retries) {
1243
1244 mdelay(1);
1245 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1246 break;
1247 }
1248 if (!retries) {
1249 ERR("Software reset timeout\n");
1250 ret = -ETIME;
1251 }
1252 spin_unlock_irqrestore(&isp116x->lock, flags);
1253 return ret;
1254}
1255
1256static int isp116x_reset(struct usb_hcd *hcd)
1257{
1258 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1259 unsigned long t;
1260 u16 clkrdy = 0;
1261 int ret, timeout = 15 ;
1262
1263 ret = isp116x_sw_reset(isp116x);
1264 if (ret)
1265 return ret;
1266
1267 t = jiffies + msecs_to_jiffies(timeout);
1268 while (time_before_eq(jiffies, t)) {
1269 msleep(4);
1270 spin_lock_irq(&isp116x->lock);
1271 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1272 spin_unlock_irq(&isp116x->lock);
1273 if (clkrdy)
1274 break;
1275 }
1276 if (!clkrdy) {
1277 ERR("Clock not ready after %dms\n", timeout);
1278
1279
1280 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1281 ret = -ENODEV;
1282 }
1283 return ret;
1284}
1285
1286static void isp116x_stop(struct usb_hcd *hcd)
1287{
1288 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1289 unsigned long flags;
1290 u32 val;
1291
1292 spin_lock_irqsave(&isp116x->lock, flags);
1293 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1294
1295
1296
1297 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1298 val &= ~(RH_A_NPS | RH_A_PSM);
1299 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1300 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1301 spin_unlock_irqrestore(&isp116x->lock, flags);
1302
1303 isp116x_sw_reset(isp116x);
1304}
1305
1306
1307
1308
1309static int isp116x_start(struct usb_hcd *hcd)
1310{
1311 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1312 struct isp116x_platform_data *board = isp116x->board;
1313 u32 val;
1314 unsigned long flags;
1315
1316 spin_lock_irqsave(&isp116x->lock, flags);
1317
1318
1319 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1320 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1321
1322 val = isp116x_read_reg16(isp116x, HCCHIPID);
1323 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1324 ERR("Invalid chip ID %04x\n", val);
1325 spin_unlock_irqrestore(&isp116x->lock, flags);
1326 return -ENODEV;
1327 }
1328
1329
1330 hcd->uses_new_polling = 1;
1331
1332 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1333 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1334
1335
1336 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1337 if (board->sel15Kres)
1338 val |= HCHWCFG_15KRSEL;
1339
1340 if (board->remote_wakeup_enable)
1341 val |= HCHWCFG_CLKNOTSTOP;
1342 if (board->oc_enable)
1343 val |= HCHWCFG_ANALOG_OC;
1344 if (board->int_act_high)
1345 val |= HCHWCFG_INT_POL;
1346 if (board->int_edge_triggered)
1347 val |= HCHWCFG_INT_TRIGGER;
1348 isp116x_write_reg16(isp116x, HCHWCFG, val);
1349
1350
1351 val = (25 << 24) & RH_A_POTPGT;
1352
1353
1354
1355 val |= RH_A_PSM;
1356
1357 val |= RH_A_OCPM;
1358 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1359 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1360
1361 val = RH_B_PPCM;
1362 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1363 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1364
1365 val = 0;
1366 if (board->remote_wakeup_enable) {
1367 if (!device_can_wakeup(hcd->self.controller))
1368 device_init_wakeup(hcd->self.controller, 1);
1369 val |= RH_HS_DRWE;
1370 }
1371 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1372 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1373
1374 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1375
1376 hcd->state = HC_STATE_RUNNING;
1377
1378
1379 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1380 if (board->remote_wakeup_enable)
1381 isp116x->intenb |= HCINT_RD;
1382 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;
1383 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1384 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1385
1386
1387 val = HCCONTROL_USB_OPER;
1388 if (board->remote_wakeup_enable)
1389 val |= HCCONTROL_RWE;
1390 isp116x_write_reg32(isp116x, HCCONTROL, val);
1391
1392
1393 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1394 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1395
1396 isp116x_show_regs_log(isp116x);
1397 spin_unlock_irqrestore(&isp116x->lock, flags);
1398 return 0;
1399}
1400
1401#ifdef CONFIG_PM
1402
1403static int isp116x_bus_suspend(struct usb_hcd *hcd)
1404{
1405 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1406 unsigned long flags;
1407 u32 val;
1408 int ret = 0;
1409
1410 spin_lock_irqsave(&isp116x->lock, flags);
1411 val = isp116x_read_reg32(isp116x, HCCONTROL);
1412
1413 switch (val & HCCONTROL_HCFS) {
1414 case HCCONTROL_USB_OPER:
1415 spin_unlock_irqrestore(&isp116x->lock, flags);
1416 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1417 val |= HCCONTROL_USB_SUSPEND;
1418 if (hcd->self.root_hub->do_remote_wakeup)
1419 val |= HCCONTROL_RWE;
1420
1421 msleep(2);
1422 spin_lock_irqsave(&isp116x->lock, flags);
1423 isp116x_write_reg32(isp116x, HCCONTROL, val);
1424 spin_unlock_irqrestore(&isp116x->lock, flags);
1425
1426 msleep(5);
1427 break;
1428 case HCCONTROL_USB_RESUME:
1429 isp116x_write_reg32(isp116x, HCCONTROL,
1430 (val & ~HCCONTROL_HCFS) |
1431 HCCONTROL_USB_RESET);
1432 case HCCONTROL_USB_RESET:
1433 ret = -EBUSY;
1434 default:
1435 spin_unlock_irqrestore(&isp116x->lock, flags);
1436 break;
1437 }
1438
1439 return ret;
1440}
1441
1442static int isp116x_bus_resume(struct usb_hcd *hcd)
1443{
1444 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1445 u32 val;
1446
1447 msleep(5);
1448 spin_lock_irq(&isp116x->lock);
1449
1450 val = isp116x_read_reg32(isp116x, HCCONTROL);
1451 switch (val & HCCONTROL_HCFS) {
1452 case HCCONTROL_USB_SUSPEND:
1453 val &= ~HCCONTROL_HCFS;
1454 val |= HCCONTROL_USB_RESUME;
1455 isp116x_write_reg32(isp116x, HCCONTROL, val);
1456 case HCCONTROL_USB_RESUME:
1457 break;
1458 case HCCONTROL_USB_OPER:
1459 spin_unlock_irq(&isp116x->lock);
1460 return 0;
1461 default:
1462
1463
1464 spin_unlock_irq(&isp116x->lock);
1465 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1466 isp116x_reset(hcd);
1467 isp116x_start(hcd);
1468 isp116x_hub_control(hcd, SetPortFeature,
1469 USB_PORT_FEAT_POWER, 1, NULL, 0);
1470 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1471 isp116x_hub_control(hcd, SetPortFeature,
1472 USB_PORT_FEAT_POWER, 2, NULL, 0);
1473 return 0;
1474 }
1475
1476 val = isp116x->rhdesca & RH_A_NDP;
1477 while (val--) {
1478 u32 stat =
1479 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1480
1481 if (!(stat & RH_PS_PSS))
1482 continue;
1483 DBG("%s: Resuming port %d\n", __func__, val);
1484 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1485 ? HCRHPORT2 : HCRHPORT1);
1486 }
1487 spin_unlock_irq(&isp116x->lock);
1488
1489 hcd->state = HC_STATE_RESUMING;
1490 msleep(20);
1491
1492
1493 spin_lock_irq(&isp116x->lock);
1494 val = isp116x_read_reg32(isp116x, HCCONTROL);
1495 isp116x_write_reg32(isp116x, HCCONTROL,
1496 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1497 spin_unlock_irq(&isp116x->lock);
1498 hcd->state = HC_STATE_RUNNING;
1499
1500 return 0;
1501}
1502
1503#else
1504
1505#define isp116x_bus_suspend NULL
1506#define isp116x_bus_resume NULL
1507
1508#endif
1509
1510static struct hc_driver isp116x_hc_driver = {
1511 .description = hcd_name,
1512 .product_desc = "ISP116x Host Controller",
1513 .hcd_priv_size = sizeof(struct isp116x),
1514
1515 .irq = isp116x_irq,
1516 .flags = HCD_USB11,
1517
1518 .reset = isp116x_reset,
1519 .start = isp116x_start,
1520 .stop = isp116x_stop,
1521
1522 .urb_enqueue = isp116x_urb_enqueue,
1523 .urb_dequeue = isp116x_urb_dequeue,
1524 .endpoint_disable = isp116x_endpoint_disable,
1525
1526 .get_frame_number = isp116x_get_frame,
1527
1528 .hub_status_data = isp116x_hub_status_data,
1529 .hub_control = isp116x_hub_control,
1530 .bus_suspend = isp116x_bus_suspend,
1531 .bus_resume = isp116x_bus_resume,
1532};
1533
1534
1535
1536static int isp116x_remove(struct platform_device *pdev)
1537{
1538 struct usb_hcd *hcd = platform_get_drvdata(pdev);
1539 struct isp116x *isp116x;
1540 struct resource *res;
1541
1542 if (!hcd)
1543 return 0;
1544 isp116x = hcd_to_isp116x(hcd);
1545 remove_debug_file(isp116x);
1546 usb_remove_hcd(hcd);
1547
1548 iounmap(isp116x->data_reg);
1549 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1550 release_mem_region(res->start, 2);
1551 iounmap(isp116x->addr_reg);
1552 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1553 release_mem_region(res->start, 2);
1554
1555 usb_put_hcd(hcd);
1556 return 0;
1557}
1558
1559#define resource_len(r) (((r)->end - (r)->start) + 1)
1560
1561static int __devinit isp116x_probe(struct platform_device *pdev)
1562{
1563 struct usb_hcd *hcd;
1564 struct isp116x *isp116x;
1565 struct resource *addr, *data, *ires;
1566 void __iomem *addr_reg;
1567 void __iomem *data_reg;
1568 int irq;
1569 int ret = 0;
1570 unsigned long irqflags;
1571
1572 if (pdev->num_resources < 3) {
1573 ret = -ENODEV;
1574 goto err1;
1575 }
1576
1577 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1578 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1579 ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1580
1581 if (!addr || !data || !ires) {
1582 ret = -ENODEV;
1583 goto err1;
1584 }
1585
1586 irq = ires->start;
1587 irqflags = ires->flags & IRQF_TRIGGER_MASK;
1588
1589 if (pdev->dev.dma_mask) {
1590 DBG("DMA not supported\n");
1591 ret = -EINVAL;
1592 goto err1;
1593 }
1594
1595 if (!request_mem_region(addr->start, 2, hcd_name)) {
1596 ret = -EBUSY;
1597 goto err1;
1598 }
1599 addr_reg = ioremap(addr->start, resource_len(addr));
1600 if (addr_reg == NULL) {
1601 ret = -ENOMEM;
1602 goto err2;
1603 }
1604 if (!request_mem_region(data->start, 2, hcd_name)) {
1605 ret = -EBUSY;
1606 goto err3;
1607 }
1608 data_reg = ioremap(data->start, resource_len(data));
1609 if (data_reg == NULL) {
1610 ret = -ENOMEM;
1611 goto err4;
1612 }
1613
1614
1615 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
1616 if (!hcd) {
1617 ret = -ENOMEM;
1618 goto err5;
1619 }
1620
1621 hcd->rsrc_start = addr->start;
1622 isp116x = hcd_to_isp116x(hcd);
1623 isp116x->data_reg = data_reg;
1624 isp116x->addr_reg = addr_reg;
1625 spin_lock_init(&isp116x->lock);
1626 INIT_LIST_HEAD(&isp116x->async);
1627 isp116x->board = pdev->dev.platform_data;
1628
1629 if (!isp116x->board) {
1630 ERR("Platform data structure not initialized\n");
1631 ret = -ENODEV;
1632 goto err6;
1633 }
1634 if (isp116x_check_platform_delay(isp116x)) {
1635 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1636 "implemented.\n");
1637 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1638 ret = -ENODEV;
1639 goto err6;
1640 }
1641
1642 ret = usb_add_hcd(hcd, irq, irqflags | IRQF_DISABLED);
1643 if (ret)
1644 goto err6;
1645
1646 ret = create_debug_file(isp116x);
1647 if (ret) {
1648 ERR("Couldn't create debugfs entry\n");
1649 goto err7;
1650 }
1651
1652 return 0;
1653
1654 err7:
1655 usb_remove_hcd(hcd);
1656 err6:
1657 usb_put_hcd(hcd);
1658 err5:
1659 iounmap(data_reg);
1660 err4:
1661 release_mem_region(data->start, 2);
1662 err3:
1663 iounmap(addr_reg);
1664 err2:
1665 release_mem_region(addr->start, 2);
1666 err1:
1667 ERR("init error, %d\n", ret);
1668 return ret;
1669}
1670
1671#ifdef CONFIG_PM
1672
1673
1674
1675static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1676{
1677 VDBG("%s: state %x\n", __func__, state.event);
1678 return 0;
1679}
1680
1681
1682
1683
1684static int isp116x_resume(struct platform_device *dev)
1685{
1686 VDBG("%s\n", __func__);
1687 return 0;
1688}
1689
1690#else
1691
1692#define isp116x_suspend NULL
1693#define isp116x_resume NULL
1694
1695#endif
1696
1697
1698MODULE_ALIAS("platform:isp116x-hcd");
1699
1700static struct platform_driver isp116x_driver = {
1701 .probe = isp116x_probe,
1702 .remove = isp116x_remove,
1703 .suspend = isp116x_suspend,
1704 .resume = isp116x_resume,
1705 .driver = {
1706 .name = (char *)hcd_name,
1707 .owner = THIS_MODULE,
1708 },
1709};
1710
1711
1712
1713static int __init isp116x_init(void)
1714{
1715 if (usb_disabled())
1716 return -ENODEV;
1717
1718 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1719 return platform_driver_register(&isp116x_driver);
1720}
1721
1722module_init(isp116x_init);
1723
1724static void __exit isp116x_cleanup(void)
1725{
1726 platform_driver_unregister(&isp116x_driver);
1727}
1728
1729module_exit(isp116x_cleanup);
1730