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