?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: w1_netlink: New init/fini netlink callbacks.
[linux-2.6/verdex.git] / drivers / usb / host / isp116x-hcd.c
blob75128c3718008a698cb0695c3eba0a0589bb2928
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/config.h>
59 #include <linux/module.h>
60 #include <linux/moduleparam.h>
61 #include <linux/kernel.h>
62 #include <linux/delay.h>
63 #include <linux/ioport.h>
64 #include <linux/sched.h>
65 #include <linux/slab.h>
66 #include <linux/smp_lock.h>
67 #include <linux/errno.h>
68 #include <linux/init.h>
69 #include <linux/list.h>
70 #include <linux/interrupt.h>
71 #include <linux/usb.h>
72 #include <linux/usb_isp116x.h>
73
74 #include <asm/io.h>
75 #include <asm/irq.h>
76 #include <asm/system.h>
77 #include <asm/byteorder.h>
78
79 #ifndef DEBUG
80 # define STUB_DEBUG_FILE
81 #endif
82
83 #include "../core/hcd.h"
84 #include "isp116x.h"
85
86 #define DRIVER_VERSION "08 Apr 2005"
87 #define DRIVER_DESC "ISP116x USB Host Controller Driver"
88
89 MODULE_DESCRIPTION(DRIVER_DESC);
90 MODULE_LICENSE("GPL");
91
92 static const char hcd_name[] = "isp116x-hcd";
93
94 /*-----------------------------------------------------------------*/
95
96 /*
97 Write len bytes to fifo, pad till 32-bit boundary
98 */
99 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
100 {
101 u8 *dp = (u8 *) buf;
102 u16 *dp2 = (u16 *) buf;
103 u16 w;
104 int quot = len % 4;
105
106 if ((unsigned long)dp2 & 1) {
107 /* not aligned */
108 for (; len > 1; len -= 2) {
109 w = *dp++;
110 w |= *dp++ << 8;
111 isp116x_raw_write_data16(isp116x, w);
112 }
113 if (len)
114 isp116x_write_data16(isp116x, (u16) * dp);
115 } else {
116 /* aligned */
117 for (; len > 1; len -= 2)
118 isp116x_raw_write_data16(isp116x, *dp2++);
119 if (len)
120 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
121 }
122 if (quot == 1 || quot == 2)
123 isp116x_raw_write_data16(isp116x, 0);
124 }
125
126 /*
127 Read len bytes from fifo and then read till 32-bit boundary.
128 */
129 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
130 {
131 u8 *dp = (u8 *) buf;
132 u16 *dp2 = (u16 *) buf;
133 u16 w;
134 int quot = len % 4;
135
136 if ((unsigned long)dp2 & 1) {
137 /* not aligned */
138 for (; len > 1; len -= 2) {
139 w = isp116x_raw_read_data16(isp116x);
140 *dp++ = w & 0xff;
141 *dp++ = (w >> 8) & 0xff;
142 }
143 if (len)
144 *dp = 0xff & isp116x_read_data16(isp116x);
145 } else {
146 /* aligned */
147 for (; len > 1; len -= 2)
148 *dp2++ = isp116x_raw_read_data16(isp116x);
149 if (len)
150 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
151 }
152 if (quot == 1 || quot == 2)
153 isp116x_raw_read_data16(isp116x);
154 }
155
156 /*
157 Write ptd's and data for scheduled transfers into
158 the fifo ram. Fifo must be empty and ready.
159 */
160 static void pack_fifo(struct isp116x *isp116x)
161 {
162 struct isp116x_ep *ep;
163 struct ptd *ptd;
164 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
165 ? isp116x->atl_bufshrt : isp116x->atl_buflen;
166 int ptd_count = 0;
167
168 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
169 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
170 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
171 for (ep = isp116x->atl_active; ep; ep = ep->active) {
172 ++ptd_count;
173 ptd = &ep->ptd;
174 dump_ptd(ptd);
175 dump_ptd_out_data(ptd, ep->data);
176 isp116x_write_data16(isp116x, ptd->count);
177 isp116x_write_data16(isp116x, ptd->mps);
178 isp116x_write_data16(isp116x, ptd->len);
179 isp116x_write_data16(isp116x, ptd->faddr);
180 buflen -= sizeof(struct ptd);
181 /* Skip writing data for last IN PTD */
182 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
183 write_ptddata_to_fifo(isp116x, ep->data, ep->length);
184 buflen -= ALIGN(ep->length, 4);
185 }
186 }
187 BUG_ON(buflen);
188 }
189
190 /*
191 Read the processed ptd's and data from fifo ram back to
192 URBs' buffers. Fifo must be full and done
193 */
194 static void unpack_fifo(struct isp116x *isp116x)
195 {
196 struct isp116x_ep *ep;
197 struct ptd *ptd;
198 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
199 ? isp116x->atl_buflen : isp116x->atl_bufshrt;
200
201 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
202 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
203 isp116x_write_addr(isp116x, HCATLPORT);
204 for (ep = isp116x->atl_active; ep; ep = ep->active) {
205 ptd = &ep->ptd;
206 ptd->count = isp116x_read_data16(isp116x);
207 ptd->mps = isp116x_read_data16(isp116x);
208 ptd->len = isp116x_read_data16(isp116x);
209 ptd->faddr = isp116x_read_data16(isp116x);
210 buflen -= sizeof(struct ptd);
211 /* Skip reading data for last Setup or Out PTD */
212 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
213 read_ptddata_from_fifo(isp116x, ep->data, ep->length);
214 buflen -= ALIGN(ep->length, 4);
215 }
216 dump_ptd(ptd);
217 dump_ptd_in_data(ptd, ep->data);
218 }
219 BUG_ON(buflen);
220 }
221
222 /*---------------------------------------------------------------*/
223
224 /*
225 Set up PTD's.
226 */
227 static void preproc_atl_queue(struct isp116x *isp116x)
228 {
229 struct isp116x_ep *ep;
230 struct urb *urb;
231 struct ptd *ptd;
232 u16 len;
233
234 for (ep = isp116x->atl_active; ep; ep = ep->active) {
235 u16 toggle = 0, dir = PTD_DIR_SETUP;
236
237 BUG_ON(list_empty(&ep->hep->urb_list));
238 urb = container_of(ep->hep->urb_list.next,
239 struct urb, urb_list);
240 ptd = &ep->ptd;
241 len = ep->length;
242 spin_lock(&urb->lock);
243 ep->data = (unsigned char *)urb->transfer_buffer
244 + urb->actual_length;
245
246 switch (ep->nextpid) {
247 case USB_PID_IN:
248 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
249 dir = PTD_DIR_IN;
250 break;
251 case USB_PID_OUT:
252 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
253 dir = PTD_DIR_OUT;
254 break;
255 case USB_PID_SETUP:
256 len = sizeof(struct usb_ctrlrequest);
257 ep->data = urb->setup_packet;
258 break;
259 case USB_PID_ACK:
260 toggle = 1;
261 len = 0;
262 dir = (urb->transfer_buffer_length
263 && usb_pipein(urb->pipe))
264 ? PTD_DIR_OUT : PTD_DIR_IN;
265 break;
266 default:
267 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
268 ep->nextpid);
269 BUG();
270 }
271
272 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
273 ptd->mps = PTD_MPS(ep->maxpacket)
274 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
275 | PTD_EP(ep->epnum);
276 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
277 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
278 spin_unlock(&urb->lock);
279 if (!ep->active) {
280 ptd->mps |= PTD_LAST_MSK;
281 isp116x->atl_last_dir = dir;
282 }
283 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
284 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
285 }
286 }
287
288 /*
289 Analyze transfer results, handle partial transfers and errors
290 */
291 static void postproc_atl_queue(struct isp116x *isp116x)
292 {
293 struct isp116x_ep *ep;
294 struct urb *urb;
295 struct usb_device *udev;
296 struct ptd *ptd;
297 int short_not_ok;
298 u8 cc;
299
300 for (ep = isp116x->atl_active; ep; ep = ep->active) {
301 BUG_ON(list_empty(&ep->hep->urb_list));
302 urb =
303 container_of(ep->hep->urb_list.next, struct urb, urb_list);
304 udev = urb->dev;
305 ptd = &ep->ptd;
306 cc = PTD_GET_CC(ptd);
307
308 spin_lock(&urb->lock);
309 short_not_ok = 1;
310
311 /* Data underrun is special. For allowed underrun
312 we clear the error and continue as normal. For
313 forbidden underrun we finish the DATA stage
314 immediately while for control transfer,
315 we do a STATUS stage. */
316 if (cc == TD_DATAUNDERRUN) {
317 if (!(urb->transfer_flags & URB_SHORT_NOT_OK)) {
318 DBG("Allowed data underrun\n");
319 cc = TD_CC_NOERROR;
320 short_not_ok = 0;
321 } else {
322 ep->error_count = 1;
323 if (usb_pipecontrol(urb->pipe))
324 ep->nextpid = USB_PID_ACK;
325 else
326 usb_settoggle(udev, ep->epnum,
327 ep->nextpid ==
328 USB_PID_OUT,
329 PTD_GET_TOGGLE(ptd) ^ 1);
330 urb->status = cc_to_error[TD_DATAUNDERRUN];
331 spin_unlock(&urb->lock);
332 continue;
333 }
334 }
335 /* Keep underrun error through the STATUS stage */
336 if (urb->status == cc_to_error[TD_DATAUNDERRUN])
337 cc = TD_DATAUNDERRUN;
338
339 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
340 && (++ep->error_count >= 3 || cc == TD_CC_STALL
341 || cc == TD_DATAOVERRUN)) {
342 if (urb->status == -EINPROGRESS)
343 urb->status = cc_to_error[cc];
344 if (ep->nextpid == USB_PID_ACK)
345 ep->nextpid = 0;
346 spin_unlock(&urb->lock);
347 continue;
348 }
349 /* According to usb spec, zero-length Int transfer signals
350 finishing of the urb. Hey, does this apply only
351 for IN endpoints? */
352 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
353 if (urb->status == -EINPROGRESS)
354 urb->status = 0;
355 spin_unlock(&urb->lock);
356 continue;
357 }
358
359 /* Relax after previously failed, but later succeeded
360 or correctly NAK'ed retransmission attempt */
361 if (ep->error_count
362 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
363 ep->error_count = 0;
364
365 /* Take into account idiosyncracies of the isp116x chip
366 regarding toggle bit for failed transfers */
367 if (ep->nextpid == USB_PID_OUT)
368 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
369 ^ (ep->error_count > 0));
370 else if (ep->nextpid == USB_PID_IN)
371 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
372 ^ (ep->error_count > 0));
373
374 switch (ep->nextpid) {
375 case USB_PID_IN:
376 case USB_PID_OUT:
377 urb->actual_length += PTD_GET_COUNT(ptd);
378 if (PTD_GET_ACTIVE(ptd)
379 || (cc != TD_CC_NOERROR && cc < 0x0E))
380 break;
381 if (urb->transfer_buffer_length != urb->actual_length) {
382 if (short_not_ok)
383 break;
384 } else {
385 if (urb->transfer_flags & URB_ZERO_PACKET
386 && ep->nextpid == USB_PID_OUT
387 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
388 DBG("Zero packet requested\n");
389 break;
390 }
391 }
392 /* All data for this URB is transferred, let's finish */
393 if (usb_pipecontrol(urb->pipe))
394 ep->nextpid = USB_PID_ACK;
395 else if (urb->status == -EINPROGRESS)
396 urb->status = 0;
397 break;
398 case USB_PID_SETUP:
399 if (PTD_GET_ACTIVE(ptd)
400 || (cc != TD_CC_NOERROR && cc < 0x0E))
401 break;
402 if (urb->transfer_buffer_length == urb->actual_length)
403 ep->nextpid = USB_PID_ACK;
404 else if (usb_pipeout(urb->pipe)) {
405 usb_settoggle(udev, 0, 1, 1);
406 ep->nextpid = USB_PID_OUT;
407 } else {
408 usb_settoggle(udev, 0, 0, 1);
409 ep->nextpid = USB_PID_IN;
410 }
411 break;
412 case USB_PID_ACK:
413 if (PTD_GET_ACTIVE(ptd)
414 || (cc != TD_CC_NOERROR && cc < 0x0E))
415 break;
416 if (urb->status == -EINPROGRESS)
417 urb->status = 0;
418 ep->nextpid = 0;
419 break;
420 default:
421 BUG_ON(1);
422 }
423 spin_unlock(&urb->lock);
424 }
425 }
426
427 /*
428 Take done or failed requests out of schedule. Give back
429 processed urbs.
430 */
431 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
432 struct urb *urb, struct pt_regs *regs)
433 __releases(isp116x->lock) __acquires(isp116x->lock)
434 {
435 unsigned i;
436
437 urb->hcpriv = NULL;
438 ep->error_count = 0;
439
440 if (usb_pipecontrol(urb->pipe))
441 ep->nextpid = USB_PID_SETUP;
442
443 urb_dbg(urb, "Finish");
444
445 spin_unlock(&isp116x->lock);
446 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, regs);
447 spin_lock(&isp116x->lock);
448
449 /* take idle endpoints out of the schedule */
450 if (!list_empty(&ep->hep->urb_list))
451 return;
452
453 /* async deschedule */
454 if (!list_empty(&ep->schedule)) {
455 list_del_init(&ep->schedule);
456 return;
457 }
458
459 /* periodic deschedule */
460 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
461 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
462 struct isp116x_ep *temp;
463 struct isp116x_ep **prev = &isp116x->periodic[i];
464
465 while (*prev && ((temp = *prev) != ep))
466 prev = &temp->next;
467 if (*prev)
468 *prev = ep->next;
469 isp116x->load[i] -= ep->load;
470 }
471 ep->branch = PERIODIC_SIZE;
472 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
473 ep->load / ep->period;
474
475 /* switch irq type? */
476 if (!--isp116x->periodic_count) {
477 isp116x->irqenb &= ~HCuPINT_SOF;
478 isp116x->irqenb |= HCuPINT_ATL;
479 }
480 }
481
482 /*
483 Scan transfer lists, schedule transfers, send data off
484 to chip.
485 */
486 static void start_atl_transfers(struct isp116x *isp116x)
487 {
488 struct isp116x_ep *last_ep = NULL, *ep;
489 struct urb *urb;
490 u16 load = 0;
491 int len, index, speed, byte_time;
492
493 if (atomic_read(&isp116x->atl_finishing))
494 return;
495
496 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
497 return;
498
499 /* FIFO not empty? */
500 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
501 return;
502
503 isp116x->atl_active = NULL;
504 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
505
506 /* Schedule int transfers */
507 if (isp116x->periodic_count) {
508 isp116x->fmindex = index =
509 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
510 if ((load = isp116x->load[index])) {
511 /* Bring all int transfers for this frame
512 into the active queue */
513 isp116x->atl_active = last_ep =
514 isp116x->periodic[index];
515 while (last_ep->next)
516 last_ep = (last_ep->active = last_ep->next);
517 last_ep->active = NULL;
518 }
519 }
520
521 /* Schedule control/bulk transfers */
522 list_for_each_entry(ep, &isp116x->async, schedule) {
523 urb = container_of(ep->hep->urb_list.next,
524 struct urb, urb_list);
525 speed = urb->dev->speed;
526 byte_time = speed == USB_SPEED_LOW
527 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
528
529 if (ep->nextpid == USB_PID_SETUP) {
530 len = sizeof(struct usb_ctrlrequest);
531 } else if (ep->nextpid == USB_PID_ACK) {
532 len = 0;
533 } else {
534 /* Find current free length ... */
535 len = (MAX_LOAD_LIMIT - load) / byte_time;
536
537 /* ... then limit it to configured max size ... */
538 len = min(len, speed == USB_SPEED_LOW ?
539 MAX_TRANSFER_SIZE_LOWSPEED :
540 MAX_TRANSFER_SIZE_FULLSPEED);
541
542 /* ... and finally cut to the multiple of MaxPacketSize,
543 or to the real length if there's enough room. */
544 if (len <
545 (urb->transfer_buffer_length -
546 urb->actual_length)) {
547 len -= len % ep->maxpacket;
548 if (!len)
549 continue;
550 } else
551 len = urb->transfer_buffer_length -
552 urb->actual_length;
553 BUG_ON(len < 0);
554 }
555
556 load += len * byte_time;
557 if (load > MAX_LOAD_LIMIT)
558 break;
559
560 ep->active = NULL;
561 ep->length = len;
562 if (last_ep)
563 last_ep->active = ep;
564 else
565 isp116x->atl_active = ep;
566 last_ep = ep;
567 }
568
569 /* Avoid starving of endpoints */
570 if ((&isp116x->async)->next != (&isp116x->async)->prev)
571 list_move(&isp116x->async, (&isp116x->async)->next);
572
573 if (isp116x->atl_active) {
574 preproc_atl_queue(isp116x);
575 pack_fifo(isp116x);
576 }
577 }
578
579 /*
580 Finish the processed transfers
581 */
582 static void finish_atl_transfers(struct isp116x *isp116x, struct pt_regs *regs)
583 {
584 struct isp116x_ep *ep;
585 struct urb *urb;
586
587 if (!isp116x->atl_active)
588 return;
589 /* Fifo not ready? */
590 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
591 return;
592
593 atomic_inc(&isp116x->atl_finishing);
594 unpack_fifo(isp116x);
595 postproc_atl_queue(isp116x);
596 for (ep = isp116x->atl_active; ep; ep = ep->active) {
597 urb =
598 container_of(ep->hep->urb_list.next, struct urb, urb_list);
599 /* USB_PID_ACK check here avoids finishing of
600 control transfers, for which TD_DATAUNDERRUN
601 occured, while URB_SHORT_NOT_OK was set */
602 if (urb && urb->status != -EINPROGRESS
603 && ep->nextpid != USB_PID_ACK)
604 finish_request(isp116x, ep, urb, regs);
605 }
606 atomic_dec(&isp116x->atl_finishing);
607 }
608
609 static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs)
610 {
611 struct isp116x *isp116x = hcd_to_isp116x(hcd);
612 u16 irqstat;
613 irqreturn_t ret = IRQ_NONE;
614
615 spin_lock(&isp116x->lock);
616 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
617 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
618 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
619
620 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
621 ret = IRQ_HANDLED;
622 finish_atl_transfers(isp116x, regs);
623 }
624
625 if (irqstat & HCuPINT_OPR) {
626 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
627 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
628 if (intstat & HCINT_UE) {
629 ERR("Unrecoverable error\n");
630 /* What should we do here? Reset? */
631 }
632 if (intstat & HCINT_RHSC) {
633 isp116x->rhstatus =
634 isp116x_read_reg32(isp116x, HCRHSTATUS);
635 isp116x->rhport[0] =
636 isp116x_read_reg32(isp116x, HCRHPORT1);
637 isp116x->rhport[1] =
638 isp116x_read_reg32(isp116x, HCRHPORT2);
639 }
640 if (intstat & HCINT_RD) {
641 DBG("---- remote wakeup\n");
642 schedule_work(&isp116x->rh_resume);
643 ret = IRQ_HANDLED;
644 }
645 irqstat &= ~HCuPINT_OPR;
646 ret = IRQ_HANDLED;
647 }
648
649 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
650 start_atl_transfers(isp116x);
651 }
652
653 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
654 spin_unlock(&isp116x->lock);
655 return ret;
656 }
657
658 /*-----------------------------------------------------------------*/
659
660 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
661 * this driver doesn't promise that much since it's got to handle an
662 * IRQ per packet; irq handling latencies also use up that time.
663 */
664
665 /* out of 1000 us */
666 #define MAX_PERIODIC_LOAD 600
667 static int balance(struct isp116x *isp116x, u16 period, u16 load)
668 {
669 int i, branch = -ENOSPC;
670
671 /* search for the least loaded schedule branch of that period
672 which has enough bandwidth left unreserved. */
673 for (i = 0; i < period; i++) {
674 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
675 int j;
676
677 for (j = i; j < PERIODIC_SIZE; j += period) {
678 if ((isp116x->load[j] + load)
679 > MAX_PERIODIC_LOAD)
680 break;
681 }
682 if (j < PERIODIC_SIZE)
683 continue;
684 branch = i;
685 }
686 }
687 return branch;
688 }
689
690 /* NB! ALL the code above this point runs with isp116x->lock
691 held, irqs off
692 */
693
694 /*-----------------------------------------------------------------*/
695
696 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
697 struct usb_host_endpoint *hep, struct urb *urb,
698 unsigned mem_flags)
699 {
700 struct isp116x *isp116x = hcd_to_isp116x(hcd);
701 struct usb_device *udev = urb->dev;
702 unsigned int pipe = urb->pipe;
703 int is_out = !usb_pipein(pipe);
704 int type = usb_pipetype(pipe);
705 int epnum = usb_pipeendpoint(pipe);
706 struct isp116x_ep *ep = NULL;
707 unsigned long flags;
708 int i;
709 int ret = 0;
710
711 urb_dbg(urb, "Enqueue");
712
713 if (type == PIPE_ISOCHRONOUS) {
714 ERR("Isochronous transfers not supported\n");
715 urb_dbg(urb, "Refused to enqueue");
716 return -ENXIO;
717 }
718 /* avoid all allocations within spinlocks: request or endpoint */
719 if (!hep->hcpriv) {
720 ep = kzalloc(sizeof *ep, mem_flags);
721 if (!ep)
722 return -ENOMEM;
723 }
724
725 spin_lock_irqsave(&isp116x->lock, flags);
726 if (!HC_IS_RUNNING(hcd->state)) {
727 ret = -ENODEV;
728 goto fail;
729 }
730
731 if (hep->hcpriv)
732 ep = hep->hcpriv;
733 else {
734 INIT_LIST_HEAD(&ep->schedule);
735 ep->udev = usb_get_dev(udev);
736 ep->epnum = epnum;
737 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
738 usb_settoggle(udev, epnum, is_out, 0);
739
740 if (type == PIPE_CONTROL) {
741 ep->nextpid = USB_PID_SETUP;
742 } else if (is_out) {
743 ep->nextpid = USB_PID_OUT;
744 } else {
745 ep->nextpid = USB_PID_IN;
746 }
747
748 if (urb->interval) {
749 /*
750 With INT URBs submitted, the driver works with SOF
751 interrupt enabled and ATL interrupt disabled. After
752 the PTDs are written to fifo ram, the chip starts
753 fifo processing and usb transfers after the next
754 SOF and continues until the transfers are finished
755 (succeeded or failed) or the frame ends. Therefore,
756 the transfers occur only in every second frame,
757 while fifo reading/writing and data processing
758 occur in every other second frame. */
759 if (urb->interval < 2)
760 urb->interval = 2;
761 if (urb->interval > 2 * PERIODIC_SIZE)
762 urb->interval = 2 * PERIODIC_SIZE;
763 ep->period = urb->interval >> 1;
764 ep->branch = PERIODIC_SIZE;
765 ep->load = usb_calc_bus_time(udev->speed,
766 !is_out,
767 (type == PIPE_ISOCHRONOUS),
768 usb_maxpacket(udev, pipe,
769 is_out)) /
770 1000;
771 }
772 hep->hcpriv = ep;
773 ep->hep = hep;
774 }
775
776 /* maybe put endpoint into schedule */
777 switch (type) {
778 case PIPE_CONTROL:
779 case PIPE_BULK:
780 if (list_empty(&ep->schedule))
781 list_add_tail(&ep->schedule, &isp116x->async);
782 break;
783 case PIPE_INTERRUPT:
784 urb->interval = ep->period;
785 ep->length = min((int)ep->maxpacket,
786 urb->transfer_buffer_length);
787
788 /* urb submitted for already existing endpoint */
789 if (ep->branch < PERIODIC_SIZE)
790 break;
791
792 ret = ep->branch = balance(isp116x, ep->period, ep->load);
793 if (ret < 0)
794 goto fail;
795 ret = 0;
796
797 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
798 + ep->branch;
799
800 /* sort each schedule branch by period (slow before fast)
801 to share the faster parts of the tree without needing
802 dummy/placeholder nodes */
803 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
804 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
805 struct isp116x_ep **prev = &isp116x->periodic[i];
806 struct isp116x_ep *here = *prev;
807
808 while (here && ep != here) {
809 if (ep->period > here->period)
810 break;
811 prev = &here->next;
812 here = *prev;
813 }
814 if (ep != here) {
815 ep->next = here;
816 *prev = ep;
817 }
818 isp116x->load[i] += ep->load;
819 }
820 hcd->self.bandwidth_allocated += ep->load / ep->period;
821
822 /* switch over to SOFint */
823 if (!isp116x->periodic_count++) {
824 isp116x->irqenb &= ~HCuPINT_ATL;
825 isp116x->irqenb |= HCuPINT_SOF;
826 isp116x_write_reg16(isp116x, HCuPINTENB,
827 isp116x->irqenb);
828 }
829 }
830
831 /* in case of unlink-during-submit */
832 spin_lock(&urb->lock);
833 if (urb->status != -EINPROGRESS) {
834 spin_unlock(&urb->lock);
835 finish_request(isp116x, ep, urb, NULL);
836 ret = 0;
837 goto fail;
838 }
839 urb->hcpriv = hep;
840 spin_unlock(&urb->lock);
841 start_atl_transfers(isp116x);
842
843 fail:
844 spin_unlock_irqrestore(&isp116x->lock, flags);
845 return ret;
846 }
847
848 /*
849 Dequeue URBs.
850 */
851 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
852 {
853 struct isp116x *isp116x = hcd_to_isp116x(hcd);
854 struct usb_host_endpoint *hep;
855 struct isp116x_ep *ep, *ep_act;
856 unsigned long flags;
857
858 spin_lock_irqsave(&isp116x->lock, flags);
859 hep = urb->hcpriv;
860 /* URB already unlinked (or never linked)? */
861 if (!hep) {
862 spin_unlock_irqrestore(&isp116x->lock, flags);
863 return 0;
864 }
865 ep = hep->hcpriv;
866 WARN_ON(hep != ep->hep);
867
868 /* In front of queue? */
869 if (ep->hep->urb_list.next == &urb->urb_list)
870 /* active? */
871 for (ep_act = isp116x->atl_active; ep_act;
872 ep_act = ep_act->active)
873 if (ep_act == ep) {
874 VDBG("dequeue, urb %p active; wait for irq\n",
875 urb);
876 urb = NULL;
877 break;
878 }
879
880 if (urb)
881 finish_request(isp116x, ep, urb, NULL);
882
883 spin_unlock_irqrestore(&isp116x->lock, flags);
884 return 0;
885 }
886
887 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
888 struct usb_host_endpoint *hep)
889 {
890 int i;
891 struct isp116x_ep *ep = hep->hcpriv;;
892
893 if (!ep)
894 return;
895
896 /* assume we'd just wait for the irq */
897 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
898 msleep(3);
899 if (!list_empty(&hep->urb_list))
900 WARN("ep %p not empty?\n", ep);
901
902 usb_put_dev(ep->udev);
903 kfree(ep);
904 hep->hcpriv = NULL;
905 }
906
907 static int isp116x_get_frame(struct usb_hcd *hcd)
908 {
909 struct isp116x *isp116x = hcd_to_isp116x(hcd);
910 u32 fmnum;
911 unsigned long flags;
912
913 spin_lock_irqsave(&isp116x->lock, flags);
914 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
915 spin_unlock_irqrestore(&isp116x->lock, flags);
916 return (int)fmnum;
917 }
918
919 /*----------------------------------------------------------------*/
920
921 /*
922 Adapted from ohci-hub.c. Currently we don't support autosuspend.
923 */
924 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
925 {
926 struct isp116x *isp116x = hcd_to_isp116x(hcd);
927 int ports, i, changed = 0;
928
929 if (!HC_IS_RUNNING(hcd->state))
930 return -ESHUTDOWN;
931
932 ports = isp116x->rhdesca & RH_A_NDP;
933
934 /* init status */
935 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
936 buf[0] = changed = 1;
937 else
938 buf[0] = 0;
939
940 for (i = 0; i < ports; i++) {
941 u32 status = isp116x->rhport[i];
942
943 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
944 | RH_PS_OCIC | RH_PS_PRSC)) {
945 changed = 1;
946 buf[0] |= 1 << (i + 1);
947 continue;
948 }
949 }
950 return changed;
951 }
952
953 static void isp116x_hub_descriptor(struct isp116x *isp116x,
954 struct usb_hub_descriptor *desc)
955 {
956 u32 reg = isp116x->rhdesca;
957
958 desc->bDescriptorType = 0x29;
959 desc->bDescLength = 9;
960 desc->bHubContrCurrent = 0;
961 desc->bNbrPorts = (u8) (reg & 0x3);
962 /* Power switching, device type, overcurrent. */
963 desc->wHubCharacteristics =
964 (__force __u16) cpu_to_le16((u16) ((reg >> 8) & 0x1f));
965 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
966 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
967 desc->bitmap[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1;
968 desc->bitmap[1] = ~0;
969 }
970
971 /* Perform reset of a given port.
972 It would be great to just start the reset and let the
973 USB core to clear the reset in due time. However,
974 root hub ports should be reset for at least 50 ms, while
975 our chip stays in reset for about 10 ms. I.e., we must
976 repeatedly reset it ourself here.
977 */
978 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
979 {
980 u32 tmp;
981 unsigned long flags, t;
982
983 /* Root hub reset should be 50 ms, but some devices
984 want it even longer. */
985 t = jiffies + msecs_to_jiffies(100);
986
987 while (time_before(jiffies, t)) {
988 spin_lock_irqsave(&isp116x->lock, flags);
989 /* spin until any current reset finishes */
990 for (;;) {
991 tmp = isp116x_read_reg32(isp116x, port ?
992 HCRHPORT2 : HCRHPORT1);
993 if (!(tmp & RH_PS_PRS))
994 break;
995 udelay(500);
996 }
997 /* Don't reset a disconnected port */
998 if (!(tmp & RH_PS_CCS)) {
999 spin_unlock_irqrestore(&isp116x->lock, flags);
1000 break;
1001 }
1002 /* Reset lasts 10ms (claims datasheet) */
1003 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
1004 HCRHPORT1, (RH_PS_PRS));
1005 spin_unlock_irqrestore(&isp116x->lock, flags);
1006 msleep(10);
1007 }
1008 }
1009
1010 /* Adapted from ohci-hub.c */
1011 static int isp116x_hub_control(struct usb_hcd *hcd,
1012 u16 typeReq,
1013 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1014 {
1015 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1016 int ret = 0;
1017 unsigned long flags;
1018 int ports = isp116x->rhdesca & RH_A_NDP;
1019 u32 tmp = 0;
1020
1021 switch (typeReq) {
1022 case ClearHubFeature:
1023 DBG("ClearHubFeature: ");
1024 switch (wValue) {
1025 case C_HUB_OVER_CURRENT:
1026 DBG("C_HUB_OVER_CURRENT\n");
1027 spin_lock_irqsave(&isp116x->lock, flags);
1028 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1029 spin_unlock_irqrestore(&isp116x->lock, flags);
1030 case C_HUB_LOCAL_POWER:
1031 DBG("C_HUB_LOCAL_POWER\n");
1032 break;
1033 default:
1034 goto error;
1035 }
1036 break;
1037 case SetHubFeature:
1038 DBG("SetHubFeature: ");
1039 switch (wValue) {
1040 case C_HUB_OVER_CURRENT:
1041 case C_HUB_LOCAL_POWER:
1042 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1043 break;
1044 default:
1045 goto error;
1046 }
1047 break;
1048 case GetHubDescriptor:
1049 DBG("GetHubDescriptor\n");
1050 isp116x_hub_descriptor(isp116x,
1051 (struct usb_hub_descriptor *)buf);
1052 break;
1053 case GetHubStatus:
1054 DBG("GetHubStatus\n");
1055 *(__le32 *) buf = 0;
1056 break;
1057 case GetPortStatus:
1058 DBG("GetPortStatus\n");
1059 if (!wIndex || wIndex > ports)
1060 goto error;
1061 tmp = isp116x->rhport[--wIndex];
1062 *(__le32 *) buf = cpu_to_le32(tmp);
1063 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1064 break;
1065 case ClearPortFeature:
1066 DBG("ClearPortFeature: ");
1067 if (!wIndex || wIndex > ports)
1068 goto error;
1069 wIndex--;
1070
1071 switch (wValue) {
1072 case USB_PORT_FEAT_ENABLE:
1073 DBG("USB_PORT_FEAT_ENABLE\n");
1074 tmp = RH_PS_CCS;
1075 break;
1076 case USB_PORT_FEAT_C_ENABLE:
1077 DBG("USB_PORT_FEAT_C_ENABLE\n");
1078 tmp = RH_PS_PESC;
1079 break;
1080 case USB_PORT_FEAT_SUSPEND:
1081 DBG("USB_PORT_FEAT_SUSPEND\n");
1082 tmp = RH_PS_POCI;
1083 break;
1084 case USB_PORT_FEAT_C_SUSPEND:
1085 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1086 tmp = RH_PS_PSSC;
1087 break;
1088 case USB_PORT_FEAT_POWER:
1089 DBG("USB_PORT_FEAT_POWER\n");
1090 tmp = RH_PS_LSDA;
1091 break;
1092 case USB_PORT_FEAT_C_CONNECTION:
1093 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1094 tmp = RH_PS_CSC;
1095 break;
1096 case USB_PORT_FEAT_C_OVER_CURRENT:
1097 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1098 tmp = RH_PS_OCIC;
1099 break;
1100 case USB_PORT_FEAT_C_RESET:
1101 DBG("USB_PORT_FEAT_C_RESET\n");
1102 tmp = RH_PS_PRSC;
1103 break;
1104 default:
1105 goto error;
1106 }
1107 spin_lock_irqsave(&isp116x->lock, flags);
1108 isp116x_write_reg32(isp116x, wIndex
1109 ? HCRHPORT2 : HCRHPORT1, tmp);
1110 isp116x->rhport[wIndex] =
1111 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1112 spin_unlock_irqrestore(&isp116x->lock, flags);
1113 break;
1114 case SetPortFeature:
1115 DBG("SetPortFeature: ");
1116 if (!wIndex || wIndex > ports)
1117 goto error;
1118 wIndex--;
1119 switch (wValue) {
1120 case USB_PORT_FEAT_SUSPEND:
1121 DBG("USB_PORT_FEAT_SUSPEND\n");
1122 spin_lock_irqsave(&isp116x->lock, flags);
1123 isp116x_write_reg32(isp116x, wIndex
1124 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1125 break;
1126 case USB_PORT_FEAT_POWER:
1127 DBG("USB_PORT_FEAT_POWER\n");
1128 spin_lock_irqsave(&isp116x->lock, flags);
1129 isp116x_write_reg32(isp116x, wIndex
1130 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1131 break;
1132 case USB_PORT_FEAT_RESET:
1133 DBG("USB_PORT_FEAT_RESET\n");
1134 root_port_reset(isp116x, wIndex);
1135 spin_lock_irqsave(&isp116x->lock, flags);
1136 break;
1137 default:
1138 goto error;
1139 }
1140 isp116x->rhport[wIndex] =
1141 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1142 spin_unlock_irqrestore(&isp116x->lock, flags);
1143 break;
1144
1145 default:
1146 error:
1147 /* "protocol stall" on error */
1148 DBG("PROTOCOL STALL\n");
1149 ret = -EPIPE;
1150 }
1151 return ret;
1152 }
1153
1154 #ifdef CONFIG_PM
1155
1156 static int isp116x_hub_suspend(struct usb_hcd *hcd)
1157 {
1158 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1159 unsigned long flags;
1160 u32 val;
1161 int ret = 0;
1162
1163 spin_lock_irqsave(&isp116x->lock, flags);
1164
1165 val = isp116x_read_reg32(isp116x, HCCONTROL);
1166 switch (val & HCCONTROL_HCFS) {
1167 case HCCONTROL_USB_OPER:
1168 hcd->state = HC_STATE_QUIESCING;
1169 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1170 val |= HCCONTROL_USB_SUSPEND;
1171 if (hcd->remote_wakeup)
1172 val |= HCCONTROL_RWE;
1173 /* Wait for usb transfers to finish */
1174 mdelay(2);
1175 isp116x_write_reg32(isp116x, HCCONTROL, val);
1176 hcd->state = HC_STATE_SUSPENDED;
1177 /* Wait for devices to suspend */
1178 mdelay(5);
1179 case HCCONTROL_USB_SUSPEND:
1180 break;
1181 case HCCONTROL_USB_RESUME:
1182 isp116x_write_reg32(isp116x, HCCONTROL,
1183 (val & ~HCCONTROL_HCFS) |
1184 HCCONTROL_USB_RESET);
1185 case HCCONTROL_USB_RESET:
1186 ret = -EBUSY;
1187 break;
1188 default:
1189 ret = -EINVAL;
1190 }
1191
1192 spin_unlock_irqrestore(&isp116x->lock, flags);
1193 return ret;
1194 }
1195
1196 static int isp116x_hub_resume(struct usb_hcd *hcd)
1197 {
1198 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1199 u32 val;
1200 int ret = -EINPROGRESS;
1201
1202 msleep(5);
1203 spin_lock_irq(&isp116x->lock);
1204
1205 val = isp116x_read_reg32(isp116x, HCCONTROL);
1206 switch (val & HCCONTROL_HCFS) {
1207 case HCCONTROL_USB_SUSPEND:
1208 val &= ~HCCONTROL_HCFS;
1209 val |= HCCONTROL_USB_RESUME;
1210 isp116x_write_reg32(isp116x, HCCONTROL, val);
1211 case HCCONTROL_USB_RESUME:
1212 break;
1213 case HCCONTROL_USB_OPER:
1214 /* Without setting power_state here the
1215 SUSPENDED state won't be removed from
1216 sysfs/usbN/power.state as a response to remote
1217 wakeup. Maybe in the future. */
1218 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1219 ret = 0;
1220 break;
1221 default:
1222 ret = -EBUSY;
1223 }
1224
1225 if (ret != -EINPROGRESS) {
1226 spin_unlock_irq(&isp116x->lock);
1227 return ret;
1228 }
1229
1230 val = isp116x->rhdesca & RH_A_NDP;
1231 while (val--) {
1232 u32 stat =
1233 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1234 /* force global, not selective, resume */
1235 if (!(stat & RH_PS_PSS))
1236 continue;
1237 DBG("%s: Resuming port %d\n", __func__, val);
1238 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1239 ? HCRHPORT2 : HCRHPORT1);
1240 }
1241 spin_unlock_irq(&isp116x->lock);
1242
1243 hcd->state = HC_STATE_RESUMING;
1244 mdelay(20);
1245
1246 /* Go operational */
1247 spin_lock_irq(&isp116x->lock);
1248 val = isp116x_read_reg32(isp116x, HCCONTROL);
1249 isp116x_write_reg32(isp116x, HCCONTROL,
1250 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1251 spin_unlock_irq(&isp116x->lock);
1252 /* see analogous comment above */
1253 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1254 hcd->state = HC_STATE_RUNNING;
1255
1256 return 0;
1257 }
1258
1259 static void isp116x_rh_resume(void *_hcd)
1260 {
1261 struct usb_hcd *hcd = _hcd;
1262
1263 usb_resume_device(hcd->self.root_hub);
1264 }
1265
1266 #else
1267
1268 #define isp116x_hub_suspend NULL
1269 #define isp116x_hub_resume NULL
1270
1271 static void isp116x_rh_resume(void *_hcd)
1272 {
1273 }
1274
1275 #endif
1276
1277 /*-----------------------------------------------------------------*/
1278
1279 #ifdef STUB_DEBUG_FILE
1280
1281 static inline void create_debug_file(struct isp116x *isp116x)
1282 {
1283 }
1284
1285 static inline void remove_debug_file(struct isp116x *isp116x)
1286 {
1287 }
1288
1289 #else
1290
1291 #include <linux/proc_fs.h>
1292 #include <linux/seq_file.h>
1293
1294 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1295 {
1296 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1297 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1298 mask & HCuPINT_SUSP ? " susp" : "",
1299 mask & HCuPINT_OPR ? " opr" : "",
1300 mask & HCuPINT_AIIEOT ? " eot" : "",
1301 mask & HCuPINT_ATL ? " atl" : "",
1302 mask & HCuPINT_SOF ? " sof" : "");
1303 }
1304
1305 static void dump_int(struct seq_file *s, char *label, u32 mask)
1306 {
1307 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1308 mask & HCINT_MIE ? " MIE" : "",
1309 mask & HCINT_RHSC ? " rhsc" : "",
1310 mask & HCINT_FNO ? " fno" : "",
1311 mask & HCINT_UE ? " ue" : "",
1312 mask & HCINT_RD ? " rd" : "",
1313 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1314 }
1315
1316 static int proc_isp116x_show(struct seq_file *s, void *unused)
1317 {
1318 struct isp116x *isp116x = s->private;
1319 struct isp116x_ep *ep;
1320 struct urb *urb;
1321 unsigned i;
1322 char *str;
1323
1324 seq_printf(s, "%s\n%s version %s\n",
1325 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1326 DRIVER_VERSION);
1327
1328 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1329 seq_printf(s, "HCD is suspended\n");
1330 return 0;
1331 }
1332 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1333 seq_printf(s, "HCD not running\n");
1334 return 0;
1335 }
1336
1337 spin_lock_irq(&isp116x->lock);
1338
1339 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1340 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1341 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1342 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1343
1344 list_for_each_entry(ep, &isp116x->async, schedule) {
1345
1346 switch (ep->nextpid) {
1347 case USB_PID_IN:
1348 str = "in";
1349 break;
1350 case USB_PID_OUT:
1351 str = "out";
1352 break;
1353 case USB_PID_SETUP:
1354 str = "setup";
1355 break;
1356 case USB_PID_ACK:
1357 str = "status";
1358 break;
1359 default:
1360 str = "?";
1361 break;
1362 };
1363 seq_printf(s, "%p, ep%d%s, maxpacket %d:\n", ep,
1364 ep->epnum, str, ep->maxpacket);
1365 list_for_each_entry(urb, &ep->hep->urb_list, urb_list) {
1366 seq_printf(s, " urb%p, %d/%d\n", urb,
1367 urb->actual_length,
1368 urb->transfer_buffer_length);
1369 }
1370 }
1371 if (!list_empty(&isp116x->async))
1372 seq_printf(s, "\n");
1373
1374 seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE);
1375
1376 for (i = 0; i < PERIODIC_SIZE; i++) {
1377 ep = isp116x->periodic[i];
1378 if (!ep)
1379 continue;
1380 seq_printf(s, "%2d [%3d]:\n", i, isp116x->load[i]);
1381
1382 /* DUMB: prints shared entries multiple times */
1383 do {
1384 seq_printf(s, " %d/%p (%sdev%d ep%d%s max %d)\n",
1385 ep->period, ep,
1386 (ep->udev->speed ==
1387 USB_SPEED_FULL) ? "" : "ls ",
1388 ep->udev->devnum, ep->epnum,
1389 (ep->epnum ==
1390 0) ? "" : ((ep->nextpid ==
1391 USB_PID_IN) ? "in" : "out"),
1392 ep->maxpacket);
1393 ep = ep->next;
1394 } while (ep);
1395 }
1396 spin_unlock_irq(&isp116x->lock);
1397 seq_printf(s, "\n");
1398
1399 return 0;
1400 }
1401
1402 static int proc_isp116x_open(struct inode *inode, struct file *file)
1403 {
1404 return single_open(file, proc_isp116x_show, PDE(inode)->data);
1405 }
1406
1407 static struct file_operations proc_ops = {
1408 .open = proc_isp116x_open,
1409 .read = seq_read,
1410 .llseek = seq_lseek,
1411 .release = single_release,
1412 };
1413
1414 /* expect just one isp116x per system */
1415 static const char proc_filename[] = "driver/isp116x";
1416
1417 static void create_debug_file(struct isp116x *isp116x)
1418 {
1419 struct proc_dir_entry *pde;
1420
1421 pde = create_proc_entry(proc_filename, 0, NULL);
1422 if (pde == NULL)
1423 return;
1424
1425 pde->proc_fops = &proc_ops;
1426 pde->data = isp116x;
1427 isp116x->pde = pde;
1428 }
1429
1430 static void remove_debug_file(struct isp116x *isp116x)
1431 {
1432 if (isp116x->pde)
1433 remove_proc_entry(proc_filename, NULL);
1434 }
1435
1436 #endif
1437
1438 /*-----------------------------------------------------------------*/
1439
1440 /*
1441 Software reset - can be called from any contect.
1442 */
1443 static int isp116x_sw_reset(struct isp116x *isp116x)
1444 {
1445 int retries = 15;
1446 unsigned long flags;
1447 int ret = 0;
1448
1449 spin_lock_irqsave(&isp116x->lock, flags);
1450 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1451 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1452 while (--retries) {
1453 /* It usually resets within 1 ms */
1454 mdelay(1);
1455 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1456 break;
1457 }
1458 if (!retries) {
1459 ERR("Software reset timeout\n");
1460 ret = -ETIME;
1461 }
1462 spin_unlock_irqrestore(&isp116x->lock, flags);
1463 return ret;
1464 }
1465
1466 /*
1467 Reset. Tries to perform platform-specific hardware
1468 reset first; falls back to software reset.
1469 */
1470 static int isp116x_reset(struct usb_hcd *hcd)
1471 {
1472 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1473 unsigned long t;
1474 u16 clkrdy = 0;
1475 int ret = 0, timeout = 15 /* ms */ ;
1476
1477 if (isp116x->board && isp116x->board->reset) {
1478 /* Hardware reset */
1479 isp116x->board->reset(hcd->self.controller, 1);
1480 msleep(10);
1481 if (isp116x->board->clock)
1482 isp116x->board->clock(hcd->self.controller, 1);
1483 msleep(1);
1484 isp116x->board->reset(hcd->self.controller, 0);
1485 } else
1486 ret = isp116x_sw_reset(isp116x);
1487
1488 if (ret)
1489 return ret;
1490
1491 t = jiffies + msecs_to_jiffies(timeout);
1492 while (time_before_eq(jiffies, t)) {
1493 msleep(4);
1494 spin_lock_irq(&isp116x->lock);
1495 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1496 spin_unlock_irq(&isp116x->lock);
1497 if (clkrdy)
1498 break;
1499 }
1500 if (!clkrdy) {
1501 ERR("Clock not ready after 20ms\n");
1502 /* After sw_reset the clock won't report to be ready, if
1503 H_WAKEUP pin is high. */
1504 if (!isp116x->board || !isp116x->board->reset)
1505 ERR("The driver does not support hardware wakeup.\n");
1506 ERR("Please make sure that the H_WAKEUP pin "
1507 "is pulled low!\n");
1508 ret = -ENODEV;
1509 }
1510 return ret;
1511 }
1512
1513 static void isp116x_stop(struct usb_hcd *hcd)
1514 {
1515 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1516 unsigned long flags;
1517 u32 val;
1518
1519 spin_lock_irqsave(&isp116x->lock, flags);
1520 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1521
1522 /* Switch off ports' power, some devices don't come up
1523 after next 'insmod' without this */
1524 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1525 val &= ~(RH_A_NPS | RH_A_PSM);
1526 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1527 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1528 spin_unlock_irqrestore(&isp116x->lock, flags);
1529
1530 /* Put the chip into reset state */
1531 if (isp116x->board && isp116x->board->reset)
1532 isp116x->board->reset(hcd->self.controller, 0);
1533 else
1534 isp116x_sw_reset(isp116x);
1535
1536 /* Stop the clock */
1537 if (isp116x->board && isp116x->board->clock)
1538 isp116x->board->clock(hcd->self.controller, 0);
1539 }
1540
1541 /*
1542 Configure the chip. The chip must be successfully reset by now.
1543 */
1544 static int isp116x_start(struct usb_hcd *hcd)
1545 {
1546 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1547 struct isp116x_platform_data *board = isp116x->board;
1548 u32 val;
1549 unsigned long flags;
1550
1551 spin_lock_irqsave(&isp116x->lock, flags);
1552
1553 /* clear interrupt status and disable all interrupt sources */
1554 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1555 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1556
1557 val = isp116x_read_reg16(isp116x, HCCHIPID);
1558 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1559 ERR("Invalid chip ID %04x\n", val);
1560 spin_unlock_irqrestore(&isp116x->lock, flags);
1561 return -ENODEV;
1562 }
1563
1564 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1565 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1566
1567 /* ----- HW conf */
1568 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1569 if (board->sel15Kres)
1570 val |= HCHWCFG_15KRSEL;
1571 /* Remote wakeup won't work without working clock */
1572 if (board->clknotstop || board->remote_wakeup_enable)
1573 val |= HCHWCFG_CLKNOTSTOP;
1574 if (board->oc_enable)
1575 val |= HCHWCFG_ANALOG_OC;
1576 if (board->int_act_high)
1577 val |= HCHWCFG_INT_POL;
1578 if (board->int_edge_triggered)
1579 val |= HCHWCFG_INT_TRIGGER;
1580 isp116x_write_reg16(isp116x, HCHWCFG, val);
1581
1582 /* ----- Root hub conf */
1583 val = 0;
1584 /* AN10003_1.pdf recommends NPS to be always 1 */
1585 if (board->no_power_switching)
1586 val |= RH_A_NPS;
1587 if (board->power_switching_mode)
1588 val |= RH_A_PSM;
1589 if (board->potpg)
1590 val |= (board->potpg << 24) & RH_A_POTPGT;
1591 else
1592 val |= (25 << 24) & RH_A_POTPGT;
1593 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1594 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1595
1596 val = RH_B_PPCM;
1597 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1598 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1599
1600 val = 0;
1601 if (board->remote_wakeup_enable) {
1602 hcd->can_wakeup = 1;
1603 val |= RH_HS_DRWE;
1604 }
1605 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1606 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1607
1608 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1609
1610 hcd->state = HC_STATE_RUNNING;
1611
1612 /* Set up interrupts */
1613 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1614 if (board->remote_wakeup_enable)
1615 isp116x->intenb |= HCINT_RD;
1616 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1617 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1618 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1619
1620 /* Go operational */
1621 val = HCCONTROL_USB_OPER;
1622 /* Remote wakeup connected - NOT SUPPORTED */
1623 /* if (board->remote_wakeup_connected)
1624 val |= HCCONTROL_RWC; */
1625 if (board->remote_wakeup_enable)
1626 val |= HCCONTROL_RWE;
1627 isp116x_write_reg32(isp116x, HCCONTROL, val);
1628
1629 /* Disable ports to avoid race in device enumeration */
1630 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1631 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1632
1633 isp116x_show_regs(isp116x);
1634 spin_unlock_irqrestore(&isp116x->lock, flags);
1635 return 0;
1636 }
1637
1638 /*-----------------------------------------------------------------*/
1639
1640 static struct hc_driver isp116x_hc_driver = {
1641 .description = hcd_name,
1642 .product_desc = "ISP116x Host Controller",
1643 .hcd_priv_size = sizeof(struct isp116x),
1644
1645 .irq = isp116x_irq,
1646 .flags = HCD_USB11,
1647
1648 .reset = isp116x_reset,
1649 .start = isp116x_start,
1650 .stop = isp116x_stop,
1651
1652 .urb_enqueue = isp116x_urb_enqueue,
1653 .urb_dequeue = isp116x_urb_dequeue,
1654 .endpoint_disable = isp116x_endpoint_disable,
1655
1656 .get_frame_number = isp116x_get_frame,
1657
1658 .hub_status_data = isp116x_hub_status_data,
1659 .hub_control = isp116x_hub_control,
1660 .hub_suspend = isp116x_hub_suspend,
1661 .hub_resume = isp116x_hub_resume,
1662 };
1663
1664 /*----------------------------------------------------------------*/
1665
1666 static int __init_or_module isp116x_remove(struct device *dev)
1667 {
1668 struct usb_hcd *hcd = dev_get_drvdata(dev);
1669 struct isp116x *isp116x;
1670 struct platform_device *pdev;
1671 struct resource *res;
1672
1673 if(!hcd)
1674 return 0;
1675 isp116x = hcd_to_isp116x(hcd);
1676 pdev = container_of(dev, struct platform_device, dev);
1677 remove_debug_file(isp116x);
1678 usb_remove_hcd(hcd);
1679
1680 iounmap(isp116x->data_reg);
1681 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1682 release_mem_region(res->start, 2);
1683 iounmap(isp116x->addr_reg);
1684 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1685 release_mem_region(res->start, 2);
1686
1687 usb_put_hcd(hcd);
1688 return 0;
1689 }
1690
1691 #define resource_len(r) (((r)->end - (r)->start) + 1)
1692
1693 static int __init isp116x_probe(struct device *dev)
1694 {
1695 struct usb_hcd *hcd;
1696 struct isp116x *isp116x;
1697 struct platform_device *pdev;
1698 struct resource *addr, *data;
1699 void __iomem *addr_reg;
1700 void __iomem *data_reg;
1701 int irq;
1702 int ret = 0;
1703
1704 pdev = container_of(dev, struct platform_device, dev);
1705 if (pdev->num_resources < 3) {
1706 ret = -ENODEV;
1707 goto err1;
1708 }
1709
1710 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1711 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1712 irq = platform_get_irq(pdev, 0);
1713 if (!addr || !data || irq < 0) {
1714 ret = -ENODEV;
1715 goto err1;
1716 }
1717
1718 if (dev->dma_mask) {
1719 DBG("DMA not supported\n");
1720 ret = -EINVAL;
1721 goto err1;
1722 }
1723
1724 if (!request_mem_region(addr->start, 2, hcd_name)) {
1725 ret = -EBUSY;
1726 goto err1;
1727 }
1728 addr_reg = ioremap(addr->start, resource_len(addr));
1729 if (addr_reg == NULL) {
1730 ret = -ENOMEM;
1731 goto err2;
1732 }
1733 if (!request_mem_region(data->start, 2, hcd_name)) {
1734 ret = -EBUSY;
1735 goto err3;
1736 }
1737 data_reg = ioremap(data->start, resource_len(data));
1738 if (data_reg == NULL) {
1739 ret = -ENOMEM;
1740 goto err4;
1741 }
1742
1743 /* allocate and initialize hcd */
1744 hcd = usb_create_hcd(&isp116x_hc_driver, dev, dev->bus_id);
1745 if (!hcd) {
1746 ret = -ENOMEM;
1747 goto err5;
1748 }
1749 /* this rsrc_start is bogus */
1750 hcd->rsrc_start = addr->start;
1751 isp116x = hcd_to_isp116x(hcd);
1752 isp116x->data_reg = data_reg;
1753 isp116x->addr_reg = addr_reg;
1754 spin_lock_init(&isp116x->lock);
1755 INIT_LIST_HEAD(&isp116x->async);
1756 INIT_WORK(&isp116x->rh_resume, isp116x_rh_resume, hcd);
1757 isp116x->board = dev->platform_data;
1758
1759 if (!isp116x->board) {
1760 ERR("Platform data structure not initialized\n");
1761 ret = -ENODEV;
1762 goto err6;
1763 }
1764 if (isp116x_check_platform_delay(isp116x)) {
1765 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1766 "implemented.\n");
1767 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1768 ret = -ENODEV;
1769 goto err6;
1770 }
1771
1772 ret = usb_add_hcd(hcd, irq, SA_INTERRUPT);
1773 if (ret != 0)
1774 goto err6;
1775
1776 create_debug_file(isp116x);
1777 return 0;
1778
1779 err6:
1780 usb_put_hcd(hcd);
1781 err5:
1782 iounmap(data_reg);
1783 err4:
1784 release_mem_region(data->start, 2);
1785 err3:
1786 iounmap(addr_reg);
1787 err2:
1788 release_mem_region(addr->start, 2);
1789 err1:
1790 ERR("init error, %d\n", ret);
1791 return ret;
1792 }
1793
1794 #ifdef CONFIG_PM
1795 /*
1796 Suspend of platform device
1797 */
1798 static int isp116x_suspend(struct device *dev, pm_message_t state, u32 phase)
1799 {
1800 int ret = 0;
1801 struct usb_hcd *hcd = dev_get_drvdata(dev);
1802
1803 VDBG("%s: state %x, phase %x\n", __func__, state, phase);
1804
1805 if (phase != SUSPEND_DISABLE && phase != SUSPEND_POWER_DOWN)
1806 return 0;
1807
1808 ret = usb_suspend_device(hcd->self.root_hub, state);
1809 if (!ret) {
1810 dev->power.power_state = state;
1811 INFO("%s suspended\n", hcd_name);
1812 } else
1813 ERR("%s suspend failed\n", hcd_name);
1814
1815 return ret;
1816 }
1817
1818 /*
1819 Resume platform device
1820 */
1821 static int isp116x_resume(struct device *dev, u32 phase)
1822 {
1823 int ret = 0;
1824 struct usb_hcd *hcd = dev_get_drvdata(dev);
1825
1826 VDBG("%s: state %x, phase %x\n", __func__, dev->power.power_state,
1827 phase);
1828 if (phase != RESUME_POWER_ON)
1829 return 0;
1830
1831 ret = usb_resume_device(hcd->self.root_hub);
1832 if (!ret) {
1833 dev->power.power_state = PMSG_ON;
1834 VDBG("%s resumed\n", (char *)hcd_name);
1835 }
1836 return ret;
1837 }
1838
1839 #else
1840
1841 #define isp116x_suspend NULL
1842 #define isp116x_resume NULL
1843
1844 #endif
1845
1846 static struct device_driver isp116x_driver = {
1847 .name = (char *)hcd_name,
1848 .bus = &platform_bus_type,
1849 .probe = isp116x_probe,
1850 .remove = isp116x_remove,
1851 .suspend = isp116x_suspend,
1852 .resume = isp116x_resume,
1853 };
1854
1855 /*-----------------------------------------------------------------*/
1856
1857 static int __init isp116x_init(void)
1858 {
1859 if (usb_disabled())
1860 return -ENODEV;
1861
1862 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1863 return driver_register(&isp116x_driver);
1864 }
1865
1866 module_init(isp116x_init);
1867
1868 static void __exit isp116x_cleanup(void)
1869 {
1870 driver_unregister(&isp116x_driver);
1871 }
1872
1873 module_exit(isp116x_cleanup);
Verdex Pro support