projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
USB: make usb_release_interface static
[deliverable/linux.git] / drivers / usb / host / isp116x-hcd.c
CommitLineData
4808a1c0
OK		 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 *
17f8bb73 20 * The driver passes all usbtests 1-14.
4808a1c0
OK		 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
4808a1c0 58#include <linux/module.h>
4808a1c0 59#include <linux/delay.h>
959eea21
OK		 60#include <linux/debugfs.h>
61#include <linux/seq_file.h>
4808a1c0
OK		 62#include <linux/errno.h>
63#include <linux/init.h>
64#include <linux/list.h>
4808a1c0 65#include <linux/usb.h>
325a4af6 66#include <linux/usb/isp116x.h>
d052d1be 67#include <linux/platform_device.h>
4808a1c0
OK		 68
69#include <asm/io.h>
70#include <asm/irq.h>
71#include <asm/system.h>
72#include <asm/byteorder.h>
73
4808a1c0
OK		 74#include "../core/hcd.h"
75#include "isp116x.h"
76
959eea21 77#define DRIVER_VERSION "03 Nov 2005"
4808a1c0
OK		 78#define DRIVER_DESC "ISP116x USB Host Controller Driver"
79
80MODULE_DESCRIPTION(DRIVER_DESC);
81MODULE_LICENSE("GPL");
82
83static const char hcd_name[] = "isp116x-hcd";
84
85/*-----------------------------------------------------------------*/
86
87/*
88 Write len bytes to fifo, pad till 32-bit boundary
89 */
90static 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 */
120static 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*/
151static 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;
4808a1c0
OK		 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) {
4808a1c0
OK		 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*/
183static 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*/
216static void preproc_atl_queue(struct isp116x *isp116x)
217{
218 struct isp116x_ep *ep;
219 struct urb *urb;
220 struct ptd *ptd;
f10eff26 221 u16 len;
4808a1c0
OK		 222
223 for (ep = isp116x->atl_active; ep; ep = ep->active) {
f10eff26
OK		 224 u16 toggle = 0, dir = PTD_DIR_SETUP;
225
4808a1c0
OK		 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;
4808a1c0
OK		 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:
4808a1c0
OK		 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:
4808a1c0
OK		 255 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
256 ep->nextpid);
17f8bb73 257 BUG();
4808a1c0
OK		 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));
4808a1c0
OK		 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
1b4cd43b
AS		 275/*
276 Take done or failed requests out of schedule. Give back
277 processed urbs.
278*/
279static 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
4808a1c0
OK		 330/*
331 Analyze transfer results, handle partial transfers and errors
332*/
333static 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;
1b4cd43b 340 int status;
4808a1c0
OK		 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);
4808a1c0 350 short_not_ok = 1;
1b4cd43b 351 status = -EINPROGRESS;
4808a1c0
OK		 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) {
1b4cd43b
AS		 359 if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
360 usb_pipecontrol(urb->pipe)) {
361 DBG("Allowed or control data underrun\n");
4808a1c0
OK		 362 cc = TD_CC_NOERROR;
363 short_not_ok = 0;
364 } else {
365 ep->error_count = 1;
1b4cd43b
AS		 366 usb_settoggle(udev, ep->epnum,
367 ep->nextpid == USB_PID_OUT,
368 PTD_GET_TOGGLE(ptd));
e9b765de 369 urb->actual_length += PTD_GET_COUNT(ptd);
1b4cd43b
AS		 370 status = cc_to_error[TD_DATAUNDERRUN];
371 goto done;
4808a1c0
OK		 372 }
373 }
4808a1c0
OK		 374
375 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
376 && (++ep->error_count >= 3 || cc == TD_CC_STALL
377 || cc == TD_DATAOVERRUN)) {
1b4cd43b 378 status = cc_to_error[cc];
4808a1c0
OK		 379 if (ep->nextpid == USB_PID_ACK)
380 ep->nextpid = 0;
1b4cd43b 381 goto done;
4808a1c0
OK		 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)) {
1b4cd43b
AS		 387 status = 0;
388 goto done;
4808a1c0
OK		 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;
1b4cd43b
AS		 427 else
428 status = 0;
4808a1c0
OK		 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;
1b4cd43b
AS		 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;
4808a1c0
OK		 454 ep->nextpid = 0;
455 break;
456 default:
959eea21 457 BUG();
4808a1c0 458 }
4808a1c0 459
1b4cd43b
AS		 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);
4808a1c0
OK		 469 }
470}
471
472/*
473 Scan transfer lists, schedule transfers, send data off
474 to chip.
475 */
476static 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*/
7d12e780 572static void finish_atl_transfers(struct isp116x *isp116x)
4808a1c0 573{
4808a1c0
OK		 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);
4808a1c0
OK		 583 atomic_dec(&isp116x->atl_finishing);
584}
585
7d12e780 586static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
4808a1c0
OK		 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;
7d12e780 599 finish_atl_transfers(isp116x);
4808a1c0
OK		 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) {
959eea21
OK		 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;
4808a1c0 612 }
9a57116b
OK		 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);
4808a1c0
OK		 619 if (intstat & HCINT_RD) {
620 DBG("---- remote wakeup\n");
ccdcf77a 621 usb_hcd_resume_root_hub(hcd);
4808a1c0
OK		 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);
959eea21 632 done:
4808a1c0
OK		 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
646static 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
675static int isp116x_urb_enqueue(struct usb_hcd *hcd,
676 struct usb_host_endpoint *hep, struct urb *urb,
55016f10 677 gfp_t mem_flags)
4808a1c0
OK		 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) {
7b842b6e 699 ep = kzalloc(sizeof *ep, mem_flags);
4808a1c0
OK		 700 if (!ep)
701 return -ENOMEM;
702 }
703
704 spin_lock_irqsave(&isp116x->lock, flags);
705 if (!HC_IS_RUNNING(hcd->state)) {
959eea21 706 kfree(ep);
4808a1c0
OK		 707 ret = -ENODEV;
708 goto fail;
709 }
710
711 if (hep->hcpriv)
712 ep = hep->hcpriv;
713 else {
714 INIT_LIST_HEAD(&ep->schedule);
6a8e87b2 715 ep->udev = udev;
4808a1c0
OK		 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
d5ce1379 772 ep->branch = ret = balance(isp116x, ep->period, ep->load);
4808a1c0
OK		 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 */
4808a1c0 812 if (urb->status != -EINPROGRESS) {
7d12e780 813 finish_request(isp116x, ep, urb);
4808a1c0
OK		 814 ret = 0;
815 goto fail;
816 }
817 urb->hcpriv = hep;
4808a1c0
OK		 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*/
828static 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)
7d12e780 858 finish_request(isp116x, ep, urb);
4808a1c0
OK		 859
860 spin_unlock_irqrestore(&isp116x->lock, flags);
861 return 0;
862}
863
864static void isp116x_endpoint_disable(struct usb_hcd *hcd,
865 struct usb_host_endpoint *hep)
866{
867 int i;
959eea21 868 struct isp116x_ep *ep = hep->hcpriv;
4808a1c0
OK		 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
4808a1c0
OK		 879 kfree(ep);
880 hep->hcpriv = NULL;
881}
882
883static 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
4808a1c0
OK		 895/*
896 Adapted from ohci-hub.c. Currently we don't support autosuspend.
897*/
898static 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;
9a57116b 902 unsigned long flags;
4808a1c0
OK		 903
904 if (!HC_IS_RUNNING(hcd->state))
905 return -ESHUTDOWN;
906
9a57116b
OK		 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;
4808a1c0 911
9a57116b
OK		 912 ports = isp116x->rhdesca & RH_A_NDP;
913 spin_lock_irqsave(&isp116x->lock, flags);
914 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
4808a1c0
OK		 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++) {
9a57116b
OK		 921 u32 status = isp116x->rhport[i] =
922 isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
4808a1c0
OK		 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 }
9a57116b 931 spin_unlock_irqrestore(&isp116x->lock, flags);
4808a1c0
OK		 932 return changed;
933}
934
935static 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. */
959eea21 945 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
4808a1c0
OK		 946 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
947 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
959eea21 948 desc->bitmap[0] = 0;
4808a1c0
OK		 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*/
959static 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 */
992static 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");
17f8bb73 1036 *(__le32 *) buf = 0;
4808a1c0
OK		 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
4808a1c0
OK		 1135/*-----------------------------------------------------------------*/
1136
959eea21 1137#ifdef CONFIG_DEBUG_FS
4808a1c0
OK		 1138
1139static 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
1150static 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
959eea21 1161static int isp116x_show_dbg(struct seq_file *s, void *unused)
4808a1c0
OK		 1162{
1163 struct isp116x *isp116x = s->private;
4808a1c0
OK		 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);
4808a1c0
OK		 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));
959eea21 1183 isp116x_show_regs_seq(isp116x, s);
4808a1c0
OK		 1184 spin_unlock_irq(&isp116x->lock);
1185 seq_printf(s, "\n");
1186
1187 return 0;
1188}
1189
959eea21 1190static int isp116x_open_seq(struct inode *inode, struct file *file)
4808a1c0 1191{
8e18e294 1192 return single_open(file, isp116x_show_dbg, inode->i_private);
4808a1c0
OK		 1193}
1194
066202dd 1195static const struct file_operations isp116x_debug_fops = {
959eea21 1196 .open = isp116x_open_seq,
4808a1c0
OK		 1197 .read = seq_read,
1198 .llseek = seq_lseek,
1199 .release = single_release,
1200};
1201
959eea21 1202static int create_debug_file(struct isp116x *isp116x)
4808a1c0 1203{
959eea21
OK		 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;
4808a1c0
OK		 1210}
1211
1212static void remove_debug_file(struct isp116x *isp116x)
1213{
959eea21 1214 debugfs_remove(isp116x->dentry);
4808a1c0
OK		 1215}
1216
959eea21
OK		 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 */
4808a1c0
OK		 1223
1224/*-----------------------------------------------------------------*/
1225
1226/*
1227 Software reset - can be called from any contect.
1228*/
1229static 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
4808a1c0
OK		 1252static int isp116x_reset(struct usb_hcd *hcd)
1253{
1254 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1255 unsigned long t;
1256 u16 clkrdy = 0;
959eea21 1257 int ret, timeout = 15 /* ms */ ;
4808a1c0 1258
f8d23d30 1259 ret = isp116x_sw_reset(isp116x);
4808a1c0
OK		 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) {
959eea21 1273 ERR("Clock not ready after %dms\n", timeout);
589a0083
OK		 1274 /* After sw_reset the clock won't report to be ready, if
1275 H_WAKEUP pin is high. */
f8d23d30 1276 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
4808a1c0
OK		 1277 ret = -ENODEV;
1278 }
1279 return ret;
1280}
1281
1282static 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
f8d23d30 1299 isp116x_sw_reset(isp116x);
4808a1c0
OK		 1300}
1301
1302/*
1303 Configure the chip. The chip must be successfully reset by now.
1304*/
1305static int isp116x_start(struct usb_hcd *hcd)
1306{
1307 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1308 struct isp116x_platform_data *board = isp116x->board;
4808a1c0
OK		 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
9a57116b
OK		 1325 /* To be removed in future */
1326 hcd->uses_new_polling = 1;
1327
4808a1c0
OK		 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 */
d4d62861 1336 if (board->remote_wakeup_enable)
4808a1c0
OK		 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 */
dc5bed09 1347 val = (25 << 24) & RH_A_POTPGT;
165c0f39
OK		 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;
9d233d9f
OK		 1352 /* Report overcurrent per port */
1353 val |= RH_A_OCPM;
4808a1c0
OK		 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) {
704aa0b7
DB		 1363 if (!device_can_wakeup(hcd->self.controller))
1364 device_init_wakeup(hcd->self.controller, 1);
4808a1c0
OK		 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);
4808a1c0 1371
4808a1c0
OK		 1372 hcd->state = HC_STATE_RUNNING;
1373
4808a1c0
OK		 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;
4808a1c0
OK		 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
959eea21 1392 isp116x_show_regs_log(isp116x);
4808a1c0
OK		 1393 spin_unlock_irqrestore(&isp116x->lock, flags);
1394 return 0;
1395}
1396
959eea21
OK		 1397#ifdef CONFIG_PM
1398
1399static 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);
959eea21 1407 val = isp116x_read_reg32(isp116x, HCCONTROL);
0be930c5 1408
959eea21
OK		 1409 switch (val & HCCONTROL_HCFS) {
1410 case HCCONTROL_USB_OPER:
0be930c5 1411 spin_unlock_irqrestore(&isp116x->lock, flags);
959eea21
OK		 1412 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1413 val |= HCCONTROL_USB_SUSPEND;
704aa0b7 1414 if (device_may_wakeup(&hcd->self.root_hub->dev))
959eea21
OK		 1415 val |= HCCONTROL_RWE;
1416 /* Wait for usb transfers to finish */
0be930c5
OK		 1417 msleep(2);
1418 spin_lock_irqsave(&isp116x->lock, flags);
959eea21 1419 isp116x_write_reg32(isp116x, HCCONTROL, val);
0be930c5 1420 spin_unlock_irqrestore(&isp116x->lock, flags);
959eea21 1421 /* Wait for devices to suspend */
0be930c5 1422 msleep(5);
959eea21
OK		 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;
0be930c5
OK		 1430 default: /* HCCONTROL_USB_SUSPEND */
1431 spin_unlock_irqrestore(&isp116x->lock, flags);
959eea21 1432 break;
959eea21
OK		 1433 }
1434
959eea21
OK		 1435 return ret;
1436}
1437
1438static 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
4808a1c0
OK		 1513
1514static 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,
0c0382e3
AS		 1534 .bus_suspend = isp116x_bus_suspend,
1535 .bus_resume = isp116x_bus_resume,
4808a1c0
OK		 1536};
1537
1538/*----------------------------------------------------------------*/
1539
b712548c 1540static int isp116x_remove(struct platform_device *pdev)
4808a1c0 1541{
3ae5eaec 1542 struct usb_hcd *hcd = platform_get_drvdata(pdev);
589a0083 1543 struct isp116x *isp116x;
4808a1c0
OK		 1544 struct resource *res;
1545
9a57116b 1546 if (!hcd)
589a0083
OK		 1547 return 0;
1548 isp116x = hcd_to_isp116x(hcd);
4808a1c0
OK		 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
5bcd70eb 1565static int __devinit isp116x_probe(struct platform_device *pdev)
4808a1c0
OK		 1566{
1567 struct usb_hcd *hcd;
1568 struct isp116x *isp116x;
4808a1c0
OK		 1569 struct resource *addr, *data;
1570 void __iomem *addr_reg;
1571 void __iomem *data_reg;
1572 int irq;
1573 int ret = 0;
1574
4808a1c0
OK		 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
3ae5eaec 1588 if (pdev->dev.dma_mask) {
4808a1c0
OK		 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 */
3ae5eaec 1614 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
4808a1c0
OK		 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);
3ae5eaec 1626 isp116x->board = pdev->dev.platform_data;
4808a1c0
OK		 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
d54b5caa 1641 ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
959eea21 1642 if (ret)
4808a1c0
OK		 1643 goto err6;
1644
959eea21
OK		 1645 ret = create_debug_file(isp116x);
1646 if (ret) {
1647 ERR("Couldn't create debugfs entry\n");
1648 goto err7;
1649 }
1650
4808a1c0
OK		 1651 return 0;
1652
959eea21
OK		 1653 err7:
1654 usb_remove_hcd(hcd);
4808a1c0
OK		 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*/
3ae5eaec 1674static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
4808a1c0 1675{
959eea21 1676 VDBG("%s: state %x\n", __func__, state.event);
3ae5eaec 1677 dev->dev.power.power_state = state;
959eea21 1678 return 0;
4808a1c0
OK		 1679}
1680
1681/*
1682 Resume platform device
1683*/
3ae5eaec 1684static int isp116x_resume(struct platform_device *dev)
4808a1c0 1685{
959eea21 1686 VDBG("%s: state %x\n", __func__, dev->power.power_state.event);
3ae5eaec 1687 dev->dev.power.power_state = PMSG_ON;
959eea21 1688 return 0;
4808a1c0
OK		 1689}
1690
1691#else
1692
1693#define isp116x_suspend NULL
1694#define isp116x_resume NULL
1695
1696#endif
1697
3ae5eaec 1698static struct platform_driver isp116x_driver = {
4808a1c0
OK		 1699 .probe = isp116x_probe,
1700 .remove = isp116x_remove,
1701 .suspend = isp116x_suspend,
1702 .resume = isp116x_resume,
0be930c5
OK		 1703 .driver = {
1704 .name = (char *)hcd_name,
1705 },
4808a1c0
OK		 1706};
1707
1708/*-----------------------------------------------------------------*/
1709
1710static int __init isp116x_init(void)
1711{
1712 if (usb_disabled())
1713 return -ENODEV;
1714
1715 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
3ae5eaec 1716 return platform_driver_register(&isp116x_driver);
4808a1c0
OK		 1717}
1718
1719module_init(isp116x_init);
1720
1721static void __exit isp116x_cleanup(void)
1722{
3ae5eaec 1723 platform_driver_unregister(&isp116x_driver);
4808a1c0
OK		 1724}
1725
1726module_exit(isp116x_cleanup);
Linux kernel - Deliverables
This page took 0.369534 seconds and 5 git commands to generate.