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