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