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;
159 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
160 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
161 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
162 for (ep = isp116x->atl_active; ep; ep = ep->active) {
166 dump_ptd_out_data(ptd, ep->data);
167 isp116x_write_data16(isp116x, ptd->count);
168 isp116x_write_data16(isp116x, ptd->mps);
169 isp116x_write_data16(isp116x, ptd->len);
170 isp116x_write_data16(isp116x, ptd->faddr);
171 buflen -= sizeof(struct ptd);
172 /* Skip writing data for last IN PTD */
173 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
174 write_ptddata_to_fifo(isp116x, ep->data, ep->length);
175 buflen -= ALIGN(ep->length, 4);
182 Read the processed ptd's and data from fifo ram back to
183 URBs' buffers. Fifo must be full and done
185 static void unpack_fifo(struct isp116x *isp116x)
187 struct isp116x_ep *ep;
189 int buflen = isp116x->atl_last_dir == PTD_DIR_IN
190 ? isp116x->atl_buflen : isp116x->atl_bufshrt;
192 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
193 isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
194 isp116x_write_addr(isp116x, HCATLPORT);
195 for (ep = isp116x->atl_active; ep; ep = ep->active) {
197 ptd->count = isp116x_read_data16(isp116x);
198 ptd->mps = isp116x_read_data16(isp116x);
199 ptd->len = isp116x_read_data16(isp116x);
200 ptd->faddr = isp116x_read_data16(isp116x);
201 buflen -= sizeof(struct ptd);
202 /* Skip reading data for last Setup or Out PTD */
203 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
204 read_ptddata_from_fifo(isp116x, ep->data, ep->length);
205 buflen -= ALIGN(ep->length, 4);
208 dump_ptd_in_data(ptd, ep->data);
213 /*---------------------------------------------------------------*/
218 static void preproc_atl_queue(struct isp116x *isp116x)
220 struct isp116x_ep *ep;
225 for (ep = isp116x->atl_active; ep; ep = ep->active) {
226 u16 toggle = 0, dir = PTD_DIR_SETUP;
228 BUG_ON(list_empty(&ep->hep->urb_list));
229 urb = container_of(ep->hep->urb_list.next,
230 struct urb, urb_list);
233 spin_lock(&urb->lock);
234 ep->data = (unsigned char *)urb->transfer_buffer
235 + urb->actual_length;
237 switch (ep->nextpid) {
239 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
243 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
247 len = sizeof(struct usb_ctrlrequest);
248 ep->data = urb->setup_packet;
253 dir = (urb->transfer_buffer_length
254 && usb_pipein(urb->pipe))
255 ? PTD_DIR_OUT : PTD_DIR_IN;
258 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
263 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
264 ptd->mps = PTD_MPS(ep->maxpacket)
265 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
267 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
268 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
269 spin_unlock(&urb->lock);
271 ptd->mps |= PTD_LAST_MSK;
272 isp116x->atl_last_dir = dir;
274 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
275 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
280 Analyze transfer results, handle partial transfers and errors
282 static void postproc_atl_queue(struct isp116x *isp116x)
284 struct isp116x_ep *ep;
286 struct usb_device *udev;
291 for (ep = isp116x->atl_active; ep; ep = ep->active) {
292 BUG_ON(list_empty(&ep->hep->urb_list));
294 container_of(ep->hep->urb_list.next, struct urb, urb_list);
297 cc = PTD_GET_CC(ptd);
299 spin_lock(&urb->lock);
301 /* Data underrun is special. For allowed underrun
302 we clear the error and continue as normal. For
303 forbidden underrun we finish the DATA stage
304 immediately while for control transfer,
305 we do a STATUS stage. */
306 if (cc == TD_DATAUNDERRUN) {
307 if (!(urb->transfer_flags & URB_SHORT_NOT_OK)) {
308 DBG("Allowed data underrun\n");
313 if (usb_pipecontrol(urb->pipe))
314 ep->nextpid = USB_PID_ACK;
316 usb_settoggle(udev, ep->epnum,
319 PTD_GET_TOGGLE(ptd));
320 urb->actual_length += PTD_GET_COUNT(ptd);
321 urb->status = cc_to_error[TD_DATAUNDERRUN];
322 spin_unlock(&urb->lock);
326 /* Keep underrun error through the STATUS stage */
327 if (urb->status == cc_to_error[TD_DATAUNDERRUN])
328 cc = TD_DATAUNDERRUN;
330 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
331 && (++ep->error_count >= 3 || cc == TD_CC_STALL
332 || cc == TD_DATAOVERRUN)) {
333 if (urb->status == -EINPROGRESS)
334 urb->status = cc_to_error[cc];
335 if (ep->nextpid == USB_PID_ACK)
337 spin_unlock(&urb->lock);
340 /* According to usb spec, zero-length Int transfer signals
341 finishing of the urb. Hey, does this apply only
343 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
344 if (urb->status == -EINPROGRESS)
346 spin_unlock(&urb->lock);
350 /* Relax after previously failed, but later succeeded
351 or correctly NAK'ed retransmission attempt */
353 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
356 /* Take into account idiosyncracies of the isp116x chip
357 regarding toggle bit for failed transfers */
358 if (ep->nextpid == USB_PID_OUT)
359 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
360 ^ (ep->error_count > 0));
361 else if (ep->nextpid == USB_PID_IN)
362 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
363 ^ (ep->error_count > 0));
365 switch (ep->nextpid) {
368 urb->actual_length += PTD_GET_COUNT(ptd);
369 if (PTD_GET_ACTIVE(ptd)
370 || (cc != TD_CC_NOERROR && cc < 0x0E))
372 if (urb->transfer_buffer_length != urb->actual_length) {
376 if (urb->transfer_flags & URB_ZERO_PACKET
377 && ep->nextpid == USB_PID_OUT
378 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
379 DBG("Zero packet requested\n");
383 /* All data for this URB is transferred, let's finish */
384 if (usb_pipecontrol(urb->pipe))
385 ep->nextpid = USB_PID_ACK;
386 else if (urb->status == -EINPROGRESS)
390 if (PTD_GET_ACTIVE(ptd)
391 || (cc != TD_CC_NOERROR && cc < 0x0E))
393 if (urb->transfer_buffer_length == urb->actual_length)
394 ep->nextpid = USB_PID_ACK;
395 else if (usb_pipeout(urb->pipe)) {
396 usb_settoggle(udev, 0, 1, 1);
397 ep->nextpid = USB_PID_OUT;
399 usb_settoggle(udev, 0, 0, 1);
400 ep->nextpid = USB_PID_IN;
404 if (PTD_GET_ACTIVE(ptd)
405 || (cc != TD_CC_NOERROR && cc < 0x0E))
407 if (urb->status == -EINPROGRESS)
414 spin_unlock(&urb->lock);
419 Take done or failed requests out of schedule. Give back
422 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
423 struct urb *urb, struct pt_regs *regs)
424 __releases(isp116x->lock) __acquires(isp116x->lock)
431 if (usb_pipecontrol(urb->pipe))
432 ep->nextpid = USB_PID_SETUP;
434 urb_dbg(urb, "Finish");
436 spin_unlock(&isp116x->lock);
437 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, regs);
438 spin_lock(&isp116x->lock);
440 /* take idle endpoints out of the schedule */
441 if (!list_empty(&ep->hep->urb_list))
444 /* async deschedule */
445 if (!list_empty(&ep->schedule)) {
446 list_del_init(&ep->schedule);
450 /* periodic deschedule */
451 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
452 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
453 struct isp116x_ep *temp;
454 struct isp116x_ep **prev = &isp116x->periodic[i];
456 while (*prev && ((temp = *prev) != ep))
460 isp116x->load[i] -= ep->load;
462 ep->branch = PERIODIC_SIZE;
463 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
464 ep->load / ep->period;
466 /* switch irq type? */
467 if (!--isp116x->periodic_count) {
468 isp116x->irqenb &= ~HCuPINT_SOF;
469 isp116x->irqenb |= HCuPINT_ATL;
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, struct pt_regs *regs)
575 struct isp116x_ep *ep;
578 if (!isp116x->atl_active)
580 /* Fifo not ready? */
581 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
584 atomic_inc(&isp116x->atl_finishing);
585 unpack_fifo(isp116x);
586 postproc_atl_queue(isp116x);
587 for (ep = isp116x->atl_active; ep; ep = ep->active) {
589 container_of(ep->hep->urb_list.next, struct urb, urb_list);
590 /* USB_PID_ACK check here avoids finishing of
591 control transfers, for which TD_DATAUNDERRUN
592 occured, while URB_SHORT_NOT_OK was set */
593 if (urb && urb->status != -EINPROGRESS
594 && ep->nextpid != USB_PID_ACK)
595 finish_request(isp116x, ep, urb, regs);
597 atomic_dec(&isp116x->atl_finishing);
600 static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs)
602 struct isp116x *isp116x = hcd_to_isp116x(hcd);
604 irqreturn_t ret = IRQ_NONE;
606 spin_lock(&isp116x->lock);
607 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
608 irqstat = isp116x_read_reg16(isp116x, HCuPINT);
609 isp116x_write_reg16(isp116x, HCuPINT, irqstat);
611 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
613 finish_atl_transfers(isp116x, regs);
616 if (irqstat & HCuPINT_OPR) {
617 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
618 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
619 if (intstat & HCINT_UE) {
620 ERR("Unrecoverable error, HC is dead!\n");
621 /* IRQ's are off, we do no DMA,
622 perfectly ready to die ... */
623 hcd->state = HC_STATE_HALT;
627 if (intstat & HCINT_RHSC)
628 /* When root hub or any of its ports is going
629 to come out of suspend, it may take more
630 than 10ms for status bits to stabilize. */
631 mod_timer(&hcd->rh_timer, jiffies
632 + msecs_to_jiffies(20) + 1);
633 if (intstat & HCINT_RD) {
634 DBG("---- remote wakeup\n");
635 usb_hcd_resume_root_hub(hcd);
637 irqstat &= ~HCuPINT_OPR;
641 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
642 start_atl_transfers(isp116x);
645 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
647 spin_unlock(&isp116x->lock);
651 /*-----------------------------------------------------------------*/
653 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
654 * this driver doesn't promise that much since it's got to handle an
655 * IRQ per packet; irq handling latencies also use up that time.
659 #define MAX_PERIODIC_LOAD 600
660 static int balance(struct isp116x *isp116x, u16 period, u16 load)
662 int i, branch = -ENOSPC;
664 /* search for the least loaded schedule branch of that period
665 which has enough bandwidth left unreserved. */
666 for (i = 0; i < period; i++) {
667 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
670 for (j = i; j < PERIODIC_SIZE; j += period) {
671 if ((isp116x->load[j] + load)
675 if (j < PERIODIC_SIZE)
683 /* NB! ALL the code above this point runs with isp116x->lock
687 /*-----------------------------------------------------------------*/
689 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
690 struct usb_host_endpoint *hep, struct urb *urb,
693 struct isp116x *isp116x = hcd_to_isp116x(hcd);
694 struct usb_device *udev = urb->dev;
695 unsigned int pipe = urb->pipe;
696 int is_out = !usb_pipein(pipe);
697 int type = usb_pipetype(pipe);
698 int epnum = usb_pipeendpoint(pipe);
699 struct isp116x_ep *ep = NULL;
704 urb_dbg(urb, "Enqueue");
706 if (type == PIPE_ISOCHRONOUS) {
707 ERR("Isochronous transfers not supported\n");
708 urb_dbg(urb, "Refused to enqueue");
711 /* avoid all allocations within spinlocks: request or endpoint */
713 ep = kzalloc(sizeof *ep, mem_flags);
718 spin_lock_irqsave(&isp116x->lock, flags);
719 if (!HC_IS_RUNNING(hcd->state)) {
728 INIT_LIST_HEAD(&ep->schedule);
729 ep->udev = usb_get_dev(udev);
731 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
732 usb_settoggle(udev, epnum, is_out, 0);
734 if (type == PIPE_CONTROL) {
735 ep->nextpid = USB_PID_SETUP;
737 ep->nextpid = USB_PID_OUT;
739 ep->nextpid = USB_PID_IN;
744 With INT URBs submitted, the driver works with SOF
745 interrupt enabled and ATL interrupt disabled. After
746 the PTDs are written to fifo ram, the chip starts
747 fifo processing and usb transfers after the next
748 SOF and continues until the transfers are finished
749 (succeeded or failed) or the frame ends. Therefore,
750 the transfers occur only in every second frame,
751 while fifo reading/writing and data processing
752 occur in every other second frame. */
753 if (urb->interval < 2)
755 if (urb->interval > 2 * PERIODIC_SIZE)
756 urb->interval = 2 * PERIODIC_SIZE;
757 ep->period = urb->interval >> 1;
758 ep->branch = PERIODIC_SIZE;
759 ep->load = usb_calc_bus_time(udev->speed,
761 (type == PIPE_ISOCHRONOUS),
762 usb_maxpacket(udev, pipe,
770 /* maybe put endpoint into schedule */
774 if (list_empty(&ep->schedule))
775 list_add_tail(&ep->schedule, &isp116x->async);
778 urb->interval = ep->period;
779 ep->length = min((int)ep->maxpacket,
780 urb->transfer_buffer_length);
782 /* urb submitted for already existing endpoint */
783 if (ep->branch < PERIODIC_SIZE)
786 ret = ep->branch = balance(isp116x, ep->period, ep->load);
791 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
794 /* sort each schedule branch by period (slow before fast)
795 to share the faster parts of the tree without needing
796 dummy/placeholder nodes */
797 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
798 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
799 struct isp116x_ep **prev = &isp116x->periodic[i];
800 struct isp116x_ep *here = *prev;
802 while (here && ep != here) {
803 if (ep->period > here->period)
812 isp116x->load[i] += ep->load;
814 hcd->self.bandwidth_allocated += ep->load / ep->period;
816 /* switch over to SOFint */
817 if (!isp116x->periodic_count++) {
818 isp116x->irqenb &= ~HCuPINT_ATL;
819 isp116x->irqenb |= HCuPINT_SOF;
820 isp116x_write_reg16(isp116x, HCuPINTENB,
825 /* in case of unlink-during-submit */
826 spin_lock(&urb->lock);
827 if (urb->status != -EINPROGRESS) {
828 spin_unlock(&urb->lock);
829 finish_request(isp116x, ep, urb, NULL);
834 spin_unlock(&urb->lock);
835 start_atl_transfers(isp116x);
838 spin_unlock_irqrestore(&isp116x->lock, flags);
845 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
847 struct isp116x *isp116x = hcd_to_isp116x(hcd);
848 struct usb_host_endpoint *hep;
849 struct isp116x_ep *ep, *ep_act;
852 spin_lock_irqsave(&isp116x->lock, flags);
854 /* URB already unlinked (or never linked)? */
856 spin_unlock_irqrestore(&isp116x->lock, flags);
860 WARN_ON(hep != ep->hep);
862 /* In front of queue? */
863 if (ep->hep->urb_list.next == &urb->urb_list)
865 for (ep_act = isp116x->atl_active; ep_act;
866 ep_act = ep_act->active)
868 VDBG("dequeue, urb %p active; wait for irq\n",
875 finish_request(isp116x, ep, urb, NULL);
877 spin_unlock_irqrestore(&isp116x->lock, flags);
881 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
882 struct usb_host_endpoint *hep)
885 struct isp116x_ep *ep = hep->hcpriv;
890 /* assume we'd just wait for the irq */
891 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
893 if (!list_empty(&hep->urb_list))
894 WARN("ep %p not empty?\n", ep);
896 usb_put_dev(ep->udev);
901 static int isp116x_get_frame(struct usb_hcd *hcd)
903 struct isp116x *isp116x = hcd_to_isp116x(hcd);
907 spin_lock_irqsave(&isp116x->lock, flags);
908 fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
909 spin_unlock_irqrestore(&isp116x->lock, flags);
914 Adapted from ohci-hub.c. Currently we don't support autosuspend.
916 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
918 struct isp116x *isp116x = hcd_to_isp116x(hcd);
919 int ports, i, changed = 0;
922 if (!HC_IS_RUNNING(hcd->state))
925 /* Report no status change now, if we are scheduled to be
927 if (timer_pending(&hcd->rh_timer))
930 ports = isp116x->rhdesca & RH_A_NDP;
931 spin_lock_irqsave(&isp116x->lock, flags);
932 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
933 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
934 buf[0] = changed = 1;
938 for (i = 0; i < ports; i++) {
939 u32 status = isp116x->rhport[i] =
940 isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
942 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
943 | RH_PS_OCIC | RH_PS_PRSC)) {
945 buf[0] |= 1 << (i + 1);
949 spin_unlock_irqrestore(&isp116x->lock, flags);
953 static void isp116x_hub_descriptor(struct isp116x *isp116x,
954 struct usb_hub_descriptor *desc)
956 u32 reg = isp116x->rhdesca;
958 desc->bDescriptorType = 0x29;
959 desc->bDescLength = 9;
960 desc->bHubContrCurrent = 0;
961 desc->bNbrPorts = (u8) (reg & 0x3);
962 /* Power switching, device type, overcurrent. */
963 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
964 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
965 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */
967 desc->bitmap[1] = ~0;
970 /* Perform reset of a given port.
971 It would be great to just start the reset and let the
972 USB core to clear the reset in due time. However,
973 root hub ports should be reset for at least 50 ms, while
974 our chip stays in reset for about 10 ms. I.e., we must
975 repeatedly reset it ourself here.
977 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
980 unsigned long flags, t;
982 /* Root hub reset should be 50 ms, but some devices
983 want it even longer. */
984 t = jiffies + msecs_to_jiffies(100);
986 while (time_before(jiffies, t)) {
987 spin_lock_irqsave(&isp116x->lock, flags);
988 /* spin until any current reset finishes */
990 tmp = isp116x_read_reg32(isp116x, port ?
991 HCRHPORT2 : HCRHPORT1);
992 if (!(tmp & RH_PS_PRS))
996 /* Don't reset a disconnected port */
997 if (!(tmp & RH_PS_CCS)) {
998 spin_unlock_irqrestore(&isp116x->lock, flags);
1001 /* Reset lasts 10ms (claims datasheet) */
1002 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
1003 HCRHPORT1, (RH_PS_PRS));
1004 spin_unlock_irqrestore(&isp116x->lock, flags);
1009 /* Adapted from ohci-hub.c */
1010 static int isp116x_hub_control(struct usb_hcd *hcd,
1012 u16 wValue, u16 wIndex, char *buf, u16 wLength)
1014 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1016 unsigned long flags;
1017 int ports = isp116x->rhdesca & RH_A_NDP;
1021 case ClearHubFeature:
1022 DBG("ClearHubFeature: ");
1024 case C_HUB_OVER_CURRENT:
1025 DBG("C_HUB_OVER_CURRENT\n");
1026 spin_lock_irqsave(&isp116x->lock, flags);
1027 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1028 spin_unlock_irqrestore(&isp116x->lock, flags);
1029 case C_HUB_LOCAL_POWER:
1030 DBG("C_HUB_LOCAL_POWER\n");
1037 DBG("SetHubFeature: ");
1039 case C_HUB_OVER_CURRENT:
1040 case C_HUB_LOCAL_POWER:
1041 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1047 case GetHubDescriptor:
1048 DBG("GetHubDescriptor\n");
1049 isp116x_hub_descriptor(isp116x,
1050 (struct usb_hub_descriptor *)buf);
1053 DBG("GetHubStatus\n");
1054 *(__le32 *) buf = 0;
1057 DBG("GetPortStatus\n");
1058 if (!wIndex || wIndex > ports)
1060 tmp = isp116x->rhport[--wIndex];
1061 *(__le32 *) buf = cpu_to_le32(tmp);
1062 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp);
1064 case ClearPortFeature:
1065 DBG("ClearPortFeature: ");
1066 if (!wIndex || wIndex > ports)
1071 case USB_PORT_FEAT_ENABLE:
1072 DBG("USB_PORT_FEAT_ENABLE\n");
1075 case USB_PORT_FEAT_C_ENABLE:
1076 DBG("USB_PORT_FEAT_C_ENABLE\n");
1079 case USB_PORT_FEAT_SUSPEND:
1080 DBG("USB_PORT_FEAT_SUSPEND\n");
1083 case USB_PORT_FEAT_C_SUSPEND:
1084 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1087 case USB_PORT_FEAT_POWER:
1088 DBG("USB_PORT_FEAT_POWER\n");
1091 case USB_PORT_FEAT_C_CONNECTION:
1092 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1095 case USB_PORT_FEAT_C_OVER_CURRENT:
1096 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1099 case USB_PORT_FEAT_C_RESET:
1100 DBG("USB_PORT_FEAT_C_RESET\n");
1106 spin_lock_irqsave(&isp116x->lock, flags);
1107 isp116x_write_reg32(isp116x, wIndex
1108 ? HCRHPORT2 : HCRHPORT1, tmp);
1109 isp116x->rhport[wIndex] =
1110 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1111 spin_unlock_irqrestore(&isp116x->lock, flags);
1113 case SetPortFeature:
1114 DBG("SetPortFeature: ");
1115 if (!wIndex || wIndex > ports)
1119 case USB_PORT_FEAT_SUSPEND:
1120 DBG("USB_PORT_FEAT_SUSPEND\n");
1121 spin_lock_irqsave(&isp116x->lock, flags);
1122 isp116x_write_reg32(isp116x, wIndex
1123 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1125 case USB_PORT_FEAT_POWER:
1126 DBG("USB_PORT_FEAT_POWER\n");
1127 spin_lock_irqsave(&isp116x->lock, flags);
1128 isp116x_write_reg32(isp116x, wIndex
1129 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1131 case USB_PORT_FEAT_RESET:
1132 DBG("USB_PORT_FEAT_RESET\n");
1133 root_port_reset(isp116x, wIndex);
1134 spin_lock_irqsave(&isp116x->lock, flags);
1139 isp116x->rhport[wIndex] =
1140 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1141 spin_unlock_irqrestore(&isp116x->lock, flags);
1146 /* "protocol stall" on error */
1147 DBG("PROTOCOL STALL\n");
1153 /*-----------------------------------------------------------------*/
1155 #ifdef CONFIG_DEBUG_FS
1157 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1159 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1160 mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1161 mask & HCuPINT_SUSP ? " susp" : "",
1162 mask & HCuPINT_OPR ? " opr" : "",
1163 mask & HCuPINT_AIIEOT ? " eot" : "",
1164 mask & HCuPINT_ATL ? " atl" : "",
1165 mask & HCuPINT_SOF ? " sof" : "");
1168 static void dump_int(struct seq_file *s, char *label, u32 mask)
1170 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1171 mask & HCINT_MIE ? " MIE" : "",
1172 mask & HCINT_RHSC ? " rhsc" : "",
1173 mask & HCINT_FNO ? " fno" : "",
1174 mask & HCINT_UE ? " ue" : "",
1175 mask & HCINT_RD ? " rd" : "",
1176 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1179 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1181 struct isp116x *isp116x = s->private;
1183 seq_printf(s, "%s\n%s version %s\n",
1184 isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1187 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1188 seq_printf(s, "HCD is suspended\n");
1191 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1192 seq_printf(s, "HCD not running\n");
1196 spin_lock_irq(&isp116x->lock);
1197 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1198 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1199 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1200 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1201 isp116x_show_regs_seq(isp116x, s);
1202 spin_unlock_irq(&isp116x->lock);
1203 seq_printf(s, "\n");
1208 static int isp116x_open_seq(struct inode *inode, struct file *file)
1210 return single_open(file, isp116x_show_dbg, inode->u.generic_ip);
1213 static struct file_operations isp116x_debug_fops = {
1214 .open = isp116x_open_seq,
1216 .llseek = seq_lseek,
1217 .release = single_release,
1220 static int create_debug_file(struct isp116x *isp116x)
1222 isp116x->dentry = debugfs_create_file(hcd_name,
1223 S_IRUGO, NULL, isp116x,
1224 &isp116x_debug_fops);
1225 if (!isp116x->dentry)
1230 static void remove_debug_file(struct isp116x *isp116x)
1232 debugfs_remove(isp116x->dentry);
1237 #define create_debug_file(d) 0
1238 #define remove_debug_file(d) do{}while(0)
1240 #endif /* CONFIG_DEBUG_FS */
1242 /*-----------------------------------------------------------------*/
1245 Software reset - can be called from any contect.
1247 static int isp116x_sw_reset(struct isp116x *isp116x)
1250 unsigned long flags;
1253 spin_lock_irqsave(&isp116x->lock, flags);
1254 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1255 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1257 /* It usually resets within 1 ms */
1259 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1263 ERR("Software reset timeout\n");
1266 spin_unlock_irqrestore(&isp116x->lock, flags);
1270 static int isp116x_reset(struct usb_hcd *hcd)
1272 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1275 int ret, timeout = 15 /* ms */ ;
1277 ret = isp116x_sw_reset(isp116x);
1281 t = jiffies + msecs_to_jiffies(timeout);
1282 while (time_before_eq(jiffies, t)) {
1284 spin_lock_irq(&isp116x->lock);
1285 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1286 spin_unlock_irq(&isp116x->lock);
1291 ERR("Clock not ready after %dms\n", timeout);
1292 /* After sw_reset the clock won't report to be ready, if
1293 H_WAKEUP pin is high. */
1294 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1300 static void isp116x_stop(struct usb_hcd *hcd)
1302 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1303 unsigned long flags;
1306 spin_lock_irqsave(&isp116x->lock, flags);
1307 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1309 /* Switch off ports' power, some devices don't come up
1310 after next 'insmod' without this */
1311 val = isp116x_read_reg32(isp116x, HCRHDESCA);
1312 val &= ~(RH_A_NPS | RH_A_PSM);
1313 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1314 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1315 spin_unlock_irqrestore(&isp116x->lock, flags);
1317 isp116x_sw_reset(isp116x);
1321 Configure the chip. The chip must be successfully reset by now.
1323 static int isp116x_start(struct usb_hcd *hcd)
1325 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1326 struct isp116x_platform_data *board = isp116x->board;
1328 unsigned long flags;
1330 spin_lock_irqsave(&isp116x->lock, flags);
1332 /* clear interrupt status and disable all interrupt sources */
1333 isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1334 isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1336 val = isp116x_read_reg16(isp116x, HCCHIPID);
1337 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1338 ERR("Invalid chip ID %04x\n", val);
1339 spin_unlock_irqrestore(&isp116x->lock, flags);
1343 /* To be removed in future */
1344 hcd->uses_new_polling = 1;
1346 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1347 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1350 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1351 if (board->sel15Kres)
1352 val |= HCHWCFG_15KRSEL;
1353 /* Remote wakeup won't work without working clock */
1354 if (board->remote_wakeup_enable)
1355 val |= HCHWCFG_CLKNOTSTOP;
1356 if (board->oc_enable)
1357 val |= HCHWCFG_ANALOG_OC;
1358 if (board->int_act_high)
1359 val |= HCHWCFG_INT_POL;
1360 if (board->int_edge_triggered)
1361 val |= HCHWCFG_INT_TRIGGER;
1362 isp116x_write_reg16(isp116x, HCHWCFG, val);
1364 /* ----- Root hub conf */
1365 val = (25 << 24) & RH_A_POTPGT;
1366 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1367 be always set. Yet, instead, we request individual port
1370 /* Report overcurrent per port */
1372 isp116x_write_reg32(isp116x, HCRHDESCA, val);
1373 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1376 isp116x_write_reg32(isp116x, HCRHDESCB, val);
1377 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1380 if (board->remote_wakeup_enable) {
1381 hcd->can_wakeup = 1;
1384 isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1385 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1387 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1389 hcd->state = HC_STATE_RUNNING;
1391 /* Set up interrupts */
1392 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1393 if (board->remote_wakeup_enable)
1394 isp116x->intenb |= HCINT_RD;
1395 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */
1396 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1397 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1399 /* Go operational */
1400 val = HCCONTROL_USB_OPER;
1401 if (board->remote_wakeup_enable)
1402 val |= HCCONTROL_RWE;
1403 isp116x_write_reg32(isp116x, HCCONTROL, val);
1405 /* Disable ports to avoid race in device enumeration */
1406 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1407 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1409 isp116x_show_regs_log(isp116x);
1410 spin_unlock_irqrestore(&isp116x->lock, flags);
1416 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1418 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1419 unsigned long flags;
1423 spin_lock_irqsave(&isp116x->lock, flags);
1425 val = isp116x_read_reg32(isp116x, HCCONTROL);
1426 switch (val & HCCONTROL_HCFS) {
1427 case HCCONTROL_USB_OPER:
1428 hcd->state = HC_STATE_QUIESCING;
1429 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1430 val |= HCCONTROL_USB_SUSPEND;
1431 if (hcd->remote_wakeup)
1432 val |= HCCONTROL_RWE;
1433 /* Wait for usb transfers to finish */
1435 isp116x_write_reg32(isp116x, HCCONTROL, val);
1436 hcd->state = HC_STATE_SUSPENDED;
1437 /* Wait for devices to suspend */
1439 case HCCONTROL_USB_SUSPEND:
1441 case HCCONTROL_USB_RESUME:
1442 isp116x_write_reg32(isp116x, HCCONTROL,
1443 (val & ~HCCONTROL_HCFS) |
1444 HCCONTROL_USB_RESET);
1445 case HCCONTROL_USB_RESET:
1452 spin_unlock_irqrestore(&isp116x->lock, flags);
1456 static int isp116x_bus_resume(struct usb_hcd *hcd)
1458 struct isp116x *isp116x = hcd_to_isp116x(hcd);
1462 spin_lock_irq(&isp116x->lock);
1464 val = isp116x_read_reg32(isp116x, HCCONTROL);
1465 switch (val & HCCONTROL_HCFS) {
1466 case HCCONTROL_USB_SUSPEND:
1467 val &= ~HCCONTROL_HCFS;
1468 val |= HCCONTROL_USB_RESUME;
1469 isp116x_write_reg32(isp116x, HCCONTROL, val);
1470 case HCCONTROL_USB_RESUME:
1472 case HCCONTROL_USB_OPER:
1473 spin_unlock_irq(&isp116x->lock);
1474 /* Without setting power_state here the
1475 SUSPENDED state won't be removed from
1476 sysfs/usbN/power.state as a response to remote
1477 wakeup. Maybe in the future. */
1478 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1481 /* HCCONTROL_USB_RESET: this may happen, when during
1482 suspension the HC lost power. Reinitialize completely */
1483 spin_unlock_irq(&isp116x->lock);
1484 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1487 isp116x_hub_control(hcd, SetPortFeature,
1488 USB_PORT_FEAT_POWER, 1, NULL, 0);
1489 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1490 isp116x_hub_control(hcd, SetPortFeature,
1491 USB_PORT_FEAT_POWER, 2, NULL, 0);
1492 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1496 val = isp116x->rhdesca & RH_A_NDP;
1499 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1500 /* force global, not selective, resume */
1501 if (!(stat & RH_PS_PSS))
1503 DBG("%s: Resuming port %d\n", __func__, val);
1504 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1505 ? HCRHPORT2 : HCRHPORT1);
1507 spin_unlock_irq(&isp116x->lock);
1509 hcd->state = HC_STATE_RESUMING;
1512 /* Go operational */
1513 spin_lock_irq(&isp116x->lock);
1514 val = isp116x_read_reg32(isp116x, HCCONTROL);
1515 isp116x_write_reg32(isp116x, HCCONTROL,
1516 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1517 spin_unlock_irq(&isp116x->lock);
1518 /* see analogous comment above */
1519 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1520 hcd->state = HC_STATE_RUNNING;
1527 #define isp116x_bus_suspend NULL
1528 #define isp116x_bus_resume NULL
1532 static struct hc_driver isp116x_hc_driver = {
1533 .description = hcd_name,
1534 .product_desc = "ISP116x Host Controller",
1535 .hcd_priv_size = sizeof(struct isp116x),
1540 .reset = isp116x_reset,
1541 .start = isp116x_start,
1542 .stop = isp116x_stop,
1544 .urb_enqueue = isp116x_urb_enqueue,
1545 .urb_dequeue = isp116x_urb_dequeue,
1546 .endpoint_disable = isp116x_endpoint_disable,
1548 .get_frame_number = isp116x_get_frame,
1550 .hub_status_data = isp116x_hub_status_data,
1551 .hub_control = isp116x_hub_control,
1552 .bus_suspend = isp116x_bus_suspend,
1553 .bus_resume = isp116x_bus_resume,
1556 /*----------------------------------------------------------------*/
1558 static int __init_or_module isp116x_remove(struct platform_device *pdev)
1560 struct usb_hcd *hcd = platform_get_drvdata(pdev);
1561 struct isp116x *isp116x;
1562 struct resource *res;
1566 isp116x = hcd_to_isp116x(hcd);
1567 remove_debug_file(isp116x);
1568 usb_remove_hcd(hcd);
1570 iounmap(isp116x->data_reg);
1571 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1572 release_mem_region(res->start, 2);
1573 iounmap(isp116x->addr_reg);
1574 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1575 release_mem_region(res->start, 2);
1581 #define resource_len(r) (((r)->end - (r)->start) + 1)
1583 static int __init isp116x_probe(struct platform_device *pdev)
1585 struct usb_hcd *hcd;
1586 struct isp116x *isp116x;
1587 struct resource *addr, *data;
1588 void __iomem *addr_reg;
1589 void __iomem *data_reg;
1593 if (pdev->num_resources < 3) {
1598 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1599 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1600 irq = platform_get_irq(pdev, 0);
1601 if (!addr || !data || irq < 0) {
1606 if (pdev->dev.dma_mask) {
1607 DBG("DMA not supported\n");
1612 if (!request_mem_region(addr->start, 2, hcd_name)) {
1616 addr_reg = ioremap(addr->start, resource_len(addr));
1617 if (addr_reg == NULL) {
1621 if (!request_mem_region(data->start, 2, hcd_name)) {
1625 data_reg = ioremap(data->start, resource_len(data));
1626 if (data_reg == NULL) {
1631 /* allocate and initialize hcd */
1632 hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
1637 /* this rsrc_start is bogus */
1638 hcd->rsrc_start = addr->start;
1639 isp116x = hcd_to_isp116x(hcd);
1640 isp116x->data_reg = data_reg;
1641 isp116x->addr_reg = addr_reg;
1642 spin_lock_init(&isp116x->lock);
1643 INIT_LIST_HEAD(&isp116x->async);
1644 isp116x->board = pdev->dev.platform_data;
1646 if (!isp116x->board) {
1647 ERR("Platform data structure not initialized\n");
1651 if (isp116x_check_platform_delay(isp116x)) {
1652 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1654 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1659 ret = usb_add_hcd(hcd, irq, SA_INTERRUPT);
1663 ret = create_debug_file(isp116x);
1665 ERR("Couldn't create debugfs entry\n");
1672 usb_remove_hcd(hcd);
1678 release_mem_region(data->start, 2);
1682 release_mem_region(addr->start, 2);
1684 ERR("init error, %d\n", ret);
1690 Suspend of platform device
1692 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1694 VDBG("%s: state %x\n", __func__, state.event);
1695 dev->dev.power.power_state = state;
1700 Resume platform device
1702 static int isp116x_resume(struct platform_device *dev)
1704 VDBG("%s: state %x\n", __func__, dev->power.power_state.event);
1705 dev->dev.power.power_state = PMSG_ON;
1711 #define isp116x_suspend NULL
1712 #define isp116x_resume NULL
1716 static struct platform_driver isp116x_driver = {
1717 .probe = isp116x_probe,
1718 .remove = isp116x_remove,
1719 .suspend = isp116x_suspend,
1720 .resume = isp116x_resume,
1722 .name = (char *)hcd_name,
1726 /*-----------------------------------------------------------------*/
1728 static int __init isp116x_init(void)
1733 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1734 return platform_driver_register(&isp116x_driver);
1737 module_init(isp116x_init);
1739 static void __exit isp116x_cleanup(void)
1741 platform_driver_unregister(&isp116x_driver);
1744 module_exit(isp116x_cleanup);