?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] USB: isp116x-hcd: replace mdelay() by msleep()
[linux-2.6/verdex.git] / drivers / usb / host / isp116x-hcd.c
blob972ce04889f8a9d602c060e896c4efa83b2ab1af
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 = usb_get_dev(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 usb_put_dev(ep->udev);
895 kfree(ep);
896 hep->hcpriv = NULL;
897 }
898
899 static int isp116x_get_frame(struct usb_hcd *hcd)
900 {
901 struct isp116x *isp116x = hcd_to_isp116x(hcd);
902 u32 fmnum;
903 unsigned long flags;
904
905 spin_lock_irqsave(&isp116x->lock, flags);
906 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
907 spin_unlock_irqrestore(&isp116x->lock, flags);
908 return (int)fmnum;
909 }
910
911 /*
912 Adapted from ohci-hub.c. Currently we don't support autosuspend.
913 */
914 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
915 {
916 struct isp116x *isp116x = hcd_to_isp116x(hcd);
917 int ports, i, changed = 0;
918 unsigned long flags;
919
920 if (!HC_IS_RUNNING(hcd->state))
921 return -ESHUTDOWN;
922
923 /* Report no status change now, if we are scheduled to be
924 called later */
925 if (timer_pending(&hcd->rh_timer))
926 return 0;
927
928 ports = isp116x->rhdesca & RH_A_NDP;
929 spin_lock_irqsave(&isp116x->lock, flags);
930 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
931 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
932 buf[0] = changed = 1;
933 else
934 buf[0] = 0;
935
936 for (i = 0; i < ports; i++) {
937 u32 status = isp116x->rhport[i] =
938 isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
939
940 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
941 | RH_PS_OCIC | RH_PS_PRSC)) {
942 changed = 1;
943 buf[0] |= 1 << (i + 1);
944 continue;
945 }
946 }
947 spin_unlock_irqrestore(&isp116x->lock, flags);
948 return changed;
949 }
950
951 static void isp116x_hub_descriptor(struct isp116x *isp116x,
952 struct usb_hub_descriptor *desc)
953 {
954 u32 reg = isp116x->rhdesca;
955
956 desc->bDescriptorType = 0x29;
957 desc->bDescLength = 9;
958 desc->bHubContrCurrent = 0;
959 desc->bNbrPorts = (u8) (reg & 0x3);
960 /* Power switching, device type, overcurrent. */
961 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
962 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
963 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
964 desc->bitmap[0] = 0;
965 desc->bitmap[1] = ~0;
966 }
967
968 /* Perform reset of a given port.
969 It would be great to just start the reset and let the
970 USB core to clear the reset in due time. However,
971 root hub ports should be reset for at least 50 ms, while
972 our chip stays in reset for about 10 ms. I.e., we must
973 repeatedly reset it ourself here.
974 */
975 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
976 {
977 u32 tmp;
978 unsigned long flags, t;
979
980 /* Root hub reset should be 50 ms, but some devices
981 want it even longer. */
982 t = jiffies + msecs_to_jiffies(100);
983
984 while (time_before(jiffies, t)) {
985 spin_lock_irqsave(&isp116x->lock, flags);
986 /* spin until any current reset finishes */
987 for (;;) {
988 tmp = isp116x_read_reg32(isp116x, port ?
989 HCRHPORT2 : HCRHPORT1);
990 if (!(tmp & RH_PS_PRS))
991 break;
992 udelay(500);
993 }
994 /* Don't reset a disconnected port */
995 if (!(tmp & RH_PS_CCS)) {
996 spin_unlock_irqrestore(&isp116x->lock, flags);
997 break;
998 }
999 /* Reset lasts 10ms (claims datasheet) */
1000 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
1001 HCRHPORT1, (RH_PS_PRS));
1002 spin_unlock_irqrestore(&isp116x->lock, flags);
1003 msleep(10);
1004 }
1005 }
1006
1007 /* Adapted from ohci-hub.c */
1008 static int isp116x_hub_control(struct usb_hcd *hcd,
1009 u16 typeReq,
1010 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1011 {
1012 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1013 int ret = 0;
1014 unsigned long flags;
1015 int ports = isp116x->rhdesca & RH_A_NDP;
1016 u32 tmp = 0;
1017
1018 switch (typeReq) {
1019 case ClearHubFeature:
1020 DBG("ClearHubFeature: ");
1021 switch (wValue) {
1022 case C_HUB_OVER_CURRENT:
1023 DBG("C_HUB_OVER_CURRENT\n");
1024 spin_lock_irqsave(&isp116x->lock, flags);
1025 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1026 spin_unlock_irqrestore(&isp116x->lock, flags);
1027 case C_HUB_LOCAL_POWER:
1028 DBG("C_HUB_LOCAL_POWER\n");
1029 break;
1030 default:
1031 goto error;
1032 }
1033 break;
1034 case SetHubFeature:
1035 DBG("SetHubFeature: ");
1036 switch (wValue) {
1037 case C_HUB_OVER_CURRENT:
1038 case C_HUB_LOCAL_POWER:
1039 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1040 break;
1041 default:
1042 goto error;
1043 }
1044 break;
1045 case GetHubDescriptor:
1046 DBG("GetHubDescriptor\n");
1047 isp116x_hub_descriptor(isp116x,
1048 (struct usb_hub_descriptor *)buf);
1049 break;
1050 case GetHubStatus:
1051 DBG("GetHubStatus\n");
1052 *(__le32 *) buf = 0;
1053 break;
1054 case GetPortStatus:
1055 DBG("GetPortStatus\n");
1056 if (!wIndex || wIndex > ports)
1057 goto error;
1058 tmp = isp116x->rhport[--wIndex];
1059 *(__le32 *) buf = cpu_to_le32(tmp);
1060 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1061 break;
1062 case ClearPortFeature:
1063 DBG("ClearPortFeature: ");
1064 if (!wIndex || wIndex > ports)
1065 goto error;
1066 wIndex--;
1067
1068 switch (wValue) {
1069 case USB_PORT_FEAT_ENABLE:
1070 DBG("USB_PORT_FEAT_ENABLE\n");
1071 tmp = RH_PS_CCS;
1072 break;
1073 case USB_PORT_FEAT_C_ENABLE:
1074 DBG("USB_PORT_FEAT_C_ENABLE\n");
1075 tmp = RH_PS_PESC;
1076 break;
1077 case USB_PORT_FEAT_SUSPEND:
1078 DBG("USB_PORT_FEAT_SUSPEND\n");
1079 tmp = RH_PS_POCI;
1080 break;
1081 case USB_PORT_FEAT_C_SUSPEND:
1082 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1083 tmp = RH_PS_PSSC;
1084 break;
1085 case USB_PORT_FEAT_POWER:
1086 DBG("USB_PORT_FEAT_POWER\n");
1087 tmp = RH_PS_LSDA;
1088 break;
1089 case USB_PORT_FEAT_C_CONNECTION:
1090 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1091 tmp = RH_PS_CSC;
1092 break;
1093 case USB_PORT_FEAT_C_OVER_CURRENT:
1094 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1095 tmp = RH_PS_OCIC;
1096 break;
1097 case USB_PORT_FEAT_C_RESET:
1098 DBG("USB_PORT_FEAT_C_RESET\n");
1099 tmp = RH_PS_PRSC;
1100 break;
1101 default:
1102 goto error;
1103 }
1104 spin_lock_irqsave(&isp116x->lock, flags);
1105 isp116x_write_reg32(isp116x, wIndex
1106 ? HCRHPORT2 : HCRHPORT1, tmp);
1107 isp116x->rhport[wIndex] =
1108 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1109 spin_unlock_irqrestore(&isp116x->lock, flags);
1110 break;
1111 case SetPortFeature:
1112 DBG("SetPortFeature: ");
1113 if (!wIndex || wIndex > ports)
1114 goto error;
1115 wIndex--;
1116 switch (wValue) {
1117 case USB_PORT_FEAT_SUSPEND:
1118 DBG("USB_PORT_FEAT_SUSPEND\n");
1119 spin_lock_irqsave(&isp116x->lock, flags);
1120 isp116x_write_reg32(isp116x, wIndex
1121 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1122 break;
1123 case USB_PORT_FEAT_POWER:
1124 DBG("USB_PORT_FEAT_POWER\n");
1125 spin_lock_irqsave(&isp116x->lock, flags);
1126 isp116x_write_reg32(isp116x, wIndex
1127 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1128 break;
1129 case USB_PORT_FEAT_RESET:
1130 DBG("USB_PORT_FEAT_RESET\n");
1131 root_port_reset(isp116x, wIndex);
1132 spin_lock_irqsave(&isp116x->lock, flags);
1133 break;
1134 default:
1135 goto error;
1136 }
1137 isp116x->rhport[wIndex] =
1138 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1139 spin_unlock_irqrestore(&isp116x->lock, flags);
1140 break;
1141
1142 default:
1143 error:
1144 /* "protocol stall" on error */
1145 DBG("PROTOCOL STALL\n");
1146 ret = -EPIPE;
1147 }
1148 return ret;
1149 }
1150
1151 /*-----------------------------------------------------------------*/
1152
1153 #ifdef CONFIG_DEBUG_FS
1154
1155 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1156 {
1157 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1158 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1159 mask & HCuPINT_SUSP ? " susp" : "",
1160 mask & HCuPINT_OPR ? " opr" : "",
1161 mask & HCuPINT_AIIEOT ? " eot" : "",
1162 mask & HCuPINT_ATL ? " atl" : "",
1163 mask & HCuPINT_SOF ? " sof" : "");
1164 }
1165
1166 static void dump_int(struct seq_file *s, char *label, u32 mask)
1167 {
1168 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1169 mask & HCINT_MIE ? " MIE" : "",
1170 mask & HCINT_RHSC ? " rhsc" : "",
1171 mask & HCINT_FNO ? " fno" : "",
1172 mask & HCINT_UE ? " ue" : "",
1173 mask & HCINT_RD ? " rd" : "",
1174 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1175 }
1176
1177 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1178 {
1179 struct isp116x *isp116x = s->private;
1180
1181 seq_printf(s, "%s\n%s version %s\n",
1182 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1183 DRIVER_VERSION);
1184
1185 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1186 seq_printf(s, "HCD is suspended\n");
1187 return 0;
1188 }
1189 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1190 seq_printf(s, "HCD not running\n");
1191 return 0;
1192 }
1193
1194 spin_lock_irq(&isp116x->lock);
1195 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1196 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1197 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1198 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1199 isp116x_show_regs_seq(isp116x, s);
1200 spin_unlock_irq(&isp116x->lock);
1201 seq_printf(s, "\n");
1202
1203 return 0;
1204 }
1205
1206 static int isp116x_open_seq(struct inode *inode, struct file *file)
1207 {
1208 return single_open(file, isp116x_show_dbg, inode->u.generic_ip);
1209 }
1210
1211 static struct file_operations isp116x_debug_fops = {
1212 .open = isp116x_open_seq,
1213 .read = seq_read,
1214 .llseek = seq_lseek,
1215 .release = single_release,
1216 };
1217
1218 static int create_debug_file(struct isp116x *isp116x)
1219 {
1220 isp116x->dentry = debugfs_create_file(hcd_name,
1221 S_IRUGO, NULL, isp116x,
1222 &isp116x_debug_fops);
1223 if (!isp116x->dentry)
1224 return -ENOMEM;
1225 return 0;
1226 }
1227
1228 static void remove_debug_file(struct isp116x *isp116x)
1229 {
1230 debugfs_remove(isp116x->dentry);
1231 }
1232
1233 #else
1234
1235 #define create_debug_file(d) 0
1236 #define remove_debug_file(d) do{}while(0)
1237
1238 #endif /* CONFIG_DEBUG_FS */
1239
1240 /*-----------------------------------------------------------------*/
1241
1242 /*
1243 Software reset - can be called from any contect.
1244 */
1245 static int isp116x_sw_reset(struct isp116x *isp116x)
1246 {
1247 int retries = 15;
1248 unsigned long flags;
1249 int ret = 0;
1250
1251 spin_lock_irqsave(&isp116x->lock, flags);
1252 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1253 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1254 while (--retries) {
1255 /* It usually resets within 1 ms */
1256 mdelay(1);
1257 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1258 break;
1259 }
1260 if (!retries) {
1261 ERR("Software reset timeout\n");
1262 ret = -ETIME;
1263 }
1264 spin_unlock_irqrestore(&isp116x->lock, flags);
1265 return ret;
1266 }
1267
1268 static int isp116x_reset(struct usb_hcd *hcd)
1269 {
1270 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1271 unsigned long t;
1272 u16 clkrdy = 0;
1273 int ret, timeout = 15 /* ms */ ;
1274
1275 ret = isp116x_sw_reset(isp116x);
1276 if (ret)
1277 return ret;
1278
1279 t = jiffies + msecs_to_jiffies(timeout);
1280 while (time_before_eq(jiffies, t)) {
1281 msleep(4);
1282 spin_lock_irq(&isp116x->lock);
1283 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1284 spin_unlock_irq(&isp116x->lock);
1285 if (clkrdy)
1286 break;
1287 }
1288 if (!clkrdy) {
1289 ERR("Clock not ready after %dms\n", timeout);
1290 /* After sw_reset the clock won't report to be ready, if
1291 H_WAKEUP pin is high. */
1292 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1293 ret = -ENODEV;
1294 }
1295 return ret;
1296 }
1297
1298 static void isp116x_stop(struct usb_hcd *hcd)
1299 {
1300 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1301 unsigned long flags;
1302 u32 val;
1303
1304 spin_lock_irqsave(&isp116x->lock, flags);
1305 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1306
1307 /* Switch off ports' power, some devices don't come up
1308 after next 'insmod' without this */
1309 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1310 val &= ~(RH_A_NPS | RH_A_PSM);
1311 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1312 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1313 spin_unlock_irqrestore(&isp116x->lock, flags);
1314
1315 isp116x_sw_reset(isp116x);
1316 }
1317
1318 /*
1319 Configure the chip. The chip must be successfully reset by now.
1320 */
1321 static int isp116x_start(struct usb_hcd *hcd)
1322 {
1323 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1324 struct isp116x_platform_data *board = isp116x->board;
1325 u32 val;
1326 unsigned long flags;
1327
1328 spin_lock_irqsave(&isp116x->lock, flags);
1329
1330 /* clear interrupt status and disable all interrupt sources */
1331 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1332 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1333
1334 val = isp116x_read_reg16(isp116x, HCCHIPID);
1335 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1336 ERR("Invalid chip ID %04x\n", val);
1337 spin_unlock_irqrestore(&isp116x->lock, flags);
1338 return -ENODEV;
1339 }
1340
1341 /* To be removed in future */
1342 hcd->uses_new_polling = 1;
1343
1344 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1345 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1346
1347 /* ----- HW conf */
1348 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1349 if (board->sel15Kres)
1350 val |= HCHWCFG_15KRSEL;
1351 /* Remote wakeup won't work without working clock */
1352 if (board->remote_wakeup_enable)
1353 val |= HCHWCFG_CLKNOTSTOP;
1354 if (board->oc_enable)
1355 val |= HCHWCFG_ANALOG_OC;
1356 if (board->int_act_high)
1357 val |= HCHWCFG_INT_POL;
1358 if (board->int_edge_triggered)
1359 val |= HCHWCFG_INT_TRIGGER;
1360 isp116x_write_reg16(isp116x, HCHWCFG, val);
1361
1362 /* ----- Root hub conf */
1363 val = (25 << 24) & RH_A_POTPGT;
1364 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1365 be always set. Yet, instead, we request individual port
1366 power switching. */
1367 val |= RH_A_PSM;
1368 /* Report overcurrent per port */
1369 val |= RH_A_OCPM;
1370 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1371 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1372
1373 val = RH_B_PPCM;
1374 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1375 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1376
1377 val = 0;
1378 if (board->remote_wakeup_enable) {
1379 if (!device_can_wakeup(hcd->self.controller))
1380 device_init_wakeup(hcd->self.controller, 1);
1381 val |= RH_HS_DRWE;
1382 }
1383 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1384 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1385
1386 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1387
1388 hcd->state = HC_STATE_RUNNING;
1389
1390 /* Set up interrupts */
1391 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1392 if (board->remote_wakeup_enable)
1393 isp116x->intenb |= HCINT_RD;
1394 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1395 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1396 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1397
1398 /* Go operational */
1399 val = HCCONTROL_USB_OPER;
1400 if (board->remote_wakeup_enable)
1401 val |= HCCONTROL_RWE;
1402 isp116x_write_reg32(isp116x, HCCONTROL, val);
1403
1404 /* Disable ports to avoid race in device enumeration */
1405 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1406 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1407
1408 isp116x_show_regs_log(isp116x);
1409 spin_unlock_irqrestore(&isp116x->lock, flags);
1410 return 0;
1411 }
1412
1413 #ifdef CONFIG_PM
1414
1415 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1416 {
1417 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1418 unsigned long flags;
1419 u32 val;
1420 int ret = 0;
1421
1422 spin_lock_irqsave(&isp116x->lock, flags);
1423 val = isp116x_read_reg32(isp116x, HCCONTROL);
1424
1425 switch (val & HCCONTROL_HCFS) {
1426 case HCCONTROL_USB_OPER:
1427 spin_unlock_irqrestore(&isp116x->lock, flags);
1428 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1429 val |= HCCONTROL_USB_SUSPEND;
1430 if (device_may_wakeup(&hcd->self.root_hub->dev))
1431 val |= HCCONTROL_RWE;
1432 /* Wait for usb transfers to finish */
1433 msleep(2);
1434 spin_lock_irqsave(&isp116x->lock, flags);
1435 isp116x_write_reg32(isp116x, HCCONTROL, val);
1436 spin_unlock_irqrestore(&isp116x->lock, flags);
1437 /* Wait for devices to suspend */
1438 msleep(5);
1439 break;
1440 case HCCONTROL_USB_RESUME:
1441 isp116x_write_reg32(isp116x, HCCONTROL,
1442 (val & ~HCCONTROL_HCFS) |
1443 HCCONTROL_USB_RESET);
1444 case HCCONTROL_USB_RESET:
1445 ret = -EBUSY;
1446 default: /* HCCONTROL_USB_SUSPEND */
1447 spin_unlock_irqrestore(&isp116x->lock, flags);
1448 break;
1449 }
1450
1451 return ret;
1452 }
1453
1454 static int isp116x_bus_resume(struct usb_hcd *hcd)
1455 {
1456 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1457 u32 val;
1458
1459 msleep(5);
1460 spin_lock_irq(&isp116x->lock);
1461
1462 val = isp116x_read_reg32(isp116x, HCCONTROL);
1463 switch (val & HCCONTROL_HCFS) {
1464 case HCCONTROL_USB_SUSPEND:
1465 val &= ~HCCONTROL_HCFS;
1466 val |= HCCONTROL_USB_RESUME;
1467 isp116x_write_reg32(isp116x, HCCONTROL, val);
1468 case HCCONTROL_USB_RESUME:
1469 break;
1470 case HCCONTROL_USB_OPER:
1471 spin_unlock_irq(&isp116x->lock);
1472 /* Without setting power_state here the
1473 SUSPENDED state won't be removed from
1474 sysfs/usbN/power.state as a response to remote
1475 wakeup. Maybe in the future. */
1476 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1477 return 0;
1478 default:
1479 /* HCCONTROL_USB_RESET: this may happen, when during
1480 suspension the HC lost power. Reinitialize completely */
1481 spin_unlock_irq(&isp116x->lock);
1482 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1483 isp116x_reset(hcd);
1484 isp116x_start(hcd);
1485 isp116x_hub_control(hcd, SetPortFeature,
1486 USB_PORT_FEAT_POWER, 1, NULL, 0);
1487 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1488 isp116x_hub_control(hcd, SetPortFeature,
1489 USB_PORT_FEAT_POWER, 2, NULL, 0);
1490 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1491 return 0;
1492 }
1493
1494 val = isp116x->rhdesca & RH_A_NDP;
1495 while (val--) {
1496 u32 stat =
1497 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1498 /* force global, not selective, resume */
1499 if (!(stat & RH_PS_PSS))
1500 continue;
1501 DBG("%s: Resuming port %d\n", __func__, val);
1502 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1503 ? HCRHPORT2 : HCRHPORT1);
1504 }
1505 spin_unlock_irq(&isp116x->lock);
1506
1507 hcd->state = HC_STATE_RESUMING;
1508 msleep(20);
1509
1510 /* Go operational */
1511 spin_lock_irq(&isp116x->lock);
1512 val = isp116x_read_reg32(isp116x, HCCONTROL);
1513 isp116x_write_reg32(isp116x, HCCONTROL,
1514 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1515 spin_unlock_irq(&isp116x->lock);
1516 /* see analogous comment above */
1517 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1518 hcd->state = HC_STATE_RUNNING;
1519
1520 return 0;
1521 }
1522
1523 #else
1524
1525 #define isp116x_bus_suspend NULL
1526 #define isp116x_bus_resume NULL
1527
1528 #endif
1529
1530 static struct hc_driver isp116x_hc_driver = {
1531 .description = hcd_name,
1532 .product_desc = "ISP116x Host Controller",
1533 .hcd_priv_size = sizeof(struct isp116x),
1534
1535 .irq = isp116x_irq,
1536 .flags = HCD_USB11,
1537
1538 .reset = isp116x_reset,
1539 .start = isp116x_start,
1540 .stop = isp116x_stop,
1541
1542 .urb_enqueue = isp116x_urb_enqueue,
1543 .urb_dequeue = isp116x_urb_dequeue,
1544 .endpoint_disable = isp116x_endpoint_disable,
1545
1546 .get_frame_number = isp116x_get_frame,
1547
1548 .hub_status_data = isp116x_hub_status_data,
1549 .hub_control = isp116x_hub_control,
1550 .bus_suspend = isp116x_bus_suspend,
1551 .bus_resume = isp116x_bus_resume,
1552 };
1553
1554 /*----------------------------------------------------------------*/
1555
1556 static int __init_or_module isp116x_remove(struct platform_device *pdev)
1557 {
1558 struct usb_hcd *hcd = platform_get_drvdata(pdev);
1559 struct isp116x *isp116x;
1560 struct resource *res;
1561
1562 if (!hcd)
1563 return 0;
1564 isp116x = hcd_to_isp116x(hcd);
1565 remove_debug_file(isp116x);
1566 usb_remove_hcd(hcd);
1567
1568 iounmap(isp116x->data_reg);
1569 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1570 release_mem_region(res->start, 2);
1571 iounmap(isp116x->addr_reg);
1572 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1573 release_mem_region(res->start, 2);
1574
1575 usb_put_hcd(hcd);
1576 return 0;
1577 }
1578
1579 #define resource_len(r) (((r)->end - (r)->start) + 1)
1580
1581 static int __init isp116x_probe(struct platform_device *pdev)
1582 {
1583 struct usb_hcd *hcd;
1584 struct isp116x *isp116x;
1585 struct resource *addr, *data;
1586 void __iomem *addr_reg;
1587 void __iomem *data_reg;
1588 int irq;
1589 int ret = 0;
1590
1591 if (pdev->num_resources < 3) {
1592 ret = -ENODEV;
1593 goto err1;
1594 }
1595
1596 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1597 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1598 irq = platform_get_irq(pdev, 0);
1599 if (!addr || !data || irq < 0) {
1600 ret = -ENODEV;
1601 goto err1;
1602 }
1603
1604 if (pdev->dev.dma_mask) {
1605 DBG("DMA not supported\n");
1606 ret = -EINVAL;
1607 goto err1;
1608 }
1609
1610 if (!request_mem_region(addr->start, 2, hcd_name)) {
1611 ret = -EBUSY;
1612 goto err1;
1613 }
1614 addr_reg = ioremap(addr->start, resource_len(addr));
1615 if (addr_reg == NULL) {
1616 ret = -ENOMEM;
1617 goto err2;
1618 }
1619 if (!request_mem_region(data->start, 2, hcd_name)) {
1620 ret = -EBUSY;
1621 goto err3;
1622 }
1623 data_reg = ioremap(data->start, resource_len(data));
1624 if (data_reg == NULL) {
1625 ret = -ENOMEM;
1626 goto err4;
1627 }
1628
1629 /* allocate and initialize hcd */
1630 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
1631 if (!hcd) {
1632 ret = -ENOMEM;
1633 goto err5;
1634 }
1635 /* this rsrc_start is bogus */
1636 hcd->rsrc_start = addr->start;
1637 isp116x = hcd_to_isp116x(hcd);
1638 isp116x->data_reg = data_reg;
1639 isp116x->addr_reg = addr_reg;
1640 spin_lock_init(&isp116x->lock);
1641 INIT_LIST_HEAD(&isp116x->async);
1642 isp116x->board = pdev->dev.platform_data;
1643
1644 if (!isp116x->board) {
1645 ERR("Platform data structure not initialized\n");
1646 ret = -ENODEV;
1647 goto err6;
1648 }
1649 if (isp116x_check_platform_delay(isp116x)) {
1650 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1651 "implemented.\n");
1652 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1653 ret = -ENODEV;
1654 goto err6;
1655 }
1656
1657 ret = usb_add_hcd(hcd, irq, SA_INTERRUPT);
1658 if (ret)
1659 goto err6;
1660
1661 ret = create_debug_file(isp116x);
1662 if (ret) {
1663 ERR("Couldn't create debugfs entry\n");
1664 goto err7;
1665 }
1666
1667 return 0;
1668
1669 err7:
1670 usb_remove_hcd(hcd);
1671 err6:
1672 usb_put_hcd(hcd);
1673 err5:
1674 iounmap(data_reg);
1675 err4:
1676 release_mem_region(data->start, 2);
1677 err3:
1678 iounmap(addr_reg);
1679 err2:
1680 release_mem_region(addr->start, 2);
1681 err1:
1682 ERR("init error, %d\n", ret);
1683 return ret;
1684 }
1685
1686 #ifdef CONFIG_PM
1687 /*
1688 Suspend of platform device
1689 */
1690 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1691 {
1692 VDBG("%s: state %x\n", __func__, state.event);
1693 dev->dev.power.power_state = state;
1694 return 0;
1695 }
1696
1697 /*
1698 Resume platform device
1699 */
1700 static int isp116x_resume(struct platform_device *dev)
1701 {
1702 VDBG("%s: state %x\n", __func__, dev->power.power_state.event);
1703 dev->dev.power.power_state = PMSG_ON;
1704 return 0;
1705 }
1706
1707 #else
1708
1709 #define isp116x_suspend NULL
1710 #define isp116x_resume NULL
1711
1712 #endif
1713
1714 static struct platform_driver isp116x_driver = {
1715 .probe = isp116x_probe,
1716 .remove = isp116x_remove,
1717 .suspend = isp116x_suspend,
1718 .resume = isp116x_resume,
1719 .driver = {
1720 .name = (char *)hcd_name,
1721 },
1722 };
1723
1724 /*-----------------------------------------------------------------*/
1725
1726 static int __init isp116x_init(void)
1727 {
1728 if (usb_disabled())
1729 return -ENODEV;
1730
1731 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1732 return platform_driver_register(&isp116x_driver);
1733 }
1734
1735 module_init(isp116x_init);
1736
1737 static void __exit isp116x_cleanup(void)
1738 {
1739 platform_driver_unregister(&isp116x_driver);
1740 }
1741
1742 module_exit(isp116x_cleanup);
Verdex Pro support