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