blob: d9e82123de2a52fce537f8252e9f828f02fda181 [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090065#include <linux/slab.h>
Olav Kongas4808a1c2005-04-09 22:57:39 +030066#include <linux/usb.h>
David Brownell325a4af2006-06-13 09:59:32 -070067#include <linux/usb/isp116x.h>
Eric Lescouet27729aa2010-04-24 23:21:52 +020068#include <linux/usb/hcd.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010069#include <linux/platform_device.h>
Olav Kongas4808a1c2005-04-09 22:57:39 +030070
71#include <asm/io.h>
72#include <asm/irq.h>
73#include <asm/system.h>
74#include <asm/byteorder.h>
75
Olav Kongas4808a1c2005-04-09 22:57:39 +030076#include "isp116x.h"
77
Olav Kongas959eea22005-11-03 17:38:14 +020078#define DRIVER_VERSION "03 Nov 2005"
Olav Kongas4808a1c2005-04-09 22:57:39 +030079#define DRIVER_DESC "ISP116x USB Host Controller Driver"
80
81MODULE_DESCRIPTION(DRIVER_DESC);
82MODULE_LICENSE("GPL");
83
84static const char hcd_name[] = "isp116x-hcd";
85
86/*-----------------------------------------------------------------*/
87
88/*
89 Write len bytes to fifo, pad till 32-bit boundary
90 */
91static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
92{
93 u8 *dp = (u8 *) buf;
94 u16 *dp2 = (u16 *) buf;
95 u16 w;
96 int quot = len % 4;
97
Julien May28874b72008-06-27 15:01:18 +020098 /* buffer is already in 'usb data order', which is LE. */
99 /* When reading buffer as u16, we have to take care byte order */
100 /* doesn't get mixed up */
101
Olav Kongas4808a1c2005-04-09 22:57:39 +0300102 if ((unsigned long)dp2 & 1) {
103 /* not aligned */
104 for (; len > 1; len -= 2) {
105 w = *dp++;
106 w |= *dp++ << 8;
107 isp116x_raw_write_data16(isp116x, w);
108 }
109 if (len)
110 isp116x_write_data16(isp116x, (u16) * dp);
111 } else {
112 /* aligned */
Julien May28874b72008-06-27 15:01:18 +0200113 for (; len > 1; len -= 2) {
114 /* Keep byte order ! */
115 isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
116 }
117
Olav Kongas4808a1c2005-04-09 22:57:39 +0300118 if (len)
119 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
120 }
121 if (quot == 1 || quot == 2)
122 isp116x_raw_write_data16(isp116x, 0);
123}
124
125/*
126 Read len bytes from fifo and then read till 32-bit boundary.
127 */
128static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
129{
130 u8 *dp = (u8 *) buf;
131 u16 *dp2 = (u16 *) buf;
132 u16 w;
133 int quot = len % 4;
134
Julien May28874b72008-06-27 15:01:18 +0200135 /* buffer is already in 'usb data order', which is LE. */
136 /* When reading buffer as u16, we have to take care byte order */
137 /* doesn't get mixed up */
138
Olav Kongas4808a1c2005-04-09 22:57:39 +0300139 if ((unsigned long)dp2 & 1) {
140 /* not aligned */
141 for (; len > 1; len -= 2) {
142 w = isp116x_raw_read_data16(isp116x);
143 *dp++ = w & 0xff;
144 *dp++ = (w >> 8) & 0xff;
145 }
Julien May28874b72008-06-27 15:01:18 +0200146
Olav Kongas4808a1c2005-04-09 22:57:39 +0300147 if (len)
148 *dp = 0xff & isp116x_read_data16(isp116x);
149 } else {
150 /* aligned */
Julien May28874b72008-06-27 15:01:18 +0200151 for (; len > 1; len -= 2) {
152 /* Keep byte order! */
153 *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
154 }
155
Olav Kongas4808a1c2005-04-09 22:57:39 +0300156 if (len)
157 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
158 }
159 if (quot == 1 || quot == 2)
160 isp116x_raw_read_data16(isp116x);
161}
162
163/*
164 Write ptd's and data for scheduled transfers into
165 the fifo ram. Fifo must be empty and ready.
166*/
167static void pack_fifo(struct isp116x *isp116x)
168{
169 struct isp116x_ep *ep;
170 struct ptd *ptd;
171 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
172 ? isp116x->atl_bufshrt : isp116x->atl_buflen;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300173
174 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
175 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
176 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
177 for (ep = isp116x->atl_active; ep; ep = ep->active) {
Olav Kongas4808a1c2005-04-09 22:57:39 +0300178 ptd = &ep->ptd;
179 dump_ptd(ptd);
180 dump_ptd_out_data(ptd, ep->data);
181 isp116x_write_data16(isp116x, ptd->count);
182 isp116x_write_data16(isp116x, ptd->mps);
183 isp116x_write_data16(isp116x, ptd->len);
184 isp116x_write_data16(isp116x, ptd->faddr);
185 buflen -= sizeof(struct ptd);
186 /* Skip writing data for last IN PTD */
187 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
188 write_ptddata_to_fifo(isp116x, ep->data, ep->length);
189 buflen -= ALIGN(ep->length, 4);
190 }
191 }
192 BUG_ON(buflen);
193}
194
195/*
196 Read the processed ptd's and data from fifo ram back to
197 URBs' buffers. Fifo must be full and done
198*/
199static void unpack_fifo(struct isp116x *isp116x)
200{
201 struct isp116x_ep *ep;
202 struct ptd *ptd;
203 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
204 ? isp116x->atl_buflen : isp116x->atl_bufshrt;
205
206 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
207 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
208 isp116x_write_addr(isp116x, HCATLPORT);
209 for (ep = isp116x->atl_active; ep; ep = ep->active) {
210 ptd = &ep->ptd;
211 ptd->count = isp116x_read_data16(isp116x);
212 ptd->mps = isp116x_read_data16(isp116x);
213 ptd->len = isp116x_read_data16(isp116x);
214 ptd->faddr = isp116x_read_data16(isp116x);
215 buflen -= sizeof(struct ptd);
216 /* Skip reading data for last Setup or Out PTD */
217 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
218 read_ptddata_from_fifo(isp116x, ep->data, ep->length);
219 buflen -= ALIGN(ep->length, 4);
220 }
221 dump_ptd(ptd);
222 dump_ptd_in_data(ptd, ep->data);
223 }
224 BUG_ON(buflen);
225}
226
227/*---------------------------------------------------------------*/
228
229/*
230 Set up PTD's.
231*/
232static void preproc_atl_queue(struct isp116x *isp116x)
233{
234 struct isp116x_ep *ep;
235 struct urb *urb;
236 struct ptd *ptd;
Olav Kongasf10eff22005-08-04 18:06:47 -0700237 u16 len;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300238
239 for (ep = isp116x->atl_active; ep; ep = ep->active) {
Olav Kongasf10eff22005-08-04 18:06:47 -0700240 u16 toggle = 0, dir = PTD_DIR_SETUP;
241
Olav Kongas4808a1c2005-04-09 22:57:39 +0300242 BUG_ON(list_empty(&ep->hep->urb_list));
243 urb = container_of(ep->hep->urb_list.next,
244 struct urb, urb_list);
245 ptd = &ep->ptd;
246 len = ep->length;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300247 ep->data = (unsigned char *)urb->transfer_buffer
248 + urb->actual_length;
249
250 switch (ep->nextpid) {
251 case USB_PID_IN:
252 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
253 dir = PTD_DIR_IN;
254 break;
255 case USB_PID_OUT:
256 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
257 dir = PTD_DIR_OUT;
258 break;
259 case USB_PID_SETUP:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300260 len = sizeof(struct usb_ctrlrequest);
261 ep->data = urb->setup_packet;
262 break;
263 case USB_PID_ACK:
264 toggle = 1;
265 len = 0;
266 dir = (urb->transfer_buffer_length
267 && usb_pipein(urb->pipe))
268 ? PTD_DIR_OUT : PTD_DIR_IN;
269 break;
270 default:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300271 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
272 ep->nextpid);
Olav Kongas17f8bb72005-06-23 20:12:24 +0300273 BUG();
Olav Kongas4808a1c2005-04-09 22:57:39 +0300274 }
275
276 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
277 ptd->mps = PTD_MPS(ep->maxpacket)
278 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
279 | PTD_EP(ep->epnum);
280 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
281 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
Olav Kongas4808a1c2005-04-09 22:57:39 +0300282 if (!ep->active) {
283 ptd->mps |= PTD_LAST_MSK;
284 isp116x->atl_last_dir = dir;
285 }
286 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
287 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
288 }
289}
290
291/*
Olav Kongas4808a1c2005-04-09 22:57:39 +0300292 Take done or failed requests out of schedule. Give back
293 processed urbs.
294*/
295static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
Alan Stern4a000272007-08-24 15:42:24 -0400296 struct urb *urb, int status)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300297__releases(isp116x->lock) __acquires(isp116x->lock)
298{
299 unsigned i;
300
Olav Kongas4808a1c2005-04-09 22:57:39 +0300301 ep->error_count = 0;
302
303 if (usb_pipecontrol(urb->pipe))
304 ep->nextpid = USB_PID_SETUP;
305
306 urb_dbg(urb, "Finish");
307
Alan Sterne9df41c2007-08-08 11:48:02 -0400308 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300309 spin_unlock(&isp116x->lock);
Alan Stern4a000272007-08-24 15:42:24 -0400310 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300311 spin_lock(&isp116x->lock);
312
313 /* take idle endpoints out of the schedule */
314 if (!list_empty(&ep->hep->urb_list))
315 return;
316
317 /* async deschedule */
318 if (!list_empty(&ep->schedule)) {
319 list_del_init(&ep->schedule);
320 return;
321 }
322
323 /* periodic deschedule */
324 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
325 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
326 struct isp116x_ep *temp;
327 struct isp116x_ep **prev = &isp116x->periodic[i];
328
329 while (*prev && ((temp = *prev) != ep))
330 prev = &temp->next;
331 if (*prev)
332 *prev = ep->next;
333 isp116x->load[i] -= ep->load;
334 }
335 ep->branch = PERIODIC_SIZE;
336 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
337 ep->load / ep->period;
338
339 /* switch irq type? */
340 if (!--isp116x->periodic_count) {
341 isp116x->irqenb &= ~HCuPINT_SOF;
342 isp116x->irqenb |= HCuPINT_ATL;
343 }
344}
345
346/*
Alan Stern1b4cd432007-07-12 17:03:01 -0400347 Analyze transfer results, handle partial transfers and errors
348*/
349static void postproc_atl_queue(struct isp116x *isp116x)
350{
351 struct isp116x_ep *ep;
352 struct urb *urb;
353 struct usb_device *udev;
354 struct ptd *ptd;
355 int short_not_ok;
356 int status;
357 u8 cc;
358
359 for (ep = isp116x->atl_active; ep; ep = ep->active) {
360 BUG_ON(list_empty(&ep->hep->urb_list));
361 urb =
362 container_of(ep->hep->urb_list.next, struct urb, urb_list);
363 udev = urb->dev;
364 ptd = &ep->ptd;
365 cc = PTD_GET_CC(ptd);
366 short_not_ok = 1;
367 status = -EINPROGRESS;
368
369 /* Data underrun is special. For allowed underrun
370 we clear the error and continue as normal. For
371 forbidden underrun we finish the DATA stage
372 immediately while for control transfer,
373 we do a STATUS stage. */
374 if (cc == TD_DATAUNDERRUN) {
375 if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
376 usb_pipecontrol(urb->pipe)) {
377 DBG("Allowed or control data underrun\n");
378 cc = TD_CC_NOERROR;
379 short_not_ok = 0;
380 } else {
381 ep->error_count = 1;
382 usb_settoggle(udev, ep->epnum,
383 ep->nextpid == USB_PID_OUT,
384 PTD_GET_TOGGLE(ptd));
385 urb->actual_length += PTD_GET_COUNT(ptd);
386 status = cc_to_error[TD_DATAUNDERRUN];
387 goto done;
388 }
389 }
390
391 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
392 && (++ep->error_count >= 3 || cc == TD_CC_STALL
393 || cc == TD_DATAOVERRUN)) {
394 status = cc_to_error[cc];
395 if (ep->nextpid == USB_PID_ACK)
396 ep->nextpid = 0;
397 goto done;
398 }
399 /* According to usb spec, zero-length Int transfer signals
400 finishing of the urb. Hey, does this apply only
401 for IN endpoints? */
402 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
403 status = 0;
404 goto done;
405 }
406
407 /* Relax after previously failed, but later succeeded
408 or correctly NAK'ed retransmission attempt */
409 if (ep->error_count
410 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
411 ep->error_count = 0;
412
413 /* Take into account idiosyncracies of the isp116x chip
414 regarding toggle bit for failed transfers */
415 if (ep->nextpid == USB_PID_OUT)
416 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
417 ^ (ep->error_count > 0));
418 else if (ep->nextpid == USB_PID_IN)
419 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
420 ^ (ep->error_count > 0));
421
422 switch (ep->nextpid) {
423 case USB_PID_IN:
424 case USB_PID_OUT:
425 urb->actual_length += PTD_GET_COUNT(ptd);
426 if (PTD_GET_ACTIVE(ptd)
427 || (cc != TD_CC_NOERROR && cc < 0x0E))
428 break;
429 if (urb->transfer_buffer_length != urb->actual_length) {
430 if (short_not_ok)
431 break;
432 } else {
433 if (urb->transfer_flags & URB_ZERO_PACKET
434 && ep->nextpid == USB_PID_OUT
435 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
436 DBG("Zero packet requested\n");
437 break;
438 }
439 }
440 /* All data for this URB is transferred, let's finish */
441 if (usb_pipecontrol(urb->pipe))
442 ep->nextpid = USB_PID_ACK;
443 else
444 status = 0;
445 break;
446 case USB_PID_SETUP:
447 if (PTD_GET_ACTIVE(ptd)
448 || (cc != TD_CC_NOERROR && cc < 0x0E))
449 break;
450 if (urb->transfer_buffer_length == urb->actual_length)
451 ep->nextpid = USB_PID_ACK;
452 else if (usb_pipeout(urb->pipe)) {
453 usb_settoggle(udev, 0, 1, 1);
454 ep->nextpid = USB_PID_OUT;
455 } else {
456 usb_settoggle(udev, 0, 0, 1);
457 ep->nextpid = USB_PID_IN;
458 }
459 break;
460 case USB_PID_ACK:
461 if (PTD_GET_ACTIVE(ptd)
462 || (cc != TD_CC_NOERROR && cc < 0x0E))
463 break;
Alan Sternb0d9efb2007-08-21 15:39:21 -0400464 status = 0;
Alan Stern1b4cd432007-07-12 17:03:01 -0400465 ep->nextpid = 0;
466 break;
467 default:
468 BUG();
469 }
470
471 done:
Alan Stern4a000272007-08-24 15:42:24 -0400472 if (status != -EINPROGRESS || urb->unlinked)
473 finish_request(isp116x, ep, urb, status);
Alan Stern1b4cd432007-07-12 17:03:01 -0400474 }
475}
476
477/*
Olav Kongas4808a1c2005-04-09 22:57:39 +0300478 Scan transfer lists, schedule transfers, send data off
479 to chip.
480 */
481static void start_atl_transfers(struct isp116x *isp116x)
482{
483 struct isp116x_ep *last_ep = NULL, *ep;
484 struct urb *urb;
485 u16 load = 0;
486 int len, index, speed, byte_time;
487
488 if (atomic_read(&isp116x->atl_finishing))
489 return;
490
491 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
492 return;
493
494 /* FIFO not empty? */
495 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
496 return;
497
498 isp116x->atl_active = NULL;
499 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
500
501 /* Schedule int transfers */
502 if (isp116x->periodic_count) {
503 isp116x->fmindex = index =
504 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
505 if ((load = isp116x->load[index])) {
506 /* Bring all int transfers for this frame
507 into the active queue */
508 isp116x->atl_active = last_ep =
509 isp116x->periodic[index];
510 while (last_ep->next)
511 last_ep = (last_ep->active = last_ep->next);
512 last_ep->active = NULL;
513 }
514 }
515
516 /* Schedule control/bulk transfers */
517 list_for_each_entry(ep, &isp116x->async, schedule) {
518 urb = container_of(ep->hep->urb_list.next,
519 struct urb, urb_list);
520 speed = urb->dev->speed;
521 byte_time = speed == USB_SPEED_LOW
522 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
523
524 if (ep->nextpid == USB_PID_SETUP) {
525 len = sizeof(struct usb_ctrlrequest);
526 } else if (ep->nextpid == USB_PID_ACK) {
527 len = 0;
528 } else {
529 /* Find current free length ... */
530 len = (MAX_LOAD_LIMIT - load) / byte_time;
531
532 /* ... then limit it to configured max size ... */
533 len = min(len, speed == USB_SPEED_LOW ?
534 MAX_TRANSFER_SIZE_LOWSPEED :
535 MAX_TRANSFER_SIZE_FULLSPEED);
536
537 /* ... and finally cut to the multiple of MaxPacketSize,
538 or to the real length if there's enough room. */
539 if (len <
540 (urb->transfer_buffer_length -
541 urb->actual_length)) {
542 len -= len % ep->maxpacket;
543 if (!len)
544 continue;
545 } else
546 len = urb->transfer_buffer_length -
547 urb->actual_length;
548 BUG_ON(len < 0);
549 }
550
551 load += len * byte_time;
552 if (load > MAX_LOAD_LIMIT)
553 break;
554
555 ep->active = NULL;
556 ep->length = len;
557 if (last_ep)
558 last_ep->active = ep;
559 else
560 isp116x->atl_active = ep;
561 last_ep = ep;
562 }
563
564 /* Avoid starving of endpoints */
565 if ((&isp116x->async)->next != (&isp116x->async)->prev)
566 list_move(&isp116x->async, (&isp116x->async)->next);
567
568 if (isp116x->atl_active) {
569 preproc_atl_queue(isp116x);
570 pack_fifo(isp116x);
571 }
572}
573
574/*
575 Finish the processed transfers
576*/
David Howells7d12e782006-10-05 14:55:46 +0100577static void finish_atl_transfers(struct isp116x *isp116x)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300578{
Olav Kongas4808a1c2005-04-09 22:57:39 +0300579 if (!isp116x->atl_active)
580 return;
581 /* Fifo not ready? */
582 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
583 return;
584
585 atomic_inc(&isp116x->atl_finishing);
586 unpack_fifo(isp116x);
587 postproc_atl_queue(isp116x);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300588 atomic_dec(&isp116x->atl_finishing);
589}
590
David Howells7d12e782006-10-05 14:55:46 +0100591static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300592{
593 struct isp116x *isp116x = hcd_to_isp116x(hcd);
594 u16 irqstat;
595 irqreturn_t ret = IRQ_NONE;
596
597 spin_lock(&isp116x->lock);
598 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
599 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
600 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
601
602 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
603 ret = IRQ_HANDLED;
David Howells7d12e782006-10-05 14:55:46 +0100604 finish_atl_transfers(isp116x);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300605 }
606
607 if (irqstat & HCuPINT_OPR) {
608 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
609 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
610 if (intstat & HCINT_UE) {
Olav Kongas959eea22005-11-03 17:38:14 +0200611 ERR("Unrecoverable error, HC is dead!\n");
612 /* IRQ's are off, we do no DMA,
613 perfectly ready to die ... */
614 hcd->state = HC_STATE_HALT;
615 ret = IRQ_HANDLED;
616 goto done;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300617 }
Olav Kongas9a571162005-08-05 14:23:35 +0300618 if (intstat & HCINT_RHSC)
619 /* When root hub or any of its ports is going
620 to come out of suspend, it may take more
621 than 10ms for status bits to stabilize. */
622 mod_timer(&hcd->rh_timer, jiffies
623 + msecs_to_jiffies(20) + 1);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300624 if (intstat & HCINT_RD) {
625 DBG("---- remote wakeup\n");
David Brownellccdcf772005-09-22 22:45:13 -0700626 usb_hcd_resume_root_hub(hcd);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300627 }
628 irqstat &= ~HCuPINT_OPR;
629 ret = IRQ_HANDLED;
630 }
631
632 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
633 start_atl_transfers(isp116x);
634 }
635
636 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
Olav Kongas959eea22005-11-03 17:38:14 +0200637 done:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300638 spin_unlock(&isp116x->lock);
639 return ret;
640}
641
642/*-----------------------------------------------------------------*/
643
644/* usb 1.1 says max 90% of a frame is available for periodic transfers.
645 * this driver doesn't promise that much since it's got to handle an
646 * IRQ per packet; irq handling latencies also use up that time.
647 */
648
649/* out of 1000 us */
650#define MAX_PERIODIC_LOAD 600
651static int balance(struct isp116x *isp116x, u16 period, u16 load)
652{
653 int i, branch = -ENOSPC;
654
655 /* search for the least loaded schedule branch of that period
656 which has enough bandwidth left unreserved. */
657 for (i = 0; i < period; i++) {
658 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
659 int j;
660
661 for (j = i; j < PERIODIC_SIZE; j += period) {
662 if ((isp116x->load[j] + load)
663 > MAX_PERIODIC_LOAD)
664 break;
665 }
666 if (j < PERIODIC_SIZE)
667 continue;
668 branch = i;
669 }
670 }
671 return branch;
672}
673
674/* NB! ALL the code above this point runs with isp116x->lock
675 held, irqs off
676*/
677
678/*-----------------------------------------------------------------*/
679
680static int isp116x_urb_enqueue(struct usb_hcd *hcd,
Alan Sterne9df41c2007-08-08 11:48:02 -0400681 struct urb *urb,
Al Viro55016f12005-10-21 03:21:58 -0400682 gfp_t mem_flags)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300683{
684 struct isp116x *isp116x = hcd_to_isp116x(hcd);
685 struct usb_device *udev = urb->dev;
686 unsigned int pipe = urb->pipe;
687 int is_out = !usb_pipein(pipe);
688 int type = usb_pipetype(pipe);
689 int epnum = usb_pipeendpoint(pipe);
Alan Sterne9df41c2007-08-08 11:48:02 -0400690 struct usb_host_endpoint *hep = urb->ep;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300691 struct isp116x_ep *ep = NULL;
692 unsigned long flags;
693 int i;
694 int ret = 0;
695
696 urb_dbg(urb, "Enqueue");
697
698 if (type == PIPE_ISOCHRONOUS) {
699 ERR("Isochronous transfers not supported\n");
700 urb_dbg(urb, "Refused to enqueue");
701 return -ENXIO;
702 }
703 /* avoid all allocations within spinlocks: request or endpoint */
704 if (!hep->hcpriv) {
Pekka Enberg7b842b62005-09-06 15:18:34 -0700705 ep = kzalloc(sizeof *ep, mem_flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300706 if (!ep)
707 return -ENOMEM;
708 }
709
710 spin_lock_irqsave(&isp116x->lock, flags);
711 if (!HC_IS_RUNNING(hcd->state)) {
Olav Kongas959eea22005-11-03 17:38:14 +0200712 kfree(ep);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300713 ret = -ENODEV;
Alan Sterne9df41c2007-08-08 11:48:02 -0400714 goto fail_not_linked;
715 }
716 ret = usb_hcd_link_urb_to_ep(hcd, urb);
717 if (ret) {
718 kfree(ep);
719 goto fail_not_linked;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300720 }
721
722 if (hep->hcpriv)
723 ep = hep->hcpriv;
724 else {
725 INIT_LIST_HEAD(&ep->schedule);
Alan Stern6a8e87b2006-01-19 10:46:27 -0500726 ep->udev = udev;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300727 ep->epnum = epnum;
728 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
729 usb_settoggle(udev, epnum, is_out, 0);
730
731 if (type == PIPE_CONTROL) {
732 ep->nextpid = USB_PID_SETUP;
733 } else if (is_out) {
734 ep->nextpid = USB_PID_OUT;
735 } else {
736 ep->nextpid = USB_PID_IN;
737 }
738
739 if (urb->interval) {
740 /*
741 With INT URBs submitted, the driver works with SOF
742 interrupt enabled and ATL interrupt disabled. After
743 the PTDs are written to fifo ram, the chip starts
744 fifo processing and usb transfers after the next
745 SOF and continues until the transfers are finished
746 (succeeded or failed) or the frame ends. Therefore,
747 the transfers occur only in every second frame,
748 while fifo reading/writing and data processing
749 occur in every other second frame. */
750 if (urb->interval < 2)
751 urb->interval = 2;
752 if (urb->interval > 2 * PERIODIC_SIZE)
753 urb->interval = 2 * PERIODIC_SIZE;
754 ep->period = urb->interval >> 1;
755 ep->branch = PERIODIC_SIZE;
756 ep->load = usb_calc_bus_time(udev->speed,
757 !is_out,
758 (type == PIPE_ISOCHRONOUS),
759 usb_maxpacket(udev, pipe,
760 is_out)) /
761 1000;
762 }
763 hep->hcpriv = ep;
764 ep->hep = hep;
765 }
766
767 /* maybe put endpoint into schedule */
768 switch (type) {
769 case PIPE_CONTROL:
770 case PIPE_BULK:
771 if (list_empty(&ep->schedule))
772 list_add_tail(&ep->schedule, &isp116x->async);
773 break;
774 case PIPE_INTERRUPT:
775 urb->interval = ep->period;
Greg Kroah-Hartman16e2e5f2009-03-03 16:44:13 -0800776 ep->length = min_t(u32, ep->maxpacket,
Olav Kongas4808a1c2005-04-09 22:57:39 +0300777 urb->transfer_buffer_length);
778
779 /* urb submitted for already existing endpoint */
780 if (ep->branch < PERIODIC_SIZE)
781 break;
782
Eric Sesterhennd5ce1372006-06-01 20:48:45 -0700783 ep->branch = ret = balance(isp116x, ep->period, ep->load);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300784 if (ret < 0)
785 goto fail;
786 ret = 0;
787
788 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
789 + ep->branch;
790
791 /* sort each schedule branch by period (slow before fast)
792 to share the faster parts of the tree without needing
793 dummy/placeholder nodes */
794 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
795 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
796 struct isp116x_ep **prev = &isp116x->periodic[i];
797 struct isp116x_ep *here = *prev;
798
799 while (here && ep != here) {
800 if (ep->period > here->period)
801 break;
802 prev = &here->next;
803 here = *prev;
804 }
805 if (ep != here) {
806 ep->next = here;
807 *prev = ep;
808 }
809 isp116x->load[i] += ep->load;
810 }
811 hcd->self.bandwidth_allocated += ep->load / ep->period;
812
813 /* switch over to SOFint */
814 if (!isp116x->periodic_count++) {
815 isp116x->irqenb &= ~HCuPINT_ATL;
816 isp116x->irqenb |= HCuPINT_SOF;
817 isp116x_write_reg16(isp116x, HCuPINTENB,
818 isp116x->irqenb);
819 }
820 }
821
Olav Kongas4808a1c2005-04-09 22:57:39 +0300822 urb->hcpriv = hep;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300823 start_atl_transfers(isp116x);
824
825 fail:
Alan Sterne9df41c2007-08-08 11:48:02 -0400826 if (ret)
827 usb_hcd_unlink_urb_from_ep(hcd, urb);
828 fail_not_linked:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300829 spin_unlock_irqrestore(&isp116x->lock, flags);
830 return ret;
831}
832
833/*
834 Dequeue URBs.
835*/
Alan Sterne9df41c2007-08-08 11:48:02 -0400836static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
837 int status)
Olav Kongas4808a1c2005-04-09 22:57:39 +0300838{
839 struct isp116x *isp116x = hcd_to_isp116x(hcd);
840 struct usb_host_endpoint *hep;
841 struct isp116x_ep *ep, *ep_act;
842 unsigned long flags;
Alan Sterne9df41c2007-08-08 11:48:02 -0400843 int rc;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300844
845 spin_lock_irqsave(&isp116x->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -0400846 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
847 if (rc)
848 goto done;
849
Olav Kongas4808a1c2005-04-09 22:57:39 +0300850 hep = urb->hcpriv;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300851 ep = hep->hcpriv;
852 WARN_ON(hep != ep->hep);
853
854 /* In front of queue? */
855 if (ep->hep->urb_list.next == &urb->urb_list)
856 /* active? */
857 for (ep_act = isp116x->atl_active; ep_act;
858 ep_act = ep_act->active)
859 if (ep_act == ep) {
860 VDBG("dequeue, urb %p active; wait for irq\n",
861 urb);
862 urb = NULL;
863 break;
864 }
865
866 if (urb)
Alan Stern4a000272007-08-24 15:42:24 -0400867 finish_request(isp116x, ep, urb, status);
Alan Sterne9df41c2007-08-08 11:48:02 -0400868 done:
Olav Kongas4808a1c2005-04-09 22:57:39 +0300869 spin_unlock_irqrestore(&isp116x->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -0400870 return rc;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300871}
872
873static void isp116x_endpoint_disable(struct usb_hcd *hcd,
874 struct usb_host_endpoint *hep)
875{
876 int i;
Olav Kongas959eea22005-11-03 17:38:14 +0200877 struct isp116x_ep *ep = hep->hcpriv;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300878
879 if (!ep)
880 return;
881
882 /* assume we'd just wait for the irq */
883 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
884 msleep(3);
885 if (!list_empty(&hep->urb_list))
Arjan van de Venb6c63932008-07-25 01:45:52 -0700886 WARNING("ep %p not empty?\n", ep);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300887
Olav Kongas4808a1c2005-04-09 22:57:39 +0300888 kfree(ep);
889 hep->hcpriv = NULL;
890}
891
892static int isp116x_get_frame(struct usb_hcd *hcd)
893{
894 struct isp116x *isp116x = hcd_to_isp116x(hcd);
895 u32 fmnum;
896 unsigned long flags;
897
898 spin_lock_irqsave(&isp116x->lock, flags);
899 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
900 spin_unlock_irqrestore(&isp116x->lock, flags);
901 return (int)fmnum;
902}
903
Olav Kongas4808a1c2005-04-09 22:57:39 +0300904/*
905 Adapted from ohci-hub.c. Currently we don't support autosuspend.
906*/
907static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
908{
909 struct isp116x *isp116x = hcd_to_isp116x(hcd);
910 int ports, i, changed = 0;
Olav Kongas9a571162005-08-05 14:23:35 +0300911 unsigned long flags;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300912
913 if (!HC_IS_RUNNING(hcd->state))
914 return -ESHUTDOWN;
915
Olav Kongas9a571162005-08-05 14:23:35 +0300916 /* Report no status change now, if we are scheduled to be
917 called later */
918 if (timer_pending(&hcd->rh_timer))
919 return 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300920
Olav Kongas9a571162005-08-05 14:23:35 +0300921 ports = isp116x->rhdesca & RH_A_NDP;
922 spin_lock_irqsave(&isp116x->lock, flags);
923 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300924 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
925 buf[0] = changed = 1;
926 else
927 buf[0] = 0;
928
929 for (i = 0; i < ports; i++) {
Anti Sullin0ed930b2008-03-03 15:39:54 +0200930 u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300931
932 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
933 | RH_PS_OCIC | RH_PS_PRSC)) {
934 changed = 1;
935 buf[0] |= 1 << (i + 1);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300936 }
937 }
Olav Kongas9a571162005-08-05 14:23:35 +0300938 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +0300939 return changed;
940}
941
942static void isp116x_hub_descriptor(struct isp116x *isp116x,
943 struct usb_hub_descriptor *desc)
944{
945 u32 reg = isp116x->rhdesca;
946
947 desc->bDescriptorType = 0x29;
948 desc->bDescLength = 9;
949 desc->bHubContrCurrent = 0;
950 desc->bNbrPorts = (u8) (reg & 0x3);
951 /* Power switching, device type, overcurrent. */
Olav Kongas959eea22005-11-03 17:38:14 +0200952 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
Olav Kongas4808a1c2005-04-09 22:57:39 +0300953 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
954 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
Olav Kongas959eea22005-11-03 17:38:14 +0200955 desc->bitmap[0] = 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +0300956 desc->bitmap[1] = ~0;
957}
958
959/* Perform reset of a given port.
960 It would be great to just start the reset and let the
961 USB core to clear the reset in due time. However,
962 root hub ports should be reset for at least 50 ms, while
963 our chip stays in reset for about 10 ms. I.e., we must
964 repeatedly reset it ourself here.
965*/
966static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
967{
968 u32 tmp;
969 unsigned long flags, t;
970
971 /* Root hub reset should be 50 ms, but some devices
972 want it even longer. */
973 t = jiffies + msecs_to_jiffies(100);
974
975 while (time_before(jiffies, t)) {
976 spin_lock_irqsave(&isp116x->lock, flags);
977 /* spin until any current reset finishes */
978 for (;;) {
979 tmp = isp116x_read_reg32(isp116x, port ?
980 HCRHPORT2 : HCRHPORT1);
981 if (!(tmp & RH_PS_PRS))
982 break;
983 udelay(500);
984 }
985 /* Don't reset a disconnected port */
986 if (!(tmp & RH_PS_CCS)) {
987 spin_unlock_irqrestore(&isp116x->lock, flags);
988 break;
989 }
990 /* Reset lasts 10ms (claims datasheet) */
991 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
992 HCRHPORT1, (RH_PS_PRS));
993 spin_unlock_irqrestore(&isp116x->lock, flags);
994 msleep(10);
995 }
996}
997
998/* Adapted from ohci-hub.c */
999static int isp116x_hub_control(struct usb_hcd *hcd,
1000 u16 typeReq,
1001 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1002{
1003 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1004 int ret = 0;
1005 unsigned long flags;
1006 int ports = isp116x->rhdesca & RH_A_NDP;
1007 u32 tmp = 0;
1008
1009 switch (typeReq) {
1010 case ClearHubFeature:
1011 DBG("ClearHubFeature: ");
1012 switch (wValue) {
1013 case C_HUB_OVER_CURRENT:
1014 DBG("C_HUB_OVER_CURRENT\n");
1015 spin_lock_irqsave(&isp116x->lock, flags);
1016 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1017 spin_unlock_irqrestore(&isp116x->lock, flags);
1018 case C_HUB_LOCAL_POWER:
1019 DBG("C_HUB_LOCAL_POWER\n");
1020 break;
1021 default:
1022 goto error;
1023 }
1024 break;
1025 case SetHubFeature:
1026 DBG("SetHubFeature: ");
1027 switch (wValue) {
1028 case C_HUB_OVER_CURRENT:
1029 case C_HUB_LOCAL_POWER:
1030 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1031 break;
1032 default:
1033 goto error;
1034 }
1035 break;
1036 case GetHubDescriptor:
1037 DBG("GetHubDescriptor\n");
1038 isp116x_hub_descriptor(isp116x,
1039 (struct usb_hub_descriptor *)buf);
1040 break;
1041 case GetHubStatus:
1042 DBG("GetHubStatus\n");
Olav Kongas17f8bb72005-06-23 20:12:24 +03001043 *(__le32 *) buf = 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001044 break;
1045 case GetPortStatus:
1046 DBG("GetPortStatus\n");
1047 if (!wIndex || wIndex > ports)
1048 goto error;
Anti Sullin0ed930b2008-03-03 15:39:54 +02001049 spin_lock_irqsave(&isp116x->lock, flags);
1050 tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1051 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001052 *(__le32 *) buf = cpu_to_le32(tmp);
1053 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1054 break;
1055 case ClearPortFeature:
1056 DBG("ClearPortFeature: ");
1057 if (!wIndex || wIndex > ports)
1058 goto error;
1059 wIndex--;
1060
1061 switch (wValue) {
1062 case USB_PORT_FEAT_ENABLE:
1063 DBG("USB_PORT_FEAT_ENABLE\n");
1064 tmp = RH_PS_CCS;
1065 break;
1066 case USB_PORT_FEAT_C_ENABLE:
1067 DBG("USB_PORT_FEAT_C_ENABLE\n");
1068 tmp = RH_PS_PESC;
1069 break;
1070 case USB_PORT_FEAT_SUSPEND:
1071 DBG("USB_PORT_FEAT_SUSPEND\n");
1072 tmp = RH_PS_POCI;
1073 break;
1074 case USB_PORT_FEAT_C_SUSPEND:
1075 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1076 tmp = RH_PS_PSSC;
1077 break;
1078 case USB_PORT_FEAT_POWER:
1079 DBG("USB_PORT_FEAT_POWER\n");
1080 tmp = RH_PS_LSDA;
1081 break;
1082 case USB_PORT_FEAT_C_CONNECTION:
1083 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1084 tmp = RH_PS_CSC;
1085 break;
1086 case USB_PORT_FEAT_C_OVER_CURRENT:
1087 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1088 tmp = RH_PS_OCIC;
1089 break;
1090 case USB_PORT_FEAT_C_RESET:
1091 DBG("USB_PORT_FEAT_C_RESET\n");
1092 tmp = RH_PS_PRSC;
1093 break;
1094 default:
1095 goto error;
1096 }
1097 spin_lock_irqsave(&isp116x->lock, flags);
1098 isp116x_write_reg32(isp116x, wIndex
1099 ? HCRHPORT2 : HCRHPORT1, tmp);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001100 spin_unlock_irqrestore(&isp116x->lock, flags);
1101 break;
1102 case SetPortFeature:
1103 DBG("SetPortFeature: ");
1104 if (!wIndex || wIndex > ports)
1105 goto error;
1106 wIndex--;
1107 switch (wValue) {
1108 case USB_PORT_FEAT_SUSPEND:
1109 DBG("USB_PORT_FEAT_SUSPEND\n");
1110 spin_lock_irqsave(&isp116x->lock, flags);
1111 isp116x_write_reg32(isp116x, wIndex
1112 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
Anti Sullin0ed930b2008-03-03 15:39:54 +02001113 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001114 break;
1115 case USB_PORT_FEAT_POWER:
1116 DBG("USB_PORT_FEAT_POWER\n");
1117 spin_lock_irqsave(&isp116x->lock, flags);
1118 isp116x_write_reg32(isp116x, wIndex
1119 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
Anti Sullin0ed930b2008-03-03 15:39:54 +02001120 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001121 break;
1122 case USB_PORT_FEAT_RESET:
1123 DBG("USB_PORT_FEAT_RESET\n");
1124 root_port_reset(isp116x, wIndex);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001125 break;
1126 default:
1127 goto error;
1128 }
Olav Kongas4808a1c2005-04-09 22:57:39 +03001129 break;
1130
1131 default:
1132 error:
1133 /* "protocol stall" on error */
1134 DBG("PROTOCOL STALL\n");
1135 ret = -EPIPE;
1136 }
1137 return ret;
1138}
1139
Olav Kongas4808a1c2005-04-09 22:57:39 +03001140/*-----------------------------------------------------------------*/
1141
Olav Kongas959eea22005-11-03 17:38:14 +02001142#ifdef CONFIG_DEBUG_FS
Olav Kongas4808a1c2005-04-09 22:57:39 +03001143
1144static void dump_irq(struct seq_file *s, char *label, u16 mask)
1145{
1146 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1147 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1148 mask & HCuPINT_SUSP ? " susp" : "",
1149 mask & HCuPINT_OPR ? " opr" : "",
1150 mask & HCuPINT_AIIEOT ? " eot" : "",
1151 mask & HCuPINT_ATL ? " atl" : "",
1152 mask & HCuPINT_SOF ? " sof" : "");
1153}
1154
1155static void dump_int(struct seq_file *s, char *label, u32 mask)
1156{
1157 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1158 mask & HCINT_MIE ? " MIE" : "",
1159 mask & HCINT_RHSC ? " rhsc" : "",
1160 mask & HCINT_FNO ? " fno" : "",
1161 mask & HCINT_UE ? " ue" : "",
1162 mask & HCINT_RD ? " rd" : "",
1163 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1164}
1165
Olav Kongas959eea22005-11-03 17:38:14 +02001166static int isp116x_show_dbg(struct seq_file *s, void *unused)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001167{
1168 struct isp116x *isp116x = s->private;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001169
1170 seq_printf(s, "%s\n%s version %s\n",
1171 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1172 DRIVER_VERSION);
1173
1174 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1175 seq_printf(s, "HCD is suspended\n");
1176 return 0;
1177 }
1178 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1179 seq_printf(s, "HCD not running\n");
1180 return 0;
1181 }
1182
1183 spin_lock_irq(&isp116x->lock);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001184 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1185 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1186 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1187 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
Olav Kongas959eea22005-11-03 17:38:14 +02001188 isp116x_show_regs_seq(isp116x, s);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001189 spin_unlock_irq(&isp116x->lock);
1190 seq_printf(s, "\n");
1191
1192 return 0;
1193}
1194
Olav Kongas959eea22005-11-03 17:38:14 +02001195static int isp116x_open_seq(struct inode *inode, struct file *file)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001196{
Theodore Ts'o8e18e292006-09-27 01:50:46 -07001197 return single_open(file, isp116x_show_dbg, inode->i_private);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001198}
1199
Luiz Fernando N. Capitulino066202d2006-08-05 20:37:11 -03001200static const struct file_operations isp116x_debug_fops = {
Olav Kongas959eea22005-11-03 17:38:14 +02001201 .open = isp116x_open_seq,
Olav Kongas4808a1c2005-04-09 22:57:39 +03001202 .read = seq_read,
1203 .llseek = seq_lseek,
1204 .release = single_release,
1205};
1206
Olav Kongas959eea22005-11-03 17:38:14 +02001207static int create_debug_file(struct isp116x *isp116x)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001208{
Olav Kongas959eea22005-11-03 17:38:14 +02001209 isp116x->dentry = debugfs_create_file(hcd_name,
1210 S_IRUGO, NULL, isp116x,
1211 &isp116x_debug_fops);
1212 if (!isp116x->dentry)
1213 return -ENOMEM;
1214 return 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001215}
1216
1217static void remove_debug_file(struct isp116x *isp116x)
1218{
Olav Kongas959eea22005-11-03 17:38:14 +02001219 debugfs_remove(isp116x->dentry);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001220}
1221
Olav Kongas959eea22005-11-03 17:38:14 +02001222#else
1223
1224#define create_debug_file(d) 0
1225#define remove_debug_file(d) do{}while(0)
1226
1227#endif /* CONFIG_DEBUG_FS */
Olav Kongas4808a1c2005-04-09 22:57:39 +03001228
1229/*-----------------------------------------------------------------*/
1230
1231/*
1232 Software reset - can be called from any contect.
1233*/
1234static int isp116x_sw_reset(struct isp116x *isp116x)
1235{
1236 int retries = 15;
1237 unsigned long flags;
1238 int ret = 0;
1239
1240 spin_lock_irqsave(&isp116x->lock, flags);
1241 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1242 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1243 while (--retries) {
1244 /* It usually resets within 1 ms */
1245 mdelay(1);
1246 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1247 break;
1248 }
1249 if (!retries) {
1250 ERR("Software reset timeout\n");
1251 ret = -ETIME;
1252 }
1253 spin_unlock_irqrestore(&isp116x->lock, flags);
1254 return ret;
1255}
1256
Olav Kongas4808a1c2005-04-09 22:57:39 +03001257static int isp116x_reset(struct usb_hcd *hcd)
1258{
1259 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1260 unsigned long t;
1261 u16 clkrdy = 0;
Olav Kongas959eea22005-11-03 17:38:14 +02001262 int ret, timeout = 15 /* ms */ ;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001263
Olav Kongasf8d23d32005-08-04 17:02:54 +03001264 ret = isp116x_sw_reset(isp116x);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001265 if (ret)
1266 return ret;
1267
1268 t = jiffies + msecs_to_jiffies(timeout);
1269 while (time_before_eq(jiffies, t)) {
1270 msleep(4);
1271 spin_lock_irq(&isp116x->lock);
1272 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1273 spin_unlock_irq(&isp116x->lock);
1274 if (clkrdy)
1275 break;
1276 }
1277 if (!clkrdy) {
Olav Kongas959eea22005-11-03 17:38:14 +02001278 ERR("Clock not ready after %dms\n", timeout);
Olav Kongas589a0082005-04-21 17:12:59 +03001279 /* After sw_reset the clock won't report to be ready, if
1280 H_WAKEUP pin is high. */
Olav Kongasf8d23d32005-08-04 17:02:54 +03001281 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
Olav Kongas4808a1c2005-04-09 22:57:39 +03001282 ret = -ENODEV;
1283 }
1284 return ret;
1285}
1286
1287static void isp116x_stop(struct usb_hcd *hcd)
1288{
1289 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1290 unsigned long flags;
1291 u32 val;
1292
1293 spin_lock_irqsave(&isp116x->lock, flags);
1294 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1295
1296 /* Switch off ports' power, some devices don't come up
1297 after next 'insmod' without this */
1298 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1299 val &= ~(RH_A_NPS | RH_A_PSM);
1300 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1301 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1302 spin_unlock_irqrestore(&isp116x->lock, flags);
1303
Olav Kongasf8d23d32005-08-04 17:02:54 +03001304 isp116x_sw_reset(isp116x);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001305}
1306
1307/*
1308 Configure the chip. The chip must be successfully reset by now.
1309*/
1310static int isp116x_start(struct usb_hcd *hcd)
1311{
1312 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1313 struct isp116x_platform_data *board = isp116x->board;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001314 u32 val;
1315 unsigned long flags;
1316
1317 spin_lock_irqsave(&isp116x->lock, flags);
1318
1319 /* clear interrupt status and disable all interrupt sources */
1320 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1321 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1322
1323 val = isp116x_read_reg16(isp116x, HCCHIPID);
1324 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1325 ERR("Invalid chip ID %04x\n", val);
1326 spin_unlock_irqrestore(&isp116x->lock, flags);
1327 return -ENODEV;
1328 }
1329
Olav Kongas9a571162005-08-05 14:23:35 +03001330 /* To be removed in future */
1331 hcd->uses_new_polling = 1;
1332
Olav Kongas4808a1c2005-04-09 22:57:39 +03001333 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1334 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1335
1336 /* ----- HW conf */
1337 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1338 if (board->sel15Kres)
1339 val |= HCHWCFG_15KRSEL;
1340 /* Remote wakeup won't work without working clock */
Olav Kongasd4d62862005-08-04 16:48:19 +03001341 if (board->remote_wakeup_enable)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001342 val |= HCHWCFG_CLKNOTSTOP;
1343 if (board->oc_enable)
1344 val |= HCHWCFG_ANALOG_OC;
1345 if (board->int_act_high)
1346 val |= HCHWCFG_INT_POL;
1347 if (board->int_edge_triggered)
1348 val |= HCHWCFG_INT_TRIGGER;
1349 isp116x_write_reg16(isp116x, HCHWCFG, val);
1350
1351 /* ----- Root hub conf */
Olav Kongasdc5bed02005-08-04 16:46:28 +03001352 val = (25 << 24) & RH_A_POTPGT;
Olav Kongas165c0f32005-08-04 16:52:31 +03001353 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1354 be always set. Yet, instead, we request individual port
1355 power switching. */
1356 val |= RH_A_PSM;
Olav Kongas9d233d92005-08-04 16:54:08 +03001357 /* Report overcurrent per port */
1358 val |= RH_A_OCPM;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001359 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1360 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1361
1362 val = RH_B_PPCM;
1363 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1364 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1365
1366 val = 0;
1367 if (board->remote_wakeup_enable) {
David Brownell704aa0b2005-11-07 15:38:24 -08001368 if (!device_can_wakeup(hcd->self.controller))
1369 device_init_wakeup(hcd->self.controller, 1);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001370 val |= RH_HS_DRWE;
1371 }
1372 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1373 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1374
1375 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001376
Olav Kongas4808a1c2005-04-09 22:57:39 +03001377 hcd->state = HC_STATE_RUNNING;
1378
Olav Kongas4808a1c2005-04-09 22:57:39 +03001379 /* Set up interrupts */
1380 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1381 if (board->remote_wakeup_enable)
1382 isp116x->intenb |= HCINT_RD;
1383 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1384 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1385 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1386
1387 /* Go operational */
1388 val = HCCONTROL_USB_OPER;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001389 if (board->remote_wakeup_enable)
1390 val |= HCCONTROL_RWE;
1391 isp116x_write_reg32(isp116x, HCCONTROL, val);
1392
1393 /* Disable ports to avoid race in device enumeration */
1394 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1395 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1396
Olav Kongas959eea22005-11-03 17:38:14 +02001397 isp116x_show_regs_log(isp116x);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001398 spin_unlock_irqrestore(&isp116x->lock, flags);
1399 return 0;
1400}
1401
Olav Kongas959eea22005-11-03 17:38:14 +02001402#ifdef CONFIG_PM
1403
1404static int isp116x_bus_suspend(struct usb_hcd *hcd)
1405{
1406 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1407 unsigned long flags;
1408 u32 val;
1409 int ret = 0;
1410
1411 spin_lock_irqsave(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001412 val = isp116x_read_reg32(isp116x, HCCONTROL);
Olav Kongas0be930c2005-12-27 16:04:02 +02001413
Olav Kongas959eea22005-11-03 17:38:14 +02001414 switch (val & HCCONTROL_HCFS) {
1415 case HCCONTROL_USB_OPER:
Olav Kongas0be930c2005-12-27 16:04:02 +02001416 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001417 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1418 val |= HCCONTROL_USB_SUSPEND;
Alan Stern58a97ff2008-04-14 12:17:10 -04001419 if (hcd->self.root_hub->do_remote_wakeup)
Olav Kongas959eea22005-11-03 17:38:14 +02001420 val |= HCCONTROL_RWE;
1421 /* Wait for usb transfers to finish */
Olav Kongas0be930c2005-12-27 16:04:02 +02001422 msleep(2);
1423 spin_lock_irqsave(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001424 isp116x_write_reg32(isp116x, HCCONTROL, val);
Olav Kongas0be930c2005-12-27 16:04:02 +02001425 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001426 /* Wait for devices to suspend */
Olav Kongas0be930c2005-12-27 16:04:02 +02001427 msleep(5);
Olav Kongas959eea22005-11-03 17:38:14 +02001428 break;
1429 case HCCONTROL_USB_RESUME:
1430 isp116x_write_reg32(isp116x, HCCONTROL,
1431 (val & ~HCCONTROL_HCFS) |
1432 HCCONTROL_USB_RESET);
1433 case HCCONTROL_USB_RESET:
1434 ret = -EBUSY;
Olav Kongas0be930c2005-12-27 16:04:02 +02001435 default: /* HCCONTROL_USB_SUSPEND */
1436 spin_unlock_irqrestore(&isp116x->lock, flags);
Olav Kongas959eea22005-11-03 17:38:14 +02001437 break;
Olav Kongas959eea22005-11-03 17:38:14 +02001438 }
1439
Olav Kongas959eea22005-11-03 17:38:14 +02001440 return ret;
1441}
1442
1443static int isp116x_bus_resume(struct usb_hcd *hcd)
1444{
1445 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1446 u32 val;
1447
1448 msleep(5);
1449 spin_lock_irq(&isp116x->lock);
1450
1451 val = isp116x_read_reg32(isp116x, HCCONTROL);
1452 switch (val & HCCONTROL_HCFS) {
1453 case HCCONTROL_USB_SUSPEND:
1454 val &= ~HCCONTROL_HCFS;
1455 val |= HCCONTROL_USB_RESUME;
1456 isp116x_write_reg32(isp116x, HCCONTROL, val);
1457 case HCCONTROL_USB_RESUME:
1458 break;
1459 case HCCONTROL_USB_OPER:
1460 spin_unlock_irq(&isp116x->lock);
Olav Kongas959eea22005-11-03 17:38:14 +02001461 return 0;
1462 default:
1463 /* HCCONTROL_USB_RESET: this may happen, when during
1464 suspension the HC lost power. Reinitialize completely */
1465 spin_unlock_irq(&isp116x->lock);
1466 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1467 isp116x_reset(hcd);
1468 isp116x_start(hcd);
1469 isp116x_hub_control(hcd, SetPortFeature,
1470 USB_PORT_FEAT_POWER, 1, NULL, 0);
1471 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1472 isp116x_hub_control(hcd, SetPortFeature,
1473 USB_PORT_FEAT_POWER, 2, NULL, 0);
Olav Kongas959eea22005-11-03 17:38:14 +02001474 return 0;
1475 }
1476
1477 val = isp116x->rhdesca & RH_A_NDP;
1478 while (val--) {
1479 u32 stat =
1480 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1481 /* force global, not selective, resume */
1482 if (!(stat & RH_PS_PSS))
1483 continue;
1484 DBG("%s: Resuming port %d\n", __func__, val);
1485 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1486 ? HCRHPORT2 : HCRHPORT1);
1487 }
1488 spin_unlock_irq(&isp116x->lock);
1489
1490 hcd->state = HC_STATE_RESUMING;
1491 msleep(20);
1492
1493 /* Go operational */
1494 spin_lock_irq(&isp116x->lock);
1495 val = isp116x_read_reg32(isp116x, HCCONTROL);
1496 isp116x_write_reg32(isp116x, HCCONTROL,
1497 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1498 spin_unlock_irq(&isp116x->lock);
Olav Kongas959eea22005-11-03 17:38:14 +02001499 hcd->state = HC_STATE_RUNNING;
1500
1501 return 0;
1502}
1503
1504#else
1505
1506#define isp116x_bus_suspend NULL
1507#define isp116x_bus_resume NULL
1508
1509#endif
Olav Kongas4808a1c2005-04-09 22:57:39 +03001510
1511static struct hc_driver isp116x_hc_driver = {
1512 .description = hcd_name,
1513 .product_desc = "ISP116x Host Controller",
1514 .hcd_priv_size = sizeof(struct isp116x),
1515
1516 .irq = isp116x_irq,
1517 .flags = HCD_USB11,
1518
1519 .reset = isp116x_reset,
1520 .start = isp116x_start,
1521 .stop = isp116x_stop,
1522
1523 .urb_enqueue = isp116x_urb_enqueue,
1524 .urb_dequeue = isp116x_urb_dequeue,
1525 .endpoint_disable = isp116x_endpoint_disable,
1526
1527 .get_frame_number = isp116x_get_frame,
1528
1529 .hub_status_data = isp116x_hub_status_data,
1530 .hub_control = isp116x_hub_control,
Alan Stern0c0382e2005-10-13 17:08:02 -04001531 .bus_suspend = isp116x_bus_suspend,
1532 .bus_resume = isp116x_bus_resume,
Olav Kongas4808a1c2005-04-09 22:57:39 +03001533};
1534
1535/*----------------------------------------------------------------*/
1536
Greg Kroah-Hartmanb7125482006-03-17 17:40:08 -08001537static int isp116x_remove(struct platform_device *pdev)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001538{
Russell King3ae5eae2005-11-09 22:32:44 +00001539 struct usb_hcd *hcd = platform_get_drvdata(pdev);
Olav Kongas589a0082005-04-21 17:12:59 +03001540 struct isp116x *isp116x;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001541 struct resource *res;
1542
Olav Kongas9a571162005-08-05 14:23:35 +03001543 if (!hcd)
Olav Kongas589a0082005-04-21 17:12:59 +03001544 return 0;
1545 isp116x = hcd_to_isp116x(hcd);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001546 remove_debug_file(isp116x);
1547 usb_remove_hcd(hcd);
1548
1549 iounmap(isp116x->data_reg);
1550 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1551 release_mem_region(res->start, 2);
1552 iounmap(isp116x->addr_reg);
1553 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1554 release_mem_region(res->start, 2);
1555
1556 usb_put_hcd(hcd);
1557 return 0;
1558}
1559
1560#define resource_len(r) (((r)->end - (r)->start) + 1)
1561
Prarit Bhargava5bcd70e2007-02-09 01:51:15 -08001562static int __devinit isp116x_probe(struct platform_device *pdev)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001563{
1564 struct usb_hcd *hcd;
1565 struct isp116x *isp116x;
Marc Zyngier27140212008-08-18 13:08:42 +02001566 struct resource *addr, *data, *ires;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001567 void __iomem *addr_reg;
1568 void __iomem *data_reg;
1569 int irq;
1570 int ret = 0;
Marc Zyngier27140212008-08-18 13:08:42 +02001571 unsigned long irqflags;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001572
Olav Kongas4808a1c2005-04-09 22:57:39 +03001573 if (pdev->num_resources < 3) {
1574 ret = -ENODEV;
1575 goto err1;
1576 }
1577
1578 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1579 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
Marc Zyngier27140212008-08-18 13:08:42 +02001580 ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1581
1582 if (!addr || !data || !ires) {
Olav Kongas4808a1c2005-04-09 22:57:39 +03001583 ret = -ENODEV;
1584 goto err1;
1585 }
1586
Marc Zyngier27140212008-08-18 13:08:42 +02001587 irq = ires->start;
1588 irqflags = ires->flags & IRQF_TRIGGER_MASK;
1589
Russell King3ae5eae2005-11-09 22:32:44 +00001590 if (pdev->dev.dma_mask) {
Olav Kongas4808a1c2005-04-09 22:57:39 +03001591 DBG("DMA not supported\n");
1592 ret = -EINVAL;
1593 goto err1;
1594 }
1595
1596 if (!request_mem_region(addr->start, 2, hcd_name)) {
1597 ret = -EBUSY;
1598 goto err1;
1599 }
1600 addr_reg = ioremap(addr->start, resource_len(addr));
1601 if (addr_reg == NULL) {
1602 ret = -ENOMEM;
1603 goto err2;
1604 }
1605 if (!request_mem_region(data->start, 2, hcd_name)) {
1606 ret = -EBUSY;
1607 goto err3;
1608 }
1609 data_reg = ioremap(data->start, resource_len(data));
1610 if (data_reg == NULL) {
1611 ret = -ENOMEM;
1612 goto err4;
1613 }
1614
1615 /* allocate and initialize hcd */
Kay Sievers7071a3c2008-05-02 06:02:41 +02001616 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
Olav Kongas4808a1c2005-04-09 22:57:39 +03001617 if (!hcd) {
1618 ret = -ENOMEM;
1619 goto err5;
1620 }
1621 /* this rsrc_start is bogus */
1622 hcd->rsrc_start = addr->start;
1623 isp116x = hcd_to_isp116x(hcd);
1624 isp116x->data_reg = data_reg;
1625 isp116x->addr_reg = addr_reg;
1626 spin_lock_init(&isp116x->lock);
1627 INIT_LIST_HEAD(&isp116x->async);
Russell King3ae5eae2005-11-09 22:32:44 +00001628 isp116x->board = pdev->dev.platform_data;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001629
1630 if (!isp116x->board) {
1631 ERR("Platform data structure not initialized\n");
1632 ret = -ENODEV;
1633 goto err6;
1634 }
1635 if (isp116x_check_platform_delay(isp116x)) {
1636 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1637 "implemented.\n");
1638 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1639 ret = -ENODEV;
1640 goto err6;
1641 }
1642
Marc Zyngier27140212008-08-18 13:08:42 +02001643 ret = usb_add_hcd(hcd, irq, irqflags | IRQF_DISABLED);
Olav Kongas959eea22005-11-03 17:38:14 +02001644 if (ret)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001645 goto err6;
1646
Olav Kongas959eea22005-11-03 17:38:14 +02001647 ret = create_debug_file(isp116x);
1648 if (ret) {
1649 ERR("Couldn't create debugfs entry\n");
1650 goto err7;
1651 }
1652
Olav Kongas4808a1c2005-04-09 22:57:39 +03001653 return 0;
1654
Olav Kongas959eea22005-11-03 17:38:14 +02001655 err7:
1656 usb_remove_hcd(hcd);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001657 err6:
1658 usb_put_hcd(hcd);
1659 err5:
1660 iounmap(data_reg);
1661 err4:
1662 release_mem_region(data->start, 2);
1663 err3:
1664 iounmap(addr_reg);
1665 err2:
1666 release_mem_region(addr->start, 2);
1667 err1:
1668 ERR("init error, %d\n", ret);
1669 return ret;
1670}
1671
1672#ifdef CONFIG_PM
1673/*
1674 Suspend of platform device
1675*/
Russell King3ae5eae2005-11-09 22:32:44 +00001676static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001677{
Olav Kongas959eea22005-11-03 17:38:14 +02001678 VDBG("%s: state %x\n", __func__, state.event);
Olav Kongas959eea22005-11-03 17:38:14 +02001679 return 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001680}
1681
1682/*
1683 Resume platform device
1684*/
Russell King3ae5eae2005-11-09 22:32:44 +00001685static int isp116x_resume(struct platform_device *dev)
Olav Kongas4808a1c2005-04-09 22:57:39 +03001686{
Alan Stern70a1c9e2008-03-06 17:00:58 -05001687 VDBG("%s\n", __func__);
Olav Kongas959eea22005-11-03 17:38:14 +02001688 return 0;
Olav Kongas4808a1c2005-04-09 22:57:39 +03001689}
1690
1691#else
1692
1693#define isp116x_suspend NULL
1694#define isp116x_resume NULL
1695
1696#endif
1697
Kay Sieversf4fce612008-04-10 21:29:22 -07001698/* work with hotplug and coldplug */
1699MODULE_ALIAS("platform:isp116x-hcd");
1700
Russell King3ae5eae2005-11-09 22:32:44 +00001701static struct platform_driver isp116x_driver = {
Olav Kongas4808a1c2005-04-09 22:57:39 +03001702 .probe = isp116x_probe,
1703 .remove = isp116x_remove,
1704 .suspend = isp116x_suspend,
1705 .resume = isp116x_resume,
Olav Kongas0be930c2005-12-27 16:04:02 +02001706 .driver = {
Kay Sieversf4fce612008-04-10 21:29:22 -07001707 .name = (char *)hcd_name,
1708 .owner = THIS_MODULE,
1709 },
Olav Kongas4808a1c2005-04-09 22:57:39 +03001710};
1711
1712/*-----------------------------------------------------------------*/
1713
1714static int __init isp116x_init(void)
1715{
1716 if (usb_disabled())
1717 return -ENODEV;
1718
1719 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
Russell King3ae5eae2005-11-09 22:32:44 +00001720 return platform_driver_register(&isp116x_driver);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001721}
1722
1723module_init(isp116x_init);
1724
1725static void __exit isp116x_cleanup(void)
1726{
Russell King3ae5eae2005-11-09 22:32:44 +00001727 platform_driver_unregister(&isp116x_driver);
Olav Kongas4808a1c2005-04-09 22:57:39 +03001728}
1729
1730module_exit(isp116x_cleanup);