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/list.h>
64 #include <linux/slab.h>
65 #include <linux/usb.h>
66 #include <linux/usb/isp116x.h>
67 #include <linux/usb/hcd.h>
68 #include <linux/platform_device.h>
72 #include <asm/byteorder.h>
76 #define DRIVER_VERSION "03 Nov 2005"
77 #define DRIVER_DESC "ISP116x USB Host Controller Driver"
79 MODULE_DESCRIPTION(DRIVER_DESC
);
80 MODULE_LICENSE("GPL");
82 static const char hcd_name
[] = "isp116x-hcd";
84 /*-----------------------------------------------------------------*/
87 Write len bytes to fifo, pad till 32-bit boundary
89 static void write_ptddata_to_fifo(struct isp116x
*isp116x
, void *buf
, int len
)
92 u16
*dp2
= (u16
*) buf
;
96 /* buffer is already in 'usb data order', which is LE. */
97 /* When reading buffer as u16, we have to take care byte order */
98 /* doesn't get mixed up */
100 if ((unsigned long)dp2
& 1) {
102 for (; len
> 1; len
-= 2) {
105 isp116x_raw_write_data16(isp116x
, w
);
108 isp116x_write_data16(isp116x
, (u16
) * dp
);
111 for (; len
> 1; len
-= 2) {
112 /* Keep byte order ! */
113 isp116x_raw_write_data16(isp116x
, cpu_to_le16(*dp2
++));
117 isp116x_write_data16(isp116x
, 0xff & *((u8
*) dp2
));
119 if (quot
== 1 || quot
== 2)
120 isp116x_raw_write_data16(isp116x
, 0);
124 Read len bytes from fifo and then read till 32-bit boundary.
126 static void read_ptddata_from_fifo(struct isp116x
*isp116x
, void *buf
, int len
)
129 u16
*dp2
= (u16
*) buf
;
133 /* buffer is already in 'usb data order', which is LE. */
134 /* When reading buffer as u16, we have to take care byte order */
135 /* doesn't get mixed up */
137 if ((unsigned long)dp2
& 1) {
139 for (; len
> 1; len
-= 2) {
140 w
= isp116x_raw_read_data16(isp116x
);
142 *dp
++ = (w
>> 8) & 0xff;
146 *dp
= 0xff & isp116x_read_data16(isp116x
);
149 for (; len
> 1; len
-= 2) {
150 /* Keep byte order! */
151 *dp2
++ = le16_to_cpu(isp116x_raw_read_data16(isp116x
));
155 *(u8
*) dp2
= 0xff & isp116x_read_data16(isp116x
);
157 if (quot
== 1 || quot
== 2)
158 isp116x_raw_read_data16(isp116x
);
162 Write ptd's and data for scheduled transfers into
163 the fifo ram. Fifo must be empty and ready.
165 static void pack_fifo(struct isp116x
*isp116x
)
167 struct isp116x_ep
*ep
;
169 int buflen
= isp116x
->atl_last_dir
== PTD_DIR_IN
170 ? isp116x
->atl_bufshrt
: isp116x
->atl_buflen
;
172 isp116x_write_reg16(isp116x
, HCuPINT
, HCuPINT_AIIEOT
);
173 isp116x_write_reg16(isp116x
, HCXFERCTR
, buflen
);
174 isp116x_write_addr(isp116x
, HCATLPORT
| ISP116x_WRITE_OFFSET
);
175 for (ep
= isp116x
->atl_active
; ep
; ep
= ep
->active
) {
178 dump_ptd_out_data(ptd
, ep
->data
);
179 isp116x_write_data16(isp116x
, ptd
->count
);
180 isp116x_write_data16(isp116x
, ptd
->mps
);
181 isp116x_write_data16(isp116x
, ptd
->len
);
182 isp116x_write_data16(isp116x
, ptd
->faddr
);
183 buflen
-= sizeof(struct ptd
);
184 /* Skip writing data for last IN PTD */
185 if (ep
->active
|| (isp116x
->atl_last_dir
!= PTD_DIR_IN
)) {
186 write_ptddata_to_fifo(isp116x
, ep
->data
, ep
->length
);
187 buflen
-= ALIGN(ep
->length
, 4);
194 Read the processed ptd's and data from fifo ram back to
195 URBs' buffers. Fifo must be full and done
197 static void unpack_fifo(struct isp116x
*isp116x
)
199 struct isp116x_ep
*ep
;
201 int buflen
= isp116x
->atl_last_dir
== PTD_DIR_IN
202 ? isp116x
->atl_buflen
: isp116x
->atl_bufshrt
;
204 isp116x_write_reg16(isp116x
, HCuPINT
, HCuPINT_AIIEOT
);
205 isp116x_write_reg16(isp116x
, HCXFERCTR
, buflen
);
206 isp116x_write_addr(isp116x
, HCATLPORT
);
207 for (ep
= isp116x
->atl_active
; ep
; ep
= ep
->active
) {
209 ptd
->count
= isp116x_read_data16(isp116x
);
210 ptd
->mps
= isp116x_read_data16(isp116x
);
211 ptd
->len
= isp116x_read_data16(isp116x
);
212 ptd
->faddr
= isp116x_read_data16(isp116x
);
213 buflen
-= sizeof(struct ptd
);
214 /* Skip reading data for last Setup or Out PTD */
215 if (ep
->active
|| (isp116x
->atl_last_dir
== PTD_DIR_IN
)) {
216 read_ptddata_from_fifo(isp116x
, ep
->data
, ep
->length
);
217 buflen
-= ALIGN(ep
->length
, 4);
220 dump_ptd_in_data(ptd
, ep
->data
);
225 /*---------------------------------------------------------------*/
230 static void preproc_atl_queue(struct isp116x
*isp116x
)
232 struct isp116x_ep
*ep
;
237 for (ep
= isp116x
->atl_active
; ep
; ep
= ep
->active
) {
238 u16 toggle
= 0, dir
= PTD_DIR_SETUP
;
240 BUG_ON(list_empty(&ep
->hep
->urb_list
));
241 urb
= container_of(ep
->hep
->urb_list
.next
,
242 struct urb
, urb_list
);
245 ep
->data
= (unsigned char *)urb
->transfer_buffer
246 + urb
->actual_length
;
248 switch (ep
->nextpid
) {
250 toggle
= usb_gettoggle(urb
->dev
, ep
->epnum
, 0);
254 toggle
= usb_gettoggle(urb
->dev
, ep
->epnum
, 1);
258 len
= sizeof(struct usb_ctrlrequest
);
259 ep
->data
= urb
->setup_packet
;
264 dir
= (urb
->transfer_buffer_length
265 && usb_pipein(urb
->pipe
))
266 ? PTD_DIR_OUT
: PTD_DIR_IN
;
269 ERR("%s %d: ep->nextpid %d\n", __func__
, __LINE__
,
274 ptd
->count
= PTD_CC_MSK
| PTD_ACTIVE_MSK
| PTD_TOGGLE(toggle
);
275 ptd
->mps
= PTD_MPS(ep
->maxpacket
)
276 | PTD_SPD(urb
->dev
->speed
== USB_SPEED_LOW
)
278 ptd
->len
= PTD_LEN(len
) | PTD_DIR(dir
);
279 ptd
->faddr
= PTD_FA(usb_pipedevice(urb
->pipe
));
281 ptd
->mps
|= PTD_LAST_MSK
;
282 isp116x
->atl_last_dir
= dir
;
284 isp116x
->atl_bufshrt
= sizeof(struct ptd
) + isp116x
->atl_buflen
;
285 isp116x
->atl_buflen
= isp116x
->atl_bufshrt
+ ALIGN(len
, 4);
290 Take done or failed requests out of schedule. Give back
293 static void finish_request(struct isp116x
*isp116x
, struct isp116x_ep
*ep
,
294 struct urb
*urb
, int status
)
295 __releases(isp116x
->lock
) __acquires(isp116x
->lock
)
301 if (usb_pipecontrol(urb
->pipe
))
302 ep
->nextpid
= USB_PID_SETUP
;
304 urb_dbg(urb
, "Finish");
306 usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x
), urb
);
307 spin_unlock(&isp116x
->lock
);
308 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x
), urb
, status
);
309 spin_lock(&isp116x
->lock
);
311 /* take idle endpoints out of the schedule */
312 if (!list_empty(&ep
->hep
->urb_list
))
315 /* async deschedule */
316 if (!list_empty(&ep
->schedule
)) {
317 list_del_init(&ep
->schedule
);
321 /* periodic deschedule */
322 DBG("deschedule qh%d/%p branch %d\n", ep
->period
, ep
, ep
->branch
);
323 for (i
= ep
->branch
; i
< PERIODIC_SIZE
; i
+= ep
->period
) {
324 struct isp116x_ep
*temp
;
325 struct isp116x_ep
**prev
= &isp116x
->periodic
[i
];
327 while (*prev
&& ((temp
= *prev
) != ep
))
331 isp116x
->load
[i
] -= ep
->load
;
333 ep
->branch
= PERIODIC_SIZE
;
334 isp116x_to_hcd(isp116x
)->self
.bandwidth_allocated
-=
335 ep
->load
/ ep
->period
;
337 /* switch irq type? */
338 if (!--isp116x
->periodic_count
) {
339 isp116x
->irqenb
&= ~HCuPINT_SOF
;
340 isp116x
->irqenb
|= HCuPINT_ATL
;
345 Analyze transfer results, handle partial transfers and errors
347 static void postproc_atl_queue(struct isp116x
*isp116x
)
349 struct isp116x_ep
*ep
;
351 struct usb_device
*udev
;
357 for (ep
= isp116x
->atl_active
; ep
; ep
= ep
->active
) {
358 BUG_ON(list_empty(&ep
->hep
->urb_list
));
360 container_of(ep
->hep
->urb_list
.next
, struct urb
, urb_list
);
363 cc
= PTD_GET_CC(ptd
);
365 status
= -EINPROGRESS
;
367 /* Data underrun is special. For allowed underrun
368 we clear the error and continue as normal. For
369 forbidden underrun we finish the DATA stage
370 immediately while for control transfer,
371 we do a STATUS stage. */
372 if (cc
== TD_DATAUNDERRUN
) {
373 if (!(urb
->transfer_flags
& URB_SHORT_NOT_OK
) ||
374 usb_pipecontrol(urb
->pipe
)) {
375 DBG("Allowed or control data underrun\n");
380 usb_settoggle(udev
, ep
->epnum
,
381 ep
->nextpid
== USB_PID_OUT
,
382 PTD_GET_TOGGLE(ptd
));
383 urb
->actual_length
+= PTD_GET_COUNT(ptd
);
384 status
= cc_to_error
[TD_DATAUNDERRUN
];
389 if (cc
!= TD_CC_NOERROR
&& cc
!= TD_NOTACCESSED
390 && (++ep
->error_count
>= 3 || cc
== TD_CC_STALL
391 || cc
== TD_DATAOVERRUN
)) {
392 status
= cc_to_error
[cc
];
393 if (ep
->nextpid
== USB_PID_ACK
)
397 /* According to usb spec, zero-length Int transfer signals
398 finishing of the urb. Hey, does this apply only
400 if (usb_pipeint(urb
->pipe
) && !PTD_GET_LEN(ptd
)) {
405 /* Relax after previously failed, but later succeeded
406 or correctly NAK'ed retransmission attempt */
408 && (cc
== TD_CC_NOERROR
|| cc
== TD_NOTACCESSED
))
411 /* Take into account idiosyncracies of the isp116x chip
412 regarding toggle bit for failed transfers */
413 if (ep
->nextpid
== USB_PID_OUT
)
414 usb_settoggle(udev
, ep
->epnum
, 1, PTD_GET_TOGGLE(ptd
)
415 ^ (ep
->error_count
> 0));
416 else if (ep
->nextpid
== USB_PID_IN
)
417 usb_settoggle(udev
, ep
->epnum
, 0, PTD_GET_TOGGLE(ptd
)
418 ^ (ep
->error_count
> 0));
420 switch (ep
->nextpid
) {
423 urb
->actual_length
+= PTD_GET_COUNT(ptd
);
424 if (PTD_GET_ACTIVE(ptd
)
425 || (cc
!= TD_CC_NOERROR
&& cc
< 0x0E))
427 if (urb
->transfer_buffer_length
!= urb
->actual_length
) {
431 if (urb
->transfer_flags
& URB_ZERO_PACKET
432 && ep
->nextpid
== USB_PID_OUT
433 && !(PTD_GET_COUNT(ptd
) % ep
->maxpacket
)) {
434 DBG("Zero packet requested\n");
438 /* All data for this URB is transferred, let's finish */
439 if (usb_pipecontrol(urb
->pipe
))
440 ep
->nextpid
= USB_PID_ACK
;
445 if (PTD_GET_ACTIVE(ptd
)
446 || (cc
!= TD_CC_NOERROR
&& cc
< 0x0E))
448 if (urb
->transfer_buffer_length
== urb
->actual_length
)
449 ep
->nextpid
= USB_PID_ACK
;
450 else if (usb_pipeout(urb
->pipe
)) {
451 usb_settoggle(udev
, 0, 1, 1);
452 ep
->nextpid
= USB_PID_OUT
;
454 usb_settoggle(udev
, 0, 0, 1);
455 ep
->nextpid
= USB_PID_IN
;
459 if (PTD_GET_ACTIVE(ptd
)
460 || (cc
!= TD_CC_NOERROR
&& cc
< 0x0E))
470 if (status
!= -EINPROGRESS
|| urb
->unlinked
)
471 finish_request(isp116x
, ep
, urb
, status
);
476 Scan transfer lists, schedule transfers, send data off
479 static void start_atl_transfers(struct isp116x
*isp116x
)
481 struct isp116x_ep
*last_ep
= NULL
, *ep
;
484 int len
, index
, speed
, byte_time
;
486 if (atomic_read(&isp116x
->atl_finishing
))
489 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x
)->state
))
492 /* FIFO not empty? */
493 if (isp116x_read_reg16(isp116x
, HCBUFSTAT
) & HCBUFSTAT_ATL_FULL
)
496 isp116x
->atl_active
= NULL
;
497 isp116x
->atl_buflen
= isp116x
->atl_bufshrt
= 0;
499 /* Schedule int transfers */
500 if (isp116x
->periodic_count
) {
501 isp116x
->fmindex
= index
=
502 (isp116x
->fmindex
+ 1) & (PERIODIC_SIZE
- 1);
503 if ((load
= isp116x
->load
[index
])) {
504 /* Bring all int transfers for this frame
505 into the active queue */
506 isp116x
->atl_active
= last_ep
=
507 isp116x
->periodic
[index
];
508 while (last_ep
->next
)
509 last_ep
= (last_ep
->active
= last_ep
->next
);
510 last_ep
->active
= NULL
;
514 /* Schedule control/bulk transfers */
515 list_for_each_entry(ep
, &isp116x
->async
, schedule
) {
516 urb
= container_of(ep
->hep
->urb_list
.next
,
517 struct urb
, urb_list
);
518 speed
= urb
->dev
->speed
;
519 byte_time
= speed
== USB_SPEED_LOW
520 ? BYTE_TIME_LOWSPEED
: BYTE_TIME_FULLSPEED
;
522 if (ep
->nextpid
== USB_PID_SETUP
) {
523 len
= sizeof(struct usb_ctrlrequest
);
524 } else if (ep
->nextpid
== USB_PID_ACK
) {
527 /* Find current free length ... */
528 len
= (MAX_LOAD_LIMIT
- load
) / byte_time
;
530 /* ... then limit it to configured max size ... */
531 len
= min(len
, speed
== USB_SPEED_LOW
?
532 MAX_TRANSFER_SIZE_LOWSPEED
:
533 MAX_TRANSFER_SIZE_FULLSPEED
);
535 /* ... and finally cut to the multiple of MaxPacketSize,
536 or to the real length if there's enough room. */
538 (urb
->transfer_buffer_length
-
539 urb
->actual_length
)) {
540 len
-= len
% ep
->maxpacket
;
544 len
= urb
->transfer_buffer_length
-
549 load
+= len
* byte_time
;
550 if (load
> MAX_LOAD_LIMIT
)
556 last_ep
->active
= ep
;
558 isp116x
->atl_active
= ep
;
562 /* Avoid starving of endpoints */
563 if ((&isp116x
->async
)->next
!= (&isp116x
->async
)->prev
)
564 list_move(&isp116x
->async
, (&isp116x
->async
)->next
);
566 if (isp116x
->atl_active
) {
567 preproc_atl_queue(isp116x
);
573 Finish the processed transfers
575 static void finish_atl_transfers(struct isp116x
*isp116x
)
577 if (!isp116x
->atl_active
)
579 /* Fifo not ready? */
580 if (!(isp116x_read_reg16(isp116x
, HCBUFSTAT
) & HCBUFSTAT_ATL_DONE
))
583 atomic_inc(&isp116x
->atl_finishing
);
584 unpack_fifo(isp116x
);
585 postproc_atl_queue(isp116x
);
586 atomic_dec(&isp116x
->atl_finishing
);
589 static irqreturn_t
isp116x_irq(struct usb_hcd
*hcd
)
591 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
593 irqreturn_t ret
= IRQ_NONE
;
595 spin_lock(&isp116x
->lock
);
596 isp116x_write_reg16(isp116x
, HCuPINTENB
, 0);
597 irqstat
= isp116x_read_reg16(isp116x
, HCuPINT
);
598 isp116x_write_reg16(isp116x
, HCuPINT
, irqstat
);
600 if (irqstat
& (HCuPINT_ATL
| HCuPINT_SOF
)) {
602 finish_atl_transfers(isp116x
);
605 if (irqstat
& HCuPINT_OPR
) {
606 u32 intstat
= isp116x_read_reg32(isp116x
, HCINTSTAT
);
607 isp116x_write_reg32(isp116x
, HCINTSTAT
, intstat
);
608 if (intstat
& HCINT_UE
) {
609 ERR("Unrecoverable error, HC is dead!\n");
610 /* IRQ's are off, we do no DMA,
611 perfectly ready to die ... */
612 hcd
->state
= HC_STATE_HALT
;
617 if (intstat
& HCINT_RHSC
)
618 /* When root hub or any of its ports is going
619 to come out of suspend, it may take more
620 than 10ms for status bits to stabilize. */
621 mod_timer(&hcd
->rh_timer
, jiffies
622 + msecs_to_jiffies(20) + 1);
623 if (intstat
& HCINT_RD
) {
624 DBG("---- remote wakeup\n");
625 usb_hcd_resume_root_hub(hcd
);
627 irqstat
&= ~HCuPINT_OPR
;
631 if (irqstat
& (HCuPINT_ATL
| HCuPINT_SOF
)) {
632 start_atl_transfers(isp116x
);
635 isp116x_write_reg16(isp116x
, HCuPINTENB
, isp116x
->irqenb
);
637 spin_unlock(&isp116x
->lock
);
641 /*-----------------------------------------------------------------*/
643 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
644 * this driver doesn't promise that much since it's got to handle an
645 * IRQ per packet; irq handling latencies also use up that time.
649 #define MAX_PERIODIC_LOAD 600
650 static int balance(struct isp116x
*isp116x
, u16 period
, u16 load
)
652 int i
, branch
= -ENOSPC
;
654 /* search for the least loaded schedule branch of that period
655 which has enough bandwidth left unreserved. */
656 for (i
= 0; i
< period
; i
++) {
657 if (branch
< 0 || isp116x
->load
[branch
] > isp116x
->load
[i
]) {
660 for (j
= i
; j
< PERIODIC_SIZE
; j
+= period
) {
661 if ((isp116x
->load
[j
] + load
)
665 if (j
< PERIODIC_SIZE
)
673 /* NB! ALL the code above this point runs with isp116x->lock
677 /*-----------------------------------------------------------------*/
679 static int isp116x_urb_enqueue(struct usb_hcd
*hcd
,
683 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
684 struct usb_device
*udev
= urb
->dev
;
685 unsigned int pipe
= urb
->pipe
;
686 int is_out
= !usb_pipein(pipe
);
687 int type
= usb_pipetype(pipe
);
688 int epnum
= usb_pipeendpoint(pipe
);
689 struct usb_host_endpoint
*hep
= urb
->ep
;
690 struct isp116x_ep
*ep
= NULL
;
695 urb_dbg(urb
, "Enqueue");
697 if (type
== PIPE_ISOCHRONOUS
) {
698 ERR("Isochronous transfers not supported\n");
699 urb_dbg(urb
, "Refused to enqueue");
702 /* avoid all allocations within spinlocks: request or endpoint */
704 ep
= kzalloc(sizeof *ep
, mem_flags
);
709 spin_lock_irqsave(&isp116x
->lock
, flags
);
710 if (!HC_IS_RUNNING(hcd
->state
)) {
713 goto fail_not_linked
;
715 ret
= usb_hcd_link_urb_to_ep(hcd
, urb
);
718 goto fail_not_linked
;
724 INIT_LIST_HEAD(&ep
->schedule
);
727 ep
->maxpacket
= usb_maxpacket(udev
, urb
->pipe
, is_out
);
728 usb_settoggle(udev
, epnum
, is_out
, 0);
730 if (type
== PIPE_CONTROL
) {
731 ep
->nextpid
= USB_PID_SETUP
;
733 ep
->nextpid
= USB_PID_OUT
;
735 ep
->nextpid
= USB_PID_IN
;
740 With INT URBs submitted, the driver works with SOF
741 interrupt enabled and ATL interrupt disabled. After
742 the PTDs are written to fifo ram, the chip starts
743 fifo processing and usb transfers after the next
744 SOF and continues until the transfers are finished
745 (succeeded or failed) or the frame ends. Therefore,
746 the transfers occur only in every second frame,
747 while fifo reading/writing and data processing
748 occur in every other second frame. */
749 if (urb
->interval
< 2)
751 if (urb
->interval
> 2 * PERIODIC_SIZE
)
752 urb
->interval
= 2 * PERIODIC_SIZE
;
753 ep
->period
= urb
->interval
>> 1;
754 ep
->branch
= PERIODIC_SIZE
;
755 ep
->load
= usb_calc_bus_time(udev
->speed
,
757 (type
== PIPE_ISOCHRONOUS
),
758 usb_maxpacket(udev
, pipe
,
766 /* maybe put endpoint into schedule */
770 if (list_empty(&ep
->schedule
))
771 list_add_tail(&ep
->schedule
, &isp116x
->async
);
774 urb
->interval
= ep
->period
;
775 ep
->length
= min_t(u32
, ep
->maxpacket
,
776 urb
->transfer_buffer_length
);
778 /* urb submitted for already existing endpoint */
779 if (ep
->branch
< PERIODIC_SIZE
)
782 ep
->branch
= ret
= balance(isp116x
, ep
->period
, ep
->load
);
787 urb
->start_frame
= (isp116x
->fmindex
& (PERIODIC_SIZE
- 1))
790 /* sort each schedule branch by period (slow before fast)
791 to share the faster parts of the tree without needing
792 dummy/placeholder nodes */
793 DBG("schedule qh%d/%p branch %d\n", ep
->period
, ep
, ep
->branch
);
794 for (i
= ep
->branch
; i
< PERIODIC_SIZE
; i
+= ep
->period
) {
795 struct isp116x_ep
**prev
= &isp116x
->periodic
[i
];
796 struct isp116x_ep
*here
= *prev
;
798 while (here
&& ep
!= here
) {
799 if (ep
->period
> here
->period
)
808 isp116x
->load
[i
] += ep
->load
;
810 hcd
->self
.bandwidth_allocated
+= ep
->load
/ ep
->period
;
812 /* switch over to SOFint */
813 if (!isp116x
->periodic_count
++) {
814 isp116x
->irqenb
&= ~HCuPINT_ATL
;
815 isp116x
->irqenb
|= HCuPINT_SOF
;
816 isp116x_write_reg16(isp116x
, HCuPINTENB
,
822 start_atl_transfers(isp116x
);
826 usb_hcd_unlink_urb_from_ep(hcd
, urb
);
828 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
835 static int isp116x_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
,
838 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
839 struct usb_host_endpoint
*hep
;
840 struct isp116x_ep
*ep
, *ep_act
;
844 spin_lock_irqsave(&isp116x
->lock
, flags
);
845 rc
= usb_hcd_check_unlink_urb(hcd
, urb
, status
);
851 WARN_ON(hep
!= ep
->hep
);
853 /* In front of queue? */
854 if (ep
->hep
->urb_list
.next
== &urb
->urb_list
)
856 for (ep_act
= isp116x
->atl_active
; ep_act
;
857 ep_act
= ep_act
->active
)
859 VDBG("dequeue, urb %p active; wait for irq\n",
866 finish_request(isp116x
, ep
, urb
, status
);
868 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
872 static void isp116x_endpoint_disable(struct usb_hcd
*hcd
,
873 struct usb_host_endpoint
*hep
)
876 struct isp116x_ep
*ep
= hep
->hcpriv
;
881 /* assume we'd just wait for the irq */
882 for (i
= 0; i
< 100 && !list_empty(&hep
->urb_list
); i
++)
884 if (!list_empty(&hep
->urb_list
))
885 WARNING("ep %p not empty?\n", ep
);
891 static int isp116x_get_frame(struct usb_hcd
*hcd
)
893 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
897 spin_lock_irqsave(&isp116x
->lock
, flags
);
898 fmnum
= isp116x_read_reg32(isp116x
, HCFMNUM
);
899 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
904 Adapted from ohci-hub.c. Currently we don't support autosuspend.
906 static int isp116x_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
908 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
909 int ports
, i
, changed
= 0;
912 if (!HC_IS_RUNNING(hcd
->state
))
915 /* Report no status change now, if we are scheduled to be
917 if (timer_pending(&hcd
->rh_timer
))
920 ports
= isp116x
->rhdesca
& RH_A_NDP
;
921 spin_lock_irqsave(&isp116x
->lock
, flags
);
922 isp116x
->rhstatus
= isp116x_read_reg32(isp116x
, HCRHSTATUS
);
923 if (isp116x
->rhstatus
& (RH_HS_LPSC
| RH_HS_OCIC
))
924 buf
[0] = changed
= 1;
928 for (i
= 0; i
< ports
; i
++) {
929 u32 status
= isp116x_read_reg32(isp116x
, i
? HCRHPORT2
: HCRHPORT1
);
931 if (status
& (RH_PS_CSC
| RH_PS_PESC
| RH_PS_PSSC
932 | RH_PS_OCIC
| RH_PS_PRSC
)) {
934 buf
[0] |= 1 << (i
+ 1);
937 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
941 static void isp116x_hub_descriptor(struct isp116x
*isp116x
,
942 struct usb_hub_descriptor
*desc
)
944 u32 reg
= isp116x
->rhdesca
;
946 desc
->bDescriptorType
= USB_DT_HUB
;
947 desc
->bDescLength
= 9;
948 desc
->bHubContrCurrent
= 0;
949 desc
->bNbrPorts
= (u8
) (reg
& 0x3);
950 /* Power switching, device type, overcurrent. */
951 desc
->wHubCharacteristics
= cpu_to_le16((u16
) ((reg
>> 8) &
955 desc
->bPwrOn2PwrGood
= (u8
) ((reg
>> 24) & 0xff);
956 /* ports removable, and legacy PortPwrCtrlMask */
957 desc
->u
.hs
.DeviceRemovable
[0] = 0;
958 desc
->u
.hs
.DeviceRemovable
[1] = ~0;
961 /* Perform reset of a given port.
962 It would be great to just start the reset and let the
963 USB core to clear the reset in due time. However,
964 root hub ports should be reset for at least 50 ms, while
965 our chip stays in reset for about 10 ms. I.e., we must
966 repeatedly reset it ourself here.
968 static inline void root_port_reset(struct isp116x
*isp116x
, unsigned port
)
971 unsigned long flags
, t
;
973 /* Root hub reset should be 50 ms, but some devices
974 want it even longer. */
975 t
= jiffies
+ msecs_to_jiffies(100);
977 while (time_before(jiffies
, t
)) {
978 spin_lock_irqsave(&isp116x
->lock
, flags
);
979 /* spin until any current reset finishes */
981 tmp
= isp116x_read_reg32(isp116x
, port
?
982 HCRHPORT2
: HCRHPORT1
);
983 if (!(tmp
& RH_PS_PRS
))
987 /* Don't reset a disconnected port */
988 if (!(tmp
& RH_PS_CCS
)) {
989 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
992 /* Reset lasts 10ms (claims datasheet) */
993 isp116x_write_reg32(isp116x
, port
? HCRHPORT2
:
994 HCRHPORT1
, (RH_PS_PRS
));
995 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1000 /* Adapted from ohci-hub.c */
1001 static int isp116x_hub_control(struct usb_hcd
*hcd
,
1003 u16 wValue
, u16 wIndex
, char *buf
, u16 wLength
)
1005 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
1007 unsigned long flags
;
1008 int ports
= isp116x
->rhdesca
& RH_A_NDP
;
1012 case ClearHubFeature
:
1013 DBG("ClearHubFeature: ");
1015 case C_HUB_OVER_CURRENT
:
1016 DBG("C_HUB_OVER_CURRENT\n");
1017 spin_lock_irqsave(&isp116x
->lock
, flags
);
1018 isp116x_write_reg32(isp116x
, HCRHSTATUS
, RH_HS_OCIC
);
1019 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1020 case C_HUB_LOCAL_POWER
:
1021 DBG("C_HUB_LOCAL_POWER\n");
1028 DBG("SetHubFeature: ");
1030 case C_HUB_OVER_CURRENT
:
1031 case C_HUB_LOCAL_POWER
:
1032 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1038 case GetHubDescriptor
:
1039 DBG("GetHubDescriptor\n");
1040 isp116x_hub_descriptor(isp116x
,
1041 (struct usb_hub_descriptor
*)buf
);
1044 DBG("GetHubStatus\n");
1045 *(__le32
*) buf
= 0;
1048 DBG("GetPortStatus\n");
1049 if (!wIndex
|| wIndex
> ports
)
1051 spin_lock_irqsave(&isp116x
->lock
, flags
);
1052 tmp
= isp116x_read_reg32(isp116x
, (--wIndex
) ? HCRHPORT2
: HCRHPORT1
);
1053 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1054 *(__le32
*) buf
= cpu_to_le32(tmp
);
1055 DBG("GetPortStatus: port[%d] %08x\n", wIndex
+ 1, tmp
);
1057 case ClearPortFeature
:
1058 DBG("ClearPortFeature: ");
1059 if (!wIndex
|| wIndex
> ports
)
1064 case USB_PORT_FEAT_ENABLE
:
1065 DBG("USB_PORT_FEAT_ENABLE\n");
1068 case USB_PORT_FEAT_C_ENABLE
:
1069 DBG("USB_PORT_FEAT_C_ENABLE\n");
1072 case USB_PORT_FEAT_SUSPEND
:
1073 DBG("USB_PORT_FEAT_SUSPEND\n");
1076 case USB_PORT_FEAT_C_SUSPEND
:
1077 DBG("USB_PORT_FEAT_C_SUSPEND\n");
1080 case USB_PORT_FEAT_POWER
:
1081 DBG("USB_PORT_FEAT_POWER\n");
1084 case USB_PORT_FEAT_C_CONNECTION
:
1085 DBG("USB_PORT_FEAT_C_CONNECTION\n");
1088 case USB_PORT_FEAT_C_OVER_CURRENT
:
1089 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1092 case USB_PORT_FEAT_C_RESET
:
1093 DBG("USB_PORT_FEAT_C_RESET\n");
1099 spin_lock_irqsave(&isp116x
->lock
, flags
);
1100 isp116x_write_reg32(isp116x
, wIndex
1101 ? HCRHPORT2
: HCRHPORT1
, tmp
);
1102 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1104 case SetPortFeature
:
1105 DBG("SetPortFeature: ");
1106 if (!wIndex
|| wIndex
> ports
)
1110 case USB_PORT_FEAT_SUSPEND
:
1111 DBG("USB_PORT_FEAT_SUSPEND\n");
1112 spin_lock_irqsave(&isp116x
->lock
, flags
);
1113 isp116x_write_reg32(isp116x
, wIndex
1114 ? HCRHPORT2
: HCRHPORT1
, RH_PS_PSS
);
1115 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1117 case USB_PORT_FEAT_POWER
:
1118 DBG("USB_PORT_FEAT_POWER\n");
1119 spin_lock_irqsave(&isp116x
->lock
, flags
);
1120 isp116x_write_reg32(isp116x
, wIndex
1121 ? HCRHPORT2
: HCRHPORT1
, RH_PS_PPS
);
1122 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1124 case USB_PORT_FEAT_RESET
:
1125 DBG("USB_PORT_FEAT_RESET\n");
1126 root_port_reset(isp116x
, wIndex
);
1135 /* "protocol stall" on error */
1136 DBG("PROTOCOL STALL\n");
1142 /*-----------------------------------------------------------------*/
1144 #ifdef CONFIG_DEBUG_FS
1146 static void dump_irq(struct seq_file
*s
, char *label
, u16 mask
)
1148 seq_printf(s
, "%s %04x%s%s%s%s%s%s\n", label
, mask
,
1149 mask
& HCuPINT_CLKRDY
? " clkrdy" : "",
1150 mask
& HCuPINT_SUSP
? " susp" : "",
1151 mask
& HCuPINT_OPR
? " opr" : "",
1152 mask
& HCuPINT_AIIEOT
? " eot" : "",
1153 mask
& HCuPINT_ATL
? " atl" : "",
1154 mask
& HCuPINT_SOF
? " sof" : "");
1157 static void dump_int(struct seq_file
*s
, char *label
, u32 mask
)
1159 seq_printf(s
, "%s %08x%s%s%s%s%s%s%s\n", label
, mask
,
1160 mask
& HCINT_MIE
? " MIE" : "",
1161 mask
& HCINT_RHSC
? " rhsc" : "",
1162 mask
& HCINT_FNO
? " fno" : "",
1163 mask
& HCINT_UE
? " ue" : "",
1164 mask
& HCINT_RD
? " rd" : "",
1165 mask
& HCINT_SF
? " sof" : "", mask
& HCINT_SO
? " so" : "");
1168 static int isp116x_show_dbg(struct seq_file
*s
, void *unused
)
1170 struct isp116x
*isp116x
= s
->private;
1172 seq_printf(s
, "%s\n%s version %s\n",
1173 isp116x_to_hcd(isp116x
)->product_desc
, hcd_name
,
1176 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x
)->state
)) {
1177 seq_printf(s
, "HCD is suspended\n");
1180 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x
)->state
)) {
1181 seq_printf(s
, "HCD not running\n");
1185 spin_lock_irq(&isp116x
->lock
);
1186 dump_irq(s
, "hc_irq_enable", isp116x_read_reg16(isp116x
, HCuPINTENB
));
1187 dump_irq(s
, "hc_irq_status", isp116x_read_reg16(isp116x
, HCuPINT
));
1188 dump_int(s
, "hc_int_enable", isp116x_read_reg32(isp116x
, HCINTENB
));
1189 dump_int(s
, "hc_int_status", isp116x_read_reg32(isp116x
, HCINTSTAT
));
1190 isp116x_show_regs_seq(isp116x
, s
);
1191 spin_unlock_irq(&isp116x
->lock
);
1192 seq_printf(s
, "\n");
1197 static int isp116x_open_seq(struct inode
*inode
, struct file
*file
)
1199 return single_open(file
, isp116x_show_dbg
, inode
->i_private
);
1202 static const struct file_operations isp116x_debug_fops
= {
1203 .open
= isp116x_open_seq
,
1205 .llseek
= seq_lseek
,
1206 .release
= single_release
,
1209 static int create_debug_file(struct isp116x
*isp116x
)
1211 isp116x
->dentry
= debugfs_create_file(hcd_name
,
1212 S_IRUGO
, NULL
, isp116x
,
1213 &isp116x_debug_fops
);
1214 if (!isp116x
->dentry
)
1219 static void remove_debug_file(struct isp116x
*isp116x
)
1221 debugfs_remove(isp116x
->dentry
);
1226 #define create_debug_file(d) 0
1227 #define remove_debug_file(d) do{}while(0)
1229 #endif /* CONFIG_DEBUG_FS */
1231 /*-----------------------------------------------------------------*/
1234 Software reset - can be called from any contect.
1236 static int isp116x_sw_reset(struct isp116x
*isp116x
)
1239 unsigned long flags
;
1242 spin_lock_irqsave(&isp116x
->lock
, flags
);
1243 isp116x_write_reg16(isp116x
, HCSWRES
, HCSWRES_MAGIC
);
1244 isp116x_write_reg32(isp116x
, HCCMDSTAT
, HCCMDSTAT_HCR
);
1246 /* It usually resets within 1 ms */
1248 if (!(isp116x_read_reg32(isp116x
, HCCMDSTAT
) & HCCMDSTAT_HCR
))
1252 ERR("Software reset timeout\n");
1255 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1259 static int isp116x_reset(struct usb_hcd
*hcd
)
1261 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
1264 int ret
, timeout
= 15 /* ms */ ;
1266 ret
= isp116x_sw_reset(isp116x
);
1270 t
= jiffies
+ msecs_to_jiffies(timeout
);
1271 while (time_before_eq(jiffies
, t
)) {
1273 spin_lock_irq(&isp116x
->lock
);
1274 clkrdy
= isp116x_read_reg16(isp116x
, HCuPINT
) & HCuPINT_CLKRDY
;
1275 spin_unlock_irq(&isp116x
->lock
);
1280 ERR("Clock not ready after %dms\n", timeout
);
1281 /* After sw_reset the clock won't report to be ready, if
1282 H_WAKEUP pin is high. */
1283 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1289 static void isp116x_stop(struct usb_hcd
*hcd
)
1291 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
1292 unsigned long flags
;
1295 spin_lock_irqsave(&isp116x
->lock
, flags
);
1296 isp116x_write_reg16(isp116x
, HCuPINTENB
, 0);
1298 /* Switch off ports' power, some devices don't come up
1299 after next 'insmod' without this */
1300 val
= isp116x_read_reg32(isp116x
, HCRHDESCA
);
1301 val
&= ~(RH_A_NPS
| RH_A_PSM
);
1302 isp116x_write_reg32(isp116x
, HCRHDESCA
, val
);
1303 isp116x_write_reg32(isp116x
, HCRHSTATUS
, RH_HS_LPS
);
1304 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1306 isp116x_sw_reset(isp116x
);
1310 Configure the chip. The chip must be successfully reset by now.
1312 static int isp116x_start(struct usb_hcd
*hcd
)
1314 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
1315 struct isp116x_platform_data
*board
= isp116x
->board
;
1317 unsigned long flags
;
1319 spin_lock_irqsave(&isp116x
->lock
, flags
);
1321 /* clear interrupt status and disable all interrupt sources */
1322 isp116x_write_reg16(isp116x
, HCuPINT
, 0xff);
1323 isp116x_write_reg16(isp116x
, HCuPINTENB
, 0);
1325 val
= isp116x_read_reg16(isp116x
, HCCHIPID
);
1326 if ((val
& HCCHIPID_MASK
) != HCCHIPID_MAGIC
) {
1327 ERR("Invalid chip ID %04x\n", val
);
1328 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1332 /* To be removed in future */
1333 hcd
->uses_new_polling
= 1;
1335 isp116x_write_reg16(isp116x
, HCITLBUFLEN
, ISP116x_ITL_BUFSIZE
);
1336 isp116x_write_reg16(isp116x
, HCATLBUFLEN
, ISP116x_ATL_BUFSIZE
);
1339 val
= HCHWCFG_INT_ENABLE
| HCHWCFG_DBWIDTH(1);
1340 if (board
->sel15Kres
)
1341 val
|= HCHWCFG_15KRSEL
;
1342 /* Remote wakeup won't work without working clock */
1343 if (board
->remote_wakeup_enable
)
1344 val
|= HCHWCFG_CLKNOTSTOP
;
1345 if (board
->oc_enable
)
1346 val
|= HCHWCFG_ANALOG_OC
;
1347 if (board
->int_act_high
)
1348 val
|= HCHWCFG_INT_POL
;
1349 if (board
->int_edge_triggered
)
1350 val
|= HCHWCFG_INT_TRIGGER
;
1351 isp116x_write_reg16(isp116x
, HCHWCFG
, val
);
1353 /* ----- Root hub conf */
1354 val
= (25 << 24) & RH_A_POTPGT
;
1355 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1356 be always set. Yet, instead, we request individual port
1359 /* Report overcurrent per port */
1361 isp116x_write_reg32(isp116x
, HCRHDESCA
, val
);
1362 isp116x
->rhdesca
= isp116x_read_reg32(isp116x
, HCRHDESCA
);
1365 isp116x_write_reg32(isp116x
, HCRHDESCB
, val
);
1366 isp116x
->rhdescb
= isp116x_read_reg32(isp116x
, HCRHDESCB
);
1369 if (board
->remote_wakeup_enable
) {
1370 if (!device_can_wakeup(hcd
->self
.controller
))
1371 device_init_wakeup(hcd
->self
.controller
, 1);
1374 isp116x_write_reg32(isp116x
, HCRHSTATUS
, val
);
1375 isp116x
->rhstatus
= isp116x_read_reg32(isp116x
, HCRHSTATUS
);
1377 isp116x_write_reg32(isp116x
, HCFMINTVL
, 0x27782edf);
1379 hcd
->state
= HC_STATE_RUNNING
;
1381 /* Set up interrupts */
1382 isp116x
->intenb
= HCINT_MIE
| HCINT_RHSC
| HCINT_UE
;
1383 if (board
->remote_wakeup_enable
)
1384 isp116x
->intenb
|= HCINT_RD
;
1385 isp116x
->irqenb
= HCuPINT_ATL
| HCuPINT_OPR
; /* | HCuPINT_SUSP; */
1386 isp116x_write_reg32(isp116x
, HCINTENB
, isp116x
->intenb
);
1387 isp116x_write_reg16(isp116x
, HCuPINTENB
, isp116x
->irqenb
);
1389 /* Go operational */
1390 val
= HCCONTROL_USB_OPER
;
1391 if (board
->remote_wakeup_enable
)
1392 val
|= HCCONTROL_RWE
;
1393 isp116x_write_reg32(isp116x
, HCCONTROL
, val
);
1395 /* Disable ports to avoid race in device enumeration */
1396 isp116x_write_reg32(isp116x
, HCRHPORT1
, RH_PS_CCS
);
1397 isp116x_write_reg32(isp116x
, HCRHPORT2
, RH_PS_CCS
);
1399 isp116x_show_regs_log(isp116x
);
1400 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1406 static int isp116x_bus_suspend(struct usb_hcd
*hcd
)
1408 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
1409 unsigned long flags
;
1413 spin_lock_irqsave(&isp116x
->lock
, flags
);
1414 val
= isp116x_read_reg32(isp116x
, HCCONTROL
);
1416 switch (val
& HCCONTROL_HCFS
) {
1417 case HCCONTROL_USB_OPER
:
1418 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1419 val
&= (~HCCONTROL_HCFS
& ~HCCONTROL_RWE
);
1420 val
|= HCCONTROL_USB_SUSPEND
;
1421 if (hcd
->self
.root_hub
->do_remote_wakeup
)
1422 val
|= HCCONTROL_RWE
;
1423 /* Wait for usb transfers to finish */
1425 spin_lock_irqsave(&isp116x
->lock
, flags
);
1426 isp116x_write_reg32(isp116x
, HCCONTROL
, val
);
1427 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1428 /* Wait for devices to suspend */
1431 case HCCONTROL_USB_RESUME
:
1432 isp116x_write_reg32(isp116x
, HCCONTROL
,
1433 (val
& ~HCCONTROL_HCFS
) |
1434 HCCONTROL_USB_RESET
);
1435 case HCCONTROL_USB_RESET
:
1437 default: /* HCCONTROL_USB_SUSPEND */
1438 spin_unlock_irqrestore(&isp116x
->lock
, flags
);
1445 static int isp116x_bus_resume(struct usb_hcd
*hcd
)
1447 struct isp116x
*isp116x
= hcd_to_isp116x(hcd
);
1451 spin_lock_irq(&isp116x
->lock
);
1453 val
= isp116x_read_reg32(isp116x
, HCCONTROL
);
1454 switch (val
& HCCONTROL_HCFS
) {
1455 case HCCONTROL_USB_SUSPEND
:
1456 val
&= ~HCCONTROL_HCFS
;
1457 val
|= HCCONTROL_USB_RESUME
;
1458 isp116x_write_reg32(isp116x
, HCCONTROL
, val
);
1459 case HCCONTROL_USB_RESUME
:
1461 case HCCONTROL_USB_OPER
:
1462 spin_unlock_irq(&isp116x
->lock
);
1465 /* HCCONTROL_USB_RESET: this may happen, when during
1466 suspension the HC lost power. Reinitialize completely */
1467 spin_unlock_irq(&isp116x
->lock
);
1468 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1471 isp116x_hub_control(hcd
, SetPortFeature
,
1472 USB_PORT_FEAT_POWER
, 1, NULL
, 0);
1473 if ((isp116x
->rhdesca
& RH_A_NDP
) == 2)
1474 isp116x_hub_control(hcd
, SetPortFeature
,
1475 USB_PORT_FEAT_POWER
, 2, NULL
, 0);
1479 val
= isp116x
->rhdesca
& RH_A_NDP
;
1482 isp116x_read_reg32(isp116x
, val
? HCRHPORT2
: HCRHPORT1
);
1483 /* force global, not selective, resume */
1484 if (!(stat
& RH_PS_PSS
))
1486 DBG("%s: Resuming port %d\n", __func__
, val
);
1487 isp116x_write_reg32(isp116x
, RH_PS_POCI
, val
1488 ? HCRHPORT2
: HCRHPORT1
);
1490 spin_unlock_irq(&isp116x
->lock
);
1492 hcd
->state
= HC_STATE_RESUMING
;
1493 msleep(USB_RESUME_TIMEOUT
);
1495 /* Go operational */
1496 spin_lock_irq(&isp116x
->lock
);
1497 val
= isp116x_read_reg32(isp116x
, HCCONTROL
);
1498 isp116x_write_reg32(isp116x
, HCCONTROL
,
1499 (val
& ~HCCONTROL_HCFS
) | HCCONTROL_USB_OPER
);
1500 spin_unlock_irq(&isp116x
->lock
);
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 static int isp116x_probe(struct platform_device
*pdev
)
1564 struct usb_hcd
*hcd
;
1565 struct isp116x
*isp116x
;
1566 struct resource
*addr
, *data
, *ires
;
1567 void __iomem
*addr_reg
;
1568 void __iomem
*data_reg
;
1571 unsigned long irqflags
;
1576 if (pdev
->num_resources
< 3) {
1581 data
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1582 addr
= platform_get_resource(pdev
, IORESOURCE_MEM
, 1);
1583 ires
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1585 if (!addr
|| !data
|| !ires
) {
1591 irqflags
= ires
->flags
& IRQF_TRIGGER_MASK
;
1593 if (pdev
->dev
.dma_mask
) {
1594 DBG("DMA not supported\n");
1599 if (!request_mem_region(addr
->start
, 2, hcd_name
)) {
1603 addr_reg
= ioremap(addr
->start
, resource_size(addr
));
1604 if (addr_reg
== NULL
) {
1608 if (!request_mem_region(data
->start
, 2, hcd_name
)) {
1612 data_reg
= ioremap(data
->start
, resource_size(data
));
1613 if (data_reg
== NULL
) {
1618 /* allocate and initialize hcd */
1619 hcd
= usb_create_hcd(&isp116x_hc_driver
, &pdev
->dev
, dev_name(&pdev
->dev
));
1624 /* this rsrc_start is bogus */
1625 hcd
->rsrc_start
= addr
->start
;
1626 isp116x
= hcd_to_isp116x(hcd
);
1627 isp116x
->data_reg
= data_reg
;
1628 isp116x
->addr_reg
= addr_reg
;
1629 spin_lock_init(&isp116x
->lock
);
1630 INIT_LIST_HEAD(&isp116x
->async
);
1631 isp116x
->board
= dev_get_platdata(&pdev
->dev
);
1633 if (!isp116x
->board
) {
1634 ERR("Platform data structure not initialized\n");
1638 if (isp116x_check_platform_delay(isp116x
)) {
1639 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1641 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1646 ret
= usb_add_hcd(hcd
, irq
, irqflags
);
1650 device_wakeup_enable(hcd
->self
.controller
);
1652 ret
= create_debug_file(isp116x
);
1654 ERR("Couldn't create debugfs entry\n");
1661 usb_remove_hcd(hcd
);
1667 release_mem_region(data
->start
, 2);
1671 release_mem_region(addr
->start
, 2);
1673 ERR("init error, %d\n", ret
);
1679 Suspend of platform device
1681 static int isp116x_suspend(struct platform_device
*dev
, pm_message_t state
)
1683 VDBG("%s: state %x\n", __func__
, state
.event
);
1688 Resume platform device
1690 static int isp116x_resume(struct platform_device
*dev
)
1692 VDBG("%s\n", __func__
);
1698 #define isp116x_suspend NULL
1699 #define isp116x_resume NULL
1703 /* work with hotplug and coldplug */
1704 MODULE_ALIAS("platform:isp116x-hcd");
1706 static struct platform_driver isp116x_driver
= {
1707 .probe
= isp116x_probe
,
1708 .remove
= isp116x_remove
,
1709 .suspend
= isp116x_suspend
,
1710 .resume
= isp116x_resume
,
1716 module_platform_driver(isp116x_driver
);