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