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