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