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 urb->status = status;
459 spin_unlock(&urb->lock);
461 if (urb->status != -EINPROGRESS || urb->unlinked)
462 finish_request(isp116x, ep, urb);
467 Scan transfer lists, schedule transfers, send data off
470 static void start_atl_transfers(struct isp116x *isp116x)
472 struct isp116x_ep *last_ep = NULL, *ep;
475 int len, index, speed, byte_time;
477 if (atomic_read(&isp116x->atl_finishing))
480 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
483 /* FIFO not empty? */
484 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
487 isp116x->atl_active = NULL;
488 isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
490 /* Schedule int transfers */
491 if (isp116x->periodic_count) {
492 isp116x->fmindex = index =
493 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
494 if ((load = isp116x->load[index])) {
495 /* Bring all int transfers for this frame
496 into the active queue */
497 isp116x->atl_active = last_ep =
498 isp116x->periodic[index];
499 while (last_ep->next)
500 last_ep = (last_ep->active = last_ep->next);
501 last_ep->active = NULL;
505 /* Schedule control/bulk transfers */
506 list_for_each_entry(ep, &isp116x->async, schedule) {
507 urb = container_of(ep->hep->urb_list.next,
508 struct urb, urb_list);
509 speed = urb->dev->speed;
510 byte_time = speed == USB_SPEED_LOW
511 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
513 if (ep->nextpid == USB_PID_SETUP) {
514 len = sizeof(struct usb_ctrlrequest);
515 } else if (ep->nextpid == USB_PID_ACK) {
518 /* Find current free length ... */
519 len = (MAX_LOAD_LIMIT - load) / byte_time;
521 /* ... then limit it to configured max size ... */
522 len = min(len, speed == USB_SPEED_LOW ?
523 MAX_TRANSFER_SIZE_LOWSPEED :
524 MAX_TRANSFER_SIZE_FULLSPEED);
526 /* ... and finally cut to the multiple of MaxPacketSize,
527 or to the real length if there's enough room. */
529 (urb->transfer_buffer_length -
530 urb->actual_length)) {
531 len -= len % ep->maxpacket;
535 len = urb->transfer_buffer_length -
540 load += len * byte_time;
541 if (load > MAX_LOAD_LIMIT)
547 last_ep->active = ep;
549 isp116x->atl_active = ep;
553 /* Avoid starving of endpoints */
554 if ((&isp116x->async)->next != (&isp116x->async)->prev)
555 list_move(&isp116x->async, (&isp116x->async)->next);
557 if (isp116x->atl_active) {
558 preproc_atl_queue(isp116x);
564 Finish the processed transfers
566 static void finish_atl_transfers(struct isp116x *isp116x)
568 if (!isp116x->atl_active)
570 /* Fifo not ready? */
571 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
574 atomic_inc(&isp116x->atl_finishing);
575 unpack_fifo(isp116x);
576 postproc_atl_queue(isp116x);
577 atomic_dec(&isp116x->atl_finishing);
580 static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
582 struct isp116x *isp116x = hcd_to_isp116x(hcd);
584 irqreturn_t ret = IRQ_NONE;
586 spin_lock(&isp116x->lock);
587 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
588 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
589 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
591 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
593 finish_atl_transfers(isp116x);
596 if (irqstat & HCuPINT_OPR) {
597 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
598 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
599 if (intstat & HCINT_UE) {
600 ERR("Unrecoverable error, HC is dead!\n");
601 /* IRQ's are off, we do no DMA,
602 perfectly ready to die ... */
603 hcd->state = HC_STATE_HALT;
607 if (intstat & HCINT_RHSC)
608 /* When root hub or any of its ports is going
609 to come out of suspend, it may take more
610 than 10ms for status bits to stabilize. */
611 mod_timer(&hcd->rh_timer, jiffies
612 + msecs_to_jiffies(20) + 1);
613 if (intstat & HCINT_RD) {
614 DBG("---- remote wakeup\n");
615 usb_hcd_resume_root_hub(hcd);
617 irqstat &= ~HCuPINT_OPR;
621 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
622 start_atl_transfers(isp116x);
625 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
627 spin_unlock(&isp116x->lock);
631 /*-----------------------------------------------------------------*/
633 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
634 * this driver doesn't promise that much since it's got to handle an
635 * IRQ per packet; irq handling latencies also use up that time.
639 #define MAX_PERIODIC_LOAD 600
640 static int balance(struct isp116x *isp116x, u16 period, u16 load)
642 int i, branch = -ENOSPC;
644 /* search for the least loaded schedule branch of that period
645 which has enough bandwidth left unreserved. */
646 for (i = 0; i < period; i++) {
647 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
650 for (j = i; j < PERIODIC_SIZE; j += period) {
651 if ((isp116x->load[j] + load)
655 if (j < PERIODIC_SIZE)
663 /* NB! ALL the code above this point runs with isp116x->lock
667 /*-----------------------------------------------------------------*/
669 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
673 struct isp116x *isp116x = hcd_to_isp116x(hcd);
674 struct usb_device *udev = urb->dev;
675 unsigned int pipe = urb->pipe;
676 int is_out = !usb_pipein(pipe);
677 int type = usb_pipetype(pipe);
678 int epnum = usb_pipeendpoint(pipe);
679 struct usb_host_endpoint *hep = urb->ep;
680 struct isp116x_ep *ep = NULL;
685 urb_dbg(urb, "Enqueue");
687 if (type == PIPE_ISOCHRONOUS) {
688 ERR("Isochronous transfers not supported\n");
689 urb_dbg(urb, "Refused to enqueue");
692 /* avoid all allocations within spinlocks: request or endpoint */
694 ep = kzalloc(sizeof *ep, mem_flags);
699 spin_lock_irqsave(&isp116x->lock, flags);
700 if (!HC_IS_RUNNING(hcd->state)) {
703 goto fail_not_linked;
705 ret = usb_hcd_link_urb_to_ep(hcd, urb);
708 goto fail_not_linked;
714 INIT_LIST_HEAD(&ep->schedule);
717 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
718 usb_settoggle(udev, epnum, is_out, 0);
720 if (type == PIPE_CONTROL) {
721 ep->nextpid = USB_PID_SETUP;
723 ep->nextpid = USB_PID_OUT;
725 ep->nextpid = USB_PID_IN;
730 With INT URBs submitted, the driver works with SOF
731 interrupt enabled and ATL interrupt disabled. After
732 the PTDs are written to fifo ram, the chip starts
733 fifo processing and usb transfers after the next
734 SOF and continues until the transfers are finished
735 (succeeded or failed) or the frame ends. Therefore,
736 the transfers occur only in every second frame,
737 while fifo reading/writing and data processing
738 occur in every other second frame. */
739 if (urb->interval < 2)
741 if (urb->interval > 2 * PERIODIC_SIZE)
742 urb->interval = 2 * PERIODIC_SIZE;
743 ep->period = urb->interval >> 1;
744 ep->branch = PERIODIC_SIZE;
745 ep->load = usb_calc_bus_time(udev->speed,
747 (type == PIPE_ISOCHRONOUS),
748 usb_maxpacket(udev, pipe,
756 /* maybe put endpoint into schedule */
760 if (list_empty(&ep->schedule))
761 list_add_tail(&ep->schedule, &isp116x->async);
764 urb->interval = ep->period;
765 ep->length = min((int)ep->maxpacket,
766 urb->transfer_buffer_length);
768 /* urb submitted for already existing endpoint */
769 if (ep->branch < PERIODIC_SIZE)
772 ep->branch = ret = balance(isp116x, ep->period, ep->load);
777 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
780 /* sort each schedule branch by period (slow before fast)
781 to share the faster parts of the tree without needing
782 dummy/placeholder nodes */
783 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
784 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
785 struct isp116x_ep **prev = &isp116x->periodic[i];
786 struct isp116x_ep *here = *prev;
788 while (here && ep != here) {
789 if (ep->period > here->period)
798 isp116x->load[i] += ep->load;
800 hcd->self.bandwidth_allocated += ep->load / ep->period;
802 /* switch over to SOFint */
803 if (!isp116x->periodic_count++) {
804 isp116x->irqenb &= ~HCuPINT_ATL;
805 isp116x->irqenb |= HCuPINT_SOF;
806 isp116x_write_reg16(isp116x, HCuPINTENB,
812 start_atl_transfers(isp116x);
816 usb_hcd_unlink_urb_from_ep(hcd, urb);
818 spin_unlock_irqrestore(&isp116x->lock, flags);
825 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
828 struct isp116x *isp116x = hcd_to_isp116x(hcd);
829 struct usb_host_endpoint *hep;
830 struct isp116x_ep *ep, *ep_act;
834 spin_lock_irqsave(&isp116x->lock, flags);
835 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
841 WARN_ON(hep != ep->hep);
843 /* In front of queue? */
844 if (ep->hep->urb_list.next == &urb->urb_list)
846 for (ep_act = isp116x->atl_active; ep_act;
847 ep_act = ep_act->active)
849 VDBG("dequeue, urb %p active; wait for irq\n",
856 finish_request(isp116x, ep, urb);
858 spin_unlock_irqrestore(&isp116x->lock, flags);
862 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
863 struct usb_host_endpoint *hep)
866 struct isp116x_ep *ep = hep->hcpriv;
871 /* assume we'd just wait for the irq */
872 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
874 if (!list_empty(&hep->urb_list))
875 WARN("ep %p not empty?\n", ep);
881 static int isp116x_get_frame(struct usb_hcd *hcd)
883 struct isp116x *isp116x = hcd_to_isp116x(hcd);
887 spin_lock_irqsave(&isp116x->lock, flags);
888 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
889 spin_unlock_irqrestore(&isp116x->lock, flags);
894 Adapted from ohci-hub.c. Currently we don't support autosuspend.
896 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
898 struct isp116x *isp116x = hcd_to_isp116x(hcd);
899 int ports, i, changed = 0;
902 if (!HC_IS_RUNNING(hcd->state))
905 /* Report no status change now, if we are scheduled to be
907 if (timer_pending(&hcd->rh_timer))
910 ports = isp116x->rhdesca & RH_A_NDP;
911 spin_lock_irqsave(&isp116x->lock, flags);
912 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
913 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
914 buf[0] = changed = 1;
918 for (i = 0; i < ports; i++) {
919 u32 status = isp116x->rhport[i] =
920 isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
922 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
923 | RH_PS_OCIC | RH_PS_PRSC)) {
925 buf[0] |= 1 << (i + 1);
929 spin_unlock_irqrestore(&isp116x->lock, flags);
933 static void isp116x_hub_descriptor(struct isp116x *isp116x,
934 struct usb_hub_descriptor *desc)
936 u32 reg = isp116x->rhdesca;
938 desc->bDescriptorType = 0x29;
939 desc->bDescLength = 9;
940 desc->bHubContrCurrent = 0;
941 desc->bNbrPorts = (u8) (reg & 0x3);
942 /* Power switching, device type, overcurrent. */
943 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
944 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
945 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
947 desc->bitmap[1] = ~0;
950 /* Perform reset of a given port.
951 It would be great to just start the reset and let the
952 USB core to clear the reset in due time. However,
953 root hub ports should be reset for at least 50 ms, while
954 our chip stays in reset for about 10 ms. I.e., we must
955 repeatedly reset it ourself here.
957 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
960 unsigned long flags, t;
962 /* Root hub reset should be 50 ms, but some devices
963 want it even longer. */
964 t = jiffies + msecs_to_jiffies(100);
966 while (time_before(jiffies, t)) {
967 spin_lock_irqsave(&isp116x->lock, flags);
968 /* spin until any current reset finishes */
970 tmp = isp116x_read_reg32(isp116x, port ?
971 HCRHPORT2 : HCRHPORT1);
972 if (!(tmp & RH_PS_PRS))
976 /* Don't reset a disconnected port */
977 if (!(tmp & RH_PS_CCS)) {
978 spin_unlock_irqrestore(&isp116x->lock, flags);
981 /* Reset lasts 10ms (claims datasheet) */
982 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
983 HCRHPORT1, (RH_PS_PRS));
984 spin_unlock_irqrestore(&isp116x->lock, flags);
989 /* Adapted from ohci-hub.c */
990 static int isp116x_hub_control(struct usb_hcd *hcd,
992 u16 wValue, u16 wIndex, char *buf, u16 wLength)
994 struct isp116x *isp116x = hcd_to_isp116x(hcd);
997 int ports = isp116x->rhdesca & RH_A_NDP;
1001 case ClearHubFeature:
1002 DBG("ClearHubFeature: ");
1004 case C_HUB_OVER_CURRENT:
1005 DBG("C_HUB_OVER_CURRENT\n");
1006 spin_lock_irqsave(&isp116x->lock, flags);
1007 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1008 spin_unlock_irqrestore(&isp116x->lock, flags);
1009 case C_HUB_LOCAL_POWER:
1010 DBG("C_HUB_LOCAL_POWER\n");
1017 DBG("SetHubFeature: ");
1019 case C_HUB_OVER_CURRENT:
1020 case C_HUB_LOCAL_POWER:
1021 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1027 case GetHubDescriptor:
1028 DBG("GetHubDescriptor\n");
1029 isp116x_hub_descriptor(isp116x,
1030 (struct usb_hub_descriptor *)buf);
1033 DBG("GetHubStatus\n");
1034 *(__le32 *) buf = 0;
1037 DBG("GetPortStatus\n");
1038 if (!wIndex || wIndex > ports)
1040 tmp = isp116x->rhport[--wIndex];
1041 *(__le32 *) buf = cpu_to_le32(tmp);
1042 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1044 case ClearPortFeature:
1045 DBG("ClearPortFeature: ");
1046 if (!wIndex || wIndex > ports)
1051 case USB_PORT_FEAT_ENABLE:
1052 DBG("USB_PORT_FEAT_ENABLE\n");
1055 case USB_PORT_FEAT_C_ENABLE:
1056 DBG("USB_PORT_FEAT_C_ENABLE\n");
1059 case USB_PORT_FEAT_SUSPEND:
1060 DBG("USB_PORT_FEAT_SUSPEND\n");
1063 case USB_PORT_FEAT_C_SUSPEND:
1064 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1067 case USB_PORT_FEAT_POWER:
1068 DBG("USB_PORT_FEAT_POWER\n");
1071 case USB_PORT_FEAT_C_CONNECTION:
1072 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1075 case USB_PORT_FEAT_C_OVER_CURRENT:
1076 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1079 case USB_PORT_FEAT_C_RESET:
1080 DBG("USB_PORT_FEAT_C_RESET\n");
1086 spin_lock_irqsave(&isp116x->lock, flags);
1087 isp116x_write_reg32(isp116x, wIndex
1088 ? HCRHPORT2 : HCRHPORT1, tmp);
1089 isp116x->rhport[wIndex] =
1090 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1091 spin_unlock_irqrestore(&isp116x->lock, flags);
1093 case SetPortFeature:
1094 DBG("SetPortFeature: ");
1095 if (!wIndex || wIndex > ports)
1099 case USB_PORT_FEAT_SUSPEND:
1100 DBG("USB_PORT_FEAT_SUSPEND\n");
1101 spin_lock_irqsave(&isp116x->lock, flags);
1102 isp116x_write_reg32(isp116x, wIndex
1103 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1105 case USB_PORT_FEAT_POWER:
1106 DBG("USB_PORT_FEAT_POWER\n");
1107 spin_lock_irqsave(&isp116x->lock, flags);
1108 isp116x_write_reg32(isp116x, wIndex
1109 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1111 case USB_PORT_FEAT_RESET:
1112 DBG("USB_PORT_FEAT_RESET\n");
1113 root_port_reset(isp116x, wIndex);
1114 spin_lock_irqsave(&isp116x->lock, flags);
1119 isp116x->rhport[wIndex] =
1120 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1121 spin_unlock_irqrestore(&isp116x->lock, flags);
1126 /* "protocol stall" on error */
1127 DBG("PROTOCOL STALL\n");
1133 /*-----------------------------------------------------------------*/
1135 #ifdef CONFIG_DEBUG_FS
1137 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1139 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1140 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1141 mask & HCuPINT_SUSP ? " susp" : "",
1142 mask & HCuPINT_OPR ? " opr" : "",
1143 mask & HCuPINT_AIIEOT ? " eot" : "",
1144 mask & HCuPINT_ATL ? " atl" : "",
1145 mask & HCuPINT_SOF ? " sof" : "");
1148 static void dump_int(struct seq_file *s, char *label, u32 mask)
1150 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1151 mask & HCINT_MIE ? " MIE" : "",
1152 mask & HCINT_RHSC ? " rhsc" : "",
1153 mask & HCINT_FNO ? " fno" : "",
1154 mask & HCINT_UE ? " ue" : "",
1155 mask & HCINT_RD ? " rd" : "",
1156 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1159 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1161 struct isp116x *isp116x = s->private;
1163 seq_printf(s, "%s\n%s version %s\n",
1164 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1167 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1168 seq_printf(s, "HCD is suspended\n");
1171 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1172 seq_printf(s, "HCD not running\n");
1176 spin_lock_irq(&isp116x->lock);
1177 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1178 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1179 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1180 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1181 isp116x_show_regs_seq(isp116x, s);
1182 spin_unlock_irq(&isp116x->lock);
1183 seq_printf(s, "\n");
1188 static int isp116x_open_seq(struct inode *inode, struct file *file)
1190 return single_open(file, isp116x_show_dbg, inode->i_private);
1193 static const struct file_operations isp116x_debug_fops = {
1194 .open = isp116x_open_seq,
1196 .llseek = seq_lseek,
1197 .release = single_release,
1200 static int create_debug_file(struct isp116x *isp116x)
1202 isp116x->dentry = debugfs_create_file(hcd_name,
1203 S_IRUGO, NULL, isp116x,
1204 &isp116x_debug_fops);
1205 if (!isp116x->dentry)
1210 static void remove_debug_file(struct isp116x *isp116x)
1212 debugfs_remove(isp116x->dentry);
1217 #define create_debug_file(d) 0
1218 #define remove_debug_file(d) do{}while(0)
1220 #endif /* CONFIG_DEBUG_FS */
1222 /*-----------------------------------------------------------------*/
1225 Software reset - can be called from any contect.
1227 static int isp116x_sw_reset(struct isp116x *isp116x)
1230 unsigned long flags;
1233 spin_lock_irqsave(&isp116x->lock, flags);
1234 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1235 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1237 /* It usually resets within 1 ms */
1239 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1243 ERR("Software reset timeout\n");
1246 spin_unlock_irqrestore(&isp116x->lock, flags);
1250 static int isp116x_reset(struct usb_hcd *hcd)
1252 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1255 int ret, timeout = 15 /* ms */ ;
1257 ret = isp116x_sw_reset(isp116x);
1261 t = jiffies + msecs_to_jiffies(timeout);
1262 while (time_before_eq(jiffies, t)) {
1264 spin_lock_irq(&isp116x->lock);
1265 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1266 spin_unlock_irq(&isp116x->lock);
1271 ERR("Clock not ready after %dms\n", timeout);
1272 /* After sw_reset the clock won't report to be ready, if
1273 H_WAKEUP pin is high. */
1274 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1280 static void isp116x_stop(struct usb_hcd *hcd)
1282 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1283 unsigned long flags;
1286 spin_lock_irqsave(&isp116x->lock, flags);
1287 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1289 /* Switch off ports' power, some devices don't come up
1290 after next 'insmod' without this */
1291 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1292 val &= ~(RH_A_NPS | RH_A_PSM);
1293 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1294 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1295 spin_unlock_irqrestore(&isp116x->lock, flags);
1297 isp116x_sw_reset(isp116x);
1301 Configure the chip. The chip must be successfully reset by now.
1303 static int isp116x_start(struct usb_hcd *hcd)
1305 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1306 struct isp116x_platform_data *board = isp116x->board;
1308 unsigned long flags;
1310 spin_lock_irqsave(&isp116x->lock, flags);
1312 /* clear interrupt status and disable all interrupt sources */
1313 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1314 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1316 val = isp116x_read_reg16(isp116x, HCCHIPID);
1317 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1318 ERR("Invalid chip ID %04x\n", val);
1319 spin_unlock_irqrestore(&isp116x->lock, flags);
1323 /* To be removed in future */
1324 hcd->uses_new_polling = 1;
1326 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1327 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1330 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1331 if (board->sel15Kres)
1332 val |= HCHWCFG_15KRSEL;
1333 /* Remote wakeup won't work without working clock */
1334 if (board->remote_wakeup_enable)
1335 val |= HCHWCFG_CLKNOTSTOP;
1336 if (board->oc_enable)
1337 val |= HCHWCFG_ANALOG_OC;
1338 if (board->int_act_high)
1339 val |= HCHWCFG_INT_POL;
1340 if (board->int_edge_triggered)
1341 val |= HCHWCFG_INT_TRIGGER;
1342 isp116x_write_reg16(isp116x, HCHWCFG, val);
1344 /* ----- Root hub conf */
1345 val = (25 << 24) & RH_A_POTPGT;
1346 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1347 be always set. Yet, instead, we request individual port
1350 /* Report overcurrent per port */
1352 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1353 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1356 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1357 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1360 if (board->remote_wakeup_enable) {
1361 if (!device_can_wakeup(hcd->self.controller))
1362 device_init_wakeup(hcd->self.controller, 1);
1365 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1366 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1368 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1370 hcd->state = HC_STATE_RUNNING;
1372 /* Set up interrupts */
1373 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1374 if (board->remote_wakeup_enable)
1375 isp116x->intenb |= HCINT_RD;
1376 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1377 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1378 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1380 /* Go operational */
1381 val = HCCONTROL_USB_OPER;
1382 if (board->remote_wakeup_enable)
1383 val |= HCCONTROL_RWE;
1384 isp116x_write_reg32(isp116x, HCCONTROL, val);
1386 /* Disable ports to avoid race in device enumeration */
1387 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1388 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1390 isp116x_show_regs_log(isp116x);
1391 spin_unlock_irqrestore(&isp116x->lock, flags);
1397 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1399 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1400 unsigned long flags;
1404 spin_lock_irqsave(&isp116x->lock, flags);
1405 val = isp116x_read_reg32(isp116x, HCCONTROL);
1407 switch (val & HCCONTROL_HCFS) {
1408 case HCCONTROL_USB_OPER:
1409 spin_unlock_irqrestore(&isp116x->lock, flags);
1410 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1411 val |= HCCONTROL_USB_SUSPEND;
1412 if (device_may_wakeup(&hcd->self.root_hub->dev))
1413 val |= HCCONTROL_RWE;
1414 /* Wait for usb transfers to finish */
1416 spin_lock_irqsave(&isp116x->lock, flags);
1417 isp116x_write_reg32(isp116x, HCCONTROL, val);
1418 spin_unlock_irqrestore(&isp116x->lock, flags);
1419 /* Wait for devices to suspend */
1422 case HCCONTROL_USB_RESUME:
1423 isp116x_write_reg32(isp116x, HCCONTROL,
1424 (val & ~HCCONTROL_HCFS) |
1425 HCCONTROL_USB_RESET);
1426 case HCCONTROL_USB_RESET:
1428 default: /* HCCONTROL_USB_SUSPEND */
1429 spin_unlock_irqrestore(&isp116x->lock, flags);
1436 static int isp116x_bus_resume(struct usb_hcd *hcd)
1438 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1442 spin_lock_irq(&isp116x->lock);
1444 val = isp116x_read_reg32(isp116x, HCCONTROL);
1445 switch (val & HCCONTROL_HCFS) {
1446 case HCCONTROL_USB_SUSPEND:
1447 val &= ~HCCONTROL_HCFS;
1448 val |= HCCONTROL_USB_RESUME;
1449 isp116x_write_reg32(isp116x, HCCONTROL, val);
1450 case HCCONTROL_USB_RESUME:
1452 case HCCONTROL_USB_OPER:
1453 spin_unlock_irq(&isp116x->lock);
1454 /* Without setting power_state here the
1455 SUSPENDED state won't be removed from
1456 sysfs/usbN/power.state as a response to remote
1457 wakeup. Maybe in the future. */
1458 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1461 /* HCCONTROL_USB_RESET: this may happen, when during
1462 suspension the HC lost power. Reinitialize completely */
1463 spin_unlock_irq(&isp116x->lock);
1464 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1467 isp116x_hub_control(hcd, SetPortFeature,
1468 USB_PORT_FEAT_POWER, 1, NULL, 0);
1469 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1470 isp116x_hub_control(hcd, SetPortFeature,
1471 USB_PORT_FEAT_POWER, 2, NULL, 0);
1472 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1476 val = isp116x->rhdesca & RH_A_NDP;
1479 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1480 /* force global, not selective, resume */
1481 if (!(stat & RH_PS_PSS))
1483 DBG("%s: Resuming port %d\n", __func__, val);
1484 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1485 ? HCRHPORT2 : HCRHPORT1);
1487 spin_unlock_irq(&isp116x->lock);
1489 hcd->state = HC_STATE_RESUMING;
1492 /* Go operational */
1493 spin_lock_irq(&isp116x->lock);
1494 val = isp116x_read_reg32(isp116x, HCCONTROL);
1495 isp116x_write_reg32(isp116x, HCCONTROL,
1496 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1497 spin_unlock_irq(&isp116x->lock);
1498 /* see analogous comment above */
1499 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1500 hcd->state = HC_STATE_RUNNING;
1507 #define isp116x_bus_suspend NULL
1508 #define isp116x_bus_resume NULL
1512 static struct hc_driver isp116x_hc_driver = {
1513 .description = hcd_name,
1514 .product_desc = "ISP116x Host Controller",
1515 .hcd_priv_size = sizeof(struct isp116x),
1520 .reset = isp116x_reset,
1521 .start = isp116x_start,
1522 .stop = isp116x_stop,
1524 .urb_enqueue = isp116x_urb_enqueue,
1525 .urb_dequeue = isp116x_urb_dequeue,
1526 .endpoint_disable = isp116x_endpoint_disable,
1528 .get_frame_number = isp116x_get_frame,
1530 .hub_status_data = isp116x_hub_status_data,
1531 .hub_control = isp116x_hub_control,
1532 .bus_suspend = isp116x_bus_suspend,
1533 .bus_resume = isp116x_bus_resume,
1536 /*----------------------------------------------------------------*/
1538 static int isp116x_remove(struct platform_device *pdev)
1540 struct usb_hcd *hcd = platform_get_drvdata(pdev);
1541 struct isp116x *isp116x;
1542 struct resource *res;
1546 isp116x = hcd_to_isp116x(hcd);
1547 remove_debug_file(isp116x);
1548 usb_remove_hcd(hcd);
1550 iounmap(isp116x->data_reg);
1551 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1552 release_mem_region(res->start, 2);
1553 iounmap(isp116x->addr_reg);
1554 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1555 release_mem_region(res->start, 2);
1561 #define resource_len(r) (((r)->end - (r)->start) + 1)
1563 static int __devinit isp116x_probe(struct platform_device *pdev)
1565 struct usb_hcd *hcd;
1566 struct isp116x *isp116x;
1567 struct resource *addr, *data;
1568 void __iomem *addr_reg;
1569 void __iomem *data_reg;
1573 if (pdev->num_resources < 3) {
1578 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1579 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1580 irq = platform_get_irq(pdev, 0);
1581 if (!addr || !data || irq < 0) {
1586 if (pdev->dev.dma_mask) {
1587 DBG("DMA not supported\n");
1592 if (!request_mem_region(addr->start, 2, hcd_name)) {
1596 addr_reg = ioremap(addr->start, resource_len(addr));
1597 if (addr_reg == NULL) {
1601 if (!request_mem_region(data->start, 2, hcd_name)) {
1605 data_reg = ioremap(data->start, resource_len(data));
1606 if (data_reg == NULL) {
1611 /* allocate and initialize hcd */
1612 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
1617 /* this rsrc_start is bogus */
1618 hcd->rsrc_start = addr->start;
1619 isp116x = hcd_to_isp116x(hcd);
1620 isp116x->data_reg = data_reg;
1621 isp116x->addr_reg = addr_reg;
1622 spin_lock_init(&isp116x->lock);
1623 INIT_LIST_HEAD(&isp116x->async);
1624 isp116x->board = pdev->dev.platform_data;
1626 if (!isp116x->board) {
1627 ERR("Platform data structure not initialized\n");
1631 if (isp116x_check_platform_delay(isp116x)) {
1632 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1634 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1639 ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
1643 ret = create_debug_file(isp116x);
1645 ERR("Couldn't create debugfs entry\n");
1652 usb_remove_hcd(hcd);
1658 release_mem_region(data->start, 2);
1662 release_mem_region(addr->start, 2);
1664 ERR("init error, %d\n", ret);
1670 Suspend of platform device
1672 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1674 VDBG("%s: state %x\n", __func__, state.event);
1675 dev->dev.power.power_state = state;
1680 Resume platform device
1682 static int isp116x_resume(struct platform_device *dev)
1684 VDBG("%s: state %x\n", __func__, dev->power.power_state.event);
1685 dev->dev.power.power_state = PMSG_ON;
1691 #define isp116x_suspend NULL
1692 #define isp116x_resume NULL
1696 static struct platform_driver isp116x_driver = {
1697 .probe = isp116x_probe,
1698 .remove = isp116x_remove,
1699 .suspend = isp116x_suspend,
1700 .resume = isp116x_resume,
1702 .name = (char *)hcd_name,
1706 /*-----------------------------------------------------------------*/
1708 static int __init isp116x_init(void)
1713 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1714 return platform_driver_register(&isp116x_driver);
1717 module_init(isp116x_init);
1719 static void __exit isp116x_cleanup(void)
1721 platform_driver_unregister(&isp116x_driver);
1724 module_exit(isp116x_cleanup);