blob: 4dda31b268929e4b74e7828d9d4af04764a475ee [file] [log] [blame]
Olav Kongas4808a1c2005-04-09 22:57:39 +03001/*
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 *
Olav Kongas17f8bb72005-06-23 20:12:24 +030020 * The driver passes all usbtests 1-14.
Olav Kongas4808a1c2005-04-09 22:57:39 +030021 *
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
Olav Kongas4808a1c2005-04-09 22:57:39 +030058#include <linux/module.h>
Olav Kongas4808a1c2005-04-09 22:57:39 +030059#include <linux/delay.h>
Olav Kongas959eea22005-11-03 17:38:14 +020060#include <linux/debugfs.h>
61#include <linux/seq_file.h>
Olav Kongas4808a1c2005-04-09 22:57:39 +030062#include <linux/errno.h>
63#include <linux/init.h>
64#include <linux/list.h>
Olav Kongas4808a1c2005-04-09 22:57:39 +030065#include <linux/usb.h>
David Brownell325a4af2006-06-13 09:59:32 -070066#include <linux/usb/isp116x.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010067#include <linux/platform_device.h>
Olav Kongas4808a1c2005-04-09 22:57:39 +030068
69#include <asm/io.h>
70#include <asm/irq.h>
71#include <asm/system.h>
72#include <asm/byteorder.h>
73
Olav Kongas4808a1c2005-04-09 22:57:39 +030074#include "../core/hcd.h"
75#include "isp116x.h"
76
Olav Kongas959eea22005-11-03 17:38:14 +020077#define DRIVER_VERSION "03 Nov 2005"
Olav Kongas4808a1c2005-04-09 22:57:39 +030078#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
Julien May28874b72008-06-27 15:01:18 +020097 /* 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
Olav Kongas4808a1c2005-04-09 22:57:39 +0300101 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 */
Julien May28874b72008-06-27 15:01:18 +0200112 for (; len > 1; len -= 2) {
113 /* Keep byte order ! */
114 isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
115 }
116
Olav Kongas4808a1c2005-04-09 22:57:39 +0300117 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
Julien May28874b72008-06-27 15:01:18 +0200134 /* 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
Olav Kongas4808a1c2005-04-09 22:57:39 +0300138 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 }
Julien May28874b72008-06-27 15:01:18 +0200145
Olav Kongas4808a1c2005-04-09 22:57:39 +0300146 if (len)
147 *dp = 0xff & isp116x_read_data16(isp116x);
148 } else {
149 /* aligned */
Julien May28874b72008-06-27 15:01:18 +0200150 for (; len > 1; len -= 2) {
151 /* Keep byte order! */
152 *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
153 }
154
Olav Kongas4808a1c2005-04-09 22:57:39 +0300155 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;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300172
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) {
Olav Kongas4808a1c2005-04-09 22:57:39 +0300177 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;
Olav Kongasf10eff22005-08-04 18:06:47 -0700236 u16 len;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300237
238 for (ep = isp116x->atl_active; ep; ep = ep->active) {
Olav Kongasf10eff22005-08-04 18:06:47 -0700239 u16 toggle = 0, dir = PTD_DIR_SETUP;
240
Olav Kongas4808a1c2005-04-09 22:57:39 +0300241 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;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300246 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:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300259 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:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300270 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
271 ep->nextpid);
Olav Kongas17f8bb72005-06-23 20:12:24 +0300272 BUG();
Olav Kongas4808a1c2005-04-09 22:57:39 +0300273 }
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));
Olav Kongas4808a1c2005-04-09 22:57:39 +0300281 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
290/*
Olav Kongas4808a1c2005-04-09 22:57:39 +0300291 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,
Alan Stern4a000272007-08-24 15:42:24 -0400295 struct urb *urb, int status)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300296__releases(isp116x->lock) __acquires(isp116x->lock)
297{
298 unsigned i;
299
Olav Kongas4808a1c2005-04-09 22:57:39 +0300300 ep->error_count = 0;
301
302 if (usb_pipecontrol(urb->pipe))
303 ep->nextpid = USB_PID_SETUP;
304
305 urb_dbg(urb, "Finish");
306
Alan Sterne9df41c2007-08-08 11:48:02 -0400307 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300308 spin_unlock(&isp116x->lock);
Alan Stern4a000272007-08-24 15:42:24 -0400309 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300310 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
345/*
Alan Stern1b4cd432007-07-12 17:03:01 -0400346 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;
355 int status;
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);
365 short_not_ok = 1;
366 status = -EINPROGRESS;
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) {
374 if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
375 usb_pipecontrol(urb->pipe)) {
376 DBG("Allowed or control data underrun\n");
377 cc = TD_CC_NOERROR;
378 short_not_ok = 0;
379 } else {
380 ep->error_count = 1;
381 usb_settoggle(udev, ep->epnum,
382 ep->nextpid == USB_PID_OUT,
383 PTD_GET_TOGGLE(ptd));
384 urb->actual_length += PTD_GET_COUNT(ptd);
385 status = cc_to_error[TD_DATAUNDERRUN];
386 goto done;
387 }
388 }
389
390 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
391 && (++ep->error_count >= 3 || cc == TD_CC_STALL
392 || cc == TD_DATAOVERRUN)) {
393 status = cc_to_error[cc];
394 if (ep->nextpid == USB_PID_ACK)
395 ep->nextpid = 0;
396 goto done;
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)) {
402 status = 0;
403 goto done;
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;
442 else
443 status = 0;
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;
Alan Sternb0d9efb2007-08-21 15:39:21 -0400463 status = 0;
Alan Stern1b4cd432007-07-12 17:03:01 -0400464 ep->nextpid = 0;
465 break;
466 default:
467 BUG();
468 }
469
470 done:
Alan Stern4a000272007-08-24 15:42:24 -0400471 if (status != -EINPROGRESS || urb->unlinked)
472 finish_request(isp116x, ep, urb, status);
Alan Stern1b4cd432007-07-12 17:03:01 -0400473 }
474}
475
476/*
Olav Kongas4808a1c2005-04-09 22:57:39 +0300477 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*/
David Howells7d12e782006-10-05 14:55:46 +0100576static void finish_atl_transfers(struct isp116x *isp116x)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300577{
Olav Kongas4808a1c2005-04-09 22:57:39 +0300578 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);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300587 atomic_dec(&isp116x->atl_finishing);
588}
589
David Howells7d12e782006-10-05 14:55:46 +0100590static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300591{
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;
David Howells7d12e782006-10-05 14:55:46 +0100603 finish_atl_transfers(isp116x);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300604 }
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) {
Olav Kongas959eea22005-11-03 17:38:14 +0200610 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;
614 ret = IRQ_HANDLED;
615 goto done;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300616 }
Olav Kongas9a571162005-08-05 14:23:35 +0300617 if (intstat & HCINT_RHSC)
618 /* When root hub or any of its ports is going
619 to come out of suspend, it may take more
620 than 10ms for status bits to stabilize. */
621 mod_timer(&hcd->rh_timer, jiffies
622 + msecs_to_jiffies(20) + 1);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300623 if (intstat & HCINT_RD) {
624 DBG("---- remote wakeup\n");
David Brownellccdcf772005-09-22 22:45:13 -0700625 usb_hcd_resume_root_hub(hcd);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300626 }
627 irqstat &= ~HCuPINT_OPR;
628 ret = IRQ_HANDLED;
629 }
630
631 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
632 start_atl_transfers(isp116x);
633 }
634
635 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
Olav Kongas959eea22005-11-03 17:38:14 +0200636 done:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300637 spin_unlock(&isp116x->lock);
638 return ret;
639}
640
641/*-----------------------------------------------------------------*/
642
643/* usb 1.1 says max 90% of a frame is available for periodic transfers.
644 * this driver doesn't promise that much since it's got to handle an
645 * IRQ per packet; irq handling latencies also use up that time.
646 */
647
648/* out of 1000 us */
649#define MAX_PERIODIC_LOAD 600
650static int balance(struct isp116x *isp116x, u16 period, u16 load)
651{
652 int i, branch = -ENOSPC;
653
654 /* search for the least loaded schedule branch of that period
655 which has enough bandwidth left unreserved. */
656 for (i = 0; i < period; i++) {
657 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
658 int j;
659
660 for (j = i; j < PERIODIC_SIZE; j += period) {
661 if ((isp116x->load[j] + load)
662 > MAX_PERIODIC_LOAD)
663 break;
664 }
665 if (j < PERIODIC_SIZE)
666 continue;
667 branch = i;
668 }
669 }
670 return branch;
671}
672
673/* NB! ALL the code above this point runs with isp116x->lock
674 held, irqs off
675*/
676
677/*-----------------------------------------------------------------*/
678
679static int isp116x_urb_enqueue(struct usb_hcd *hcd,
Alan Sterne9df41c2007-08-08 11:48:02 -0400680 struct urb *urb,
Al Viro55016f12005-10-21 03:21:58 -0400681 gfp_t mem_flags)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300682{
683 struct isp116x *isp116x = hcd_to_isp116x(hcd);
684 struct usb_device *udev = urb->dev;
685 unsigned int pipe = urb->pipe;
686 int is_out = !usb_pipein(pipe);
687 int type = usb_pipetype(pipe);
688 int epnum = usb_pipeendpoint(pipe);
Alan Sterne9df41c2007-08-08 11:48:02 -0400689 struct usb_host_endpoint *hep = urb->ep;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300690 struct isp116x_ep *ep = NULL;
691 unsigned long flags;
692 int i;
693 int ret = 0;
694
695 urb_dbg(urb, "Enqueue");
696
697 if (type == PIPE_ISOCHRONOUS) {
698 ERR("Isochronous transfers not supported\n");
699 urb_dbg(urb, "Refused to enqueue");
700 return -ENXIO;
701 }
702 /* avoid all allocations within spinlocks: request or endpoint */
703 if (!hep->hcpriv) {
Pekka Enberg7b842b62005-09-06 15:18:34 -0700704 ep = kzalloc(sizeof *ep, mem_flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300705 if (!ep)
706 return -ENOMEM;
707 }
708
709 spin_lock_irqsave(&isp116x->lock, flags);
710 if (!HC_IS_RUNNING(hcd->state)) {
Olav Kongas959eea22005-11-03 17:38:14 +0200711 kfree(ep);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300712 ret = -ENODEV;
Alan Sterne9df41c2007-08-08 11:48:02 -0400713 goto fail_not_linked;
714 }
715 ret = usb_hcd_link_urb_to_ep(hcd, urb);
716 if (ret) {
717 kfree(ep);
718 goto fail_not_linked;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300719 }
720
721 if (hep->hcpriv)
722 ep = hep->hcpriv;
723 else {
724 INIT_LIST_HEAD(&ep->schedule);
Alan Stern6a8e87b2006-01-19 10:46:27 -0500725 ep->udev = udev;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300726 ep->epnum = epnum;
727 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
728 usb_settoggle(udev, epnum, is_out, 0);
729
730 if (type == PIPE_CONTROL) {
731 ep->nextpid = USB_PID_SETUP;
732 } else if (is_out) {
733 ep->nextpid = USB_PID_OUT;
734 } else {
735 ep->nextpid = USB_PID_IN;
736 }
737
738 if (urb->interval) {
739 /*
740 With INT URBs submitted, the driver works with SOF
741 interrupt enabled and ATL interrupt disabled. After
742 the PTDs are written to fifo ram, the chip starts
743 fifo processing and usb transfers after the next
744 SOF and continues until the transfers are finished
745 (succeeded or failed) or the frame ends. Therefore,
746 the transfers occur only in every second frame,
747 while fifo reading/writing and data processing
748 occur in every other second frame. */
749 if (urb->interval < 2)
750 urb->interval = 2;
751 if (urb->interval > 2 * PERIODIC_SIZE)
752 urb->interval = 2 * PERIODIC_SIZE;
753 ep->period = urb->interval >> 1;
754 ep->branch = PERIODIC_SIZE;
755 ep->load = usb_calc_bus_time(udev->speed,
756 !is_out,
757 (type == PIPE_ISOCHRONOUS),
758 usb_maxpacket(udev, pipe,
759 is_out)) /
760 1000;
761 }
762 hep->hcpriv = ep;
763 ep->hep = hep;
764 }
765
766 /* maybe put endpoint into schedule */
767 switch (type) {
768 case PIPE_CONTROL:
769 case PIPE_BULK:
770 if (list_empty(&ep->schedule))
771 list_add_tail(&ep->schedule, &isp116x->async);
772 break;
773 case PIPE_INTERRUPT:
774 urb->interval = ep->period;
775 ep->length = min((int)ep->maxpacket,
776 urb->transfer_buffer_length);
777
778 /* urb submitted for already existing endpoint */
779 if (ep->branch < PERIODIC_SIZE)
780 break;
781
Eric Sesterhennd5ce1372006-06-01 20:48:45 -0700782 ep->branch = ret = balance(isp116x, ep->period, ep->load);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300783 if (ret < 0)
784 goto fail;
785 ret = 0;
786
787 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
788 + ep->branch;
789
790 /* sort each schedule branch by period (slow before fast)
791 to share the faster parts of the tree without needing
792 dummy/placeholder nodes */
793 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
794 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
795 struct isp116x_ep **prev = &isp116x->periodic[i];
796 struct isp116x_ep *here = *prev;
797
798 while (here && ep != here) {
799 if (ep->period > here->period)
800 break;
801 prev = &here->next;
802 here = *prev;
803 }
804 if (ep != here) {
805 ep->next = here;
806 *prev = ep;
807 }
808 isp116x->load[i] += ep->load;
809 }
810 hcd->self.bandwidth_allocated += ep->load / ep->period;
811
812 /* switch over to SOFint */
813 if (!isp116x->periodic_count++) {
814 isp116x->irqenb &= ~HCuPINT_ATL;
815 isp116x->irqenb |= HCuPINT_SOF;
816 isp116x_write_reg16(isp116x, HCuPINTENB,
817 isp116x->irqenb);
818 }
819 }
820
Olav Kongas4808a1c2005-04-09 22:57:39 +0300821 urb->hcpriv = hep;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300822 start_atl_transfers(isp116x);
823
824 fail:
Alan Sterne9df41c2007-08-08 11:48:02 -0400825 if (ret)
826 usb_hcd_unlink_urb_from_ep(hcd, urb);
827 fail_not_linked:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300828 spin_unlock_irqrestore(&isp116x->lock, flags);
829 return ret;
830}
831
832/*
833 Dequeue URBs.
834*/
Alan Sterne9df41c2007-08-08 11:48:02 -0400835static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
836 int status)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300837{
838 struct isp116x *isp116x = hcd_to_isp116x(hcd);
839 struct usb_host_endpoint *hep;
840 struct isp116x_ep *ep, *ep_act;
841 unsigned long flags;
Alan Sterne9df41c2007-08-08 11:48:02 -0400842 int rc;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300843
844 spin_lock_irqsave(&isp116x->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -0400845 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
846 if (rc)
847 goto done;
848
Olav Kongas4808a1c2005-04-09 22:57:39 +0300849 hep = urb->hcpriv;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300850 ep = hep->hcpriv;
851 WARN_ON(hep != ep->hep);
852
853 /* In front of queue? */
854 if (ep->hep->urb_list.next == &urb->urb_list)
855 /* active? */
856 for (ep_act = isp116x->atl_active; ep_act;
857 ep_act = ep_act->active)
858 if (ep_act == ep) {
859 VDBG("dequeue, urb %p active; wait for irq\n",
860 urb);
861 urb = NULL;
862 break;
863 }
864
865 if (urb)
Alan Stern4a000272007-08-24 15:42:24 -0400866 finish_request(isp116x, ep, urb, status);
Alan Sterne9df41c2007-08-08 11:48:02 -0400867 done:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300868 spin_unlock_irqrestore(&isp116x->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -0400869 return rc;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300870}
871
872static void isp116x_endpoint_disable(struct usb_hcd *hcd,
873 struct usb_host_endpoint *hep)
874{
875 int i;
Olav Kongas959eea22005-11-03 17:38:14 +0200876 struct isp116x_ep *ep = hep->hcpriv;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300877
878 if (!ep)
879 return;
880
881 /* assume we'd just wait for the irq */
882 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
883 msleep(3);
884 if (!list_empty(&hep->urb_list))
Arjan van de Venb6c63932008-07-25 01:45:52 -0700885 WARNING("ep %p not empty?\n", ep);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300886
Olav Kongas4808a1c2005-04-09 22:57:39 +0300887 kfree(ep);
888 hep->hcpriv = NULL;
889}
890
891static int isp116x_get_frame(struct usb_hcd *hcd)
892{
893 struct isp116x *isp116x = hcd_to_isp116x(hcd);
894 u32 fmnum;
895 unsigned long flags;
896
897 spin_lock_irqsave(&isp116x->lock, flags);
898 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
899 spin_unlock_irqrestore(&isp116x->lock, flags);
900 return (int)fmnum;
901}
902
Olav Kongas4808a1c2005-04-09 22:57:39 +0300903/*
904 Adapted from ohci-hub.c. Currently we don't support autosuspend.
905*/
906static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
907{
908 struct isp116x *isp116x = hcd_to_isp116x(hcd);
909 int ports, i, changed = 0;
Olav Kongas9a571162005-08-05 14:23:35 +0300910 unsigned long flags;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300911
912 if (!HC_IS_RUNNING(hcd->state))
913 return -ESHUTDOWN;
914
Olav Kongas9a571162005-08-05 14:23:35 +0300915 /* Report no status change now, if we are scheduled to be
916 called later */
917 if (timer_pending(&hcd->rh_timer))
918 return 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300919
Olav Kongas9a571162005-08-05 14:23:35 +0300920 ports = isp116x->rhdesca & RH_A_NDP;
921 spin_lock_irqsave(&isp116x->lock, flags);
922 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300923 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
924 buf[0] = changed = 1;
925 else
926 buf[0] = 0;
927
928 for (i = 0; i < ports; i++) {
Anti Sullin0ed930b2008-03-03 15:39:54 +0200929 u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300930
931 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
932 | RH_PS_OCIC | RH_PS_PRSC)) {
933 changed = 1;
934 buf[0] |= 1 << (i + 1);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300935 }
936 }
Olav Kongas9a571162005-08-05 14:23:35 +0300937 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300938 return changed;
939}
940
941static void isp116x_hub_descriptor(struct isp116x *isp116x,
942 struct usb_hub_descriptor *desc)
943{
944 u32 reg = isp116x->rhdesca;
945
946 desc->bDescriptorType = 0x29;
947 desc->bDescLength = 9;
948 desc->bHubContrCurrent = 0;
949 desc->bNbrPorts = (u8) (reg & 0x3);
950 /* Power switching, device type, overcurrent. */
Olav Kongas959eea22005-11-03 17:38:14 +0200951 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
Olav Kongas4808a1c2005-04-09 22:57:39 +0300952 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
953 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
Olav Kongas959eea22005-11-03 17:38:14 +0200954 desc->bitmap[0] = 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300955 desc->bitmap[1] = ~0;
956}
957
958/* Perform reset of a given port.
959 It would be great to just start the reset and let the
960 USB core to clear the reset in due time. However,
961 root hub ports should be reset for at least 50 ms, while
962 our chip stays in reset for about 10 ms. I.e., we must
963 repeatedly reset it ourself here.
964*/
965static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
966{
967 u32 tmp;
968 unsigned long flags, t;
969
970 /* Root hub reset should be 50 ms, but some devices
971 want it even longer. */
972 t = jiffies + msecs_to_jiffies(100);
973
974 while (time_before(jiffies, t)) {
975 spin_lock_irqsave(&isp116x->lock, flags);
976 /* spin until any current reset finishes */
977 for (;;) {
978 tmp = isp116x_read_reg32(isp116x, port ?
979 HCRHPORT2 : HCRHPORT1);
980 if (!(tmp & RH_PS_PRS))
981 break;
982 udelay(500);
983 }
984 /* Don't reset a disconnected port */
985 if (!(tmp & RH_PS_CCS)) {
986 spin_unlock_irqrestore(&isp116x->lock, flags);
987 break;
988 }
989 /* Reset lasts 10ms (claims datasheet) */
990 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
991 HCRHPORT1, (RH_PS_PRS));
992 spin_unlock_irqrestore(&isp116x->lock, flags);
993 msleep(10);
994 }
995}
996
997/* Adapted from ohci-hub.c */
998static int isp116x_hub_control(struct usb_hcd *hcd,
999 u16 typeReq,
1000 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1001{
1002 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1003 int ret = 0;
1004 unsigned long flags;
1005 int ports = isp116x->rhdesca & RH_A_NDP;
1006 u32 tmp = 0;
1007
1008 switch (typeReq) {
1009 case ClearHubFeature:
1010 DBG("ClearHubFeature: ");
1011 switch (wValue) {
1012 case C_HUB_OVER_CURRENT:
1013 DBG("C_HUB_OVER_CURRENT\n");
1014 spin_lock_irqsave(&isp116x->lock, flags);
1015 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1016 spin_unlock_irqrestore(&isp116x->lock, flags);
1017 case C_HUB_LOCAL_POWER:
1018 DBG("C_HUB_LOCAL_POWER\n");
1019 break;
1020 default:
1021 goto error;
1022 }
1023 break;
1024 case SetHubFeature:
1025 DBG("SetHubFeature: ");
1026 switch (wValue) {
1027 case C_HUB_OVER_CURRENT:
1028 case C_HUB_LOCAL_POWER:
1029 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1030 break;
1031 default:
1032 goto error;
1033 }
1034 break;
1035 case GetHubDescriptor:
1036 DBG("GetHubDescriptor\n");
1037 isp116x_hub_descriptor(isp116x,
1038 (struct usb_hub_descriptor *)buf);
1039 break;
1040 case GetHubStatus:
1041 DBG("GetHubStatus\n");
Olav Kongas17f8bb72005-06-23 20:12:24 +03001042 *(__le32 *) buf = 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001043 break;
1044 case GetPortStatus:
1045 DBG("GetPortStatus\n");
1046 if (!wIndex || wIndex > ports)
1047 goto error;
Anti Sullin0ed930b2008-03-03 15:39:54 +02001048 spin_lock_irqsave(&isp116x->lock, flags);
1049 tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1050 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001051 *(__le32 *) buf = cpu_to_le32(tmp);
1052 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1053 break;
1054 case ClearPortFeature:
1055 DBG("ClearPortFeature: ");
1056 if (!wIndex || wIndex > ports)
1057 goto error;
1058 wIndex--;
1059
1060 switch (wValue) {
1061 case USB_PORT_FEAT_ENABLE:
1062 DBG("USB_PORT_FEAT_ENABLE\n");
1063 tmp = RH_PS_CCS;
1064 break;
1065 case USB_PORT_FEAT_C_ENABLE:
1066 DBG("USB_PORT_FEAT_C_ENABLE\n");
1067 tmp = RH_PS_PESC;
1068 break;
1069 case USB_PORT_FEAT_SUSPEND:
1070 DBG("USB_PORT_FEAT_SUSPEND\n");
1071 tmp = RH_PS_POCI;
1072 break;
1073 case USB_PORT_FEAT_C_SUSPEND:
1074 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1075 tmp = RH_PS_PSSC;
1076 break;
1077 case USB_PORT_FEAT_POWER:
1078 DBG("USB_PORT_FEAT_POWER\n");
1079 tmp = RH_PS_LSDA;
1080 break;
1081 case USB_PORT_FEAT_C_CONNECTION:
1082 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1083 tmp = RH_PS_CSC;
1084 break;
1085 case USB_PORT_FEAT_C_OVER_CURRENT:
1086 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1087 tmp = RH_PS_OCIC;
1088 break;
1089 case USB_PORT_FEAT_C_RESET:
1090 DBG("USB_PORT_FEAT_C_RESET\n");
1091 tmp = RH_PS_PRSC;
1092 break;
1093 default:
1094 goto error;
1095 }
1096 spin_lock_irqsave(&isp116x->lock, flags);
1097 isp116x_write_reg32(isp116x, wIndex
1098 ? HCRHPORT2 : HCRHPORT1, tmp);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001099 spin_unlock_irqrestore(&isp116x->lock, flags);
1100 break;
1101 case SetPortFeature:
1102 DBG("SetPortFeature: ");
1103 if (!wIndex || wIndex > ports)
1104 goto error;
1105 wIndex--;
1106 switch (wValue) {
1107 case USB_PORT_FEAT_SUSPEND:
1108 DBG("USB_PORT_FEAT_SUSPEND\n");
1109 spin_lock_irqsave(&isp116x->lock, flags);
1110 isp116x_write_reg32(isp116x, wIndex
1111 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
Anti Sullin0ed930b2008-03-03 15:39:54 +02001112 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001113 break;
1114 case USB_PORT_FEAT_POWER:
1115 DBG("USB_PORT_FEAT_POWER\n");
1116 spin_lock_irqsave(&isp116x->lock, flags);
1117 isp116x_write_reg32(isp116x, wIndex
1118 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
Anti Sullin0ed930b2008-03-03 15:39:54 +02001119 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001120 break;
1121 case USB_PORT_FEAT_RESET:
1122 DBG("USB_PORT_FEAT_RESET\n");
1123 root_port_reset(isp116x, wIndex);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001124 break;
1125 default:
1126 goto error;
1127 }
Olav Kongas4808a1c2005-04-09 22:57:39 +03001128 break;
1129
1130 default:
1131 error:
1132 /* "protocol stall" on error */
1133 DBG("PROTOCOL STALL\n");
1134 ret = -EPIPE;
1135 }
1136 return ret;
1137}
1138
Olav Kongas4808a1c2005-04-09 22:57:39 +03001139/*-----------------------------------------------------------------*/
1140
Olav Kongas959eea22005-11-03 17:38:14 +02001141#ifdef CONFIG_DEBUG_FS
Olav Kongas4808a1c2005-04-09 22:57:39 +03001142
1143static void dump_irq(struct seq_file *s, char *label, u16 mask)
1144{
1145 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1146 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1147 mask & HCuPINT_SUSP ? " susp" : "",
1148 mask & HCuPINT_OPR ? " opr" : "",
1149 mask & HCuPINT_AIIEOT ? " eot" : "",
1150 mask & HCuPINT_ATL ? " atl" : "",
1151 mask & HCuPINT_SOF ? " sof" : "");
1152}
1153
1154static void dump_int(struct seq_file *s, char *label, u32 mask)
1155{
1156 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1157 mask & HCINT_MIE ? " MIE" : "",
1158 mask & HCINT_RHSC ? " rhsc" : "",
1159 mask & HCINT_FNO ? " fno" : "",
1160 mask & HCINT_UE ? " ue" : "",
1161 mask & HCINT_RD ? " rd" : "",
1162 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1163}
1164
Olav Kongas959eea22005-11-03 17:38:14 +02001165static int isp116x_show_dbg(struct seq_file *s, void *unused)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001166{
1167 struct isp116x *isp116x = s->private;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001168
1169 seq_printf(s, "%s\n%s version %s\n",
1170 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1171 DRIVER_VERSION);
1172
1173 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1174 seq_printf(s, "HCD is suspended\n");
1175 return 0;
1176 }
1177 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1178 seq_printf(s, "HCD not running\n");
1179 return 0;
1180 }
1181
1182 spin_lock_irq(&isp116x->lock);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001183 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1184 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1185 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1186 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
Olav Kongas959eea22005-11-03 17:38:14 +02001187 isp116x_show_regs_seq(isp116x, s);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001188 spin_unlock_irq(&isp116x->lock);
1189 seq_printf(s, "\n");
1190
1191 return 0;
1192}
1193
Olav Kongas959eea22005-11-03 17:38:14 +02001194static int isp116x_open_seq(struct inode *inode, struct file *file)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001195{
Theodore Ts'o8e18e292006-09-27 01:50:46 -07001196 return single_open(file, isp116x_show_dbg, inode->i_private);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001197}
1198
Luiz Fernando N. Capitulino066202d2006-08-05 20:37:11 -03001199static const struct file_operations isp116x_debug_fops = {
Olav Kongas959eea22005-11-03 17:38:14 +02001200 .open = isp116x_open_seq,
Olav Kongas4808a1c2005-04-09 22:57:39 +03001201 .read = seq_read,
1202 .llseek = seq_lseek,
1203 .release = single_release,
1204};
1205
Olav Kongas959eea22005-11-03 17:38:14 +02001206static int create_debug_file(struct isp116x *isp116x)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001207{
Olav Kongas959eea22005-11-03 17:38:14 +02001208 isp116x->dentry = debugfs_create_file(hcd_name,
1209 S_IRUGO, NULL, isp116x,
1210 &isp116x_debug_fops);
1211 if (!isp116x->dentry)
1212 return -ENOMEM;
1213 return 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001214}
1215
1216static void remove_debug_file(struct isp116x *isp116x)
1217{
Olav Kongas959eea22005-11-03 17:38:14 +02001218 debugfs_remove(isp116x->dentry);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001219}
1220
Olav Kongas959eea22005-11-03 17:38:14 +02001221#else
1222
1223#define create_debug_file(d) 0
1224#define remove_debug_file(d) do{}while(0)
1225
1226#endif /* CONFIG_DEBUG_FS */
Olav Kongas4808a1c2005-04-09 22:57:39 +03001227
1228/*-----------------------------------------------------------------*/
1229
1230/*
1231 Software reset - can be called from any contect.
1232*/
1233static int isp116x_sw_reset(struct isp116x *isp116x)
1234{
1235 int retries = 15;
1236 unsigned long flags;
1237 int ret = 0;
1238
1239 spin_lock_irqsave(&isp116x->lock, flags);
1240 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1241 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1242 while (--retries) {
1243 /* It usually resets within 1 ms */
1244 mdelay(1);
1245 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1246 break;
1247 }
1248 if (!retries) {
1249 ERR("Software reset timeout\n");
1250 ret = -ETIME;
1251 }
1252 spin_unlock_irqrestore(&isp116x->lock, flags);
1253 return ret;
1254}
1255
Olav Kongas4808a1c2005-04-09 22:57:39 +03001256static int isp116x_reset(struct usb_hcd *hcd)
1257{
1258 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1259 unsigned long t;
1260 u16 clkrdy = 0;
Olav Kongas959eea22005-11-03 17:38:14 +02001261 int ret, timeout = 15 /* ms */ ;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001262
Olav Kongasf8d23d32005-08-04 17:02:54 +03001263 ret = isp116x_sw_reset(isp116x);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001264 if (ret)
1265 return ret;
1266
1267 t = jiffies + msecs_to_jiffies(timeout);
1268 while (time_before_eq(jiffies, t)) {
1269 msleep(4);
1270 spin_lock_irq(&isp116x->lock);
1271 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1272 spin_unlock_irq(&isp116x->lock);
1273 if (clkrdy)
1274 break;
1275 }
1276 if (!clkrdy) {
Olav Kongas959eea22005-11-03 17:38:14 +02001277 ERR("Clock not ready after %dms\n", timeout);
Olav Kongas589a0082005-04-21 17:12:59 +03001278 /* After sw_reset the clock won't report to be ready, if
1279 H_WAKEUP pin is high. */
Olav Kongasf8d23d32005-08-04 17:02:54 +03001280 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
Olav Kongas4808a1c2005-04-09 22:57:39 +03001281 ret = -ENODEV;
1282 }
1283 return ret;
1284}
1285
1286static void isp116x_stop(struct usb_hcd *hcd)
1287{
1288 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1289 unsigned long flags;
1290 u32 val;
1291
1292 spin_lock_irqsave(&isp116x->lock, flags);
1293 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1294
1295 /* Switch off ports' power, some devices don't come up
1296 after next 'insmod' without this */
1297 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1298 val &= ~(RH_A_NPS | RH_A_PSM);
1299 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1300 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1301 spin_unlock_irqrestore(&isp116x->lock, flags);
1302
Olav Kongasf8d23d32005-08-04 17:02:54 +03001303 isp116x_sw_reset(isp116x);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001304}
1305
1306/*
1307 Configure the chip. The chip must be successfully reset by now.
1308*/
1309static int isp116x_start(struct usb_hcd *hcd)
1310{
1311 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1312 struct isp116x_platform_data *board = isp116x->board;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001313 u32 val;
1314 unsigned long flags;
1315
1316 spin_lock_irqsave(&isp116x->lock, flags);
1317
1318 /* clear interrupt status and disable all interrupt sources */
1319 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1320 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1321
1322 val = isp116x_read_reg16(isp116x, HCCHIPID);
1323 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1324 ERR("Invalid chip ID %04x\n", val);
1325 spin_unlock_irqrestore(&isp116x->lock, flags);
1326 return -ENODEV;
1327 }
1328
Olav Kongas9a571162005-08-05 14:23:35 +03001329 /* To be removed in future */
1330 hcd->uses_new_polling = 1;
1331
Olav Kongas4808a1c2005-04-09 22:57:39 +03001332 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1333 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1334
1335 /* ----- HW conf */
1336 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1337 if (board->sel15Kres)
1338 val |= HCHWCFG_15KRSEL;
1339 /* Remote wakeup won't work without working clock */
Olav Kongasd4d62862005-08-04 16:48:19 +03001340 if (board->remote_wakeup_enable)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001341 val |= HCHWCFG_CLKNOTSTOP;
1342 if (board->oc_enable)
1343 val |= HCHWCFG_ANALOG_OC;
1344 if (board->int_act_high)
1345 val |= HCHWCFG_INT_POL;
1346 if (board->int_edge_triggered)
1347 val |= HCHWCFG_INT_TRIGGER;
1348 isp116x_write_reg16(isp116x, HCHWCFG, val);
1349
1350 /* ----- Root hub conf */
Olav Kongasdc5bed02005-08-04 16:46:28 +03001351 val = (25 << 24) & RH_A_POTPGT;
Olav Kongas165c0f32005-08-04 16:52:31 +03001352 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1353 be always set. Yet, instead, we request individual port
1354 power switching. */
1355 val |= RH_A_PSM;
Olav Kongas9d233d92005-08-04 16:54:08 +03001356 /* Report overcurrent per port */
1357 val |= RH_A_OCPM;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001358 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1359 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1360
1361 val = RH_B_PPCM;
1362 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1363 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1364
1365 val = 0;
1366 if (board->remote_wakeup_enable) {
David Brownell704aa0b2005-11-07 15:38:24 -08001367 if (!device_can_wakeup(hcd->self.controller))
1368 device_init_wakeup(hcd->self.controller, 1);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001369 val |= RH_HS_DRWE;
1370 }
1371 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1372 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1373
1374 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001375
Olav Kongas4808a1c2005-04-09 22:57:39 +03001376 hcd->state = HC_STATE_RUNNING;
1377
Olav Kongas4808a1c2005-04-09 22:57:39 +03001378 /* Set up interrupts */
1379 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1380 if (board->remote_wakeup_enable)
1381 isp116x->intenb |= HCINT_RD;
1382 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1383 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1384 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1385
1386 /* Go operational */
1387 val = HCCONTROL_USB_OPER;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001388 if (board->remote_wakeup_enable)
1389 val |= HCCONTROL_RWE;
1390 isp116x_write_reg32(isp116x, HCCONTROL, val);
1391
1392 /* Disable ports to avoid race in device enumeration */
1393 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1394 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1395
Olav Kongas959eea22005-11-03 17:38:14 +02001396 isp116x_show_regs_log(isp116x);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001397 spin_unlock_irqrestore(&isp116x->lock, flags);
1398 return 0;
1399}
1400
Olav Kongas959eea22005-11-03 17:38:14 +02001401#ifdef CONFIG_PM
1402
1403static int isp116x_bus_suspend(struct usb_hcd *hcd)
1404{
1405 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1406 unsigned long flags;
1407 u32 val;
1408 int ret = 0;
1409
1410 spin_lock_irqsave(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001411 val = isp116x_read_reg32(isp116x, HCCONTROL);
Olav Kongas0be930c2005-12-27 16:04:02 +02001412
Olav Kongas959eea22005-11-03 17:38:14 +02001413 switch (val & HCCONTROL_HCFS) {
1414 case HCCONTROL_USB_OPER:
Olav Kongas0be930c2005-12-27 16:04:02 +02001415 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001416 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1417 val |= HCCONTROL_USB_SUSPEND;
Alan Stern58a97ff2008-04-14 12:17:10 -04001418 if (hcd->self.root_hub->do_remote_wakeup)
Olav Kongas959eea22005-11-03 17:38:14 +02001419 val |= HCCONTROL_RWE;
1420 /* Wait for usb transfers to finish */
Olav Kongas0be930c2005-12-27 16:04:02 +02001421 msleep(2);
1422 spin_lock_irqsave(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001423 isp116x_write_reg32(isp116x, HCCONTROL, val);
Olav Kongas0be930c2005-12-27 16:04:02 +02001424 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001425 /* Wait for devices to suspend */
Olav Kongas0be930c2005-12-27 16:04:02 +02001426 msleep(5);
Olav Kongas959eea22005-11-03 17:38:14 +02001427 break;
1428 case HCCONTROL_USB_RESUME:
1429 isp116x_write_reg32(isp116x, HCCONTROL,
1430 (val & ~HCCONTROL_HCFS) |
1431 HCCONTROL_USB_RESET);
1432 case HCCONTROL_USB_RESET:
1433 ret = -EBUSY;
Olav Kongas0be930c2005-12-27 16:04:02 +02001434 default: /* HCCONTROL_USB_SUSPEND */
1435 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001436 break;
Olav Kongas959eea22005-11-03 17:38:14 +02001437 }
1438
Olav Kongas959eea22005-11-03 17:38:14 +02001439 return ret;
1440}
1441
1442static int isp116x_bus_resume(struct usb_hcd *hcd)
1443{
1444 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1445 u32 val;
1446
1447 msleep(5);
1448 spin_lock_irq(&isp116x->lock);
1449
1450 val = isp116x_read_reg32(isp116x, HCCONTROL);
1451 switch (val & HCCONTROL_HCFS) {
1452 case HCCONTROL_USB_SUSPEND:
1453 val &= ~HCCONTROL_HCFS;
1454 val |= HCCONTROL_USB_RESUME;
1455 isp116x_write_reg32(isp116x, HCCONTROL, val);
1456 case HCCONTROL_USB_RESUME:
1457 break;
1458 case HCCONTROL_USB_OPER:
1459 spin_unlock_irq(&isp116x->lock);
Olav Kongas959eea22005-11-03 17:38:14 +02001460 return 0;
1461 default:
1462 /* HCCONTROL_USB_RESET: this may happen, when during
1463 suspension the HC lost power. Reinitialize completely */
1464 spin_unlock_irq(&isp116x->lock);
1465 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1466 isp116x_reset(hcd);
1467 isp116x_start(hcd);
1468 isp116x_hub_control(hcd, SetPortFeature,
1469 USB_PORT_FEAT_POWER, 1, NULL, 0);
1470 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1471 isp116x_hub_control(hcd, SetPortFeature,
1472 USB_PORT_FEAT_POWER, 2, NULL, 0);
Olav Kongas959eea22005-11-03 17:38:14 +02001473 return 0;
1474 }
1475
1476 val = isp116x->rhdesca & RH_A_NDP;
1477 while (val--) {
1478 u32 stat =
1479 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1480 /* force global, not selective, resume */
1481 if (!(stat & RH_PS_PSS))
1482 continue;
1483 DBG("%s: Resuming port %d\n", __func__, val);
1484 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1485 ? HCRHPORT2 : HCRHPORT1);
1486 }
1487 spin_unlock_irq(&isp116x->lock);
1488
1489 hcd->state = HC_STATE_RESUMING;
1490 msleep(20);
1491
1492 /* Go operational */
1493 spin_lock_irq(&isp116x->lock);
1494 val = isp116x_read_reg32(isp116x, HCCONTROL);
1495 isp116x_write_reg32(isp116x, HCCONTROL,
1496 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1497 spin_unlock_irq(&isp116x->lock);
Olav Kongas959eea22005-11-03 17:38:14 +02001498 hcd->state = HC_STATE_RUNNING;
1499
1500 return 0;
1501}
1502
1503#else
1504
1505#define isp116x_bus_suspend NULL
1506#define isp116x_bus_resume NULL
1507
1508#endif
Olav Kongas4808a1c2005-04-09 22:57:39 +03001509
1510static struct hc_driver isp116x_hc_driver = {
1511 .description = hcd_name,
1512 .product_desc = "ISP116x Host Controller",
1513 .hcd_priv_size = sizeof(struct isp116x),
1514
1515 .irq = isp116x_irq,
1516 .flags = HCD_USB11,
1517
1518 .reset = isp116x_reset,
1519 .start = isp116x_start,
1520 .stop = isp116x_stop,
1521
1522 .urb_enqueue = isp116x_urb_enqueue,
1523 .urb_dequeue = isp116x_urb_dequeue,
1524 .endpoint_disable = isp116x_endpoint_disable,
1525
1526 .get_frame_number = isp116x_get_frame,
1527
1528 .hub_status_data = isp116x_hub_status_data,
1529 .hub_control = isp116x_hub_control,
Alan Stern0c0382e2005-10-13 17:08:02 -04001530 .bus_suspend = isp116x_bus_suspend,
1531 .bus_resume = isp116x_bus_resume,
Olav Kongas4808a1c2005-04-09 22:57:39 +03001532};
1533
1534/*----------------------------------------------------------------*/
1535
Greg Kroah-Hartmanb7125482006-03-17 17:40:08 -08001536static int isp116x_remove(struct platform_device *pdev)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001537{
Russell King3ae5eae2005-11-09 22:32:44 +00001538 struct usb_hcd *hcd = platform_get_drvdata(pdev);
Olav Kongas589a0082005-04-21 17:12:59 +03001539 struct isp116x *isp116x;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001540 struct resource *res;
1541
Olav Kongas9a571162005-08-05 14:23:35 +03001542 if (!hcd)
Olav Kongas589a0082005-04-21 17:12:59 +03001543 return 0;
1544 isp116x = hcd_to_isp116x(hcd);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001545 remove_debug_file(isp116x);
1546 usb_remove_hcd(hcd);
1547
1548 iounmap(isp116x->data_reg);
1549 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1550 release_mem_region(res->start, 2);
1551 iounmap(isp116x->addr_reg);
1552 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1553 release_mem_region(res->start, 2);
1554
1555 usb_put_hcd(hcd);
1556 return 0;
1557}
1558
1559#define resource_len(r) (((r)->end - (r)->start) + 1)
1560
Prarit Bhargava5bcd70e2007-02-09 01:51:15 -08001561static int __devinit isp116x_probe(struct platform_device *pdev)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001562{
1563 struct usb_hcd *hcd;
1564 struct isp116x *isp116x;
Marc Zyngier27140212008-08-18 13:08:42 +02001565 struct resource *addr, *data, *ires;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001566 void __iomem *addr_reg;
1567 void __iomem *data_reg;
1568 int irq;
1569 int ret = 0;
Marc Zyngier27140212008-08-18 13:08:42 +02001570 unsigned long irqflags;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001571
Olav Kongas4808a1c2005-04-09 22:57:39 +03001572 if (pdev->num_resources < 3) {
1573 ret = -ENODEV;
1574 goto err1;
1575 }
1576
1577 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1578 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
Marc Zyngier27140212008-08-18 13:08:42 +02001579 ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1580
1581 if (!addr || !data || !ires) {
Olav Kongas4808a1c2005-04-09 22:57:39 +03001582 ret = -ENODEV;
1583 goto err1;
1584 }
1585
Marc Zyngier27140212008-08-18 13:08:42 +02001586 irq = ires->start;
1587 irqflags = ires->flags & IRQF_TRIGGER_MASK;
1588
Russell King3ae5eae2005-11-09 22:32:44 +00001589 if (pdev->dev.dma_mask) {
Olav Kongas4808a1c2005-04-09 22:57:39 +03001590 DBG("DMA not supported\n");
1591 ret = -EINVAL;
1592 goto err1;
1593 }
1594
1595 if (!request_mem_region(addr->start, 2, hcd_name)) {
1596 ret = -EBUSY;
1597 goto err1;
1598 }
1599 addr_reg = ioremap(addr->start, resource_len(addr));
1600 if (addr_reg == NULL) {
1601 ret = -ENOMEM;
1602 goto err2;
1603 }
1604 if (!request_mem_region(data->start, 2, hcd_name)) {
1605 ret = -EBUSY;
1606 goto err3;
1607 }
1608 data_reg = ioremap(data->start, resource_len(data));
1609 if (data_reg == NULL) {
1610 ret = -ENOMEM;
1611 goto err4;
1612 }
1613
1614 /* allocate and initialize hcd */
Kay Sievers7071a3c2008-05-02 06:02:41 +02001615 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
Olav Kongas4808a1c2005-04-09 22:57:39 +03001616 if (!hcd) {
1617 ret = -ENOMEM;
1618 goto err5;
1619 }
1620 /* this rsrc_start is bogus */
1621 hcd->rsrc_start = addr->start;
1622 isp116x = hcd_to_isp116x(hcd);
1623 isp116x->data_reg = data_reg;
1624 isp116x->addr_reg = addr_reg;
1625 spin_lock_init(&isp116x->lock);
1626 INIT_LIST_HEAD(&isp116x->async);
Russell King3ae5eae2005-11-09 22:32:44 +00001627 isp116x->board = pdev->dev.platform_data;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001628
1629 if (!isp116x->board) {
1630 ERR("Platform data structure not initialized\n");
1631 ret = -ENODEV;
1632 goto err6;
1633 }
1634 if (isp116x_check_platform_delay(isp116x)) {
1635 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1636 "implemented.\n");
1637 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1638 ret = -ENODEV;
1639 goto err6;
1640 }
1641
Marc Zyngier27140212008-08-18 13:08:42 +02001642 ret = usb_add_hcd(hcd, irq, irqflags | IRQF_DISABLED);
Olav Kongas959eea22005-11-03 17:38:14 +02001643 if (ret)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001644 goto err6;
1645
Olav Kongas959eea22005-11-03 17:38:14 +02001646 ret = create_debug_file(isp116x);
1647 if (ret) {
1648 ERR("Couldn't create debugfs entry\n");
1649 goto err7;
1650 }
1651
Olav Kongas4808a1c2005-04-09 22:57:39 +03001652 return 0;
1653
Olav Kongas959eea22005-11-03 17:38:14 +02001654 err7:
1655 usb_remove_hcd(hcd);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001656 err6:
1657 usb_put_hcd(hcd);
1658 err5:
1659 iounmap(data_reg);
1660 err4:
1661 release_mem_region(data->start, 2);
1662 err3:
1663 iounmap(addr_reg);
1664 err2:
1665 release_mem_region(addr->start, 2);
1666 err1:
1667 ERR("init error, %d\n", ret);
1668 return ret;
1669}
1670
1671#ifdef CONFIG_PM
1672/*
1673 Suspend of platform device
1674*/
Russell King3ae5eae2005-11-09 22:32:44 +00001675static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001676{
Olav Kongas959eea22005-11-03 17:38:14 +02001677 VDBG("%s: state %x\n", __func__, state.event);
Olav Kongas959eea22005-11-03 17:38:14 +02001678 return 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001679}
1680
1681/*
1682 Resume platform device
1683*/
Russell King3ae5eae2005-11-09 22:32:44 +00001684static int isp116x_resume(struct platform_device *dev)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001685{
Alan Stern70a1c9e2008-03-06 17:00:58 -05001686 VDBG("%s\n", __func__);
Olav Kongas959eea22005-11-03 17:38:14 +02001687 return 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001688}
1689
1690#else
1691
1692#define isp116x_suspend NULL
1693#define isp116x_resume NULL
1694
1695#endif
1696
Kay Sieversf4fce612008-04-10 21:29:22 -07001697/* work with hotplug and coldplug */
1698MODULE_ALIAS("platform:isp116x-hcd");
1699
Russell King3ae5eae2005-11-09 22:32:44 +00001700static struct platform_driver isp116x_driver = {
Olav Kongas4808a1c2005-04-09 22:57:39 +03001701 .probe = isp116x_probe,
1702 .remove = isp116x_remove,
1703 .suspend = isp116x_suspend,
1704 .resume = isp116x_resume,
Olav Kongas0be930c2005-12-27 16:04:02 +02001705 .driver = {
Kay Sieversf4fce612008-04-10 21:29:22 -07001706 .name = (char *)hcd_name,
1707 .owner = THIS_MODULE,
1708 },
Olav Kongas4808a1c2005-04-09 22:57:39 +03001709};
1710
1711/*-----------------------------------------------------------------*/
1712
1713static int __init isp116x_init(void)
1714{
1715 if (usb_disabled())
1716 return -ENODEV;
1717
1718 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
Russell King3ae5eae2005-11-09 22:32:44 +00001719 return platform_driver_register(&isp116x_driver);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001720}
1721
1722module_init(isp116x_init);
1723
1724static void __exit isp116x_cleanup(void)
1725{
Russell King3ae5eae2005-11-09 22:32:44 +00001726 platform_driver_unregister(&isp116x_driver);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001727}
1728
1729module_exit(isp116x_cleanup);