projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'stable/for-jens-3.5' of git://git.kernel.org/pub/scm/linux/kernel/git...
[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>
5a0e3ad6 65#include <linux/slab.h>
4808a1c0 66#include <linux/usb.h>
325a4af6 67#include <linux/usb/isp116x.h>
27729aad 68#include <linux/usb/hcd.h>
d052d1be 69#include <linux/platform_device.h>
4808a1c0
OK		 70
71#include <asm/io.h>
72#include <asm/irq.h>
4808a1c0
OK		 73#include <asm/byteorder.h>
74
4808a1c0
OK		 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
28874b7e
JM		 97 /* buffer is already in 'usb data order', which is LE. */
98 /* When reading buffer as u16, we have to take care byte order */
99 /* doesn't get mixed up */
100
4808a1c0
OK		 101 if ((unsigned long)dp2 & 1) {
102 /* not aligned */
103 for (; len > 1; len -= 2) {
104 w = *dp++;
105 w |= *dp++ << 8;
106 isp116x_raw_write_data16(isp116x, w);
107 }
108 if (len)
109 isp116x_write_data16(isp116x, (u16) * dp);
110 } else {
111 /* aligned */
28874b7e
JM		 112 for (; len > 1; len -= 2) {
113 /* Keep byte order ! */
114 isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
115 }
116
4808a1c0
OK		 117 if (len)
118 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
119 }
120 if (quot == 1 || quot == 2)
121 isp116x_raw_write_data16(isp116x, 0);
122}
123
124/*
125 Read len bytes from fifo and then read till 32-bit boundary.
126 */
127static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
128{
129 u8 *dp = (u8 *) buf;
130 u16 *dp2 = (u16 *) buf;
131 u16 w;
132 int quot = len % 4;
133
28874b7e
JM		 134 /* buffer is already in 'usb data order', which is LE. */
135 /* When reading buffer as u16, we have to take care byte order */
136 /* doesn't get mixed up */
137
4808a1c0
OK		 138 if ((unsigned long)dp2 & 1) {
139 /* not aligned */
140 for (; len > 1; len -= 2) {
141 w = isp116x_raw_read_data16(isp116x);
142 *dp++ = w & 0xff;
143 *dp++ = (w >> 8) & 0xff;
144 }
28874b7e 145
4808a1c0
OK		 146 if (len)
147 *dp = 0xff & isp116x_read_data16(isp116x);
148 } else {
149 /* aligned */
28874b7e
JM		 150 for (; len > 1; len -= 2) {
151 /* Keep byte order! */
152 *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
153 }
154
4808a1c0
OK		 155 if (len)
156 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
157 }
158 if (quot == 1 || quot == 2)
159 isp116x_raw_read_data16(isp116x);
160}
161
162/*
163 Write ptd's and data for scheduled transfers into
164 the fifo ram. Fifo must be empty and ready.
165*/
166static void pack_fifo(struct isp116x *isp116x)
167{
168 struct isp116x_ep *ep;
169 struct ptd *ptd;
170 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
171 ? isp116x->atl_bufshrt : isp116x->atl_buflen;
4808a1c0
OK		 172
173 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
174 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
175 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
176 for (ep = isp116x->atl_active; ep; ep = ep->active) {
4808a1c0
OK		 177 ptd = &ep->ptd;
178 dump_ptd(ptd);
179 dump_ptd_out_data(ptd, ep->data);
180 isp116x_write_data16(isp116x, ptd->count);
181 isp116x_write_data16(isp116x, ptd->mps);
182 isp116x_write_data16(isp116x, ptd->len);
183 isp116x_write_data16(isp116x, ptd->faddr);
184 buflen -= sizeof(struct ptd);
185 /* Skip writing data for last IN PTD */
186 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
187 write_ptddata_to_fifo(isp116x, ep->data, ep->length);
188 buflen -= ALIGN(ep->length, 4);
189 }
190 }
191 BUG_ON(buflen);
192}
193
194/*
195 Read the processed ptd's and data from fifo ram back to
196 URBs' buffers. Fifo must be full and done
197*/
198static void unpack_fifo(struct isp116x *isp116x)
199{
200 struct isp116x_ep *ep;
201 struct ptd *ptd;
202 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
203 ? isp116x->atl_buflen : isp116x->atl_bufshrt;
204
205 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
206 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
207 isp116x_write_addr(isp116x, HCATLPORT);
208 for (ep = isp116x->atl_active; ep; ep = ep->active) {
209 ptd = &ep->ptd;
210 ptd->count = isp116x_read_data16(isp116x);
211 ptd->mps = isp116x_read_data16(isp116x);
212 ptd->len = isp116x_read_data16(isp116x);
213 ptd->faddr = isp116x_read_data16(isp116x);
214 buflen -= sizeof(struct ptd);
215 /* Skip reading data for last Setup or Out PTD */
216 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
217 read_ptddata_from_fifo(isp116x, ep->data, ep->length);
218 buflen -= ALIGN(ep->length, 4);
219 }
220 dump_ptd(ptd);
221 dump_ptd_in_data(ptd, ep->data);
222 }
223 BUG_ON(buflen);
224}
225
226/*---------------------------------------------------------------*/
227
228/*
229 Set up PTD's.
230*/
231static void preproc_atl_queue(struct isp116x *isp116x)
232{
233 struct isp116x_ep *ep;
234 struct urb *urb;
235 struct ptd *ptd;
f10eff26 236 u16 len;
4808a1c0
OK		 237
238 for (ep = isp116x->atl_active; ep; ep = ep->active) {
f10eff26
OK		 239 u16 toggle = 0, dir = PTD_DIR_SETUP;
240
4808a1c0
OK		 241 BUG_ON(list_empty(&ep->hep->urb_list));
242 urb = container_of(ep->hep->urb_list.next,
243 struct urb, urb_list);
244 ptd = &ep->ptd;
245 len = ep->length;
4808a1c0
OK		 246 ep->data = (unsigned char *)urb->transfer_buffer
247 + urb->actual_length;
248
249 switch (ep->nextpid) {
250 case USB_PID_IN:
251 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
252 dir = PTD_DIR_IN;
253 break;
254 case USB_PID_OUT:
255 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
256 dir = PTD_DIR_OUT;
257 break;
258 case USB_PID_SETUP:
4808a1c0
OK		 259 len = sizeof(struct usb_ctrlrequest);
260 ep->data = urb->setup_packet;
261 break;
262 case USB_PID_ACK:
263 toggle = 1;
264 len = 0;
265 dir = (urb->transfer_buffer_length
266 && usb_pipein(urb->pipe))
267 ? PTD_DIR_OUT : PTD_DIR_IN;
268 break;
269 default:
4808a1c0
OK		 270 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
271 ep->nextpid);
17f8bb73 272 BUG();
4808a1c0
OK		 273 }
274
275 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
276 ptd->mps = PTD_MPS(ep->maxpacket)
277 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
278 | PTD_EP(ep->epnum);
279 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
280 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
4808a1c0
OK		 281 if (!ep->active) {
282 ptd->mps |= PTD_LAST_MSK;
283 isp116x->atl_last_dir = dir;
284 }
285 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
286 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
287 }
288}
289
1b4cd43b
AS		 290/*
291 Take done or failed requests out of schedule. Give back
292 processed urbs.
293*/
294static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
4a00027d 295 struct urb *urb, int status)
1b4cd43b
AS		 296__releases(isp116x->lock) __acquires(isp116x->lock)
297{
298 unsigned i;
299
1b4cd43b
AS		 300 ep->error_count = 0;
301
302 if (usb_pipecontrol(urb->pipe))
303 ep->nextpid = USB_PID_SETUP;
304
305 urb_dbg(urb, "Finish");
306
e9df41c5 307 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
1b4cd43b 308 spin_unlock(&isp116x->lock);
4a00027d 309 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
1b4cd43b
AS		 310 spin_lock(&isp116x->lock);
311
312 /* take idle endpoints out of the schedule */
313 if (!list_empty(&ep->hep->urb_list))
314 return;
315
316 /* async deschedule */
317 if (!list_empty(&ep->schedule)) {
318 list_del_init(&ep->schedule);
319 return;
320 }
321
322 /* periodic deschedule */
323 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
324 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
325 struct isp116x_ep *temp;
326 struct isp116x_ep **prev = &isp116x->periodic[i];
327
328 while (*prev && ((temp = *prev) != ep))
329 prev = &temp->next;
330 if (*prev)
331 *prev = ep->next;
332 isp116x->load[i] -= ep->load;
333 }
334 ep->branch = PERIODIC_SIZE;
335 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
336 ep->load / ep->period;
337
338 /* switch irq type? */
339 if (!--isp116x->periodic_count) {
340 isp116x->irqenb &= ~HCuPINT_SOF;
341 isp116x->irqenb |= HCuPINT_ATL;
342 }
343}
344
4808a1c0
OK		 345/*
346 Analyze transfer results, handle partial transfers and errors
347*/
348static void postproc_atl_queue(struct isp116x *isp116x)
349{
350 struct isp116x_ep *ep;
351 struct urb *urb;
352 struct usb_device *udev;
353 struct ptd *ptd;
354 int short_not_ok;
1b4cd43b 355 int status;
4808a1c0
OK		 356 u8 cc;
357
358 for (ep = isp116x->atl_active; ep; ep = ep->active) {
359 BUG_ON(list_empty(&ep->hep->urb_list));
360 urb =
361 container_of(ep->hep->urb_list.next, struct urb, urb_list);
362 udev = urb->dev;
363 ptd = &ep->ptd;
364 cc = PTD_GET_CC(ptd);
4808a1c0 365 short_not_ok = 1;
1b4cd43b 366 status = -EINPROGRESS;
4808a1c0
OK		 367
368 /* Data underrun is special. For allowed underrun
369 we clear the error and continue as normal. For
370 forbidden underrun we finish the DATA stage
371 immediately while for control transfer,
372 we do a STATUS stage. */
373 if (cc == TD_DATAUNDERRUN) {
1b4cd43b
AS		 374 if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
375 usb_pipecontrol(urb->pipe)) {
376 DBG("Allowed or control data underrun\n");
4808a1c0
OK		 377 cc = TD_CC_NOERROR;
378 short_not_ok = 0;
379 } else {
380 ep->error_count = 1;
1b4cd43b
AS		 381 usb_settoggle(udev, ep->epnum,
382 ep->nextpid == USB_PID_OUT,
383 PTD_GET_TOGGLE(ptd));
e9b765de 384 urb->actual_length += PTD_GET_COUNT(ptd);
1b4cd43b
AS		 385 status = cc_to_error[TD_DATAUNDERRUN];
386 goto done;
4808a1c0
OK		 387 }
388 }
4808a1c0
OK		 389
390 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
391 && (++ep->error_count >= 3 || cc == TD_CC_STALL
392 || cc == TD_DATAOVERRUN)) {
1b4cd43b 393 status = cc_to_error[cc];
4808a1c0
OK		 394 if (ep->nextpid == USB_PID_ACK)
395 ep->nextpid = 0;
1b4cd43b 396 goto done;
4808a1c0
OK		 397 }
398 /* According to usb spec, zero-length Int transfer signals
399 finishing of the urb. Hey, does this apply only
400 for IN endpoints? */
401 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
1b4cd43b
AS		 402 status = 0;
403 goto done;
4808a1c0
OK		 404 }
405
406 /* Relax after previously failed, but later succeeded
407 or correctly NAK'ed retransmission attempt */
408 if (ep->error_count
409 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
410 ep->error_count = 0;
411
412 /* Take into account idiosyncracies of the isp116x chip
413 regarding toggle bit for failed transfers */
414 if (ep->nextpid == USB_PID_OUT)
415 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
416 ^ (ep->error_count > 0));
417 else if (ep->nextpid == USB_PID_IN)
418 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
419 ^ (ep->error_count > 0));
420
421 switch (ep->nextpid) {
422 case USB_PID_IN:
423 case USB_PID_OUT:
424 urb->actual_length += PTD_GET_COUNT(ptd);
425 if (PTD_GET_ACTIVE(ptd)
426 || (cc != TD_CC_NOERROR && cc < 0x0E))
427 break;
428 if (urb->transfer_buffer_length != urb->actual_length) {
429 if (short_not_ok)
430 break;
431 } else {
432 if (urb->transfer_flags & URB_ZERO_PACKET
433 && ep->nextpid == USB_PID_OUT
434 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
435 DBG("Zero packet requested\n");
436 break;
437 }
438 }
439 /* All data for this URB is transferred, let's finish */
440 if (usb_pipecontrol(urb->pipe))
441 ep->nextpid = USB_PID_ACK;
1b4cd43b
AS		 442 else
443 status = 0;
4808a1c0
OK		 444 break;
445 case USB_PID_SETUP:
446 if (PTD_GET_ACTIVE(ptd)
447 || (cc != TD_CC_NOERROR && cc < 0x0E))
448 break;
449 if (urb->transfer_buffer_length == urb->actual_length)
450 ep->nextpid = USB_PID_ACK;
451 else if (usb_pipeout(urb->pipe)) {
452 usb_settoggle(udev, 0, 1, 1);
453 ep->nextpid = USB_PID_OUT;
454 } else {
455 usb_settoggle(udev, 0, 0, 1);
456 ep->nextpid = USB_PID_IN;
457 }
458 break;
459 case USB_PID_ACK:
460 if (PTD_GET_ACTIVE(ptd)
461 || (cc != TD_CC_NOERROR && cc < 0x0E))
462 break;
b0d9efba 463 status = 0;
4808a1c0
OK		 464 ep->nextpid = 0;
465 break;
466 default:
959eea21 467 BUG();
4808a1c0 468 }
4808a1c0 469
1b4cd43b 470 done:
4a00027d
AS		 471 if (status != -EINPROGRESS || urb->unlinked)
472 finish_request(isp116x, ep, urb, status);
4808a1c0
OK		 473 }
474}
475
476/*
477 Scan transfer lists, schedule transfers, send data off
478 to chip.
479 */
480static void start_atl_transfers(struct isp116x *isp116x)
481{
482 struct isp116x_ep *last_ep = NULL, *ep;
483 struct urb *urb;
484 u16 load = 0;
485 int len, index, speed, byte_time;
486
487 if (atomic_read(&isp116x->atl_finishing))
488 return;
489
490 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
491 return;
492
493 /* FIFO not empty? */
494 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
495 return;
496
497 isp116x->atl_active = NULL;
498 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
499
500 /* Schedule int transfers */
501 if (isp116x->periodic_count) {
502 isp116x->fmindex = index =
503 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
504 if ((load = isp116x->load[index])) {
505 /* Bring all int transfers for this frame
506 into the active queue */
507 isp116x->atl_active = last_ep =
508 isp116x->periodic[index];
509 while (last_ep->next)
510 last_ep = (last_ep->active = last_ep->next);
511 last_ep->active = NULL;
512 }
513 }
514
515 /* Schedule control/bulk transfers */
516 list_for_each_entry(ep, &isp116x->async, schedule) {
517 urb = container_of(ep->hep->urb_list.next,
518 struct urb, urb_list);
519 speed = urb->dev->speed;
520 byte_time = speed == USB_SPEED_LOW
521 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
522
523 if (ep->nextpid == USB_PID_SETUP) {
524 len = sizeof(struct usb_ctrlrequest);
525 } else if (ep->nextpid == USB_PID_ACK) {
526 len = 0;
527 } else {
528 /* Find current free length ... */
529 len = (MAX_LOAD_LIMIT - load) / byte_time;
530
531 /* ... then limit it to configured max size ... */
532 len = min(len, speed == USB_SPEED_LOW ?
533 MAX_TRANSFER_SIZE_LOWSPEED :
534 MAX_TRANSFER_SIZE_FULLSPEED);
535
536 /* ... and finally cut to the multiple of MaxPacketSize,
537 or to the real length if there's enough room. */
538 if (len <
539 (urb->transfer_buffer_length -
540 urb->actual_length)) {
541 len -= len % ep->maxpacket;
542 if (!len)
543 continue;
544 } else
545 len = urb->transfer_buffer_length -
546 urb->actual_length;
547 BUG_ON(len < 0);
548 }
549
550 load += len * byte_time;
551 if (load > MAX_LOAD_LIMIT)
552 break;
553
554 ep->active = NULL;
555 ep->length = len;
556 if (last_ep)
557 last_ep->active = ep;
558 else
559 isp116x->atl_active = ep;
560 last_ep = ep;
561 }
562
563 /* Avoid starving of endpoints */
564 if ((&isp116x->async)->next != (&isp116x->async)->prev)
565 list_move(&isp116x->async, (&isp116x->async)->next);
566
567 if (isp116x->atl_active) {
568 preproc_atl_queue(isp116x);
569 pack_fifo(isp116x);
570 }
571}
572
573/*
574 Finish the processed transfers
575*/
7d12e780 576static void finish_atl_transfers(struct isp116x *isp116x)
4808a1c0 577{
4808a1c0
OK		 578 if (!isp116x->atl_active)
579 return;
580 /* Fifo not ready? */
581 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
582 return;
583
584 atomic_inc(&isp116x->atl_finishing);
585 unpack_fifo(isp116x);
586 postproc_atl_queue(isp116x);
4808a1c0
OK		 587 atomic_dec(&isp116x->atl_finishing);
588}
589
7d12e780 590static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
4808a1c0
OK		 591{
592 struct isp116x *isp116x = hcd_to_isp116x(hcd);
593 u16 irqstat;
594 irqreturn_t ret = IRQ_NONE;
595
596 spin_lock(&isp116x->lock);
597 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
598 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
599 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
600
601 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
602 ret = IRQ_HANDLED;
7d12e780 603 finish_atl_transfers(isp116x);
4808a1c0
OK		 604 }
605
606 if (irqstat & HCuPINT_OPR) {
607 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
608 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
609 if (intstat & HCINT_UE) {
959eea21
OK		 610 ERR("Unrecoverable error, HC is dead!\n");
611 /* IRQ's are off, we do no DMA,
612 perfectly ready to die ... */
613 hcd->state = HC_STATE_HALT;
69fff59d 614 usb_hc_died(hcd);
959eea21
OK		 615 ret = IRQ_HANDLED;
616 goto done;
4808a1c0 617 }
9a57116b
OK		 618 if (intstat & HCINT_RHSC)
619 /* When root hub or any of its ports is going
620 to come out of suspend, it may take more
621 than 10ms for status bits to stabilize. */
622 mod_timer(&hcd->rh_timer, jiffies
623 + msecs_to_jiffies(20) + 1);
4808a1c0
OK		 624 if (intstat & HCINT_RD) {
625 DBG("---- remote wakeup\n");
ccdcf77a 626 usb_hcd_resume_root_hub(hcd);
4808a1c0
OK		 627 }
628 irqstat &= ~HCuPINT_OPR;
629 ret = IRQ_HANDLED;
630 }
631
632 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
633 start_atl_transfers(isp116x);
634 }
635
636 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
959eea21 637 done:
4808a1c0
OK		 638 spin_unlock(&isp116x->lock);
639 return ret;
640}
641
642/*-----------------------------------------------------------------*/
643
644/* usb 1.1 says max 90% of a frame is available for periodic transfers.
645 * this driver doesn't promise that much since it's got to handle an
646 * IRQ per packet; irq handling latencies also use up that time.
647 */
648
649/* out of 1000 us */
650#define MAX_PERIODIC_LOAD 600
651static int balance(struct isp116x *isp116x, u16 period, u16 load)
652{
653 int i, branch = -ENOSPC;
654
655 /* search for the least loaded schedule branch of that period
656 which has enough bandwidth left unreserved. */
657 for (i = 0; i < period; i++) {
658 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
659 int j;
660
661 for (j = i; j < PERIODIC_SIZE; j += period) {
662 if ((isp116x->load[j] + load)
663 > MAX_PERIODIC_LOAD)
664 break;
665 }
666 if (j < PERIODIC_SIZE)
667 continue;
668 branch = i;
669 }
670 }
671 return branch;
672}
673
674/* NB! ALL the code above this point runs with isp116x->lock
675 held, irqs off
676*/
677
678/*-----------------------------------------------------------------*/
679
680static int isp116x_urb_enqueue(struct usb_hcd *hcd,
e9df41c5 681 struct urb *urb,
55016f10 682 gfp_t mem_flags)
4808a1c0
OK		 683{
684 struct isp116x *isp116x = hcd_to_isp116x(hcd);
685 struct usb_device *udev = urb->dev;
686 unsigned int pipe = urb->pipe;
687 int is_out = !usb_pipein(pipe);
688 int type = usb_pipetype(pipe);
689 int epnum = usb_pipeendpoint(pipe);
e9df41c5 690 struct usb_host_endpoint *hep = urb->ep;
4808a1c0
OK		 691 struct isp116x_ep *ep = NULL;
692 unsigned long flags;
693 int i;
694 int ret = 0;
695
696 urb_dbg(urb, "Enqueue");
697
698 if (type == PIPE_ISOCHRONOUS) {
699 ERR("Isochronous transfers not supported\n");
700 urb_dbg(urb, "Refused to enqueue");
701 return -ENXIO;
702 }
703 /* avoid all allocations within spinlocks: request or endpoint */
704 if (!hep->hcpriv) {
7b842b6e 705 ep = kzalloc(sizeof *ep, mem_flags);
4808a1c0
OK		 706 if (!ep)
707 return -ENOMEM;
708 }
709
710 spin_lock_irqsave(&isp116x->lock, flags);
711 if (!HC_IS_RUNNING(hcd->state)) {
959eea21 712 kfree(ep);
4808a1c0 713 ret = -ENODEV;
e9df41c5
AS		 714 goto fail_not_linked;
715 }
716 ret = usb_hcd_link_urb_to_ep(hcd, urb);
717 if (ret) {
718 kfree(ep);
719 goto fail_not_linked;
4808a1c0
OK		 720 }
721
722 if (hep->hcpriv)
723 ep = hep->hcpriv;
724 else {
725 INIT_LIST_HEAD(&ep->schedule);
6a8e87b2 726 ep->udev = udev;
4808a1c0
OK		 727 ep->epnum = epnum;
728 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
729 usb_settoggle(udev, epnum, is_out, 0);
730
731 if (type == PIPE_CONTROL) {
732 ep->nextpid = USB_PID_SETUP;
733 } else if (is_out) {
734 ep->nextpid = USB_PID_OUT;
735 } else {
736 ep->nextpid = USB_PID_IN;
737 }
738
739 if (urb->interval) {
740 /*
741 With INT URBs submitted, the driver works with SOF
742 interrupt enabled and ATL interrupt disabled. After
743 the PTDs are written to fifo ram, the chip starts
744 fifo processing and usb transfers after the next
745 SOF and continues until the transfers are finished
746 (succeeded or failed) or the frame ends. Therefore,
747 the transfers occur only in every second frame,
748 while fifo reading/writing and data processing
749 occur in every other second frame. */
750 if (urb->interval < 2)
751 urb->interval = 2;
752 if (urb->interval > 2 * PERIODIC_SIZE)
753 urb->interval = 2 * PERIODIC_SIZE;
754 ep->period = urb->interval >> 1;
755 ep->branch = PERIODIC_SIZE;
756 ep->load = usb_calc_bus_time(udev->speed,
757 !is_out,
758 (type == PIPE_ISOCHRONOUS),
759 usb_maxpacket(udev, pipe,
760 is_out)) /
761 1000;
762 }
763 hep->hcpriv = ep;
764 ep->hep = hep;
765 }
766
767 /* maybe put endpoint into schedule */
768 switch (type) {
769 case PIPE_CONTROL:
770 case PIPE_BULK:
771 if (list_empty(&ep->schedule))
772 list_add_tail(&ep->schedule, &isp116x->async);
773 break;
774 case PIPE_INTERRUPT:
775 urb->interval = ep->period;
16e2e5f6 776 ep->length = min_t(u32, ep->maxpacket,
4808a1c0
OK		 777 urb->transfer_buffer_length);
778
779 /* urb submitted for already existing endpoint */
780 if (ep->branch < PERIODIC_SIZE)
781 break;
782
d5ce1379 783 ep->branch = ret = balance(isp116x, ep->period, ep->load);
4808a1c0
OK		 784 if (ret < 0)
785 goto fail;
786 ret = 0;
787
788 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
789 + ep->branch;
790
791 /* sort each schedule branch by period (slow before fast)
792 to share the faster parts of the tree without needing
793 dummy/placeholder nodes */
794 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
795 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
796 struct isp116x_ep **prev = &isp116x->periodic[i];
797 struct isp116x_ep *here = *prev;
798
799 while (here && ep != here) {
800 if (ep->period > here->period)
801 break;
802 prev = &here->next;
803 here = *prev;
804 }
805 if (ep != here) {
806 ep->next = here;
807 *prev = ep;
808 }
809 isp116x->load[i] += ep->load;
810 }
811 hcd->self.bandwidth_allocated += ep->load / ep->period;
812
813 /* switch over to SOFint */
814 if (!isp116x->periodic_count++) {
815 isp116x->irqenb &= ~HCuPINT_ATL;
816 isp116x->irqenb |= HCuPINT_SOF;
817 isp116x_write_reg16(isp116x, HCuPINTENB,
818 isp116x->irqenb);
819 }
820 }
821
4808a1c0 822 urb->hcpriv = hep;
4808a1c0
OK		 823 start_atl_transfers(isp116x);
824
825 fail:
e9df41c5
AS		 826 if (ret)
827 usb_hcd_unlink_urb_from_ep(hcd, urb);
828 fail_not_linked:
4808a1c0
OK		 829 spin_unlock_irqrestore(&isp116x->lock, flags);
830 return ret;
831}
832
833/*
834 Dequeue URBs.
835*/
e9df41c5
AS		 836static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
837 int status)
4808a1c0
OK		 838{
839 struct isp116x *isp116x = hcd_to_isp116x(hcd);
840 struct usb_host_endpoint *hep;
841 struct isp116x_ep *ep, *ep_act;
842 unsigned long flags;
e9df41c5 843 int rc;
4808a1c0
OK		 844
845 spin_lock_irqsave(&isp116x->lock, flags);
e9df41c5
AS		 846 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
847 if (rc)
848 goto done;
849
4808a1c0 850 hep = urb->hcpriv;
4808a1c0
OK		 851 ep = hep->hcpriv;
852 WARN_ON(hep != ep->hep);
853
854 /* In front of queue? */
855 if (ep->hep->urb_list.next == &urb->urb_list)
856 /* active? */
857 for (ep_act = isp116x->atl_active; ep_act;
858 ep_act = ep_act->active)
859 if (ep_act == ep) {
860 VDBG("dequeue, urb %p active; wait for irq\n",
861 urb);
862 urb = NULL;
863 break;
864 }
865
866 if (urb)
4a00027d 867 finish_request(isp116x, ep, urb, status);
e9df41c5 868 done:
4808a1c0 869 spin_unlock_irqrestore(&isp116x->lock, flags);
e9df41c5 870 return rc;
4808a1c0
OK		 871}
872
873static void isp116x_endpoint_disable(struct usb_hcd *hcd,
874 struct usb_host_endpoint *hep)
875{
876 int i;
959eea21 877 struct isp116x_ep *ep = hep->hcpriv;
4808a1c0
OK		 878
879 if (!ep)
880 return;
881
882 /* assume we'd just wait for the irq */
883 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
884 msleep(3);
885 if (!list_empty(&hep->urb_list))
b6c63937 886 WARNING("ep %p not empty?\n", ep);
4808a1c0 887
4808a1c0
OK		 888 kfree(ep);
889 hep->hcpriv = NULL;
890}
891
892static int isp116x_get_frame(struct usb_hcd *hcd)
893{
894 struct isp116x *isp116x = hcd_to_isp116x(hcd);
895 u32 fmnum;
896 unsigned long flags;
897
898 spin_lock_irqsave(&isp116x->lock, flags);
899 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
900 spin_unlock_irqrestore(&isp116x->lock, flags);
901 return (int)fmnum;
902}
903
4808a1c0
OK		 904/*
905 Adapted from ohci-hub.c. Currently we don't support autosuspend.
906*/
907static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
908{
909 struct isp116x *isp116x = hcd_to_isp116x(hcd);
910 int ports, i, changed = 0;
9a57116b 911 unsigned long flags;
4808a1c0
OK		 912
913 if (!HC_IS_RUNNING(hcd->state))
914 return -ESHUTDOWN;
915
9a57116b
OK		 916 /* Report no status change now, if we are scheduled to be
917 called later */
918 if (timer_pending(&hcd->rh_timer))
919 return 0;
4808a1c0 920
9a57116b
OK		 921 ports = isp116x->rhdesca & RH_A_NDP;
922 spin_lock_irqsave(&isp116x->lock, flags);
923 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
4808a1c0
OK		 924 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
925 buf[0] = changed = 1;
926 else
927 buf[0] = 0;
928
929 for (i = 0; i < ports; i++) {
0ed930bf 930 u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
4808a1c0
OK		 931
932 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
933 | RH_PS_OCIC | RH_PS_PRSC)) {
934 changed = 1;
935 buf[0] |= 1 << (i + 1);
4808a1c0
OK		 936 }
937 }
9a57116b 938 spin_unlock_irqrestore(&isp116x->lock, flags);
4808a1c0
OK		 939 return changed;
940}
941
942static void isp116x_hub_descriptor(struct isp116x *isp116x,
943 struct usb_hub_descriptor *desc)
944{
945 u32 reg = isp116x->rhdesca;
946
947 desc->bDescriptorType = 0x29;
948 desc->bDescLength = 9;
949 desc->bHubContrCurrent = 0;
950 desc->bNbrPorts = (u8) (reg & 0x3);
951 /* Power switching, device type, overcurrent. */
959eea21 952 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
4808a1c0 953 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
da13051c 954 /* ports removable, and legacy PortPwrCtrlMask */
dbe79bbe
JY		 955 desc->u.hs.DeviceRemovable[0] = 0;
956 desc->u.hs.DeviceRemovable[1] = ~0;
4808a1c0
OK		 957}
958
959/* Perform reset of a given port.
960 It would be great to just start the reset and let the
961 USB core to clear the reset in due time. However,
962 root hub ports should be reset for at least 50 ms, while
963 our chip stays in reset for about 10 ms. I.e., we must
964 repeatedly reset it ourself here.
965*/
966static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
967{
968 u32 tmp;
969 unsigned long flags, t;
970
971 /* Root hub reset should be 50 ms, but some devices
972 want it even longer. */
973 t = jiffies + msecs_to_jiffies(100);
974
975 while (time_before(jiffies, t)) {
976 spin_lock_irqsave(&isp116x->lock, flags);
977 /* spin until any current reset finishes */
978 for (;;) {
979 tmp = isp116x_read_reg32(isp116x, port ?
980 HCRHPORT2 : HCRHPORT1);
981 if (!(tmp & RH_PS_PRS))
982 break;
983 udelay(500);
984 }
985 /* Don't reset a disconnected port */
986 if (!(tmp & RH_PS_CCS)) {
987 spin_unlock_irqrestore(&isp116x->lock, flags);
988 break;
989 }
990 /* Reset lasts 10ms (claims datasheet) */
991 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
992 HCRHPORT1, (RH_PS_PRS));
993 spin_unlock_irqrestore(&isp116x->lock, flags);
994 msleep(10);
995 }
996}
997
998/* Adapted from ohci-hub.c */
999static int isp116x_hub_control(struct usb_hcd *hcd,
1000 u16 typeReq,
1001 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1002{
1003 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1004 int ret = 0;
1005 unsigned long flags;
1006 int ports = isp116x->rhdesca & RH_A_NDP;
1007 u32 tmp = 0;
1008
1009 switch (typeReq) {
1010 case ClearHubFeature:
1011 DBG("ClearHubFeature: ");
1012 switch (wValue) {
1013 case C_HUB_OVER_CURRENT:
1014 DBG("C_HUB_OVER_CURRENT\n");
1015 spin_lock_irqsave(&isp116x->lock, flags);
1016 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1017 spin_unlock_irqrestore(&isp116x->lock, flags);
1018 case C_HUB_LOCAL_POWER:
1019 DBG("C_HUB_LOCAL_POWER\n");
1020 break;
1021 default:
1022 goto error;
1023 }
1024 break;
1025 case SetHubFeature:
1026 DBG("SetHubFeature: ");
1027 switch (wValue) {
1028 case C_HUB_OVER_CURRENT:
1029 case C_HUB_LOCAL_POWER:
1030 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1031 break;
1032 default:
1033 goto error;
1034 }
1035 break;
1036 case GetHubDescriptor:
1037 DBG("GetHubDescriptor\n");
1038 isp116x_hub_descriptor(isp116x,
1039 (struct usb_hub_descriptor *)buf);
1040 break;
1041 case GetHubStatus:
1042 DBG("GetHubStatus\n");
17f8bb73 1043 *(__le32 *) buf = 0;
4808a1c0
OK		 1044 break;
1045 case GetPortStatus:
1046 DBG("GetPortStatus\n");
1047 if (!wIndex || wIndex > ports)
1048 goto error;
0ed930bf
AS		 1049 spin_lock_irqsave(&isp116x->lock, flags);
1050 tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1051 spin_unlock_irqrestore(&isp116x->lock, flags);
4808a1c0
OK		 1052 *(__le32 *) buf = cpu_to_le32(tmp);
1053 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1054 break;
1055 case ClearPortFeature:
1056 DBG("ClearPortFeature: ");
1057 if (!wIndex || wIndex > ports)
1058 goto error;
1059 wIndex--;
1060
1061 switch (wValue) {
1062 case USB_PORT_FEAT_ENABLE:
1063 DBG("USB_PORT_FEAT_ENABLE\n");
1064 tmp = RH_PS_CCS;
1065 break;
1066 case USB_PORT_FEAT_C_ENABLE:
1067 DBG("USB_PORT_FEAT_C_ENABLE\n");
1068 tmp = RH_PS_PESC;
1069 break;
1070 case USB_PORT_FEAT_SUSPEND:
1071 DBG("USB_PORT_FEAT_SUSPEND\n");
1072 tmp = RH_PS_POCI;
1073 break;
1074 case USB_PORT_FEAT_C_SUSPEND:
1075 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1076 tmp = RH_PS_PSSC;
1077 break;
1078 case USB_PORT_FEAT_POWER:
1079 DBG("USB_PORT_FEAT_POWER\n");
1080 tmp = RH_PS_LSDA;
1081 break;
1082 case USB_PORT_FEAT_C_CONNECTION:
1083 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1084 tmp = RH_PS_CSC;
1085 break;
1086 case USB_PORT_FEAT_C_OVER_CURRENT:
1087 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1088 tmp = RH_PS_OCIC;
1089 break;
1090 case USB_PORT_FEAT_C_RESET:
1091 DBG("USB_PORT_FEAT_C_RESET\n");
1092 tmp = RH_PS_PRSC;
1093 break;
1094 default:
1095 goto error;
1096 }
1097 spin_lock_irqsave(&isp116x->lock, flags);
1098 isp116x_write_reg32(isp116x, wIndex
1099 ? HCRHPORT2 : HCRHPORT1, tmp);
4808a1c0
OK		 1100 spin_unlock_irqrestore(&isp116x->lock, flags);
1101 break;
1102 case SetPortFeature:
1103 DBG("SetPortFeature: ");
1104 if (!wIndex || wIndex > ports)
1105 goto error;
1106 wIndex--;
1107 switch (wValue) {
1108 case USB_PORT_FEAT_SUSPEND:
1109 DBG("USB_PORT_FEAT_SUSPEND\n");
1110 spin_lock_irqsave(&isp116x->lock, flags);
1111 isp116x_write_reg32(isp116x, wIndex
1112 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
0ed930bf 1113 spin_unlock_irqrestore(&isp116x->lock, flags);
4808a1c0
OK		 1114 break;
1115 case USB_PORT_FEAT_POWER:
1116 DBG("USB_PORT_FEAT_POWER\n");
1117 spin_lock_irqsave(&isp116x->lock, flags);
1118 isp116x_write_reg32(isp116x, wIndex
1119 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
0ed930bf 1120 spin_unlock_irqrestore(&isp116x->lock, flags);
4808a1c0
OK		 1121 break;
1122 case USB_PORT_FEAT_RESET:
1123 DBG("USB_PORT_FEAT_RESET\n");
1124 root_port_reset(isp116x, wIndex);
4808a1c0
OK		 1125 break;
1126 default:
1127 goto error;
1128 }
4808a1c0
OK		 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;
58a97ffe 1419 if (hcd->self.root_hub->do_remote_wakeup)
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);
959eea21
OK		 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);
959eea21
OK		 1474 return 0;
1475 }
1476
1477 val = isp116x->rhdesca & RH_A_NDP;
1478 while (val--) {
1479 u32 stat =
1480 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1481 /* force global, not selective, resume */
1482 if (!(stat & RH_PS_PSS))
1483 continue;
1484 DBG("%s: Resuming port %d\n", __func__, val);
1485 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1486 ? HCRHPORT2 : HCRHPORT1);
1487 }
1488 spin_unlock_irq(&isp116x->lock);
1489
1490 hcd->state = HC_STATE_RESUMING;
1491 msleep(20);
1492
1493 /* Go operational */
1494 spin_lock_irq(&isp116x->lock);
1495 val = isp116x_read_reg32(isp116x, HCCONTROL);
1496 isp116x_write_reg32(isp116x, HCCONTROL,
1497 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1498 spin_unlock_irq(&isp116x->lock);
959eea21
OK		 1499 hcd->state = HC_STATE_RUNNING;
1500
1501 return 0;
1502}
1503
1504#else
1505
1506#define isp116x_bus_suspend NULL
1507#define isp116x_bus_resume NULL
1508
1509#endif
4808a1c0
OK		 1510
1511static struct hc_driver isp116x_hc_driver = {
1512 .description = hcd_name,
1513 .product_desc = "ISP116x Host Controller",
1514 .hcd_priv_size = sizeof(struct isp116x),
1515
1516 .irq = isp116x_irq,
1517 .flags = HCD_USB11,
1518
1519 .reset = isp116x_reset,
1520 .start = isp116x_start,
1521 .stop = isp116x_stop,
1522
1523 .urb_enqueue = isp116x_urb_enqueue,
1524 .urb_dequeue = isp116x_urb_dequeue,
1525 .endpoint_disable = isp116x_endpoint_disable,
1526
1527 .get_frame_number = isp116x_get_frame,
1528
1529 .hub_status_data = isp116x_hub_status_data,
1530 .hub_control = isp116x_hub_control,
0c0382e3
AS		 1531 .bus_suspend = isp116x_bus_suspend,
1532 .bus_resume = isp116x_bus_resume,
4808a1c0
OK		 1533};
1534
1535/*----------------------------------------------------------------*/
1536
b712548c 1537static int isp116x_remove(struct platform_device *pdev)
4808a1c0 1538{
3ae5eaec 1539 struct usb_hcd *hcd = platform_get_drvdata(pdev);
589a0083 1540 struct isp116x *isp116x;
4808a1c0
OK		 1541 struct resource *res;
1542
9a57116b 1543 if (!hcd)
589a0083
OK		 1544 return 0;
1545 isp116x = hcd_to_isp116x(hcd);
4808a1c0
OK		 1546 remove_debug_file(isp116x);
1547 usb_remove_hcd(hcd);
1548
1549 iounmap(isp116x->data_reg);
1550 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1551 release_mem_region(res->start, 2);
1552 iounmap(isp116x->addr_reg);
1553 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1554 release_mem_region(res->start, 2);
1555
1556 usb_put_hcd(hcd);
1557 return 0;
1558}
1559
5bcd70eb 1560static int __devinit isp116x_probe(struct platform_device *pdev)
4808a1c0
OK		 1561{
1562 struct usb_hcd *hcd;
1563 struct isp116x *isp116x;
27140219 1564 struct resource *addr, *data, *ires;
4808a1c0
OK		 1565 void __iomem *addr_reg;
1566 void __iomem *data_reg;
1567 int irq;
1568 int ret = 0;
27140219 1569 unsigned long irqflags;
4808a1c0 1570
2e8d3fe4
TK		 1571 if (usb_disabled())
1572 return -ENODEV;
1573
4808a1c0
OK		 1574 if (pdev->num_resources < 3) {
1575 ret = -ENODEV;
1576 goto err1;
1577 }
1578
1579 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1580 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
27140219
MZ		 1581 ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1582
1583 if (!addr || !data || !ires) {
4808a1c0
OK		 1584 ret = -ENODEV;
1585 goto err1;
1586 }
1587
27140219
MZ		 1588 irq = ires->start;
1589 irqflags = ires->flags & IRQF_TRIGGER_MASK;
1590
3ae5eaec 1591 if (pdev->dev.dma_mask) {
4808a1c0
OK		 1592 DBG("DMA not supported\n");
1593 ret = -EINVAL;
1594 goto err1;
1595 }
1596
1597 if (!request_mem_region(addr->start, 2, hcd_name)) {
1598 ret = -EBUSY;
1599 goto err1;
1600 }
7a9d93e5 1601 addr_reg = ioremap(addr->start, resource_size(addr));
4808a1c0
OK		 1602 if (addr_reg == NULL) {
1603 ret = -ENOMEM;
1604 goto err2;
1605 }
1606 if (!request_mem_region(data->start, 2, hcd_name)) {
1607 ret = -EBUSY;
1608 goto err3;
1609 }
7a9d93e5 1610 data_reg = ioremap(data->start, resource_size(data));
4808a1c0
OK		 1611 if (data_reg == NULL) {
1612 ret = -ENOMEM;
1613 goto err4;
1614 }
1615
1616 /* allocate and initialize hcd */
7071a3ce 1617 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
4808a1c0
OK		 1618 if (!hcd) {
1619 ret = -ENOMEM;
1620 goto err5;
1621 }
1622 /* this rsrc_start is bogus */
1623 hcd->rsrc_start = addr->start;
1624 isp116x = hcd_to_isp116x(hcd);
1625 isp116x->data_reg = data_reg;
1626 isp116x->addr_reg = addr_reg;
1627 spin_lock_init(&isp116x->lock);
1628 INIT_LIST_HEAD(&isp116x->async);
3ae5eaec 1629 isp116x->board = pdev->dev.platform_data;
4808a1c0
OK		 1630
1631 if (!isp116x->board) {
1632 ERR("Platform data structure not initialized\n");
1633 ret = -ENODEV;
1634 goto err6;
1635 }
1636 if (isp116x_check_platform_delay(isp116x)) {
1637 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1638 "implemented.\n");
1639 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1640 ret = -ENODEV;
1641 goto err6;
1642 }
1643
b5dd18d8 1644 ret = usb_add_hcd(hcd, irq, irqflags);
959eea21 1645 if (ret)
4808a1c0
OK		 1646 goto err6;
1647
959eea21
OK		 1648 ret = create_debug_file(isp116x);
1649 if (ret) {
1650 ERR("Couldn't create debugfs entry\n");
1651 goto err7;
1652 }
1653
4808a1c0
OK		 1654 return 0;
1655
959eea21
OK		 1656 err7:
1657 usb_remove_hcd(hcd);
4808a1c0
OK		 1658 err6:
1659 usb_put_hcd(hcd);
1660 err5:
1661 iounmap(data_reg);
1662 err4:
1663 release_mem_region(data->start, 2);
1664 err3:
1665 iounmap(addr_reg);
1666 err2:
1667 release_mem_region(addr->start, 2);
1668 err1:
1669 ERR("init error, %d\n", ret);
1670 return ret;
1671}
1672
1673#ifdef CONFIG_PM
1674/*
1675 Suspend of platform device
1676*/
3ae5eaec 1677static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
4808a1c0 1678{
959eea21 1679 VDBG("%s: state %x\n", __func__, state.event);
959eea21 1680 return 0;
4808a1c0
OK		 1681}
1682
1683/*
1684 Resume platform device
1685*/
3ae5eaec 1686static int isp116x_resume(struct platform_device *dev)
4808a1c0 1687{
70a1c9e0 1688 VDBG("%s\n", __func__);
959eea21 1689 return 0;
4808a1c0
OK		 1690}
1691
1692#else
1693
1694#define isp116x_suspend NULL
1695#define isp116x_resume NULL
1696
1697#endif
1698
f4fce61d
KS		 1699/* work with hotplug and coldplug */
1700MODULE_ALIAS("platform:isp116x-hcd");
1701
3ae5eaec 1702static struct platform_driver isp116x_driver = {
4808a1c0
OK		 1703 .probe = isp116x_probe,
1704 .remove = isp116x_remove,
1705 .suspend = isp116x_suspend,
1706 .resume = isp116x_resume,
0be930c5 1707 .driver = {
f4fce61d
KS		 1708 .name = (char *)hcd_name,
1709 .owner = THIS_MODULE,
1710 },
4808a1c0
OK		 1711};
1712
2e8d3fe4 1713module_platform_driver(isp116x_driver);
Linux kernel - Deliverables
This page took 0.90195 seconds and 5 git commands to generate.