?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This client driver allows you to use a GPIO pin as a source for PPS
[linux-2.6/next.git] / drivers / usb / host / isp116x-hcd.c
blobbaae4ccd16ac0cca4a3cccec2245b54399932eed
1 /*
2 * ISP116x HCD (Host Controller Driver) for USB.
3 *
4 * Derived from the SL811 HCD, rewritten for ISP116x.
5 * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
6 *
7 * Portions:
8 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
9 * Copyright (C) 2004 David Brownell
10 *
11 * Periodic scheduling is based on Roman's OHCI code
12 * Copyright (C) 1999 Roman Weissgaerber
13 *
14 */
15
16 /*
17 * The driver basically works. A number of people have used it with a range
18 * of devices.
19 *
20 * The driver passes all usbtests 1-14.
21 *
22 * Suspending/resuming of root hub via sysfs works. Remote wakeup works too.
23 * And suspending/resuming of platform device works too. Suspend/resume
24 * via HCD operations vector is not implemented.
25 *
26 * Iso transfer support is not implemented. Adding this would include
27 * implementing recovery from the failure to service the processed ITL
28 * fifo ram in time, which will involve chip reset.
29 *
30 * TODO:
31 + More testing of suspend/resume.
32 */
33
34 /*
35 ISP116x chips require certain delays between accesses to its
36 registers. The following timing options exist.
37
38 1. Configure your memory controller (the best)
39 2. Implement platform-specific delay function possibly
40 combined with configuring the memory controller; see
41 include/linux/usb-isp116x.h for more info. Some broken
42 memory controllers line LH7A400 SMC need this. Also,
43 uncomment for that to work the following
44 USE_PLATFORM_DELAY macro.
45 3. Use ndelay (easiest, poorest). For that, uncomment
46 the following USE_NDELAY macro.
47 */
48 #define USE_PLATFORM_DELAY
49 //#define USE_NDELAY
50
51 //#define DEBUG
52 //#define VERBOSE
53 /* Transfer descriptors. See dump_ptd() for printout format */
54 //#define PTD_TRACE
55 /* enqueuing/finishing log of urbs */
56 //#define URB_TRACE
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/slab.h>
66 #include <linux/usb.h>
67 #include <linux/usb/isp116x.h>
68 #include <linux/usb/hcd.h>
69 #include <linux/platform_device.h>
70
71 #include <asm/io.h>
72 #include <asm/irq.h>
73 #include <asm/system.h>
74 #include <asm/byteorder.h>
75
76 #include "isp116x.h"
77
78 #define DRIVER_VERSION "03 Nov 2005"
79 #define DRIVER_DESC "ISP116x USB Host Controller Driver"
80
81 MODULE_DESCRIPTION(DRIVER_DESC);
82 MODULE_LICENSE("GPL");
83
84 static const char hcd_name[] = "isp116x-hcd";
85
86 /*-----------------------------------------------------------------*/
87
88 /*
89 Write len bytes to fifo, pad till 32-bit boundary
90 */
91 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
92 {
93 u8 *dp = (u8 *) buf;
94 u16 *dp2 = (u16 *) buf;
95 u16 w;
96 int quot = len % 4;
97
98 /* buffer is already in 'usb data order', which is LE. */
99 /* When reading buffer as u16, we have to take care byte order */
100 /* doesn't get mixed up */
101
102 if ((unsigned long)dp2 & 1) {
103 /* not aligned */
104 for (; len > 1; len -= 2) {
105 w = *dp++;
106 w |= *dp++ << 8;
107 isp116x_raw_write_data16(isp116x, w);
108 }
109 if (len)
110 isp116x_write_data16(isp116x, (u16) * dp);
111 } else {
112 /* aligned */
113 for (; len > 1; len -= 2) {
114 /* Keep byte order ! */
115 isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
116 }
117
118 if (len)
119 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
120 }
121 if (quot == 1 || quot == 2)
122 isp116x_raw_write_data16(isp116x, 0);
123 }
124
125 /*
126 Read len bytes from fifo and then read till 32-bit boundary.
127 */
128 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
129 {
130 u8 *dp = (u8 *) buf;
131 u16 *dp2 = (u16 *) buf;
132 u16 w;
133 int quot = len % 4;
134
135 /* buffer is already in 'usb data order', which is LE. */
136 /* When reading buffer as u16, we have to take care byte order */
137 /* doesn't get mixed up */
138
139 if ((unsigned long)dp2 & 1) {
140 /* not aligned */
141 for (; len > 1; len -= 2) {
142 w = isp116x_raw_read_data16(isp116x);
143 *dp++ = w & 0xff;
144 *dp++ = (w >> 8) & 0xff;
145 }
146
147 if (len)
148 *dp = 0xff & isp116x_read_data16(isp116x);
149 } else {
150 /* aligned */
151 for (; len > 1; len -= 2) {
152 /* Keep byte order! */
153 *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
154 }
155
156 if (len)
157 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
158 }
159 if (quot == 1 || quot == 2)
160 isp116x_raw_read_data16(isp116x);
161 }
162
163 /*
164 Write ptd's and data for scheduled transfers into
165 the fifo ram. Fifo must be empty and ready.
166 */
167 static void pack_fifo(struct isp116x *isp116x)
168 {
169 struct isp116x_ep *ep;
170 struct ptd *ptd;
171 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
172 ? isp116x->atl_bufshrt : isp116x->atl_buflen;
173
174 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
175 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
176 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
177 for (ep = isp116x->atl_active; ep; ep = ep->active) {
178 ptd = &ep->ptd;
179 dump_ptd(ptd);
180 dump_ptd_out_data(ptd, ep->data);
181 isp116x_write_data16(isp116x, ptd->count);
182 isp116x_write_data16(isp116x, ptd->mps);
183 isp116x_write_data16(isp116x, ptd->len);
184 isp116x_write_data16(isp116x, ptd->faddr);
185 buflen -= sizeof(struct ptd);
186 /* Skip writing data for last IN PTD */
187 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
188 write_ptddata_to_fifo(isp116x, ep->data, ep->length);
189 buflen -= ALIGN(ep->length, 4);
190 }
191 }
192 BUG_ON(buflen);
193 }
194
195 /*
196 Read the processed ptd's and data from fifo ram back to
197 URBs' buffers. Fifo must be full and done
198 */
199 static void unpack_fifo(struct isp116x *isp116x)
200 {
201 struct isp116x_ep *ep;
202 struct ptd *ptd;
203 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
204 ? isp116x->atl_buflen : isp116x->atl_bufshrt;
205
206 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
207 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
208 isp116x_write_addr(isp116x, HCATLPORT);
209 for (ep = isp116x->atl_active; ep; ep = ep->active) {
210 ptd = &ep->ptd;
211 ptd->count = isp116x_read_data16(isp116x);
212 ptd->mps = isp116x_read_data16(isp116x);
213 ptd->len = isp116x_read_data16(isp116x);
214 ptd->faddr = isp116x_read_data16(isp116x);
215 buflen -= sizeof(struct ptd);
216 /* Skip reading data for last Setup or Out PTD */
217 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
218 read_ptddata_from_fifo(isp116x, ep->data, ep->length);
219 buflen -= ALIGN(ep->length, 4);
220 }
221 dump_ptd(ptd);
222 dump_ptd_in_data(ptd, ep->data);
223 }
224 BUG_ON(buflen);
225 }
226
227 /*---------------------------------------------------------------*/
228
229 /*
230 Set up PTD's.
231 */
232 static void preproc_atl_queue(struct isp116x *isp116x)
233 {
234 struct isp116x_ep *ep;
235 struct urb *urb;
236 struct ptd *ptd;
237 u16 len;
238
239 for (ep = isp116x->atl_active; ep; ep = ep->active) {
240 u16 toggle = 0, dir = PTD_DIR_SETUP;
241
242 BUG_ON(list_empty(&ep->hep->urb_list));
243 urb = container_of(ep->hep->urb_list.next,
244 struct urb, urb_list);
245 ptd = &ep->ptd;
246 len = ep->length;
247 ep->data = (unsigned char *)urb->transfer_buffer
248 + urb->actual_length;
249
250 switch (ep->nextpid) {
251 case USB_PID_IN:
252 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
253 dir = PTD_DIR_IN;
254 break;
255 case USB_PID_OUT:
256 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
257 dir = PTD_DIR_OUT;
258 break;
259 case USB_PID_SETUP:
260 len = sizeof(struct usb_ctrlrequest);
261 ep->data = urb->setup_packet;
262 break;
263 case USB_PID_ACK:
264 toggle = 1;
265 len = 0;
266 dir = (urb->transfer_buffer_length
267 && usb_pipein(urb->pipe))
268 ? PTD_DIR_OUT : PTD_DIR_IN;
269 break;
270 default:
271 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
272 ep->nextpid);
273 BUG();
274 }
275
276 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
277 ptd->mps = PTD_MPS(ep->maxpacket)
278 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
279 | PTD_EP(ep->epnum);
280 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
281 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
282 if (!ep->active) {
283 ptd->mps |= PTD_LAST_MSK;
284 isp116x->atl_last_dir = dir;
285 }
286 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
287 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
288 }
289 }
290
291 /*
292 Take done or failed requests out of schedule. Give back
293 processed urbs.
294 */
295 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
296 struct urb *urb, int status)
297 __releases(isp116x->lock) __acquires(isp116x->lock)
298 {
299 unsigned i;
300
301 ep->error_count = 0;
302
303 if (usb_pipecontrol(urb->pipe))
304 ep->nextpid = USB_PID_SETUP;
305
306 urb_dbg(urb, "Finish");
307
308 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
309 spin_unlock(&isp116x->lock);
310 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
311 spin_lock(&isp116x->lock);
312
313 /* take idle endpoints out of the schedule */
314 if (!list_empty(&ep->hep->urb_list))
315 return;
316
317 /* async deschedule */
318 if (!list_empty(&ep->schedule)) {
319 list_del_init(&ep->schedule);
320 return;
321 }
322
323 /* periodic deschedule */
324 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
325 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
326 struct isp116x_ep *temp;
327 struct isp116x_ep **prev = &isp116x->periodic[i];
328
329 while (*prev && ((temp = *prev) != ep))
330 prev = &temp->next;
331 if (*prev)
332 *prev = ep->next;
333 isp116x->load[i] -= ep->load;
334 }
335 ep->branch = PERIODIC_SIZE;
336 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
337 ep->load / ep->period;
338
339 /* switch irq type? */
340 if (!--isp116x->periodic_count) {
341 isp116x->irqenb &= ~HCuPINT_SOF;
342 isp116x->irqenb |= HCuPINT_ATL;
343 }
344 }
345
346 /*
347 Analyze transfer results, handle partial transfers and errors
348 */
349 static void postproc_atl_queue(struct isp116x *isp116x)
350 {
351 struct isp116x_ep *ep;
352 struct urb *urb;
353 struct usb_device *udev;
354 struct ptd *ptd;
355 int short_not_ok;
356 int status;
357 u8 cc;
358
359 for (ep = isp116x->atl_active; ep; ep = ep->active) {
360 BUG_ON(list_empty(&ep->hep->urb_list));
361 urb =
362 container_of(ep->hep->urb_list.next, struct urb, urb_list);
363 udev = urb->dev;
364 ptd = &ep->ptd;
365 cc = PTD_GET_CC(ptd);
366 short_not_ok = 1;
367 status = -EINPROGRESS;
368
369 /* Data underrun is special. For allowed underrun
370 we clear the error and continue as normal. For
371 forbidden underrun we finish the DATA stage
372 immediately while for control transfer,
373 we do a STATUS stage. */
374 if (cc == TD_DATAUNDERRUN) {
375 if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
376 usb_pipecontrol(urb->pipe)) {
377 DBG("Allowed or control data underrun\n");
378 cc = TD_CC_NOERROR;
379 short_not_ok = 0;
380 } else {
381 ep->error_count = 1;
382 usb_settoggle(udev, ep->epnum,
383 ep->nextpid == USB_PID_OUT,
384 PTD_GET_TOGGLE(ptd));
385 urb->actual_length += PTD_GET_COUNT(ptd);
386 status = cc_to_error[TD_DATAUNDERRUN];
387 goto done;
388 }
389 }
390
391 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
392 && (++ep->error_count >= 3 || cc == TD_CC_STALL
393 || cc == TD_DATAOVERRUN)) {
394 status = cc_to_error[cc];
395 if (ep->nextpid == USB_PID_ACK)
396 ep->nextpid = 0;
397 goto done;
398 }
399 /* According to usb spec, zero-length Int transfer signals
400 finishing of the urb. Hey, does this apply only
401 for IN endpoints? */
402 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
403 status = 0;
404 goto done;
405 }
406
407 /* Relax after previously failed, but later succeeded
408 or correctly NAK'ed retransmission attempt */
409 if (ep->error_count
410 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
411 ep->error_count = 0;
412
413 /* Take into account idiosyncracies of the isp116x chip
414 regarding toggle bit for failed transfers */
415 if (ep->nextpid == USB_PID_OUT)
416 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
417 ^ (ep->error_count > 0));
418 else if (ep->nextpid == USB_PID_IN)
419 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
420 ^ (ep->error_count > 0));
421
422 switch (ep->nextpid) {
423 case USB_PID_IN:
424 case USB_PID_OUT:
425 urb->actual_length += PTD_GET_COUNT(ptd);
426 if (PTD_GET_ACTIVE(ptd)
427 || (cc != TD_CC_NOERROR && cc < 0x0E))
428 break;
429 if (urb->transfer_buffer_length != urb->actual_length) {
430 if (short_not_ok)
431 break;
432 } else {
433 if (urb->transfer_flags & URB_ZERO_PACKET
434 && ep->nextpid == USB_PID_OUT
435 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
436 DBG("Zero packet requested\n");
437 break;
438 }
439 }
440 /* All data for this URB is transferred, let's finish */
441 if (usb_pipecontrol(urb->pipe))
442 ep->nextpid = USB_PID_ACK;
443 else
444 status = 0;
445 break;
446 case USB_PID_SETUP:
447 if (PTD_GET_ACTIVE(ptd)
448 || (cc != TD_CC_NOERROR && cc < 0x0E))
449 break;
450 if (urb->transfer_buffer_length == urb->actual_length)
451 ep->nextpid = USB_PID_ACK;
452 else if (usb_pipeout(urb->pipe)) {
453 usb_settoggle(udev, 0, 1, 1);
454 ep->nextpid = USB_PID_OUT;
455 } else {
456 usb_settoggle(udev, 0, 0, 1);
457 ep->nextpid = USB_PID_IN;
458 }
459 break;
460 case USB_PID_ACK:
461 if (PTD_GET_ACTIVE(ptd)
462 || (cc != TD_CC_NOERROR && cc < 0x0E))
463 break;
464 status = 0;
465 ep->nextpid = 0;
466 break;
467 default:
468 BUG();
469 }
470
471 done:
472 if (status != -EINPROGRESS || urb->unlinked)
473 finish_request(isp116x, ep, urb, status);
474 }
475 }
476
477 /*
478 Scan transfer lists, schedule transfers, send data off
479 to chip.
480 */
481 static void start_atl_transfers(struct isp116x *isp116x)
482 {
483 struct isp116x_ep *last_ep = NULL, *ep;
484 struct urb *urb;
485 u16 load = 0;
486 int len, index, speed, byte_time;
487
488 if (atomic_read(&isp116x->atl_finishing))
489 return;
490
491 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
492 return;
493
494 /* FIFO not empty? */
495 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
496 return;
497
498 isp116x->atl_active = NULL;
499 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
500
501 /* Schedule int transfers */
502 if (isp116x->periodic_count) {
503 isp116x->fmindex = index =
504 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
505 if ((load = isp116x->load[index])) {
506 /* Bring all int transfers for this frame
507 into the active queue */
508 isp116x->atl_active = last_ep =
509 isp116x->periodic[index];
510 while (last_ep->next)
511 last_ep = (last_ep->active = last_ep->next);
512 last_ep->active = NULL;
513 }
514 }
515
516 /* Schedule control/bulk transfers */
517 list_for_each_entry(ep, &isp116x->async, schedule) {
518 urb = container_of(ep->hep->urb_list.next,
519 struct urb, urb_list);
520 speed = urb->dev->speed;
521 byte_time = speed == USB_SPEED_LOW
522 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
523
524 if (ep->nextpid == USB_PID_SETUP) {
525 len = sizeof(struct usb_ctrlrequest);
526 } else if (ep->nextpid == USB_PID_ACK) {
527 len = 0;
528 } else {
529 /* Find current free length ... */
530 len = (MAX_LOAD_LIMIT - load) / byte_time;
531
532 /* ... then limit it to configured max size ... */
533 len = min(len, speed == USB_SPEED_LOW ?
534 MAX_TRANSFER_SIZE_LOWSPEED :
535 MAX_TRANSFER_SIZE_FULLSPEED);
536
537 /* ... and finally cut to the multiple of MaxPacketSize,
538 or to the real length if there's enough room. */
539 if (len <
540 (urb->transfer_buffer_length -
541 urb->actual_length)) {
542 len -= len % ep->maxpacket;
543 if (!len)
544 continue;
545 } else
546 len = urb->transfer_buffer_length -
547 urb->actual_length;
548 BUG_ON(len < 0);
549 }
550
551 load += len * byte_time;
552 if (load > MAX_LOAD_LIMIT)
553 break;
554
555 ep->active = NULL;
556 ep->length = len;
557 if (last_ep)
558 last_ep->active = ep;
559 else
560 isp116x->atl_active = ep;
561 last_ep = ep;
562 }
563
564 /* Avoid starving of endpoints */
565 if ((&isp116x->async)->next != (&isp116x->async)->prev)
566 list_move(&isp116x->async, (&isp116x->async)->next);
567
568 if (isp116x->atl_active) {
569 preproc_atl_queue(isp116x);
570 pack_fifo(isp116x);
571 }
572 }
573
574 /*
575 Finish the processed transfers
576 */
577 static void finish_atl_transfers(struct isp116x *isp116x)
578 {
579 if (!isp116x->atl_active)
580 return;
581 /* Fifo not ready? */
582 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
583 return;
584
585 atomic_inc(&isp116x->atl_finishing);
586 unpack_fifo(isp116x);
587 postproc_atl_queue(isp116x);
588 atomic_dec(&isp116x->atl_finishing);
589 }
590
591 static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
592 {
593 struct isp116x *isp116x = hcd_to_isp116x(hcd);
594 u16 irqstat;
595 irqreturn_t ret = IRQ_NONE;
596
597 spin_lock(&isp116x->lock);
598 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
599 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
600 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
601
602 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
603 ret = IRQ_HANDLED;
604 finish_atl_transfers(isp116x);
605 }
606
607 if (irqstat & HCuPINT_OPR) {
608 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
609 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
610 if (intstat & HCINT_UE) {
611 ERR("Unrecoverable error, HC is dead!\n");
612 /* IRQ's are off, we do no DMA,
613 perfectly ready to die ... */
614 hcd->state = HC_STATE_HALT;
615 usb_hc_died(hcd);
616 ret = IRQ_HANDLED;
617 goto done;
618 }
619 if (intstat & HCINT_RHSC)
620 /* When root hub or any of its ports is going
621 to come out of suspend, it may take more
622 than 10ms for status bits to stabilize. */
623 mod_timer(&hcd->rh_timer, jiffies
624 + msecs_to_jiffies(20) + 1);
625 if (intstat & HCINT_RD) {
626 DBG("---- remote wakeup\n");
627 usb_hcd_resume_root_hub(hcd);
628 }
629 irqstat &= ~HCuPINT_OPR;
630 ret = IRQ_HANDLED;
631 }
632
633 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
634 start_atl_transfers(isp116x);
635 }
636
637 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
638 done:
639 spin_unlock(&isp116x->lock);
640 return ret;
641 }
642
643 /*-----------------------------------------------------------------*/
644
645 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
646 * this driver doesn't promise that much since it's got to handle an
647 * IRQ per packet; irq handling latencies also use up that time.
648 */
649
650 /* out of 1000 us */
651 #define MAX_PERIODIC_LOAD 600
652 static int balance(struct isp116x *isp116x, u16 period, u16 load)
653 {
654 int i, branch = -ENOSPC;
655
656 /* search for the least loaded schedule branch of that period
657 which has enough bandwidth left unreserved. */
658 for (i = 0; i < period; i++) {
659 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
660 int j;
661
662 for (j = i; j < PERIODIC_SIZE; j += period) {
663 if ((isp116x->load[j] + load)
664 > MAX_PERIODIC_LOAD)
665 break;
666 }
667 if (j < PERIODIC_SIZE)
668 continue;
669 branch = i;
670 }
671 }
672 return branch;
673 }
674
675 /* NB! ALL the code above this point runs with isp116x->lock
676 held, irqs off
677 */
678
679 /*-----------------------------------------------------------------*/
680
681 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
682 struct urb *urb,
683 gfp_t mem_flags)
684 {
685 struct isp116x *isp116x = hcd_to_isp116x(hcd);
686 struct usb_device *udev = urb->dev;
687 unsigned int pipe = urb->pipe;
688 int is_out = !usb_pipein(pipe);
689 int type = usb_pipetype(pipe);
690 int epnum = usb_pipeendpoint(pipe);
691 struct usb_host_endpoint *hep = urb->ep;
692 struct isp116x_ep *ep = NULL;
693 unsigned long flags;
694 int i;
695 int ret = 0;
696
697 urb_dbg(urb, "Enqueue");
698
699 if (type == PIPE_ISOCHRONOUS) {
700 ERR("Isochronous transfers not supported\n");
701 urb_dbg(urb, "Refused to enqueue");
702 return -ENXIO;
703 }
704 /* avoid all allocations within spinlocks: request or endpoint */
705 if (!hep->hcpriv) {
706 ep = kzalloc(sizeof *ep, mem_flags);
707 if (!ep)
708 return -ENOMEM;
709 }
710
711 spin_lock_irqsave(&isp116x->lock, flags);
712 if (!HC_IS_RUNNING(hcd->state)) {
713 kfree(ep);
714 ret = -ENODEV;
715 goto fail_not_linked;
716 }
717 ret = usb_hcd_link_urb_to_ep(hcd, urb);
718 if (ret) {
719 kfree(ep);
720 goto fail_not_linked;
721 }
722
723 if (hep->hcpriv)
724 ep = hep->hcpriv;
725 else {
726 INIT_LIST_HEAD(&ep->schedule);
727 ep->udev = udev;
728 ep->epnum = epnum;
729 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
730 usb_settoggle(udev, epnum, is_out, 0);
731
732 if (type == PIPE_CONTROL) {
733 ep->nextpid = USB_PID_SETUP;
734 } else if (is_out) {
735 ep->nextpid = USB_PID_OUT;
736 } else {
737 ep->nextpid = USB_PID_IN;
738 }
739
740 if (urb->interval) {
741 /*
742 With INT URBs submitted, the driver works with SOF
743 interrupt enabled and ATL interrupt disabled. After
744 the PTDs are written to fifo ram, the chip starts
745 fifo processing and usb transfers after the next
746 SOF and continues until the transfers are finished
747 (succeeded or failed) or the frame ends. Therefore,
748 the transfers occur only in every second frame,
749 while fifo reading/writing and data processing
750 occur in every other second frame. */
751 if (urb->interval < 2)
752 urb->interval = 2;
753 if (urb->interval > 2 * PERIODIC_SIZE)
754 urb->interval = 2 * PERIODIC_SIZE;
755 ep->period = urb->interval >> 1;
756 ep->branch = PERIODIC_SIZE;
757 ep->load = usb_calc_bus_time(udev->speed,
758 !is_out,
759 (type == PIPE_ISOCHRONOUS),
760 usb_maxpacket(udev, pipe,
761 is_out)) /
762 1000;
763 }
764 hep->hcpriv = ep;
765 ep->hep = hep;
766 }
767
768 /* maybe put endpoint into schedule */
769 switch (type) {
770 case PIPE_CONTROL:
771 case PIPE_BULK:
772 if (list_empty(&ep->schedule))
773 list_add_tail(&ep->schedule, &isp116x->async);
774 break;
775 case PIPE_INTERRUPT:
776 urb->interval = ep->period;
777 ep->length = min_t(u32, ep->maxpacket,
778 urb->transfer_buffer_length);
779
780 /* urb submitted for already existing endpoint */
781 if (ep->branch < PERIODIC_SIZE)
782 break;
783
784 ep->branch = ret = balance(isp116x, ep->period, ep->load);
785 if (ret < 0)
786 goto fail;
787 ret = 0;
788
789 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
790 + ep->branch;
791
792 /* sort each schedule branch by period (slow before fast)
793 to share the faster parts of the tree without needing
794 dummy/placeholder nodes */
795 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
796 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
797 struct isp116x_ep **prev = &isp116x->periodic[i];
798 struct isp116x_ep *here = *prev;
799
800 while (here && ep != here) {
801 if (ep->period > here->period)
802 break;
803 prev = &here->next;
804 here = *prev;
805 }
806 if (ep != here) {
807 ep->next = here;
808 *prev = ep;
809 }
810 isp116x->load[i] += ep->load;
811 }
812 hcd->self.bandwidth_allocated += ep->load / ep->period;
813
814 /* switch over to SOFint */
815 if (!isp116x->periodic_count++) {
816 isp116x->irqenb &= ~HCuPINT_ATL;
817 isp116x->irqenb |= HCuPINT_SOF;
818 isp116x_write_reg16(isp116x, HCuPINTENB,
819 isp116x->irqenb);
820 }
821 }
822
823 urb->hcpriv = hep;
824 start_atl_transfers(isp116x);
825
826 fail:
827 if (ret)
828 usb_hcd_unlink_urb_from_ep(hcd, urb);
829 fail_not_linked:
830 spin_unlock_irqrestore(&isp116x->lock, flags);
831 return ret;
832 }
833
834 /*
835 Dequeue URBs.
836 */
837 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
838 int status)
839 {
840 struct isp116x *isp116x = hcd_to_isp116x(hcd);
841 struct usb_host_endpoint *hep;
842 struct isp116x_ep *ep, *ep_act;
843 unsigned long flags;
844 int rc;
845
846 spin_lock_irqsave(&isp116x->lock, flags);
847 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
848 if (rc)
849 goto done;
850
851 hep = urb->hcpriv;
852 ep = hep->hcpriv;
853 WARN_ON(hep != ep->hep);
854
855 /* In front of queue? */
856 if (ep->hep->urb_list.next == &urb->urb_list)
857 /* active? */
858 for (ep_act = isp116x->atl_active; ep_act;
859 ep_act = ep_act->active)
860 if (ep_act == ep) {
861 VDBG("dequeue, urb %p active; wait for irq\n",
862 urb);
863 urb = NULL;
864 break;
865 }
866
867 if (urb)
868 finish_request(isp116x, ep, urb, status);
869 done:
870 spin_unlock_irqrestore(&isp116x->lock, flags);
871 return rc;
872 }
873
874 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
875 struct usb_host_endpoint *hep)
876 {
877 int i;
878 struct isp116x_ep *ep = hep->hcpriv;
879
880 if (!ep)
881 return;
882
883 /* assume we'd just wait for the irq */
884 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
885 msleep(3);
886 if (!list_empty(&hep->urb_list))
887 WARNING("ep %p not empty?\n", ep);
888
889 kfree(ep);
890 hep->hcpriv = NULL;
891 }
892
893 static int isp116x_get_frame(struct usb_hcd *hcd)
894 {
895 struct isp116x *isp116x = hcd_to_isp116x(hcd);
896 u32 fmnum;
897 unsigned long flags;
898
899 spin_lock_irqsave(&isp116x->lock, flags);
900 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
901 spin_unlock_irqrestore(&isp116x->lock, flags);
902 return (int)fmnum;
903 }
904
905 /*
906 Adapted from ohci-hub.c. Currently we don't support autosuspend.
907 */
908 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
909 {
910 struct isp116x *isp116x = hcd_to_isp116x(hcd);
911 int ports, i, changed = 0;
912 unsigned long flags;
913
914 if (!HC_IS_RUNNING(hcd->state))
915 return -ESHUTDOWN;
916
917 /* Report no status change now, if we are scheduled to be
918 called later */
919 if (timer_pending(&hcd->rh_timer))
920 return 0;
921
922 ports = isp116x->rhdesca & RH_A_NDP;
923 spin_lock_irqsave(&isp116x->lock, flags);
924 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
925 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
926 buf[0] = changed = 1;
927 else
928 buf[0] = 0;
929
930 for (i = 0; i < ports; i++) {
931 u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
932
933 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
934 | RH_PS_OCIC | RH_PS_PRSC)) {
935 changed = 1;
936 buf[0] |= 1 << (i + 1);
937 }
938 }
939 spin_unlock_irqrestore(&isp116x->lock, flags);
940 return changed;
941 }
942
943 static void isp116x_hub_descriptor(struct isp116x *isp116x,
944 struct usb_hub_descriptor *desc)
945 {
946 u32 reg = isp116x->rhdesca;
947
948 desc->bDescriptorType = 0x29;
949 desc->bDescLength = 9;
950 desc->bHubContrCurrent = 0;
951 desc->bNbrPorts = (u8) (reg & 0x3);
952 /* Power switching, device type, overcurrent. */
953 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
954 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
955 /* ports removable, and legacy PortPwrCtrlMask */
956 desc->u.hs.DeviceRemovable[0] = 0;
957 desc->u.hs.DeviceRemovable[1] = ~0;
958 }
959
960 /* Perform reset of a given port.
961 It would be great to just start the reset and let the
962 USB core to clear the reset in due time. However,
963 root hub ports should be reset for at least 50 ms, while
964 our chip stays in reset for about 10 ms. I.e., we must
965 repeatedly reset it ourself here.
966 */
967 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
968 {
969 u32 tmp;
970 unsigned long flags, t;
971
972 /* Root hub reset should be 50 ms, but some devices
973 want it even longer. */
974 t = jiffies + msecs_to_jiffies(100);
975
976 while (time_before(jiffies, t)) {
977 spin_lock_irqsave(&isp116x->lock, flags);
978 /* spin until any current reset finishes */
979 for (;;) {
980 tmp = isp116x_read_reg32(isp116x, port ?
981 HCRHPORT2 : HCRHPORT1);
982 if (!(tmp & RH_PS_PRS))
983 break;
984 udelay(500);
985 }
986 /* Don't reset a disconnected port */
987 if (!(tmp & RH_PS_CCS)) {
988 spin_unlock_irqrestore(&isp116x->lock, flags);
989 break;
990 }
991 /* Reset lasts 10ms (claims datasheet) */
992 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
993 HCRHPORT1, (RH_PS_PRS));
994 spin_unlock_irqrestore(&isp116x->lock, flags);
995 msleep(10);
996 }
997 }
998
999 /* Adapted from ohci-hub.c */
1000 static int isp116x_hub_control(struct usb_hcd *hcd,
1001 u16 typeReq,
1002 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1003 {
1004 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1005 int ret = 0;
1006 unsigned long flags;
1007 int ports = isp116x->rhdesca & RH_A_NDP;
1008 u32 tmp = 0;
1009
1010 switch (typeReq) {
1011 case ClearHubFeature:
1012 DBG("ClearHubFeature: ");
1013 switch (wValue) {
1014 case C_HUB_OVER_CURRENT:
1015 DBG("C_HUB_OVER_CURRENT\n");
1016 spin_lock_irqsave(&isp116x->lock, flags);
1017 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1018 spin_unlock_irqrestore(&isp116x->lock, flags);
1019 case C_HUB_LOCAL_POWER:
1020 DBG("C_HUB_LOCAL_POWER\n");
1021 break;
1022 default:
1023 goto error;
1024 }
1025 break;
1026 case SetHubFeature:
1027 DBG("SetHubFeature: ");
1028 switch (wValue) {
1029 case C_HUB_OVER_CURRENT:
1030 case C_HUB_LOCAL_POWER:
1031 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1032 break;
1033 default:
1034 goto error;
1035 }
1036 break;
1037 case GetHubDescriptor:
1038 DBG("GetHubDescriptor\n");
1039 isp116x_hub_descriptor(isp116x,
1040 (struct usb_hub_descriptor *)buf);
1041 break;
1042 case GetHubStatus:
1043 DBG("GetHubStatus\n");
1044 *(__le32 *) buf = 0;
1045 break;
1046 case GetPortStatus:
1047 DBG("GetPortStatus\n");
1048 if (!wIndex || wIndex > ports)
1049 goto error;
1050 spin_lock_irqsave(&isp116x->lock, flags);
1051 tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1052 spin_unlock_irqrestore(&isp116x->lock, flags);
1053 *(__le32 *) buf = cpu_to_le32(tmp);
1054 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1055 break;
1056 case ClearPortFeature:
1057 DBG("ClearPortFeature: ");
1058 if (!wIndex || wIndex > ports)
1059 goto error;
1060 wIndex--;
1061
1062 switch (wValue) {
1063 case USB_PORT_FEAT_ENABLE:
1064 DBG("USB_PORT_FEAT_ENABLE\n");
1065 tmp = RH_PS_CCS;
1066 break;
1067 case USB_PORT_FEAT_C_ENABLE:
1068 DBG("USB_PORT_FEAT_C_ENABLE\n");
1069 tmp = RH_PS_PESC;
1070 break;
1071 case USB_PORT_FEAT_SUSPEND:
1072 DBG("USB_PORT_FEAT_SUSPEND\n");
1073 tmp = RH_PS_POCI;
1074 break;
1075 case USB_PORT_FEAT_C_SUSPEND:
1076 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1077 tmp = RH_PS_PSSC;
1078 break;
1079 case USB_PORT_FEAT_POWER:
1080 DBG("USB_PORT_FEAT_POWER\n");
1081 tmp = RH_PS_LSDA;
1082 break;
1083 case USB_PORT_FEAT_C_CONNECTION:
1084 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1085 tmp = RH_PS_CSC;
1086 break;
1087 case USB_PORT_FEAT_C_OVER_CURRENT:
1088 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1089 tmp = RH_PS_OCIC;
1090 break;
1091 case USB_PORT_FEAT_C_RESET:
1092 DBG("USB_PORT_FEAT_C_RESET\n");
1093 tmp = RH_PS_PRSC;
1094 break;
1095 default:
1096 goto error;
1097 }
1098 spin_lock_irqsave(&isp116x->lock, flags);
1099 isp116x_write_reg32(isp116x, wIndex
1100 ? HCRHPORT2 : HCRHPORT1, tmp);
1101 spin_unlock_irqrestore(&isp116x->lock, flags);
1102 break;
1103 case SetPortFeature:
1104 DBG("SetPortFeature: ");
1105 if (!wIndex || wIndex > ports)
1106 goto error;
1107 wIndex--;
1108 switch (wValue) {
1109 case USB_PORT_FEAT_SUSPEND:
1110 DBG("USB_PORT_FEAT_SUSPEND\n");
1111 spin_lock_irqsave(&isp116x->lock, flags);
1112 isp116x_write_reg32(isp116x, wIndex
1113 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1114 spin_unlock_irqrestore(&isp116x->lock, flags);
1115 break;
1116 case USB_PORT_FEAT_POWER:
1117 DBG("USB_PORT_FEAT_POWER\n");
1118 spin_lock_irqsave(&isp116x->lock, flags);
1119 isp116x_write_reg32(isp116x, wIndex
1120 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1121 spin_unlock_irqrestore(&isp116x->lock, flags);
1122 break;
1123 case USB_PORT_FEAT_RESET:
1124 DBG("USB_PORT_FEAT_RESET\n");
1125 root_port_reset(isp116x, wIndex);
1126 break;
1127 default:
1128 goto error;
1129 }
1130 break;
1131
1132 default:
1133 error:
1134 /* "protocol stall" on error */
1135 DBG("PROTOCOL STALL\n");
1136 ret = -EPIPE;
1137 }
1138 return ret;
1139 }
1140
1141 /*-----------------------------------------------------------------*/
1142
1143 #ifdef CONFIG_DEBUG_FS
1144
1145 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1146 {
1147 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1148 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1149 mask & HCuPINT_SUSP ? " susp" : "",
1150 mask & HCuPINT_OPR ? " opr" : "",
1151 mask & HCuPINT_AIIEOT ? " eot" : "",
1152 mask & HCuPINT_ATL ? " atl" : "",
1153 mask & HCuPINT_SOF ? " sof" : "");
1154 }
1155
1156 static void dump_int(struct seq_file *s, char *label, u32 mask)
1157 {
1158 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1159 mask & HCINT_MIE ? " MIE" : "",
1160 mask & HCINT_RHSC ? " rhsc" : "",
1161 mask & HCINT_FNO ? " fno" : "",
1162 mask & HCINT_UE ? " ue" : "",
1163 mask & HCINT_RD ? " rd" : "",
1164 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1165 }
1166
1167 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1168 {
1169 struct isp116x *isp116x = s->private;
1170
1171 seq_printf(s, "%s\n%s version %s\n",
1172 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1173 DRIVER_VERSION);
1174
1175 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1176 seq_printf(s, "HCD is suspended\n");
1177 return 0;
1178 }
1179 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1180 seq_printf(s, "HCD not running\n");
1181 return 0;
1182 }
1183
1184 spin_lock_irq(&isp116x->lock);
1185 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1186 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1187 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1188 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1189 isp116x_show_regs_seq(isp116x, s);
1190 spin_unlock_irq(&isp116x->lock);
1191 seq_printf(s, "\n");
1192
1193 return 0;
1194 }
1195
1196 static int isp116x_open_seq(struct inode *inode, struct file *file)
1197 {
1198 return single_open(file, isp116x_show_dbg, inode->i_private);
1199 }
1200
1201 static const struct file_operations isp116x_debug_fops = {
1202 .open = isp116x_open_seq,
1203 .read = seq_read,
1204 .llseek = seq_lseek,
1205 .release = single_release,
1206 };
1207
1208 static int create_debug_file(struct isp116x *isp116x)
1209 {
1210 isp116x->dentry = debugfs_create_file(hcd_name,
1211 S_IRUGO, NULL, isp116x,
1212 &isp116x_debug_fops);
1213 if (!isp116x->dentry)
1214 return -ENOMEM;
1215 return 0;
1216 }
1217
1218 static void remove_debug_file(struct isp116x *isp116x)
1219 {
1220 debugfs_remove(isp116x->dentry);
1221 }
1222
1223 #else
1224
1225 #define create_debug_file(d) 0
1226 #define remove_debug_file(d) do{}while(0)
1227
1228 #endif /* CONFIG_DEBUG_FS */
1229
1230 /*-----------------------------------------------------------------*/
1231
1232 /*
1233 Software reset - can be called from any contect.
1234 */
1235 static int isp116x_sw_reset(struct isp116x *isp116x)
1236 {
1237 int retries = 15;
1238 unsigned long flags;
1239 int ret = 0;
1240
1241 spin_lock_irqsave(&isp116x->lock, flags);
1242 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1243 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1244 while (--retries) {
1245 /* It usually resets within 1 ms */
1246 mdelay(1);
1247 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1248 break;
1249 }
1250 if (!retries) {
1251 ERR("Software reset timeout\n");
1252 ret = -ETIME;
1253 }
1254 spin_unlock_irqrestore(&isp116x->lock, flags);
1255 return ret;
1256 }
1257
1258 static int isp116x_reset(struct usb_hcd *hcd)
1259 {
1260 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1261 unsigned long t;
1262 u16 clkrdy = 0;
1263 int ret, timeout = 15 /* ms */ ;
1264
1265 ret = isp116x_sw_reset(isp116x);
1266 if (ret)
1267 return ret;
1268
1269 t = jiffies + msecs_to_jiffies(timeout);
1270 while (time_before_eq(jiffies, t)) {
1271 msleep(4);
1272 spin_lock_irq(&isp116x->lock);
1273 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1274 spin_unlock_irq(&isp116x->lock);
1275 if (clkrdy)
1276 break;
1277 }
1278 if (!clkrdy) {
1279 ERR("Clock not ready after %dms\n", timeout);
1280 /* After sw_reset the clock won't report to be ready, if
1281 H_WAKEUP pin is high. */
1282 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1283 ret = -ENODEV;
1284 }
1285 return ret;
1286 }
1287
1288 static void isp116x_stop(struct usb_hcd *hcd)
1289 {
1290 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1291 unsigned long flags;
1292 u32 val;
1293
1294 spin_lock_irqsave(&isp116x->lock, flags);
1295 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1296
1297 /* Switch off ports' power, some devices don't come up
1298 after next 'insmod' without this */
1299 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1300 val &= ~(RH_A_NPS | RH_A_PSM);
1301 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1302 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1303 spin_unlock_irqrestore(&isp116x->lock, flags);
1304
1305 isp116x_sw_reset(isp116x);
1306 }
1307
1308 /*
1309 Configure the chip. The chip must be successfully reset by now.
1310 */
1311 static int isp116x_start(struct usb_hcd *hcd)
1312 {
1313 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1314 struct isp116x_platform_data *board = isp116x->board;
1315 u32 val;
1316 unsigned long flags;
1317
1318 spin_lock_irqsave(&isp116x->lock, flags);
1319
1320 /* clear interrupt status and disable all interrupt sources */
1321 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1322 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1323
1324 val = isp116x_read_reg16(isp116x, HCCHIPID);
1325 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1326 ERR("Invalid chip ID %04x\n", val);
1327 spin_unlock_irqrestore(&isp116x->lock, flags);
1328 return -ENODEV;
1329 }
1330
1331 /* To be removed in future */
1332 hcd->uses_new_polling = 1;
1333
1334 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1335 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1336
1337 /* ----- HW conf */
1338 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1339 if (board->sel15Kres)
1340 val |= HCHWCFG_15KRSEL;
1341 /* Remote wakeup won't work without working clock */
1342 if (board->remote_wakeup_enable)
1343 val |= HCHWCFG_CLKNOTSTOP;
1344 if (board->oc_enable)
1345 val |= HCHWCFG_ANALOG_OC;
1346 if (board->int_act_high)
1347 val |= HCHWCFG_INT_POL;
1348 if (board->int_edge_triggered)
1349 val |= HCHWCFG_INT_TRIGGER;
1350 isp116x_write_reg16(isp116x, HCHWCFG, val);
1351
1352 /* ----- Root hub conf */
1353 val = (25 << 24) & RH_A_POTPGT;
1354 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1355 be always set. Yet, instead, we request individual port
1356 power switching. */
1357 val |= RH_A_PSM;
1358 /* Report overcurrent per port */
1359 val |= RH_A_OCPM;
1360 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1361 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1362
1363 val = RH_B_PPCM;
1364 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1365 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1366
1367 val = 0;
1368 if (board->remote_wakeup_enable) {
1369 if (!device_can_wakeup(hcd->self.controller))
1370 device_init_wakeup(hcd->self.controller, 1);
1371 val |= RH_HS_DRWE;
1372 }
1373 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1374 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1375
1376 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1377
1378 hcd->state = HC_STATE_RUNNING;
1379
1380 /* Set up interrupts */
1381 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1382 if (board->remote_wakeup_enable)
1383 isp116x->intenb |= HCINT_RD;
1384 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1385 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1386 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1387
1388 /* Go operational */
1389 val = HCCONTROL_USB_OPER;
1390 if (board->remote_wakeup_enable)
1391 val |= HCCONTROL_RWE;
1392 isp116x_write_reg32(isp116x, HCCONTROL, val);
1393
1394 /* Disable ports to avoid race in device enumeration */
1395 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1396 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1397
1398 isp116x_show_regs_log(isp116x);
1399 spin_unlock_irqrestore(&isp116x->lock, flags);
1400 return 0;
1401 }
1402
1403 #ifdef CONFIG_PM
1404
1405 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1406 {
1407 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1408 unsigned long flags;
1409 u32 val;
1410 int ret = 0;
1411
1412 spin_lock_irqsave(&isp116x->lock, flags);
1413 val = isp116x_read_reg32(isp116x, HCCONTROL);
1414
1415 switch (val & HCCONTROL_HCFS) {
1416 case HCCONTROL_USB_OPER:
1417 spin_unlock_irqrestore(&isp116x->lock, flags);
1418 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1419 val |= HCCONTROL_USB_SUSPEND;
1420 if (hcd->self.root_hub->do_remote_wakeup)
1421 val |= HCCONTROL_RWE;
1422 /* Wait for usb transfers to finish */
1423 msleep(2);
1424 spin_lock_irqsave(&isp116x->lock, flags);
1425 isp116x_write_reg32(isp116x, HCCONTROL, val);
1426 spin_unlock_irqrestore(&isp116x->lock, flags);
1427 /* Wait for devices to suspend */
1428 msleep(5);
1429 break;
1430 case HCCONTROL_USB_RESUME:
1431 isp116x_write_reg32(isp116x, HCCONTROL,
1432 (val & ~HCCONTROL_HCFS) |
1433 HCCONTROL_USB_RESET);
1434 case HCCONTROL_USB_RESET:
1435 ret = -EBUSY;
1436 default: /* HCCONTROL_USB_SUSPEND */
1437 spin_unlock_irqrestore(&isp116x->lock, flags);
1438 break;
1439 }
1440
1441 return ret;
1442 }
1443
1444 static int isp116x_bus_resume(struct usb_hcd *hcd)
1445 {
1446 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1447 u32 val;
1448
1449 msleep(5);
1450 spin_lock_irq(&isp116x->lock);
1451
1452 val = isp116x_read_reg32(isp116x, HCCONTROL);
1453 switch (val & HCCONTROL_HCFS) {
1454 case HCCONTROL_USB_SUSPEND:
1455 val &= ~HCCONTROL_HCFS;
1456 val |= HCCONTROL_USB_RESUME;
1457 isp116x_write_reg32(isp116x, HCCONTROL, val);
1458 case HCCONTROL_USB_RESUME:
1459 break;
1460 case HCCONTROL_USB_OPER:
1461 spin_unlock_irq(&isp116x->lock);
1462 return 0;
1463 default:
1464 /* HCCONTROL_USB_RESET: this may happen, when during
1465 suspension the HC lost power. Reinitialize completely */
1466 spin_unlock_irq(&isp116x->lock);
1467 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1468 isp116x_reset(hcd);
1469 isp116x_start(hcd);
1470 isp116x_hub_control(hcd, SetPortFeature,
1471 USB_PORT_FEAT_POWER, 1, NULL, 0);
1472 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1473 isp116x_hub_control(hcd, SetPortFeature,
1474 USB_PORT_FEAT_POWER, 2, NULL, 0);
1475 return 0;
1476 }
1477
1478 val = isp116x->rhdesca & RH_A_NDP;
1479 while (val--) {
1480 u32 stat =
1481 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1482 /* force global, not selective, resume */
1483 if (!(stat & RH_PS_PSS))
1484 continue;
1485 DBG("%s: Resuming port %d\n", __func__, val);
1486 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1487 ? HCRHPORT2 : HCRHPORT1);
1488 }
1489 spin_unlock_irq(&isp116x->lock);
1490
1491 hcd->state = HC_STATE_RESUMING;
1492 msleep(20);
1493
1494 /* Go operational */
1495 spin_lock_irq(&isp116x->lock);
1496 val = isp116x_read_reg32(isp116x, HCCONTROL);
1497 isp116x_write_reg32(isp116x, HCCONTROL,
1498 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1499 spin_unlock_irq(&isp116x->lock);
1500 hcd->state = HC_STATE_RUNNING;
1501
1502 return 0;
1503 }
1504
1505 #else
1506
1507 #define isp116x_bus_suspend NULL
1508 #define isp116x_bus_resume NULL
1509
1510 #endif
1511
1512 static struct hc_driver isp116x_hc_driver = {
1513 .description = hcd_name,
1514 .product_desc = "ISP116x Host Controller",
1515 .hcd_priv_size = sizeof(struct isp116x),
1516
1517 .irq = isp116x_irq,
1518 .flags = HCD_USB11,
1519
1520 .reset = isp116x_reset,
1521 .start = isp116x_start,
1522 .stop = isp116x_stop,
1523
1524 .urb_enqueue = isp116x_urb_enqueue,
1525 .urb_dequeue = isp116x_urb_dequeue,
1526 .endpoint_disable = isp116x_endpoint_disable,
1527
1528 .get_frame_number = isp116x_get_frame,
1529
1530 .hub_status_data = isp116x_hub_status_data,
1531 .hub_control = isp116x_hub_control,
1532 .bus_suspend = isp116x_bus_suspend,
1533 .bus_resume = isp116x_bus_resume,
1534 };
1535
1536 /*----------------------------------------------------------------*/
1537
1538 static int isp116x_remove(struct platform_device *pdev)
1539 {
1540 struct usb_hcd *hcd = platform_get_drvdata(pdev);
1541 struct isp116x *isp116x;
1542 struct resource *res;
1543
1544 if (!hcd)
1545 return 0;
1546 isp116x = hcd_to_isp116x(hcd);
1547 remove_debug_file(isp116x);
1548 usb_remove_hcd(hcd);
1549
1550 iounmap(isp116x->data_reg);
1551 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1552 release_mem_region(res->start, 2);
1553 iounmap(isp116x->addr_reg);
1554 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1555 release_mem_region(res->start, 2);
1556
1557 usb_put_hcd(hcd);
1558 return 0;
1559 }
1560
1561 static 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_size(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_size(data));
1609 if (data_reg == NULL) {
1610 ret = -ENOMEM;
1611 goto err4;
1612 }
1613
1614 /* allocate and initialize hcd */
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 /* this rsrc_start is bogus */
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 Suspend of platform device
1674 */
1675 static 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 Resume platform device
1683 */
1684 static 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 /* work with hotplug and coldplug */
1698 MODULE_ALIAS("platform:isp116x-hcd");
1699
1700 static 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
1713 static 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
1722 module_init(isp116x_init);
1723
1724 static void __exit isp116x_cleanup(void)
1725 {
1726 platform_driver_unregister(&isp116x_driver);
1727 }
1728
1729 module_exit(isp116x_cleanup);
linux-next