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)
287 if (usb_pipecontrol(urb->pipe))
288 ep->nextpid = USB_PID_SETUP;
290 urb_dbg(urb, "Finish");
292 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
293 spin_unlock(&isp116x->lock);
294 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb);
295 spin_lock(&isp116x->lock);
297 /* take idle endpoints out of the schedule */
298 if (!list_empty(&ep->hep->urb_list))
301 /* async deschedule */
302 if (!list_empty(&ep->schedule)) {
303 list_del_init(&ep->schedule);
307 /* periodic deschedule */
308 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
309 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
310 struct isp116x_ep *temp;
311 struct isp116x_ep **prev = &isp116x->periodic[i];
313 while (*prev && ((temp = *prev) != ep))
317 isp116x->load[i] -= ep->load;
319 ep->branch = PERIODIC_SIZE;
320 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
321 ep->load / ep->period;
323 /* switch irq type? */
324 if (!--isp116x->periodic_count) {
325 isp116x->irqenb &= ~HCuPINT_SOF;
326 isp116x->irqenb |= HCuPINT_ATL;
331 Analyze transfer results, handle partial transfers and errors
333 static void postproc_atl_queue(struct isp116x *isp116x)
335 struct isp116x_ep *ep;
337 struct usb_device *udev;
343 for (ep = isp116x->atl_active; ep; ep = ep->active) {
344 BUG_ON(list_empty(&ep->hep->urb_list));
346 container_of(ep->hep->urb_list.next, struct urb, urb_list);
349 cc = PTD_GET_CC(ptd);
351 status = -EINPROGRESS;
353 /* Data underrun is special. For allowed underrun
354 we clear the error and continue as normal. For
355 forbidden underrun we finish the DATA stage
356 immediately while for control transfer,
357 we do a STATUS stage. */
358 if (cc == TD_DATAUNDERRUN) {
359 if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
360 usb_pipecontrol(urb->pipe)) {
361 DBG("Allowed or control data underrun\n");
366 usb_settoggle(udev, ep->epnum,
367 ep->nextpid == USB_PID_OUT,
368 PTD_GET_TOGGLE(ptd));
369 urb->actual_length += PTD_GET_COUNT(ptd);
370 status = cc_to_error[TD_DATAUNDERRUN];
375 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
376 && (++ep->error_count >= 3 || cc == TD_CC_STALL
377 || cc == TD_DATAOVERRUN)) {
378 status = cc_to_error[cc];
379 if (ep->nextpid == USB_PID_ACK)
383 /* According to usb spec, zero-length Int transfer signals
384 finishing of the urb. Hey, does this apply only
386 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
391 /* Relax after previously failed, but later succeeded
392 or correctly NAK'ed retransmission attempt */
394 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
397 /* Take into account idiosyncracies of the isp116x chip
398 regarding toggle bit for failed transfers */
399 if (ep->nextpid == USB_PID_OUT)
400 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
401 ^ (ep->error_count > 0));
402 else if (ep->nextpid == USB_PID_IN)
403 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
404 ^ (ep->error_count > 0));
406 switch (ep->nextpid) {
409 urb->actual_length += PTD_GET_COUNT(ptd);
410 if (PTD_GET_ACTIVE(ptd)
411 || (cc != TD_CC_NOERROR && cc < 0x0E))
413 if (urb->transfer_buffer_length != urb->actual_length) {
417 if (urb->transfer_flags & URB_ZERO_PACKET
418 && ep->nextpid == USB_PID_OUT
419 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
420 DBG("Zero packet requested\n");
424 /* All data for this URB is transferred, let's finish */
425 if (usb_pipecontrol(urb->pipe))
426 ep->nextpid = USB_PID_ACK;
431 if (PTD_GET_ACTIVE(ptd)
432 || (cc != TD_CC_NOERROR && cc < 0x0E))
434 if (urb->transfer_buffer_length == urb->actual_length)
435 ep->nextpid = USB_PID_ACK;
436 else if (usb_pipeout(urb->pipe)) {
437 usb_settoggle(udev, 0, 1, 1);
438 ep->nextpid = USB_PID_OUT;
440 usb_settoggle(udev, 0, 0, 1);
441 ep->nextpid = USB_PID_IN;
445 if (PTD_GET_ACTIVE(ptd)
446 || (cc != TD_CC_NOERROR && cc < 0x0E))
456 if (status != -EINPROGRESS) {
457 spin_lock(&urb->lock);
458 if (urb->status == -EINPROGRESS)
459 urb->status = status;
460 spin_unlock(&urb->lock);
462 if (urb->status != -EINPROGRESS)
463 finish_request(isp116x, ep, urb);
468 Scan transfer lists, schedule transfers, send data off
471 static void start_atl_transfers(struct isp116x *isp116x)
473 struct isp116x_ep *last_ep = NULL, *ep;
476 int len, index, speed, byte_time;
478 if (atomic_read(&isp116x->atl_finishing))
481 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
484 /* FIFO not empty? */
485 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
488 isp116x->atl_active = NULL;
489 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
491 /* Schedule int transfers */
492 if (isp116x->periodic_count) {
493 isp116x->fmindex = index =
494 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
495 if ((load = isp116x->load[index])) {
496 /* Bring all int transfers for this frame
497 into the active queue */
498 isp116x->atl_active = last_ep =
499 isp116x->periodic[index];
500 while (last_ep->next)
501 last_ep = (last_ep->active = last_ep->next);
502 last_ep->active = NULL;
506 /* Schedule control/bulk transfers */
507 list_for_each_entry(ep, &isp116x->async, schedule) {
508 urb = container_of(ep->hep->urb_list.next,
509 struct urb, urb_list);
510 speed = urb->dev->speed;
511 byte_time = speed == USB_SPEED_LOW
512 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
514 if (ep->nextpid == USB_PID_SETUP) {
515 len = sizeof(struct usb_ctrlrequest);
516 } else if (ep->nextpid == USB_PID_ACK) {
519 /* Find current free length ... */
520 len = (MAX_LOAD_LIMIT - load) / byte_time;
522 /* ... then limit it to configured max size ... */
523 len = min(len, speed == USB_SPEED_LOW ?
524 MAX_TRANSFER_SIZE_LOWSPEED :
525 MAX_TRANSFER_SIZE_FULLSPEED);
527 /* ... and finally cut to the multiple of MaxPacketSize,
528 or to the real length if there's enough room. */
530 (urb->transfer_buffer_length -
531 urb->actual_length)) {
532 len -= len % ep->maxpacket;
536 len = urb->transfer_buffer_length -
541 load += len * byte_time;
542 if (load > MAX_LOAD_LIMIT)
548 last_ep->active = ep;
550 isp116x->atl_active = ep;
554 /* Avoid starving of endpoints */
555 if ((&isp116x->async)->next != (&isp116x->async)->prev)
556 list_move(&isp116x->async, (&isp116x->async)->next);
558 if (isp116x->atl_active) {
559 preproc_atl_queue(isp116x);
565 Finish the processed transfers
567 static void finish_atl_transfers(struct isp116x *isp116x)
569 if (!isp116x->atl_active)
571 /* Fifo not ready? */
572 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
575 atomic_inc(&isp116x->atl_finishing);
576 unpack_fifo(isp116x);
577 postproc_atl_queue(isp116x);
578 atomic_dec(&isp116x->atl_finishing);
581 static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
583 struct isp116x *isp116x = hcd_to_isp116x(hcd);
585 irqreturn_t ret = IRQ_NONE;
587 spin_lock(&isp116x->lock);
588 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
589 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
590 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
592 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
594 finish_atl_transfers(isp116x);
597 if (irqstat & HCuPINT_OPR) {
598 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
599 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
600 if (intstat & HCINT_UE) {
601 ERR("Unrecoverable error, HC is dead!\n");
602 /* IRQ's are off, we do no DMA,
603 perfectly ready to die ... */
604 hcd->state = HC_STATE_HALT;
608 if (intstat & HCINT_RHSC)
609 /* When root hub or any of its ports is going
610 to come out of suspend, it may take more
611 than 10ms for status bits to stabilize. */
612 mod_timer(&hcd->rh_timer, jiffies
613 + msecs_to_jiffies(20) + 1);
614 if (intstat & HCINT_RD) {
615 DBG("---- remote wakeup\n");
616 usb_hcd_resume_root_hub(hcd);
618 irqstat &= ~HCuPINT_OPR;
622 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
623 start_atl_transfers(isp116x);
626 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
628 spin_unlock(&isp116x->lock);
632 /*-----------------------------------------------------------------*/
634 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
635 * this driver doesn't promise that much since it's got to handle an
636 * IRQ per packet; irq handling latencies also use up that time.
640 #define MAX_PERIODIC_LOAD 600
641 static int balance(struct isp116x *isp116x, u16 period, u16 load)
643 int i, branch = -ENOSPC;
645 /* search for the least loaded schedule branch of that period
646 which has enough bandwidth left unreserved. */
647 for (i = 0; i < period; i++) {
648 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
651 for (j = i; j < PERIODIC_SIZE; j += period) {
652 if ((isp116x->load[j] + load)
656 if (j < PERIODIC_SIZE)
664 /* NB! ALL the code above this point runs with isp116x->lock
668 /*-----------------------------------------------------------------*/
670 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
674 struct isp116x *isp116x = hcd_to_isp116x(hcd);
675 struct usb_device *udev = urb->dev;
676 unsigned int pipe = urb->pipe;
677 int is_out = !usb_pipein(pipe);
678 int type = usb_pipetype(pipe);
679 int epnum = usb_pipeendpoint(pipe);
680 struct usb_host_endpoint *hep = urb->ep;
681 struct isp116x_ep *ep = NULL;
686 urb_dbg(urb, "Enqueue");
688 if (type == PIPE_ISOCHRONOUS) {
689 ERR("Isochronous transfers not supported\n");
690 urb_dbg(urb, "Refused to enqueue");
693 /* avoid all allocations within spinlocks: request or endpoint */
695 ep = kzalloc(sizeof *ep, mem_flags);
700 spin_lock_irqsave(&isp116x->lock, flags);
701 if (!HC_IS_RUNNING(hcd->state)) {
704 goto fail_not_linked;
706 ret = usb_hcd_link_urb_to_ep(hcd, urb);
709 goto fail_not_linked;
715 INIT_LIST_HEAD(&ep->schedule);
718 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
719 usb_settoggle(udev, epnum, is_out, 0);
721 if (type == PIPE_CONTROL) {
722 ep->nextpid = USB_PID_SETUP;
724 ep->nextpid = USB_PID_OUT;
726 ep->nextpid = USB_PID_IN;
731 With INT URBs submitted, the driver works with SOF
732 interrupt enabled and ATL interrupt disabled. After
733 the PTDs are written to fifo ram, the chip starts
734 fifo processing and usb transfers after the next
735 SOF and continues until the transfers are finished
736 (succeeded or failed) or the frame ends. Therefore,
737 the transfers occur only in every second frame,
738 while fifo reading/writing and data processing
739 occur in every other second frame. */
740 if (urb->interval < 2)
742 if (urb->interval > 2 * PERIODIC_SIZE)
743 urb->interval = 2 * PERIODIC_SIZE;
744 ep->period = urb->interval >> 1;
745 ep->branch = PERIODIC_SIZE;
746 ep->load = usb_calc_bus_time(udev->speed,
748 (type == PIPE_ISOCHRONOUS),
749 usb_maxpacket(udev, pipe,
757 /* maybe put endpoint into schedule */
761 if (list_empty(&ep->schedule))
762 list_add_tail(&ep->schedule, &isp116x->async);
765 urb->interval = ep->period;
766 ep->length = min((int)ep->maxpacket,
767 urb->transfer_buffer_length);
769 /* urb submitted for already existing endpoint */
770 if (ep->branch < PERIODIC_SIZE)
773 ep->branch = ret = balance(isp116x, ep->period, ep->load);
778 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
781 /* sort each schedule branch by period (slow before fast)
782 to share the faster parts of the tree without needing
783 dummy/placeholder nodes */
784 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
785 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
786 struct isp116x_ep **prev = &isp116x->periodic[i];
787 struct isp116x_ep *here = *prev;
789 while (here && ep != here) {
790 if (ep->period > here->period)
799 isp116x->load[i] += ep->load;
801 hcd->self.bandwidth_allocated += ep->load / ep->period;
803 /* switch over to SOFint */
804 if (!isp116x->periodic_count++) {
805 isp116x->irqenb &= ~HCuPINT_ATL;
806 isp116x->irqenb |= HCuPINT_SOF;
807 isp116x_write_reg16(isp116x, HCuPINTENB,
813 start_atl_transfers(isp116x);
817 usb_hcd_unlink_urb_from_ep(hcd, urb);
819 spin_unlock_irqrestore(&isp116x->lock, flags);
826 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
829 struct isp116x *isp116x = hcd_to_isp116x(hcd);
830 struct usb_host_endpoint *hep;
831 struct isp116x_ep *ep, *ep_act;
835 spin_lock_irqsave(&isp116x->lock, flags);
836 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
842 WARN_ON(hep != ep->hep);
844 /* In front of queue? */
845 if (ep->hep->urb_list.next == &urb->urb_list)
847 for (ep_act = isp116x->atl_active; ep_act;
848 ep_act = ep_act->active)
850 VDBG("dequeue, urb %p active; wait for irq\n",
857 finish_request(isp116x, ep, urb);
859 spin_unlock_irqrestore(&isp116x->lock, flags);
863 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
864 struct usb_host_endpoint *hep)
867 struct isp116x_ep *ep = hep->hcpriv;
872 /* assume we'd just wait for the irq */
873 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
875 if (!list_empty(&hep->urb_list))
876 WARN("ep %p not empty?\n", ep);
882 static int isp116x_get_frame(struct usb_hcd *hcd)
884 struct isp116x *isp116x = hcd_to_isp116x(hcd);
888 spin_lock_irqsave(&isp116x->lock, flags);
889 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
890 spin_unlock_irqrestore(&isp116x->lock, flags);
895 Adapted from ohci-hub.c. Currently we don't support autosuspend.
897 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
899 struct isp116x *isp116x = hcd_to_isp116x(hcd);
900 int ports, i, changed = 0;
903 if (!HC_IS_RUNNING(hcd->state))
906 /* Report no status change now, if we are scheduled to be
908 if (timer_pending(&hcd->rh_timer))
911 ports = isp116x->rhdesca & RH_A_NDP;
912 spin_lock_irqsave(&isp116x->lock, flags);
913 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
914 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
915 buf[0] = changed = 1;
919 for (i = 0; i < ports; i++) {
920 u32 status = isp116x->rhport[i] =
921 isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
923 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
924 | RH_PS_OCIC | RH_PS_PRSC)) {
926 buf[0] |= 1 << (i + 1);
930 spin_unlock_irqrestore(&isp116x->lock, flags);
934 static void isp116x_hub_descriptor(struct isp116x *isp116x,
935 struct usb_hub_descriptor *desc)
937 u32 reg = isp116x->rhdesca;
939 desc->bDescriptorType = 0x29;
940 desc->bDescLength = 9;
941 desc->bHubContrCurrent = 0;
942 desc->bNbrPorts = (u8) (reg & 0x3);
943 /* Power switching, device type, overcurrent. */
944 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
945 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
946 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
948 desc->bitmap[1] = ~0;
951 /* Perform reset of a given port.
952 It would be great to just start the reset and let the
953 USB core to clear the reset in due time. However,
954 root hub ports should be reset for at least 50 ms, while
955 our chip stays in reset for about 10 ms. I.e., we must
956 repeatedly reset it ourself here.
958 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
961 unsigned long flags, t;
963 /* Root hub reset should be 50 ms, but some devices
964 want it even longer. */
965 t = jiffies + msecs_to_jiffies(100);
967 while (time_before(jiffies, t)) {
968 spin_lock_irqsave(&isp116x->lock, flags);
969 /* spin until any current reset finishes */
971 tmp = isp116x_read_reg32(isp116x, port ?
972 HCRHPORT2 : HCRHPORT1);
973 if (!(tmp & RH_PS_PRS))
977 /* Don't reset a disconnected port */
978 if (!(tmp & RH_PS_CCS)) {
979 spin_unlock_irqrestore(&isp116x->lock, flags);
982 /* Reset lasts 10ms (claims datasheet) */
983 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
984 HCRHPORT1, (RH_PS_PRS));
985 spin_unlock_irqrestore(&isp116x->lock, flags);
990 /* Adapted from ohci-hub.c */
991 static int isp116x_hub_control(struct usb_hcd *hcd,
993 u16 wValue, u16 wIndex, char *buf, u16 wLength)
995 struct isp116x *isp116x = hcd_to_isp116x(hcd);
998 int ports = isp116x->rhdesca & RH_A_NDP;
1002 case ClearHubFeature:
1003 DBG("ClearHubFeature: ");
1005 case C_HUB_OVER_CURRENT:
1006 DBG("C_HUB_OVER_CURRENT\n");
1007 spin_lock_irqsave(&isp116x->lock, flags);
1008 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1009 spin_unlock_irqrestore(&isp116x->lock, flags);
1010 case C_HUB_LOCAL_POWER:
1011 DBG("C_HUB_LOCAL_POWER\n");
1018 DBG("SetHubFeature: ");
1020 case C_HUB_OVER_CURRENT:
1021 case C_HUB_LOCAL_POWER:
1022 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1028 case GetHubDescriptor:
1029 DBG("GetHubDescriptor\n");
1030 isp116x_hub_descriptor(isp116x,
1031 (struct usb_hub_descriptor *)buf);
1034 DBG("GetHubStatus\n");
1035 *(__le32 *) buf = 0;
1038 DBG("GetPortStatus\n");
1039 if (!wIndex || wIndex > ports)
1041 tmp = isp116x->rhport[--wIndex];
1042 *(__le32 *) buf = cpu_to_le32(tmp);
1043 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1045 case ClearPortFeature:
1046 DBG("ClearPortFeature: ");
1047 if (!wIndex || wIndex > ports)
1052 case USB_PORT_FEAT_ENABLE:
1053 DBG("USB_PORT_FEAT_ENABLE\n");
1056 case USB_PORT_FEAT_C_ENABLE:
1057 DBG("USB_PORT_FEAT_C_ENABLE\n");
1060 case USB_PORT_FEAT_SUSPEND:
1061 DBG("USB_PORT_FEAT_SUSPEND\n");
1064 case USB_PORT_FEAT_C_SUSPEND:
1065 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1068 case USB_PORT_FEAT_POWER:
1069 DBG("USB_PORT_FEAT_POWER\n");
1072 case USB_PORT_FEAT_C_CONNECTION:
1073 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1076 case USB_PORT_FEAT_C_OVER_CURRENT:
1077 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1080 case USB_PORT_FEAT_C_RESET:
1081 DBG("USB_PORT_FEAT_C_RESET\n");
1087 spin_lock_irqsave(&isp116x->lock, flags);
1088 isp116x_write_reg32(isp116x, wIndex
1089 ? HCRHPORT2 : HCRHPORT1, tmp);
1090 isp116x->rhport[wIndex] =
1091 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1092 spin_unlock_irqrestore(&isp116x->lock, flags);
1094 case SetPortFeature:
1095 DBG("SetPortFeature: ");
1096 if (!wIndex || wIndex > ports)
1100 case USB_PORT_FEAT_SUSPEND:
1101 DBG("USB_PORT_FEAT_SUSPEND\n");
1102 spin_lock_irqsave(&isp116x->lock, flags);
1103 isp116x_write_reg32(isp116x, wIndex
1104 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1106 case USB_PORT_FEAT_POWER:
1107 DBG("USB_PORT_FEAT_POWER\n");
1108 spin_lock_irqsave(&isp116x->lock, flags);
1109 isp116x_write_reg32(isp116x, wIndex
1110 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1112 case USB_PORT_FEAT_RESET:
1113 DBG("USB_PORT_FEAT_RESET\n");
1114 root_port_reset(isp116x, wIndex);
1115 spin_lock_irqsave(&isp116x->lock, flags);
1120 isp116x->rhport[wIndex] =
1121 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1122 spin_unlock_irqrestore(&isp116x->lock, flags);
1127 /* "protocol stall" on error */
1128 DBG("PROTOCOL STALL\n");
1134 /*-----------------------------------------------------------------*/
1136 #ifdef CONFIG_DEBUG_FS
1138 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1140 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1141 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1142 mask & HCuPINT_SUSP ? " susp" : "",
1143 mask & HCuPINT_OPR ? " opr" : "",
1144 mask & HCuPINT_AIIEOT ? " eot" : "",
1145 mask & HCuPINT_ATL ? " atl" : "",
1146 mask & HCuPINT_SOF ? " sof" : "");
1149 static void dump_int(struct seq_file *s, char *label, u32 mask)
1151 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1152 mask & HCINT_MIE ? " MIE" : "",
1153 mask & HCINT_RHSC ? " rhsc" : "",
1154 mask & HCINT_FNO ? " fno" : "",
1155 mask & HCINT_UE ? " ue" : "",
1156 mask & HCINT_RD ? " rd" : "",
1157 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1160 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1162 struct isp116x *isp116x = s->private;
1164 seq_printf(s, "%s\n%s version %s\n",
1165 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1168 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1169 seq_printf(s, "HCD is suspended\n");
1172 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1173 seq_printf(s, "HCD not running\n");
1177 spin_lock_irq(&isp116x->lock);
1178 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1179 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1180 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1181 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1182 isp116x_show_regs_seq(isp116x, s);
1183 spin_unlock_irq(&isp116x->lock);
1184 seq_printf(s, "\n");
1189 static int isp116x_open_seq(struct inode *inode, struct file *file)
1191 return single_open(file, isp116x_show_dbg, inode->i_private);
1194 static const struct file_operations isp116x_debug_fops = {
1195 .open = isp116x_open_seq,
1197 .llseek = seq_lseek,
1198 .release = single_release,
1201 static int create_debug_file(struct isp116x *isp116x)
1203 isp116x->dentry = debugfs_create_file(hcd_name,
1204 S_IRUGO, NULL, isp116x,
1205 &isp116x_debug_fops);
1206 if (!isp116x->dentry)
1211 static void remove_debug_file(struct isp116x *isp116x)
1213 debugfs_remove(isp116x->dentry);
1218 #define create_debug_file(d) 0
1219 #define remove_debug_file(d) do{}while(0)
1221 #endif /* CONFIG_DEBUG_FS */
1223 /*-----------------------------------------------------------------*/
1226 Software reset - can be called from any contect.
1228 static int isp116x_sw_reset(struct isp116x *isp116x)
1231 unsigned long flags;
1234 spin_lock_irqsave(&isp116x->lock, flags);
1235 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1236 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1238 /* It usually resets within 1 ms */
1240 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1244 ERR("Software reset timeout\n");
1247 spin_unlock_irqrestore(&isp116x->lock, flags);
1251 static int isp116x_reset(struct usb_hcd *hcd)
1253 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1256 int ret, timeout = 15 /* ms */ ;
1258 ret = isp116x_sw_reset(isp116x);
1262 t = jiffies + msecs_to_jiffies(timeout);
1263 while (time_before_eq(jiffies, t)) {
1265 spin_lock_irq(&isp116x->lock);
1266 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1267 spin_unlock_irq(&isp116x->lock);
1272 ERR("Clock not ready after %dms\n", timeout);
1273 /* After sw_reset the clock won't report to be ready, if
1274 H_WAKEUP pin is high. */
1275 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1281 static void isp116x_stop(struct usb_hcd *hcd)
1283 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1284 unsigned long flags;
1287 spin_lock_irqsave(&isp116x->lock, flags);
1288 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1290 /* Switch off ports' power, some devices don't come up
1291 after next 'insmod' without this */
1292 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1293 val &= ~(RH_A_NPS | RH_A_PSM);
1294 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1295 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1296 spin_unlock_irqrestore(&isp116x->lock, flags);
1298 isp116x_sw_reset(isp116x);
1302 Configure the chip. The chip must be successfully reset by now.
1304 static int isp116x_start(struct usb_hcd *hcd)
1306 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1307 struct isp116x_platform_data *board = isp116x->board;
1309 unsigned long flags;
1311 spin_lock_irqsave(&isp116x->lock, flags);
1313 /* clear interrupt status and disable all interrupt sources */
1314 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1315 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1317 val = isp116x_read_reg16(isp116x, HCCHIPID);
1318 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1319 ERR("Invalid chip ID %04x\n", val);
1320 spin_unlock_irqrestore(&isp116x->lock, flags);
1324 /* To be removed in future */
1325 hcd->uses_new_polling = 1;
1327 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1328 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1331 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1332 if (board->sel15Kres)
1333 val |= HCHWCFG_15KRSEL;
1334 /* Remote wakeup won't work without working clock */
1335 if (board->remote_wakeup_enable)
1336 val |= HCHWCFG_CLKNOTSTOP;
1337 if (board->oc_enable)
1338 val |= HCHWCFG_ANALOG_OC;
1339 if (board->int_act_high)
1340 val |= HCHWCFG_INT_POL;
1341 if (board->int_edge_triggered)
1342 val |= HCHWCFG_INT_TRIGGER;
1343 isp116x_write_reg16(isp116x, HCHWCFG, val);
1345 /* ----- Root hub conf */
1346 val = (25 << 24) & RH_A_POTPGT;
1347 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1348 be always set. Yet, instead, we request individual port
1351 /* Report overcurrent per port */
1353 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1354 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1357 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1358 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1361 if (board->remote_wakeup_enable) {
1362 if (!device_can_wakeup(hcd->self.controller))
1363 device_init_wakeup(hcd->self.controller, 1);
1366 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1367 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1369 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1371 hcd->state = HC_STATE_RUNNING;
1373 /* Set up interrupts */
1374 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1375 if (board->remote_wakeup_enable)
1376 isp116x->intenb |= HCINT_RD;
1377 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1378 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1379 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1381 /* Go operational */
1382 val = HCCONTROL_USB_OPER;
1383 if (board->remote_wakeup_enable)
1384 val |= HCCONTROL_RWE;
1385 isp116x_write_reg32(isp116x, HCCONTROL, val);
1387 /* Disable ports to avoid race in device enumeration */
1388 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1389 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1391 isp116x_show_regs_log(isp116x);
1392 spin_unlock_irqrestore(&isp116x->lock, flags);
1398 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1400 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1401 unsigned long flags;
1405 spin_lock_irqsave(&isp116x->lock, flags);
1406 val = isp116x_read_reg32(isp116x, HCCONTROL);
1408 switch (val & HCCONTROL_HCFS) {
1409 case HCCONTROL_USB_OPER:
1410 spin_unlock_irqrestore(&isp116x->lock, flags);
1411 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1412 val |= HCCONTROL_USB_SUSPEND;
1413 if (device_may_wakeup(&hcd->self.root_hub->dev))
1414 val |= HCCONTROL_RWE;
1415 /* Wait for usb transfers to finish */
1417 spin_lock_irqsave(&isp116x->lock, flags);
1418 isp116x_write_reg32(isp116x, HCCONTROL, val);
1419 spin_unlock_irqrestore(&isp116x->lock, flags);
1420 /* Wait for devices to suspend */
1423 case HCCONTROL_USB_RESUME:
1424 isp116x_write_reg32(isp116x, HCCONTROL,
1425 (val & ~HCCONTROL_HCFS) |
1426 HCCONTROL_USB_RESET);
1427 case HCCONTROL_USB_RESET:
1429 default: /* HCCONTROL_USB_SUSPEND */
1430 spin_unlock_irqrestore(&isp116x->lock, flags);
1437 static int isp116x_bus_resume(struct usb_hcd *hcd)
1439 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1443 spin_lock_irq(&isp116x->lock);
1445 val = isp116x_read_reg32(isp116x, HCCONTROL);
1446 switch (val & HCCONTROL_HCFS) {
1447 case HCCONTROL_USB_SUSPEND:
1448 val &= ~HCCONTROL_HCFS;
1449 val |= HCCONTROL_USB_RESUME;
1450 isp116x_write_reg32(isp116x, HCCONTROL, val);
1451 case HCCONTROL_USB_RESUME:
1453 case HCCONTROL_USB_OPER:
1454 spin_unlock_irq(&isp116x->lock);
1455 /* Without setting power_state here the
1456 SUSPENDED state won't be removed from
1457 sysfs/usbN/power.state as a response to remote
1458 wakeup. Maybe in the future. */
1459 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1462 /* HCCONTROL_USB_RESET: this may happen, when during
1463 suspension the HC lost power. Reinitialize completely */
1464 spin_unlock_irq(&isp116x->lock);
1465 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1468 isp116x_hub_control(hcd, SetPortFeature,
1469 USB_PORT_FEAT_POWER, 1, NULL, 0);
1470 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1471 isp116x_hub_control(hcd, SetPortFeature,
1472 USB_PORT_FEAT_POWER, 2, NULL, 0);
1473 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1477 val = isp116x->rhdesca & RH_A_NDP;
1480 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1481 /* force global, not selective, resume */
1482 if (!(stat & RH_PS_PSS))
1484 DBG("%s: Resuming port %d\n", __func__, val);
1485 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1486 ? HCRHPORT2 : HCRHPORT1);
1488 spin_unlock_irq(&isp116x->lock);
1490 hcd->state = HC_STATE_RESUMING;
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);
1499 /* see analogous comment above */
1500 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1501 hcd->state = HC_STATE_RUNNING;
1508 #define isp116x_bus_suspend NULL
1509 #define isp116x_bus_resume NULL
1513 static struct hc_driver isp116x_hc_driver = {
1514 .description = hcd_name,
1515 .product_desc = "ISP116x Host Controller",
1516 .hcd_priv_size = sizeof(struct isp116x),
1521 .reset = isp116x_reset,
1522 .start = isp116x_start,
1523 .stop = isp116x_stop,
1525 .urb_enqueue = isp116x_urb_enqueue,
1526 .urb_dequeue = isp116x_urb_dequeue,
1527 .endpoint_disable = isp116x_endpoint_disable,
1529 .get_frame_number = isp116x_get_frame,
1531 .hub_status_data = isp116x_hub_status_data,
1532 .hub_control = isp116x_hub_control,
1533 .bus_suspend = isp116x_bus_suspend,
1534 .bus_resume = isp116x_bus_resume,
1537 /*----------------------------------------------------------------*/
1539 static int isp116x_remove(struct platform_device *pdev)
1541 struct usb_hcd *hcd = platform_get_drvdata(pdev);
1542 struct isp116x *isp116x;
1543 struct resource *res;
1547 isp116x = hcd_to_isp116x(hcd);
1548 remove_debug_file(isp116x);
1549 usb_remove_hcd(hcd);
1551 iounmap(isp116x->data_reg);
1552 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1553 release_mem_region(res->start, 2);
1554 iounmap(isp116x->addr_reg);
1555 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1556 release_mem_region(res->start, 2);
1562 #define resource_len(r) (((r)->end - (r)->start) + 1)
1564 static int __devinit isp116x_probe(struct platform_device *pdev)
1566 struct usb_hcd *hcd;
1567 struct isp116x *isp116x;
1568 struct resource *addr, *data;
1569 void __iomem *addr_reg;
1570 void __iomem *data_reg;
1574 if (pdev->num_resources < 3) {
1579 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1580 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1581 irq = platform_get_irq(pdev, 0);
1582 if (!addr || !data || irq < 0) {
1587 if (pdev->dev.dma_mask) {
1588 DBG("DMA not supported\n");
1593 if (!request_mem_region(addr->start, 2, hcd_name)) {
1597 addr_reg = ioremap(addr->start, resource_len(addr));
1598 if (addr_reg == NULL) {
1602 if (!request_mem_region(data->start, 2, hcd_name)) {
1606 data_reg = ioremap(data->start, resource_len(data));
1607 if (data_reg == NULL) {
1612 /* allocate and initialize hcd */
1613 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
1618 /* this rsrc_start is bogus */
1619 hcd->rsrc_start = addr->start;
1620 isp116x = hcd_to_isp116x(hcd);
1621 isp116x->data_reg = data_reg;
1622 isp116x->addr_reg = addr_reg;
1623 spin_lock_init(&isp116x->lock);
1624 INIT_LIST_HEAD(&isp116x->async);
1625 isp116x->board = pdev->dev.platform_data;
1627 if (!isp116x->board) {
1628 ERR("Platform data structure not initialized\n");
1632 if (isp116x_check_platform_delay(isp116x)) {
1633 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1635 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1640 ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
1644 ret = create_debug_file(isp116x);
1646 ERR("Couldn't create debugfs entry\n");
1653 usb_remove_hcd(hcd);
1659 release_mem_region(data->start, 2);
1663 release_mem_region(addr->start, 2);
1665 ERR("init error, %d\n", ret);
1671 Suspend of platform device
1673 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1675 VDBG("%s: state %x\n", __func__, state.event);
1676 dev->dev.power.power_state = state;
1681 Resume platform device
1683 static int isp116x_resume(struct platform_device *dev)
1685 VDBG("%s: state %x\n", __func__, dev->power.power_state.event);
1686 dev->dev.power.power_state = PMSG_ON;
1692 #define isp116x_suspend NULL
1693 #define isp116x_resume NULL
1697 static struct platform_driver isp116x_driver = {
1698 .probe = isp116x_probe,
1699 .remove = isp116x_remove,
1700 .suspend = isp116x_suspend,
1701 .resume = isp116x_resume,
1703 .name = (char *)hcd_name,
1707 /*-----------------------------------------------------------------*/
1709 static int __init isp116x_init(void)
1714 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1715 return platform_driver_register(&isp116x_driver);
1718 module_init(isp116x_init);
1720 static void __exit isp116x_cleanup(void)
1722 platform_driver_unregister(&isp116x_driver);
1725 module_exit(isp116x_cleanup);