2 * ISP116x HCD (Host Controller Driver) for USB.
4 * Derived from the SL811 HCD, rewritten for ISP116x.
5 * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
8 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
9 * Copyright (C) 2004 David Brownell
11 * Periodic scheduling is based on Roman's OHCI code
12 * Copyright (C) 1999 Roman Weissgaerber
17 * The driver basically works. A number of people have used it with a range
20 * The driver passes all usbtests 1-14.
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.
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.
31 + More testing of suspend/resume.
35 ISP116x chips require certain delays between accesses to its
36 registers. The following timing options exist.
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.
48 #define USE_PLATFORM_DELAY
53 /* Transfer descriptors. See dump_ptd() for printout format */
55 /* enqueuing/finishing log of urbs */
58 #include <linux/module.h>
59 #include <linux/delay.h>
60 #include <linux/debugfs.h>
61 #include <linux/seq_file.h>
62 #include <linux/errno.h>
63 #include <linux/init.h>
64 #include <linux/list.h>
65 #include <linux/usb.h>
66 #include <linux/usb/isp116x.h>
67 #include <linux/platform_device.h>
71 #include <asm/system.h>
72 #include <asm/byteorder.h>
74 #include "../core/hcd.h"
77 #define DRIVER_VERSION "03 Nov 2005"
78 #define DRIVER_DESC "ISP116x USB Host Controller Driver"
80 MODULE_DESCRIPTION(DRIVER_DESC);
81 MODULE_LICENSE("GPL");
83 static const char hcd_name[] = "isp116x-hcd";
85 /*-----------------------------------------------------------------*/
88 Write len bytes to fifo, pad till 32-bit boundary
90 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
93 u16 *dp2 = (u16 *) buf;
97 if ((unsigned long)dp2 & 1) {
99 for (; len > 1; len -= 2) {
102 isp116x_raw_write_data16(isp116x, w);
105 isp116x_write_data16(isp116x, (u16) * dp);
108 for (; len > 1; len -= 2)
109 isp116x_raw_write_data16(isp116x, *dp2++);
111 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
113 if (quot == 1 || quot == 2)
114 isp116x_raw_write_data16(isp116x, 0);
118 Read len bytes from fifo and then read till 32-bit boundary.
120 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
123 u16 *dp2 = (u16 *) buf;
127 if ((unsigned long)dp2 & 1) {
129 for (; len > 1; len -= 2) {
130 w = isp116x_raw_read_data16(isp116x);
132 *dp++ = (w >> 8) & 0xff;
135 *dp = 0xff & isp116x_read_data16(isp116x);
138 for (; len > 1; len -= 2)
139 *dp2++ = isp116x_raw_read_data16(isp116x);
141 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
143 if (quot == 1 || quot == 2)
144 isp116x_raw_read_data16(isp116x);
148 Write ptd's and data for scheduled transfers into
149 the fifo ram. Fifo must be empty and ready.
151 static void pack_fifo(struct isp116x *isp116x)
153 struct isp116x_ep *ep;
155 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
156 ? isp116x->atl_bufshrt : isp116x->atl_buflen;
158 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
159 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
160 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
161 for (ep = isp116x->atl_active; ep; ep = ep->active) {
164 dump_ptd_out_data(ptd, ep->data);
165 isp116x_write_data16(isp116x, ptd->count);
166 isp116x_write_data16(isp116x, ptd->mps);
167 isp116x_write_data16(isp116x, ptd->len);
168 isp116x_write_data16(isp116x, ptd->faddr);
169 buflen -= sizeof(struct ptd);
170 /* Skip writing data for last IN PTD */
171 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
172 write_ptddata_to_fifo(isp116x, ep->data, ep->length);
173 buflen -= ALIGN(ep->length, 4);
180 Read the processed ptd's and data from fifo ram back to
181 URBs' buffers. Fifo must be full and done
183 static void unpack_fifo(struct isp116x *isp116x)
185 struct isp116x_ep *ep;
187 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
188 ? isp116x->atl_buflen : isp116x->atl_bufshrt;
190 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
191 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
192 isp116x_write_addr(isp116x, HCATLPORT);
193 for (ep = isp116x->atl_active; ep; ep = ep->active) {
195 ptd->count = isp116x_read_data16(isp116x);
196 ptd->mps = isp116x_read_data16(isp116x);
197 ptd->len = isp116x_read_data16(isp116x);
198 ptd->faddr = isp116x_read_data16(isp116x);
199 buflen -= sizeof(struct ptd);
200 /* Skip reading data for last Setup or Out PTD */
201 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
202 read_ptddata_from_fifo(isp116x, ep->data, ep->length);
203 buflen -= ALIGN(ep->length, 4);
206 dump_ptd_in_data(ptd, ep->data);
211 /*---------------------------------------------------------------*/
216 static void preproc_atl_queue(struct isp116x *isp116x)
218 struct isp116x_ep *ep;
223 for (ep = isp116x->atl_active; ep; ep = ep->active) {
224 u16 toggle = 0, dir = PTD_DIR_SETUP;
226 BUG_ON(list_empty(&ep->hep->urb_list));
227 urb = container_of(ep->hep->urb_list.next,
228 struct urb, urb_list);
231 ep->data = (unsigned char *)urb->transfer_buffer
232 + urb->actual_length;
234 switch (ep->nextpid) {
236 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
240 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
244 len = sizeof(struct usb_ctrlrequest);
245 ep->data = urb->setup_packet;
250 dir = (urb->transfer_buffer_length
251 && usb_pipein(urb->pipe))
252 ? PTD_DIR_OUT : PTD_DIR_IN;
255 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
260 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
261 ptd->mps = PTD_MPS(ep->maxpacket)
262 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
264 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
265 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
267 ptd->mps |= PTD_LAST_MSK;
268 isp116x->atl_last_dir = dir;
270 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
271 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
276 Take done or failed requests out of schedule. Give back
279 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
281 __releases(isp116x->lock) __acquires(isp116x->lock)
288 if (usb_pipecontrol(urb->pipe))
289 ep->nextpid = USB_PID_SETUP;
291 urb_dbg(urb, "Finish");
293 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
294 spin_unlock(&isp116x->lock);
295 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb);
296 spin_lock(&isp116x->lock);
298 /* take idle endpoints out of the schedule */
299 if (!list_empty(&ep->hep->urb_list))
302 /* async deschedule */
303 if (!list_empty(&ep->schedule)) {
304 list_del_init(&ep->schedule);
308 /* periodic deschedule */
309 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
310 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
311 struct isp116x_ep *temp;
312 struct isp116x_ep **prev = &isp116x->periodic[i];
314 while (*prev && ((temp = *prev) != ep))
318 isp116x->load[i] -= ep->load;
320 ep->branch = PERIODIC_SIZE;
321 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
322 ep->load / ep->period;
324 /* switch irq type? */
325 if (!--isp116x->periodic_count) {
326 isp116x->irqenb &= ~HCuPINT_SOF;
327 isp116x->irqenb |= HCuPINT_ATL;
332 Analyze transfer results, handle partial transfers and errors
334 static void postproc_atl_queue(struct isp116x *isp116x)
336 struct isp116x_ep *ep;
338 struct usb_device *udev;
344 for (ep = isp116x->atl_active; ep; ep = ep->active) {
345 BUG_ON(list_empty(&ep->hep->urb_list));
347 container_of(ep->hep->urb_list.next, struct urb, urb_list);
350 cc = PTD_GET_CC(ptd);
352 status = -EINPROGRESS;
354 /* Data underrun is special. For allowed underrun
355 we clear the error and continue as normal. For
356 forbidden underrun we finish the DATA stage
357 immediately while for control transfer,
358 we do a STATUS stage. */
359 if (cc == TD_DATAUNDERRUN) {
360 if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
361 usb_pipecontrol(urb->pipe)) {
362 DBG("Allowed or control data underrun\n");
367 usb_settoggle(udev, ep->epnum,
368 ep->nextpid == USB_PID_OUT,
369 PTD_GET_TOGGLE(ptd));
370 urb->actual_length += PTD_GET_COUNT(ptd);
371 status = cc_to_error[TD_DATAUNDERRUN];
376 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
377 && (++ep->error_count >= 3 || cc == TD_CC_STALL
378 || cc == TD_DATAOVERRUN)) {
379 status = cc_to_error[cc];
380 if (ep->nextpid == USB_PID_ACK)
384 /* According to usb spec, zero-length Int transfer signals
385 finishing of the urb. Hey, does this apply only
387 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
392 /* Relax after previously failed, but later succeeded
393 or correctly NAK'ed retransmission attempt */
395 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
398 /* Take into account idiosyncracies of the isp116x chip
399 regarding toggle bit for failed transfers */
400 if (ep->nextpid == USB_PID_OUT)
401 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
402 ^ (ep->error_count > 0));
403 else if (ep->nextpid == USB_PID_IN)
404 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
405 ^ (ep->error_count > 0));
407 switch (ep->nextpid) {
410 urb->actual_length += PTD_GET_COUNT(ptd);
411 if (PTD_GET_ACTIVE(ptd)
412 || (cc != TD_CC_NOERROR && cc < 0x0E))
414 if (urb->transfer_buffer_length != urb->actual_length) {
418 if (urb->transfer_flags & URB_ZERO_PACKET
419 && ep->nextpid == USB_PID_OUT
420 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
421 DBG("Zero packet requested\n");
425 /* All data for this URB is transferred, let's finish */
426 if (usb_pipecontrol(urb->pipe))
427 ep->nextpid = USB_PID_ACK;
432 if (PTD_GET_ACTIVE(ptd)
433 || (cc != TD_CC_NOERROR && cc < 0x0E))
435 if (urb->transfer_buffer_length == urb->actual_length)
436 ep->nextpid = USB_PID_ACK;
437 else if (usb_pipeout(urb->pipe)) {
438 usb_settoggle(udev, 0, 1, 1);
439 ep->nextpid = USB_PID_OUT;
441 usb_settoggle(udev, 0, 0, 1);
442 ep->nextpid = USB_PID_IN;
446 if (PTD_GET_ACTIVE(ptd)
447 || (cc != TD_CC_NOERROR && cc < 0x0E))
449 if ((urb->transfer_flags & URB_SHORT_NOT_OK) &&
451 urb->transfer_buffer_length)
462 if (status != -EINPROGRESS) {
463 spin_lock(&urb->lock);
464 if (urb->status == -EINPROGRESS)
465 urb->status = status;
466 spin_unlock(&urb->lock);
468 if (urb->status != -EINPROGRESS)
469 finish_request(isp116x, ep, urb);
474 Scan transfer lists, schedule transfers, send data off
477 static void start_atl_transfers(struct isp116x *isp116x)
479 struct isp116x_ep *last_ep = NULL, *ep;
482 int len, index, speed, byte_time;
484 if (atomic_read(&isp116x->atl_finishing))
487 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
490 /* FIFO not empty? */
491 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
494 isp116x->atl_active = NULL;
495 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
497 /* Schedule int transfers */
498 if (isp116x->periodic_count) {
499 isp116x->fmindex = index =
500 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
501 if ((load = isp116x->load[index])) {
502 /* Bring all int transfers for this frame
503 into the active queue */
504 isp116x->atl_active = last_ep =
505 isp116x->periodic[index];
506 while (last_ep->next)
507 last_ep = (last_ep->active = last_ep->next);
508 last_ep->active = NULL;
512 /* Schedule control/bulk transfers */
513 list_for_each_entry(ep, &isp116x->async, schedule) {
514 urb = container_of(ep->hep->urb_list.next,
515 struct urb, urb_list);
516 speed = urb->dev->speed;
517 byte_time = speed == USB_SPEED_LOW
518 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
520 if (ep->nextpid == USB_PID_SETUP) {
521 len = sizeof(struct usb_ctrlrequest);
522 } else if (ep->nextpid == USB_PID_ACK) {
525 /* Find current free length ... */
526 len = (MAX_LOAD_LIMIT - load) / byte_time;
528 /* ... then limit it to configured max size ... */
529 len = min(len, speed == USB_SPEED_LOW ?
530 MAX_TRANSFER_SIZE_LOWSPEED :
531 MAX_TRANSFER_SIZE_FULLSPEED);
533 /* ... and finally cut to the multiple of MaxPacketSize,
534 or to the real length if there's enough room. */
536 (urb->transfer_buffer_length -
537 urb->actual_length)) {
538 len -= len % ep->maxpacket;
542 len = urb->transfer_buffer_length -
547 load += len * byte_time;
548 if (load > MAX_LOAD_LIMIT)
554 last_ep->active = ep;
556 isp116x->atl_active = ep;
560 /* Avoid starving of endpoints */
561 if ((&isp116x->async)->next != (&isp116x->async)->prev)
562 list_move(&isp116x->async, (&isp116x->async)->next);
564 if (isp116x->atl_active) {
565 preproc_atl_queue(isp116x);
571 Finish the processed transfers
573 static void finish_atl_transfers(struct isp116x *isp116x)
575 if (!isp116x->atl_active)
577 /* Fifo not ready? */
578 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
581 atomic_inc(&isp116x->atl_finishing);
582 unpack_fifo(isp116x);
583 postproc_atl_queue(isp116x);
584 atomic_dec(&isp116x->atl_finishing);
587 static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
589 struct isp116x *isp116x = hcd_to_isp116x(hcd);
591 irqreturn_t ret = IRQ_NONE;
593 spin_lock(&isp116x->lock);
594 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
595 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
596 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
598 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
600 finish_atl_transfers(isp116x);
603 if (irqstat & HCuPINT_OPR) {
604 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
605 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
606 if (intstat & HCINT_UE) {
607 ERR("Unrecoverable error, HC is dead!\n");
608 /* IRQ's are off, we do no DMA,
609 perfectly ready to die ... */
610 hcd->state = HC_STATE_HALT;
614 if (intstat & HCINT_RHSC)
615 /* When root hub or any of its ports is going
616 to come out of suspend, it may take more
617 than 10ms for status bits to stabilize. */
618 mod_timer(&hcd->rh_timer, jiffies
619 + msecs_to_jiffies(20) + 1);
620 if (intstat & HCINT_RD) {
621 DBG("---- remote wakeup\n");
622 usb_hcd_resume_root_hub(hcd);
624 irqstat &= ~HCuPINT_OPR;
628 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
629 start_atl_transfers(isp116x);
632 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
634 spin_unlock(&isp116x->lock);
638 /*-----------------------------------------------------------------*/
640 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
641 * this driver doesn't promise that much since it's got to handle an
642 * IRQ per packet; irq handling latencies also use up that time.
646 #define MAX_PERIODIC_LOAD 600
647 static int balance(struct isp116x *isp116x, u16 period, u16 load)
649 int i, branch = -ENOSPC;
651 /* search for the least loaded schedule branch of that period
652 which has enough bandwidth left unreserved. */
653 for (i = 0; i < period; i++) {
654 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
657 for (j = i; j < PERIODIC_SIZE; j += period) {
658 if ((isp116x->load[j] + load)
662 if (j < PERIODIC_SIZE)
670 /* NB! ALL the code above this point runs with isp116x->lock
674 /*-----------------------------------------------------------------*/
676 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
680 struct isp116x *isp116x = hcd_to_isp116x(hcd);
681 struct usb_device *udev = urb->dev;
682 unsigned int pipe = urb->pipe;
683 int is_out = !usb_pipein(pipe);
684 int type = usb_pipetype(pipe);
685 int epnum = usb_pipeendpoint(pipe);
686 struct usb_host_endpoint *hep = urb->ep;
687 struct isp116x_ep *ep = NULL;
692 urb_dbg(urb, "Enqueue");
694 if (type == PIPE_ISOCHRONOUS) {
695 ERR("Isochronous transfers not supported\n");
696 urb_dbg(urb, "Refused to enqueue");
699 /* avoid all allocations within spinlocks: request or endpoint */
701 ep = kzalloc(sizeof *ep, mem_flags);
706 spin_lock_irqsave(&isp116x->lock, flags);
707 if (!HC_IS_RUNNING(hcd->state)) {
710 goto fail_not_linked;
712 ret = usb_hcd_link_urb_to_ep(hcd, urb);
715 goto fail_not_linked;
721 INIT_LIST_HEAD(&ep->schedule);
724 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
725 usb_settoggle(udev, epnum, is_out, 0);
727 if (type == PIPE_CONTROL) {
728 ep->nextpid = USB_PID_SETUP;
730 ep->nextpid = USB_PID_OUT;
732 ep->nextpid = USB_PID_IN;
737 With INT URBs submitted, the driver works with SOF
738 interrupt enabled and ATL interrupt disabled. After
739 the PTDs are written to fifo ram, the chip starts
740 fifo processing and usb transfers after the next
741 SOF and continues until the transfers are finished
742 (succeeded or failed) or the frame ends. Therefore,
743 the transfers occur only in every second frame,
744 while fifo reading/writing and data processing
745 occur in every other second frame. */
746 if (urb->interval < 2)
748 if (urb->interval > 2 * PERIODIC_SIZE)
749 urb->interval = 2 * PERIODIC_SIZE;
750 ep->period = urb->interval >> 1;
751 ep->branch = PERIODIC_SIZE;
752 ep->load = usb_calc_bus_time(udev->speed,
754 (type == PIPE_ISOCHRONOUS),
755 usb_maxpacket(udev, pipe,
763 /* maybe put endpoint into schedule */
767 if (list_empty(&ep->schedule))
768 list_add_tail(&ep->schedule, &isp116x->async);
771 urb->interval = ep->period;
772 ep->length = min((int)ep->maxpacket,
773 urb->transfer_buffer_length);
775 /* urb submitted for already existing endpoint */
776 if (ep->branch < PERIODIC_SIZE)
779 ep->branch = ret = balance(isp116x, ep->period, ep->load);
784 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
787 /* sort each schedule branch by period (slow before fast)
788 to share the faster parts of the tree without needing
789 dummy/placeholder nodes */
790 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
791 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
792 struct isp116x_ep **prev = &isp116x->periodic[i];
793 struct isp116x_ep *here = *prev;
795 while (here && ep != here) {
796 if (ep->period > here->period)
805 isp116x->load[i] += ep->load;
807 hcd->self.bandwidth_allocated += ep->load / ep->period;
809 /* switch over to SOFint */
810 if (!isp116x->periodic_count++) {
811 isp116x->irqenb &= ~HCuPINT_ATL;
812 isp116x->irqenb |= HCuPINT_SOF;
813 isp116x_write_reg16(isp116x, HCuPINTENB,
818 /* in case of unlink-during-submit */
819 if (urb->status != -EINPROGRESS) {
820 finish_request(isp116x, ep, urb);
825 start_atl_transfers(isp116x);
829 usb_hcd_unlink_urb_from_ep(hcd, urb);
831 spin_unlock_irqrestore(&isp116x->lock, flags);
838 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
841 struct isp116x *isp116x = hcd_to_isp116x(hcd);
842 struct usb_host_endpoint *hep;
843 struct isp116x_ep *ep, *ep_act;
847 spin_lock_irqsave(&isp116x->lock, flags);
848 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
854 WARN_ON(hep != ep->hep);
856 /* In front of queue? */
857 if (ep->hep->urb_list.next == &urb->urb_list)
859 for (ep_act = isp116x->atl_active; ep_act;
860 ep_act = ep_act->active)
862 VDBG("dequeue, urb %p active; wait for irq\n",
869 finish_request(isp116x, ep, urb);
871 spin_unlock_irqrestore(&isp116x->lock, flags);
875 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
876 struct usb_host_endpoint *hep)
879 struct isp116x_ep *ep = hep->hcpriv;
884 /* assume we'd just wait for the irq */
885 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
887 if (!list_empty(&hep->urb_list))
888 WARN("ep %p not empty?\n", ep);
894 static int isp116x_get_frame(struct usb_hcd *hcd)
896 struct isp116x *isp116x = hcd_to_isp116x(hcd);
900 spin_lock_irqsave(&isp116x->lock, flags);
901 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
902 spin_unlock_irqrestore(&isp116x->lock, flags);
907 Adapted from ohci-hub.c. Currently we don't support autosuspend.
909 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
911 struct isp116x *isp116x = hcd_to_isp116x(hcd);
912 int ports, i, changed = 0;
915 if (!HC_IS_RUNNING(hcd->state))
918 /* Report no status change now, if we are scheduled to be
920 if (timer_pending(&hcd->rh_timer))
923 ports = isp116x->rhdesca & RH_A_NDP;
924 spin_lock_irqsave(&isp116x->lock, flags);
925 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
926 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
927 buf[0] = changed = 1;
931 for (i = 0; i < ports; i++) {
932 u32 status = isp116x->rhport[i] =
933 isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
935 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
936 | RH_PS_OCIC | RH_PS_PRSC)) {
938 buf[0] |= 1 << (i + 1);
942 spin_unlock_irqrestore(&isp116x->lock, flags);
946 static void isp116x_hub_descriptor(struct isp116x *isp116x,
947 struct usb_hub_descriptor *desc)
949 u32 reg = isp116x->rhdesca;
951 desc->bDescriptorType = 0x29;
952 desc->bDescLength = 9;
953 desc->bHubContrCurrent = 0;
954 desc->bNbrPorts = (u8) (reg & 0x3);
955 /* Power switching, device type, overcurrent. */
956 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
957 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
958 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
960 desc->bitmap[1] = ~0;
963 /* Perform reset of a given port.
964 It would be great to just start the reset and let the
965 USB core to clear the reset in due time. However,
966 root hub ports should be reset for at least 50 ms, while
967 our chip stays in reset for about 10 ms. I.e., we must
968 repeatedly reset it ourself here.
970 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
973 unsigned long flags, t;
975 /* Root hub reset should be 50 ms, but some devices
976 want it even longer. */
977 t = jiffies + msecs_to_jiffies(100);
979 while (time_before(jiffies, t)) {
980 spin_lock_irqsave(&isp116x->lock, flags);
981 /* spin until any current reset finishes */
983 tmp = isp116x_read_reg32(isp116x, port ?
984 HCRHPORT2 : HCRHPORT1);
985 if (!(tmp & RH_PS_PRS))
989 /* Don't reset a disconnected port */
990 if (!(tmp & RH_PS_CCS)) {
991 spin_unlock_irqrestore(&isp116x->lock, flags);
994 /* Reset lasts 10ms (claims datasheet) */
995 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
996 HCRHPORT1, (RH_PS_PRS));
997 spin_unlock_irqrestore(&isp116x->lock, flags);
1002 /* Adapted from ohci-hub.c */
1003 static int isp116x_hub_control(struct usb_hcd *hcd,
1005 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1007 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1009 unsigned long flags;
1010 int ports = isp116x->rhdesca & RH_A_NDP;
1014 case ClearHubFeature:
1015 DBG("ClearHubFeature: ");
1017 case C_HUB_OVER_CURRENT:
1018 DBG("C_HUB_OVER_CURRENT\n");
1019 spin_lock_irqsave(&isp116x->lock, flags);
1020 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1021 spin_unlock_irqrestore(&isp116x->lock, flags);
1022 case C_HUB_LOCAL_POWER:
1023 DBG("C_HUB_LOCAL_POWER\n");
1030 DBG("SetHubFeature: ");
1032 case C_HUB_OVER_CURRENT:
1033 case C_HUB_LOCAL_POWER:
1034 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1040 case GetHubDescriptor:
1041 DBG("GetHubDescriptor\n");
1042 isp116x_hub_descriptor(isp116x,
1043 (struct usb_hub_descriptor *)buf);
1046 DBG("GetHubStatus\n");
1047 *(__le32 *) buf = 0;
1050 DBG("GetPortStatus\n");
1051 if (!wIndex || wIndex > ports)
1053 tmp = isp116x->rhport[--wIndex];
1054 *(__le32 *) buf = cpu_to_le32(tmp);
1055 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1057 case ClearPortFeature:
1058 DBG("ClearPortFeature: ");
1059 if (!wIndex || wIndex > ports)
1064 case USB_PORT_FEAT_ENABLE:
1065 DBG("USB_PORT_FEAT_ENABLE\n");
1068 case USB_PORT_FEAT_C_ENABLE:
1069 DBG("USB_PORT_FEAT_C_ENABLE\n");
1072 case USB_PORT_FEAT_SUSPEND:
1073 DBG("USB_PORT_FEAT_SUSPEND\n");
1076 case USB_PORT_FEAT_C_SUSPEND:
1077 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1080 case USB_PORT_FEAT_POWER:
1081 DBG("USB_PORT_FEAT_POWER\n");
1084 case USB_PORT_FEAT_C_CONNECTION:
1085 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1088 case USB_PORT_FEAT_C_OVER_CURRENT:
1089 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1092 case USB_PORT_FEAT_C_RESET:
1093 DBG("USB_PORT_FEAT_C_RESET\n");
1099 spin_lock_irqsave(&isp116x->lock, flags);
1100 isp116x_write_reg32(isp116x, wIndex
1101 ? HCRHPORT2 : HCRHPORT1, tmp);
1102 isp116x->rhport[wIndex] =
1103 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1104 spin_unlock_irqrestore(&isp116x->lock, flags);
1106 case SetPortFeature:
1107 DBG("SetPortFeature: ");
1108 if (!wIndex || wIndex > ports)
1112 case USB_PORT_FEAT_SUSPEND:
1113 DBG("USB_PORT_FEAT_SUSPEND\n");
1114 spin_lock_irqsave(&isp116x->lock, flags);
1115 isp116x_write_reg32(isp116x, wIndex
1116 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1118 case USB_PORT_FEAT_POWER:
1119 DBG("USB_PORT_FEAT_POWER\n");
1120 spin_lock_irqsave(&isp116x->lock, flags);
1121 isp116x_write_reg32(isp116x, wIndex
1122 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1124 case USB_PORT_FEAT_RESET:
1125 DBG("USB_PORT_FEAT_RESET\n");
1126 root_port_reset(isp116x, wIndex);
1127 spin_lock_irqsave(&isp116x->lock, flags);
1132 isp116x->rhport[wIndex] =
1133 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1134 spin_unlock_irqrestore(&isp116x->lock, flags);
1139 /* "protocol stall" on error */
1140 DBG("PROTOCOL STALL\n");
1146 /*-----------------------------------------------------------------*/
1148 #ifdef CONFIG_DEBUG_FS
1150 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1152 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1153 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1154 mask & HCuPINT_SUSP ? " susp" : "",
1155 mask & HCuPINT_OPR ? " opr" : "",
1156 mask & HCuPINT_AIIEOT ? " eot" : "",
1157 mask & HCuPINT_ATL ? " atl" : "",
1158 mask & HCuPINT_SOF ? " sof" : "");
1161 static void dump_int(struct seq_file *s, char *label, u32 mask)
1163 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1164 mask & HCINT_MIE ? " MIE" : "",
1165 mask & HCINT_RHSC ? " rhsc" : "",
1166 mask & HCINT_FNO ? " fno" : "",
1167 mask & HCINT_UE ? " ue" : "",
1168 mask & HCINT_RD ? " rd" : "",
1169 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1172 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1174 struct isp116x *isp116x = s->private;
1176 seq_printf(s, "%s\n%s version %s\n",
1177 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1180 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1181 seq_printf(s, "HCD is suspended\n");
1184 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1185 seq_printf(s, "HCD not running\n");
1189 spin_lock_irq(&isp116x->lock);
1190 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1191 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1192 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1193 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1194 isp116x_show_regs_seq(isp116x, s);
1195 spin_unlock_irq(&isp116x->lock);
1196 seq_printf(s, "\n");
1201 static int isp116x_open_seq(struct inode *inode, struct file *file)
1203 return single_open(file, isp116x_show_dbg, inode->i_private);
1206 static const struct file_operations isp116x_debug_fops = {
1207 .open = isp116x_open_seq,
1209 .llseek = seq_lseek,
1210 .release = single_release,
1213 static int create_debug_file(struct isp116x *isp116x)
1215 isp116x->dentry = debugfs_create_file(hcd_name,
1216 S_IRUGO, NULL, isp116x,
1217 &isp116x_debug_fops);
1218 if (!isp116x->dentry)
1223 static void remove_debug_file(struct isp116x *isp116x)
1225 debugfs_remove(isp116x->dentry);
1230 #define create_debug_file(d) 0
1231 #define remove_debug_file(d) do{}while(0)
1233 #endif /* CONFIG_DEBUG_FS */
1235 /*-----------------------------------------------------------------*/
1238 Software reset - can be called from any contect.
1240 static int isp116x_sw_reset(struct isp116x *isp116x)
1243 unsigned long flags;
1246 spin_lock_irqsave(&isp116x->lock, flags);
1247 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1248 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1250 /* It usually resets within 1 ms */
1252 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1256 ERR("Software reset timeout\n");
1259 spin_unlock_irqrestore(&isp116x->lock, flags);
1263 static int isp116x_reset(struct usb_hcd *hcd)
1265 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1268 int ret, timeout = 15 /* ms */ ;
1270 ret = isp116x_sw_reset(isp116x);
1274 t = jiffies + msecs_to_jiffies(timeout);
1275 while (time_before_eq(jiffies, t)) {
1277 spin_lock_irq(&isp116x->lock);
1278 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1279 spin_unlock_irq(&isp116x->lock);
1284 ERR("Clock not ready after %dms\n", timeout);
1285 /* After sw_reset the clock won't report to be ready, if
1286 H_WAKEUP pin is high. */
1287 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1293 static void isp116x_stop(struct usb_hcd *hcd)
1295 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1296 unsigned long flags;
1299 spin_lock_irqsave(&isp116x->lock, flags);
1300 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1302 /* Switch off ports' power, some devices don't come up
1303 after next 'insmod' without this */
1304 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1305 val &= ~(RH_A_NPS | RH_A_PSM);
1306 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1307 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1308 spin_unlock_irqrestore(&isp116x->lock, flags);
1310 isp116x_sw_reset(isp116x);
1314 Configure the chip. The chip must be successfully reset by now.
1316 static int isp116x_start(struct usb_hcd *hcd)
1318 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1319 struct isp116x_platform_data *board = isp116x->board;
1321 unsigned long flags;
1323 spin_lock_irqsave(&isp116x->lock, flags);
1325 /* clear interrupt status and disable all interrupt sources */
1326 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1327 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1329 val = isp116x_read_reg16(isp116x, HCCHIPID);
1330 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1331 ERR("Invalid chip ID %04x\n", val);
1332 spin_unlock_irqrestore(&isp116x->lock, flags);
1336 /* To be removed in future */
1337 hcd->uses_new_polling = 1;
1339 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1340 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1343 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1344 if (board->sel15Kres)
1345 val |= HCHWCFG_15KRSEL;
1346 /* Remote wakeup won't work without working clock */
1347 if (board->remote_wakeup_enable)
1348 val |= HCHWCFG_CLKNOTSTOP;
1349 if (board->oc_enable)
1350 val |= HCHWCFG_ANALOG_OC;
1351 if (board->int_act_high)
1352 val |= HCHWCFG_INT_POL;
1353 if (board->int_edge_triggered)
1354 val |= HCHWCFG_INT_TRIGGER;
1355 isp116x_write_reg16(isp116x, HCHWCFG, val);
1357 /* ----- Root hub conf */
1358 val = (25 << 24) & RH_A_POTPGT;
1359 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1360 be always set. Yet, instead, we request individual port
1363 /* Report overcurrent per port */
1365 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1366 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1369 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1370 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1373 if (board->remote_wakeup_enable) {
1374 if (!device_can_wakeup(hcd->self.controller))
1375 device_init_wakeup(hcd->self.controller, 1);
1378 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1379 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1381 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1383 hcd->state = HC_STATE_RUNNING;
1385 /* Set up interrupts */
1386 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1387 if (board->remote_wakeup_enable)
1388 isp116x->intenb |= HCINT_RD;
1389 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1390 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1391 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1393 /* Go operational */
1394 val = HCCONTROL_USB_OPER;
1395 if (board->remote_wakeup_enable)
1396 val |= HCCONTROL_RWE;
1397 isp116x_write_reg32(isp116x, HCCONTROL, val);
1399 /* Disable ports to avoid race in device enumeration */
1400 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1401 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1403 isp116x_show_regs_log(isp116x);
1404 spin_unlock_irqrestore(&isp116x->lock, flags);
1410 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1412 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1413 unsigned long flags;
1417 spin_lock_irqsave(&isp116x->lock, flags);
1418 val = isp116x_read_reg32(isp116x, HCCONTROL);
1420 switch (val & HCCONTROL_HCFS) {
1421 case HCCONTROL_USB_OPER:
1422 spin_unlock_irqrestore(&isp116x->lock, flags);
1423 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1424 val |= HCCONTROL_USB_SUSPEND;
1425 if (device_may_wakeup(&hcd->self.root_hub->dev))
1426 val |= HCCONTROL_RWE;
1427 /* Wait for usb transfers to finish */
1429 spin_lock_irqsave(&isp116x->lock, flags);
1430 isp116x_write_reg32(isp116x, HCCONTROL, val);
1431 spin_unlock_irqrestore(&isp116x->lock, flags);
1432 /* Wait for devices to suspend */
1435 case HCCONTROL_USB_RESUME:
1436 isp116x_write_reg32(isp116x, HCCONTROL,
1437 (val & ~HCCONTROL_HCFS) |
1438 HCCONTROL_USB_RESET);
1439 case HCCONTROL_USB_RESET:
1441 default: /* HCCONTROL_USB_SUSPEND */
1442 spin_unlock_irqrestore(&isp116x->lock, flags);
1449 static int isp116x_bus_resume(struct usb_hcd *hcd)
1451 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1455 spin_lock_irq(&isp116x->lock);
1457 val = isp116x_read_reg32(isp116x, HCCONTROL);
1458 switch (val & HCCONTROL_HCFS) {
1459 case HCCONTROL_USB_SUSPEND:
1460 val &= ~HCCONTROL_HCFS;
1461 val |= HCCONTROL_USB_RESUME;
1462 isp116x_write_reg32(isp116x, HCCONTROL, val);
1463 case HCCONTROL_USB_RESUME:
1465 case HCCONTROL_USB_OPER:
1466 spin_unlock_irq(&isp116x->lock);
1467 /* Without setting power_state here the
1468 SUSPENDED state won't be removed from
1469 sysfs/usbN/power.state as a response to remote
1470 wakeup. Maybe in the future. */
1471 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1474 /* HCCONTROL_USB_RESET: this may happen, when during
1475 suspension the HC lost power. Reinitialize completely */
1476 spin_unlock_irq(&isp116x->lock);
1477 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1480 isp116x_hub_control(hcd, SetPortFeature,
1481 USB_PORT_FEAT_POWER, 1, NULL, 0);
1482 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1483 isp116x_hub_control(hcd, SetPortFeature,
1484 USB_PORT_FEAT_POWER, 2, NULL, 0);
1485 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1489 val = isp116x->rhdesca & RH_A_NDP;
1492 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1493 /* force global, not selective, resume */
1494 if (!(stat & RH_PS_PSS))
1496 DBG("%s: Resuming port %d\n", __func__, val);
1497 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1498 ? HCRHPORT2 : HCRHPORT1);
1500 spin_unlock_irq(&isp116x->lock);
1502 hcd->state = HC_STATE_RESUMING;
1505 /* Go operational */
1506 spin_lock_irq(&isp116x->lock);
1507 val = isp116x_read_reg32(isp116x, HCCONTROL);
1508 isp116x_write_reg32(isp116x, HCCONTROL,
1509 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1510 spin_unlock_irq(&isp116x->lock);
1511 /* see analogous comment above */
1512 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1513 hcd->state = HC_STATE_RUNNING;
1520 #define isp116x_bus_suspend NULL
1521 #define isp116x_bus_resume NULL
1525 static struct hc_driver isp116x_hc_driver = {
1526 .description = hcd_name,
1527 .product_desc = "ISP116x Host Controller",
1528 .hcd_priv_size = sizeof(struct isp116x),
1533 .reset = isp116x_reset,
1534 .start = isp116x_start,
1535 .stop = isp116x_stop,
1537 .urb_enqueue = isp116x_urb_enqueue,
1538 .urb_dequeue = isp116x_urb_dequeue,
1539 .endpoint_disable = isp116x_endpoint_disable,
1541 .get_frame_number = isp116x_get_frame,
1543 .hub_status_data = isp116x_hub_status_data,
1544 .hub_control = isp116x_hub_control,
1545 .bus_suspend = isp116x_bus_suspend,
1546 .bus_resume = isp116x_bus_resume,
1549 /*----------------------------------------------------------------*/
1551 static int isp116x_remove(struct platform_device *pdev)
1553 struct usb_hcd *hcd = platform_get_drvdata(pdev);
1554 struct isp116x *isp116x;
1555 struct resource *res;
1559 isp116x = hcd_to_isp116x(hcd);
1560 remove_debug_file(isp116x);
1561 usb_remove_hcd(hcd);
1563 iounmap(isp116x->data_reg);
1564 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1565 release_mem_region(res->start, 2);
1566 iounmap(isp116x->addr_reg);
1567 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1568 release_mem_region(res->start, 2);
1574 #define resource_len(r) (((r)->end - (r)->start) + 1)
1576 static int __devinit isp116x_probe(struct platform_device *pdev)
1578 struct usb_hcd *hcd;
1579 struct isp116x *isp116x;
1580 struct resource *addr, *data;
1581 void __iomem *addr_reg;
1582 void __iomem *data_reg;
1586 if (pdev->num_resources < 3) {
1591 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1592 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1593 irq = platform_get_irq(pdev, 0);
1594 if (!addr || !data || irq < 0) {
1599 if (pdev->dev.dma_mask) {
1600 DBG("DMA not supported\n");
1605 if (!request_mem_region(addr->start, 2, hcd_name)) {
1609 addr_reg = ioremap(addr->start, resource_len(addr));
1610 if (addr_reg == NULL) {
1614 if (!request_mem_region(data->start, 2, hcd_name)) {
1618 data_reg = ioremap(data->start, resource_len(data));
1619 if (data_reg == NULL) {
1624 /* allocate and initialize hcd */
1625 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
1630 /* this rsrc_start is bogus */
1631 hcd->rsrc_start = addr->start;
1632 isp116x = hcd_to_isp116x(hcd);
1633 isp116x->data_reg = data_reg;
1634 isp116x->addr_reg = addr_reg;
1635 spin_lock_init(&isp116x->lock);
1636 INIT_LIST_HEAD(&isp116x->async);
1637 isp116x->board = pdev->dev.platform_data;
1639 if (!isp116x->board) {
1640 ERR("Platform data structure not initialized\n");
1644 if (isp116x_check_platform_delay(isp116x)) {
1645 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1647 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1652 ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
1656 ret = create_debug_file(isp116x);
1658 ERR("Couldn't create debugfs entry\n");
1665 usb_remove_hcd(hcd);
1671 release_mem_region(data->start, 2);
1675 release_mem_region(addr->start, 2);
1677 ERR("init error, %d\n", ret);
1683 Suspend of platform device
1685 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1687 VDBG("%s: state %x\n", __func__, state.event);
1688 dev->dev.power.power_state = state;
1693 Resume platform device
1695 static int isp116x_resume(struct platform_device *dev)
1697 VDBG("%s: state %x\n", __func__, dev->power.power_state.event);
1698 dev->dev.power.power_state = PMSG_ON;
1704 #define isp116x_suspend NULL
1705 #define isp116x_resume NULL
1709 static struct platform_driver isp116x_driver = {
1710 .probe = isp116x_probe,
1711 .remove = isp116x_remove,
1712 .suspend = isp116x_suspend,
1713 .resume = isp116x_resume,
1715 .name = (char *)hcd_name,
1719 /*-----------------------------------------------------------------*/
1721 static int __init isp116x_init(void)
1726 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1727 return platform_driver_register(&isp116x_driver);
1730 module_init(isp116x_init);
1732 static void __exit isp116x_cleanup(void)
1734 platform_driver_unregister(&isp116x_driver);
1737 module_exit(isp116x_cleanup);