2 * Driver for the NXP ISP1760 chip
4 * However, the code might contain some bugs. What doesn't work for sure is:
7 e The interrupt line is configured as active low, level.
9 * (c) 2007 Sebastian Siewior <bigeasy@linutronix.de>
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/list.h>
16 #include <linux/usb.h>
17 #include <linux/debugfs.h>
18 #include <linux/uaccess.h>
20 #include <asm/unaligned.h>
22 #include "../core/hcd.h"
23 #include "isp1760-hcd.h"
25 static struct kmem_cache
*qtd_cachep
;
26 static struct kmem_cache
*qh_cachep
;
31 struct inter_packet_info atl_ints
[32];
32 struct inter_packet_info int_ints
[32];
33 struct memory_chunk memory_pool
[BLOCKS
];
35 /* periodic schedule support */
36 #define DEFAULT_I_TDPS 1024
37 unsigned periodic_size
;
39 unsigned long reset_done
;
40 unsigned long next_statechange
;
41 unsigned int devflags
;
44 static inline struct isp1760_hcd
*hcd_to_priv(struct usb_hcd
*hcd
)
46 return (struct isp1760_hcd
*) (hcd
->hcd_priv
);
48 static inline struct usb_hcd
*priv_to_hcd(struct isp1760_hcd
*priv
)
50 return container_of((void *) priv
, struct usb_hcd
, hcd_priv
);
53 /* Section 2.2 Host Controller Capability Registers */
54 #define HC_LENGTH(p) (((p)>>00)&0x00ff) /* bits 7:0 */
55 #define HC_VERSION(p) (((p)>>16)&0xffff) /* bits 31:16 */
56 #define HCS_INDICATOR(p) ((p)&(1 << 16)) /* true: has port indicators */
57 #define HCS_PPC(p) ((p)&(1 << 4)) /* true: port power control */
58 #define HCS_N_PORTS(p) (((p)>>0)&0xf) /* bits 3:0, ports on HC */
59 #define HCC_ISOC_CACHE(p) ((p)&(1 << 7)) /* true: can cache isoc frame */
60 #define HCC_ISOC_THRES(p) (((p)>>4)&0x7) /* bits 6:4, uframes cached */
62 /* Section 2.3 Host Controller Operational Registers */
63 #define CMD_LRESET (1<<7) /* partial reset (no ports, etc) */
64 #define CMD_RESET (1<<1) /* reset HC not bus */
65 #define CMD_RUN (1<<0) /* start/stop HC */
66 #define STS_PCD (1<<2) /* port change detect */
67 #define FLAG_CF (1<<0) /* true: we'll support "high speed" */
69 #define PORT_OWNER (1<<13) /* true: companion hc owns this port */
70 #define PORT_POWER (1<<12) /* true: has power (see PPC) */
71 #define PORT_USB11(x) (((x) & (3 << 10)) == (1 << 10)) /* USB 1.1 device */
72 #define PORT_RESET (1<<8) /* reset port */
73 #define PORT_SUSPEND (1<<7) /* suspend port */
74 #define PORT_RESUME (1<<6) /* resume it */
75 #define PORT_PE (1<<2) /* port enable */
76 #define PORT_CSC (1<<1) /* connect status change */
77 #define PORT_CONNECT (1<<0) /* device connected */
78 #define PORT_RWC_BITS (PORT_CSC)
81 struct isp1760_qtd
*hw_next
;
86 /* the rest is HCD-private */
87 struct list_head qtd_list
;
93 #define URB_COMPLETE_NOTIFY (1 << 0)
94 #define URB_ENQUEUED (1 << 1)
95 #define URB_TYPE_ATL (1 << 2)
96 #define URB_TYPE_INT (1 << 3)
100 /* first part defined by EHCI spec */
101 struct list_head qtd_list
;
102 struct isp1760_hcd
*priv
;
104 /* periodic schedule info */
105 unsigned short period
; /* polling interval */
106 struct usb_device
*dev
;
112 #define ehci_port_speed(priv, portsc) (1 << USB_PORT_FEAT_HIGHSPEED)
114 static unsigned int isp1760_readl(__u32 __iomem
*regs
)
119 static void isp1760_writel(const unsigned int val
, __u32 __iomem
*regs
)
125 * The next two copy via MMIO data to/from the device. memcpy_{to|from}io()
126 * doesn't quite work because some people have to enforce 32-bit access
128 static void priv_read_copy(struct isp1760_hcd
*priv
, u32
*src
,
129 __u32 __iomem
*dst
, u32 offset
, u32 len
)
131 struct usb_hcd
*hcd
= priv_to_hcd(priv
);
136 printk(KERN_ERR
"ERROR: buffer: %p len: %d\n", src
, len
);
139 isp1760_writel(offset
, hcd
->regs
+ HC_MEMORY_REG
);
141 * 90nsec delay, the spec says something how this could be avoided.
146 *src
= __raw_readl(dst
);
155 /* in case we have 3, 2 or 1 by left. The dst buffer may not be fully
158 val
= isp1760_readl(dst
);
170 static void priv_write_copy(const struct isp1760_hcd
*priv
, const u32
*src
,
171 __u32 __iomem
*dst
, u32 len
)
174 __raw_writel(*src
, dst
);
182 /* in case we have 3, 2 or 1 by left. The buffer is allocated and the
183 * extra bytes should not be read by the HW
186 __raw_writel(*src
, dst
);
189 /* memory management of the 60kb on the chip from 0x1000 to 0xffff */
190 static void init_memory(struct isp1760_hcd
*priv
)
196 for (i
= 0; i
< BLOCK_1_NUM
; i
++) {
197 priv
->memory_pool
[i
].start
= payload
;
198 priv
->memory_pool
[i
].size
= BLOCK_1_SIZE
;
199 priv
->memory_pool
[i
].free
= 1;
200 payload
+= priv
->memory_pool
[i
].size
;
204 for (i
= BLOCK_1_NUM
; i
< BLOCK_1_NUM
+ BLOCK_2_NUM
; i
++) {
205 priv
->memory_pool
[i
].start
= payload
;
206 priv
->memory_pool
[i
].size
= BLOCK_2_SIZE
;
207 priv
->memory_pool
[i
].free
= 1;
208 payload
+= priv
->memory_pool
[i
].size
;
212 for (i
= BLOCK_1_NUM
+ BLOCK_2_NUM
; i
< BLOCKS
; i
++) {
213 priv
->memory_pool
[i
].start
= payload
;
214 priv
->memory_pool
[i
].size
= BLOCK_3_SIZE
;
215 priv
->memory_pool
[i
].free
= 1;
216 payload
+= priv
->memory_pool
[i
].size
;
219 BUG_ON(payload
- priv
->memory_pool
[i
- 1].size
> PAYLOAD_SIZE
);
222 static u32
alloc_mem(struct isp1760_hcd
*priv
, u32 size
)
227 return ISP1760_NULL_POINTER
;
229 for (i
= 0; i
< BLOCKS
; i
++) {
230 if (priv
->memory_pool
[i
].size
>= size
&&
231 priv
->memory_pool
[i
].free
) {
233 priv
->memory_pool
[i
].free
= 0;
234 return priv
->memory_pool
[i
].start
;
238 printk(KERN_ERR
"ISP1760 MEM: can not allocate %d bytes of memory\n",
240 printk(KERN_ERR
"Current memory map:\n");
241 for (i
= 0; i
< BLOCKS
; i
++) {
242 printk(KERN_ERR
"Pool %2d size %4d status: %d\n",
243 i
, priv
->memory_pool
[i
].size
,
244 priv
->memory_pool
[i
].free
);
246 /* XXX maybe -ENOMEM could be possible */
251 static void free_mem(struct isp1760_hcd
*priv
, u32 mem
)
255 if (mem
== ISP1760_NULL_POINTER
)
258 for (i
= 0; i
< BLOCKS
; i
++) {
259 if (priv
->memory_pool
[i
].start
== mem
) {
261 BUG_ON(priv
->memory_pool
[i
].free
);
263 priv
->memory_pool
[i
].free
= 1;
268 printk(KERN_ERR
"Trying to free not-here-allocated memory :%08x\n",
273 static void isp1760_init_regs(struct usb_hcd
*hcd
)
275 isp1760_writel(0, hcd
->regs
+ HC_BUFFER_STATUS_REG
);
276 isp1760_writel(NO_TRANSFER_ACTIVE
, hcd
->regs
+
277 HC_ATL_PTD_SKIPMAP_REG
);
278 isp1760_writel(NO_TRANSFER_ACTIVE
, hcd
->regs
+
279 HC_INT_PTD_SKIPMAP_REG
);
280 isp1760_writel(NO_TRANSFER_ACTIVE
, hcd
->regs
+
281 HC_ISO_PTD_SKIPMAP_REG
);
283 isp1760_writel(~NO_TRANSFER_ACTIVE
, hcd
->regs
+
284 HC_ATL_PTD_DONEMAP_REG
);
285 isp1760_writel(~NO_TRANSFER_ACTIVE
, hcd
->regs
+
286 HC_INT_PTD_DONEMAP_REG
);
287 isp1760_writel(~NO_TRANSFER_ACTIVE
, hcd
->regs
+
288 HC_ISO_PTD_DONEMAP_REG
);
291 static int handshake(struct isp1760_hcd
*priv
, void __iomem
*ptr
,
292 u32 mask
, u32 done
, int usec
)
297 result
= isp1760_readl(ptr
);
309 /* reset a non-running (STS_HALT == 1) controller */
310 static int ehci_reset(struct isp1760_hcd
*priv
)
313 struct usb_hcd
*hcd
= priv_to_hcd(priv
);
314 u32 command
= isp1760_readl(hcd
->regs
+ HC_USBCMD
);
316 command
|= CMD_RESET
;
317 isp1760_writel(command
, hcd
->regs
+ HC_USBCMD
);
318 hcd
->state
= HC_STATE_HALT
;
319 priv
->next_statechange
= jiffies
;
320 retval
= handshake(priv
, hcd
->regs
+ HC_USBCMD
,
321 CMD_RESET
, 0, 250 * 1000);
325 static void qh_destroy(struct isp1760_qh
*qh
)
327 BUG_ON(!list_empty(&qh
->qtd_list
));
328 kmem_cache_free(qh_cachep
, qh
);
331 static struct isp1760_qh
*isp1760_qh_alloc(struct isp1760_hcd
*priv
,
334 struct isp1760_qh
*qh
;
336 qh
= kmem_cache_zalloc(qh_cachep
, flags
);
340 INIT_LIST_HEAD(&qh
->qtd_list
);
345 /* magic numbers that can affect system performance */
346 #define EHCI_TUNE_CERR 3 /* 0-3 qtd retries; 0 == don't stop */
347 #define EHCI_TUNE_RL_HS 4 /* nak throttle; see 4.9 */
348 #define EHCI_TUNE_RL_TT 0
349 #define EHCI_TUNE_MULT_HS 1 /* 1-3 transactions/uframe; 4.10.3 */
350 #define EHCI_TUNE_MULT_TT 1
351 #define EHCI_TUNE_FLS 2 /* (small) 256 frame schedule */
353 /* one-time init, only for memory state */
354 static int priv_init(struct usb_hcd
*hcd
)
356 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
359 spin_lock_init(&priv
->lock
);
362 * hw default: 1K periodic list heads, one per frame.
363 * periodic_size can shrink by USBCMD update if hcc_params allows.
365 priv
->periodic_size
= DEFAULT_I_TDPS
;
367 /* controllers may cache some of the periodic schedule ... */
368 hcc_params
= isp1760_readl(hcd
->regs
+ HC_HCCPARAMS
);
369 /* full frame cache */
370 if (HCC_ISOC_CACHE(hcc_params
))
372 else /* N microframes cached */
373 priv
->i_thresh
= 2 + HCC_ISOC_THRES(hcc_params
);
378 static int isp1760_hc_setup(struct usb_hcd
*hcd
)
380 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
384 /* Setup HW Mode Control: This assumes a level active-low interrupt */
385 hwmode
= HW_DATA_BUS_32BIT
;
387 if (priv
->devflags
& ISP1760_FLAG_BUS_WIDTH_16
)
388 hwmode
&= ~HW_DATA_BUS_32BIT
;
389 if (priv
->devflags
& ISP1760_FLAG_ANALOG_OC
)
390 hwmode
|= HW_ANA_DIGI_OC
;
391 if (priv
->devflags
& ISP1760_FLAG_DACK_POL_HIGH
)
392 hwmode
|= HW_DACK_POL_HIGH
;
393 if (priv
->devflags
& ISP1760_FLAG_DREQ_POL_HIGH
)
394 hwmode
|= HW_DREQ_POL_HIGH
;
397 * We have to set this first in case we're in 16-bit mode.
398 * Write it twice to ensure correct upper bits if switching
401 isp1760_writel(hwmode
, hcd
->regs
+ HC_HW_MODE_CTRL
);
402 isp1760_writel(hwmode
, hcd
->regs
+ HC_HW_MODE_CTRL
);
404 isp1760_writel(0xdeadbabe, hcd
->regs
+ HC_SCRATCH_REG
);
405 /* Change bus pattern */
406 scratch
= isp1760_readl(hcd
->regs
+ HC_CHIP_ID_REG
);
407 scratch
= isp1760_readl(hcd
->regs
+ HC_SCRATCH_REG
);
408 if (scratch
!= 0xdeadbabe) {
409 printk(KERN_ERR
"ISP1760: Scratch test failed.\n");
414 isp1760_init_regs(hcd
);
417 isp1760_writel(SW_RESET_RESET_ALL
, hcd
->regs
+ HC_RESET_REG
);
420 isp1760_writel(SW_RESET_RESET_HC
, hcd
->regs
+ HC_RESET_REG
);
423 result
= ehci_reset(priv
);
429 isp1760_info(priv
, "bus width: %d, oc: %s\n",
430 (priv
->devflags
& ISP1760_FLAG_BUS_WIDTH_16
) ?
431 16 : 32, (priv
->devflags
& ISP1760_FLAG_ANALOG_OC
) ?
432 "analog" : "digital");
435 isp1760_writel(hwmode
| ALL_ATX_RESET
, hcd
->regs
+ HC_HW_MODE_CTRL
);
437 isp1760_writel(hwmode
, hcd
->regs
+ HC_HW_MODE_CTRL
);
439 isp1760_writel(INTERRUPT_ENABLE_MASK
, hcd
->regs
+ HC_INTERRUPT_REG
);
440 isp1760_writel(INTERRUPT_ENABLE_MASK
, hcd
->regs
+ HC_INTERRUPT_ENABLE
);
443 * PORT 1 Control register of the ISP1760 is the OTG control
444 * register on ISP1761.
446 if (!(priv
->devflags
& ISP1760_FLAG_ISP1761
) &&
447 !(priv
->devflags
& ISP1760_FLAG_PORT1_DIS
)) {
448 isp1760_writel(PORT1_POWER
| PORT1_INIT2
,
449 hcd
->regs
+ HC_PORT1_CTRL
);
453 priv
->hcs_params
= isp1760_readl(hcd
->regs
+ HC_HCSPARAMS
);
455 return priv_init(hcd
);
458 static void isp1760_init_maps(struct usb_hcd
*hcd
)
460 /*set last maps, for iso its only 1, else 32 tds bitmap*/
461 isp1760_writel(0x80000000, hcd
->regs
+ HC_ATL_PTD_LASTPTD_REG
);
462 isp1760_writel(0x80000000, hcd
->regs
+ HC_INT_PTD_LASTPTD_REG
);
463 isp1760_writel(0x00000001, hcd
->regs
+ HC_ISO_PTD_LASTPTD_REG
);
466 static void isp1760_enable_interrupts(struct usb_hcd
*hcd
)
468 isp1760_writel(0, hcd
->regs
+ HC_ATL_IRQ_MASK_AND_REG
);
469 isp1760_writel(0, hcd
->regs
+ HC_ATL_IRQ_MASK_OR_REG
);
470 isp1760_writel(0, hcd
->regs
+ HC_INT_IRQ_MASK_AND_REG
);
471 isp1760_writel(0, hcd
->regs
+ HC_INT_IRQ_MASK_OR_REG
);
472 isp1760_writel(0, hcd
->regs
+ HC_ISO_IRQ_MASK_AND_REG
);
473 isp1760_writel(0xffffffff, hcd
->regs
+ HC_ISO_IRQ_MASK_OR_REG
);
477 static int isp1760_run(struct usb_hcd
*hcd
)
479 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
485 hcd
->uses_new_polling
= 1;
488 hcd
->state
= HC_STATE_RUNNING
;
489 isp1760_enable_interrupts(hcd
);
490 temp
= isp1760_readl(hcd
->regs
+ HC_HW_MODE_CTRL
);
491 isp1760_writel(temp
| HW_GLOBAL_INTR_EN
, hcd
->regs
+ HC_HW_MODE_CTRL
);
493 command
= isp1760_readl(hcd
->regs
+ HC_USBCMD
);
494 command
&= ~(CMD_LRESET
|CMD_RESET
);
496 isp1760_writel(command
, hcd
->regs
+ HC_USBCMD
);
498 retval
= handshake(priv
, hcd
->regs
+ HC_USBCMD
, CMD_RUN
, CMD_RUN
,
505 * Spec says to write FLAG_CF as last config action, priv code grabs
506 * the semaphore while doing so.
508 down_write(&ehci_cf_port_reset_rwsem
);
509 isp1760_writel(FLAG_CF
, hcd
->regs
+ HC_CONFIGFLAG
);
511 retval
= handshake(priv
, hcd
->regs
+ HC_CONFIGFLAG
, FLAG_CF
, FLAG_CF
,
513 up_write(&ehci_cf_port_reset_rwsem
);
517 chipid
= isp1760_readl(hcd
->regs
+ HC_CHIP_ID_REG
);
518 isp1760_info(priv
, "USB ISP %04x HW rev. %d started\n", chipid
& 0xffff,
521 /* PTD Register Init Part 2, Step 28 */
523 isp1760_init_maps(hcd
);
525 /* GRR this is run-once init(), being done every time the HC starts.
526 * So long as they're part of class devices, we can't do it init()
527 * since the class device isn't created that early.
532 static u32
base_to_chip(u32 base
)
534 return ((base
- 0x400) >> 3);
537 static void transform_into_atl(struct isp1760_hcd
*priv
, struct isp1760_qh
*qh
,
538 struct isp1760_qtd
*qtd
, struct urb
*urb
,
539 u32 payload
, struct ptd
*ptd
)
549 u32 nak
= NAK_COUNTER
;
551 /* according to 3.6.2, max packet len can not be > 0x400 */
552 maxpacket
= usb_maxpacket(urb
->dev
, urb
->pipe
, usb_pipeout(urb
->pipe
));
553 multi
= 1 + ((maxpacket
>> 11) & 0x3);
558 dw0
|= PTD_LENGTH(qtd
->length
);
559 dw0
|= PTD_MAXPACKET(maxpacket
);
560 dw0
|= PTD_ENDPOINT(usb_pipeendpoint(urb
->pipe
));
561 dw1
= usb_pipeendpoint(urb
->pipe
) >> 1;
564 dw1
|= PTD_DEVICE_ADDR(usb_pipedevice(urb
->pipe
));
566 pid_code
= qtd
->packet_type
;
567 dw1
|= PTD_PID_TOKEN(pid_code
);
569 if (usb_pipebulk(urb
->pipe
))
570 dw1
|= PTD_TRANS_BULK
;
571 else if (usb_pipeint(urb
->pipe
))
572 dw1
|= PTD_TRANS_INT
;
574 if (urb
->dev
->speed
!= USB_SPEED_HIGH
) {
575 /* split transaction */
577 dw1
|= PTD_TRANS_SPLIT
;
578 if (urb
->dev
->speed
== USB_SPEED_LOW
)
579 dw1
|= PTD_SE_USB_LOSPEED
;
581 dw1
|= PTD_PORT_NUM(urb
->dev
->ttport
);
582 dw1
|= PTD_HUB_NUM(urb
->dev
->tt
->hub
->devnum
);
584 /* SE bit for Split INT transfers */
585 if (usb_pipeint(urb
->pipe
) &&
586 (urb
->dev
->speed
== USB_SPEED_LOW
))
593 dw0
|= PTD_MULTI(multi
);
594 if (usb_pipecontrol(urb
->pipe
) || usb_pipebulk(urb
->pipe
))
601 dw2
|= PTD_DATA_START_ADDR(base_to_chip(payload
));
602 dw2
|= PTD_RL_CNT(rl
);
603 dw3
|= PTD_NAC_CNT(nak
);
606 if (usb_pipecontrol(urb
->pipe
))
607 dw3
|= PTD_DATA_TOGGLE(qtd
->toggle
);
614 dw3
|= PTD_CERR(ERR_COUNTER
);
616 memset(ptd
, 0, sizeof(*ptd
));
618 ptd
->dw0
= cpu_to_le32(dw0
);
619 ptd
->dw1
= cpu_to_le32(dw1
);
620 ptd
->dw2
= cpu_to_le32(dw2
);
621 ptd
->dw3
= cpu_to_le32(dw3
);
624 static void transform_add_int(struct isp1760_hcd
*priv
, struct isp1760_qh
*qh
,
625 struct isp1760_qtd
*qtd
, struct urb
*urb
,
626 u32 payload
, struct ptd
*ptd
)
635 maxpacket
= usb_maxpacket(urb
->dev
, urb
->pipe
, usb_pipeout(urb
->pipe
));
636 multi
= 1 + ((maxpacket
>> 11) & 0x3);
638 /* length of the data per uframe */
639 maxpacket
= multi
* maxpacket
;
641 numberofusofs
= urb
->transfer_buffer_length
/ maxpacket
;
642 if (urb
->transfer_buffer_length
% maxpacket
)
647 for (i
= 0; i
< numberofusofs
; i
++) {
652 if (urb
->dev
->speed
!= USB_SPEED_HIGH
) {
654 ptd
->dw5
= __constant_cpu_to_le32(0x1c);
656 if (qh
->period
>= 32)
657 period
= qh
->period
/ 2;
664 period
= qh
->period
/8;
671 if (qh
->period
>= 8) {
672 /* millisecond period */
673 period
= (period
<< 3);
675 /* usof based tranmsfers */
676 /* minimum 4 usofs */
681 ptd
->dw2
|= cpu_to_le32(period
);
682 ptd
->dw4
= cpu_to_le32(usof
);
685 static void transform_into_int(struct isp1760_hcd
*priv
, struct isp1760_qh
*qh
,
686 struct isp1760_qtd
*qtd
, struct urb
*urb
,
687 u32 payload
, struct ptd
*ptd
)
689 transform_into_atl(priv
, qh
, qtd
, urb
, payload
, ptd
);
690 transform_add_int(priv
, qh
, qtd
, urb
, payload
, ptd
);
693 static int qtd_fill(struct isp1760_qtd
*qtd
, void *databuffer
, size_t len
,
698 qtd
->data_buffer
= databuffer
;
699 qtd
->packet_type
= GET_QTD_TOKEN_TYPE(token
);
700 qtd
->toggle
= GET_DATA_TOGGLE(token
);
702 if (len
> HC_ATL_PL_SIZE
)
703 count
= HC_ATL_PL_SIZE
;
711 static int check_error(struct ptd
*ptd
)
716 dw3
= le32_to_cpu(ptd
->dw3
);
717 if (dw3
& DW3_HALT_BIT
)
720 if (dw3
& DW3_ERROR_BIT
) {
721 printk(KERN_ERR
"error bit is set in DW3\n");
725 if (dw3
& DW3_QTD_ACTIVE
) {
726 printk(KERN_ERR
"transfer active bit is set DW3\n");
727 printk(KERN_ERR
"nak counter: %d, rl: %d\n", (dw3
>> 19) & 0xf,
728 (le32_to_cpu(ptd
->dw2
) >> 25) & 0xf);
734 static void check_int_err_status(u32 dw4
)
740 for (i
= 0; i
< 8; i
++) {
743 printk(KERN_ERR
"ERROR: under run , %d\n", i
);
747 printk(KERN_ERR
"ERROR: transaction error, %d\n", i
);
751 printk(KERN_ERR
"ERROR: babble error, %d\n", i
);
758 static void enqueue_one_qtd(struct isp1760_qtd
*qtd
, struct isp1760_hcd
*priv
,
762 struct usb_hcd
*hcd
= priv_to_hcd(priv
);
764 token
= qtd
->packet_type
;
766 if (qtd
->length
&& (qtd
->length
<= HC_ATL_PL_SIZE
)) {
772 priv_write_copy(priv
, qtd
->data_buffer
,
779 static void enqueue_one_atl_qtd(u32 atl_regs
, u32 payload
,
780 struct isp1760_hcd
*priv
, struct isp1760_qh
*qh
,
781 struct urb
*urb
, u32 slot
, struct isp1760_qtd
*qtd
)
784 struct usb_hcd
*hcd
= priv_to_hcd(priv
);
786 transform_into_atl(priv
, qh
, qtd
, urb
, payload
, &ptd
);
787 priv_write_copy(priv
, (u32
*)&ptd
, hcd
->regs
+ atl_regs
, sizeof(ptd
));
788 enqueue_one_qtd(qtd
, priv
, payload
);
790 priv
->atl_ints
[slot
].urb
= urb
;
791 priv
->atl_ints
[slot
].qh
= qh
;
792 priv
->atl_ints
[slot
].qtd
= qtd
;
793 priv
->atl_ints
[slot
].data_buffer
= qtd
->data_buffer
;
794 priv
->atl_ints
[slot
].payload
= payload
;
795 qtd
->status
|= URB_ENQUEUED
| URB_TYPE_ATL
;
796 qtd
->status
|= slot
<< 16;
799 static void enqueue_one_int_qtd(u32 int_regs
, u32 payload
,
800 struct isp1760_hcd
*priv
, struct isp1760_qh
*qh
,
801 struct urb
*urb
, u32 slot
, struct isp1760_qtd
*qtd
)
804 struct usb_hcd
*hcd
= priv_to_hcd(priv
);
806 transform_into_int(priv
, qh
, qtd
, urb
, payload
, &ptd
);
807 priv_write_copy(priv
, (u32
*)&ptd
, hcd
->regs
+ int_regs
, sizeof(ptd
));
808 enqueue_one_qtd(qtd
, priv
, payload
);
810 priv
->int_ints
[slot
].urb
= urb
;
811 priv
->int_ints
[slot
].qh
= qh
;
812 priv
->int_ints
[slot
].qtd
= qtd
;
813 priv
->int_ints
[slot
].data_buffer
= qtd
->data_buffer
;
814 priv
->int_ints
[slot
].payload
= payload
;
815 qtd
->status
|= URB_ENQUEUED
| URB_TYPE_INT
;
816 qtd
->status
|= slot
<< 16;
819 static void enqueue_an_ATL_packet(struct usb_hcd
*hcd
, struct isp1760_qh
*qh
,
820 struct isp1760_qtd
*qtd
)
822 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
823 u32 skip_map
, or_map
;
826 u32 atl_regs
, payload
;
829 skip_map
= isp1760_readl(hcd
->regs
+ HC_ATL_PTD_SKIPMAP_REG
);
832 slot
= __ffs(skip_map
);
833 queue_entry
= 1 << slot
;
835 atl_regs
= ATL_REGS_OFFSET
+ slot
* sizeof(struct ptd
);
837 payload
= alloc_mem(priv
, qtd
->length
);
839 enqueue_one_atl_qtd(atl_regs
, payload
, priv
, qh
, qtd
->urb
, slot
, qtd
);
841 or_map
= isp1760_readl(hcd
->regs
+ HC_ATL_IRQ_MASK_OR_REG
);
842 or_map
|= queue_entry
;
843 isp1760_writel(or_map
, hcd
->regs
+ HC_ATL_IRQ_MASK_OR_REG
);
845 skip_map
&= ~queue_entry
;
846 isp1760_writel(skip_map
, hcd
->regs
+ HC_ATL_PTD_SKIPMAP_REG
);
848 buffstatus
= isp1760_readl(hcd
->regs
+ HC_BUFFER_STATUS_REG
);
849 buffstatus
|= ATL_BUFFER
;
850 isp1760_writel(buffstatus
, hcd
->regs
+ HC_BUFFER_STATUS_REG
);
853 static void enqueue_an_INT_packet(struct usb_hcd
*hcd
, struct isp1760_qh
*qh
,
854 struct isp1760_qtd
*qtd
)
856 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
857 u32 skip_map
, or_map
;
860 u32 int_regs
, payload
;
863 skip_map
= isp1760_readl(hcd
->regs
+ HC_INT_PTD_SKIPMAP_REG
);
866 slot
= __ffs(skip_map
);
867 queue_entry
= 1 << slot
;
869 int_regs
= INT_REGS_OFFSET
+ slot
* sizeof(struct ptd
);
871 payload
= alloc_mem(priv
, qtd
->length
);
873 enqueue_one_int_qtd(int_regs
, payload
, priv
, qh
, qtd
->urb
, slot
, qtd
);
875 or_map
= isp1760_readl(hcd
->regs
+ HC_INT_IRQ_MASK_OR_REG
);
876 or_map
|= queue_entry
;
877 isp1760_writel(or_map
, hcd
->regs
+ HC_INT_IRQ_MASK_OR_REG
);
879 skip_map
&= ~queue_entry
;
880 isp1760_writel(skip_map
, hcd
->regs
+ HC_INT_PTD_SKIPMAP_REG
);
882 buffstatus
= isp1760_readl(hcd
->regs
+ HC_BUFFER_STATUS_REG
);
883 buffstatus
|= INT_BUFFER
;
884 isp1760_writel(buffstatus
, hcd
->regs
+ HC_BUFFER_STATUS_REG
);
887 static void isp1760_urb_done(struct isp1760_hcd
*priv
, struct urb
*urb
, int status
)
888 __releases(priv
->lock
)
889 __acquires(priv
->lock
)
891 if (!urb
->unlinked
) {
892 if (status
== -EINPROGRESS
)
896 /* complete() can reenter this HCD */
897 usb_hcd_unlink_urb_from_ep(priv_to_hcd(priv
), urb
);
898 spin_unlock(&priv
->lock
);
899 usb_hcd_giveback_urb(priv_to_hcd(priv
), urb
, status
);
900 spin_lock(&priv
->lock
);
903 static void isp1760_qtd_free(struct isp1760_qtd
*qtd
)
905 kmem_cache_free(qtd_cachep
, qtd
);
908 static struct isp1760_qtd
*clean_this_qtd(struct isp1760_qtd
*qtd
)
910 struct isp1760_qtd
*tmp_qtd
;
912 tmp_qtd
= qtd
->hw_next
;
913 list_del(&qtd
->qtd_list
);
914 isp1760_qtd_free(qtd
);
919 * Remove this QTD from the QH list and free its memory. If this QTD
920 * isn't the last one than remove also his successor(s).
921 * Returns the QTD which is part of an new URB and should be enqueued.
923 static struct isp1760_qtd
*clean_up_qtdlist(struct isp1760_qtd
*qtd
)
925 struct isp1760_qtd
*tmp_qtd
;
929 tmp_qtd
= qtd
->hw_next
;
930 last_one
= qtd
->status
& URB_COMPLETE_NOTIFY
;
931 list_del(&qtd
->qtd_list
);
932 isp1760_qtd_free(qtd
);
934 } while (!last_one
&& qtd
);
939 static void do_atl_int(struct usb_hcd
*usb_hcd
)
941 struct isp1760_hcd
*priv
= hcd_to_priv(usb_hcd
);
942 u32 done_map
, skip_map
;
944 struct urb
*urb
= NULL
;
951 u32 status
= -EINVAL
;
953 struct isp1760_qtd
*qtd
;
954 struct isp1760_qh
*qh
;
958 done_map
= isp1760_readl(usb_hcd
->regs
+
959 HC_ATL_PTD_DONEMAP_REG
);
960 skip_map
= isp1760_readl(usb_hcd
->regs
+
961 HC_ATL_PTD_SKIPMAP_REG
);
963 or_map
= isp1760_readl(usb_hcd
->regs
+ HC_ATL_IRQ_MASK_OR_REG
);
965 isp1760_writel(or_map
, usb_hcd
->regs
+ HC_ATL_IRQ_MASK_OR_REG
);
967 atl_regs_base
= ATL_REGS_OFFSET
;
975 queue_entry
= __ffs(done_map
);
976 done_map
&= ~(1 << queue_entry
);
977 skip_map
|= 1 << queue_entry
;
979 atl_regs
= atl_regs_base
+ queue_entry
* sizeof(struct ptd
);
981 urb
= priv
->atl_ints
[queue_entry
].urb
;
982 qtd
= priv
->atl_ints
[queue_entry
].qtd
;
983 qh
= priv
->atl_ints
[queue_entry
].qh
;
984 payload
= priv
->atl_ints
[queue_entry
].payload
;
987 printk(KERN_ERR
"qh is 0\n");
990 priv_read_copy(priv
, (u32
*)&ptd
, usb_hcd
->regs
+ atl_regs
,
991 atl_regs
, sizeof(ptd
));
993 dw1
= le32_to_cpu(ptd
.dw1
);
994 dw2
= le32_to_cpu(ptd
.dw2
);
995 dw3
= le32_to_cpu(ptd
.dw3
);
996 rl
= (dw2
>> 25) & 0x0f;
997 nakcount
= (dw3
>> 19) & 0xf;
999 /* Transfer Error, *but* active and no HALT -> reload */
1000 if ((dw3
& DW3_ERROR_BIT
) && (dw3
& DW3_QTD_ACTIVE
) &&
1001 !(dw3
& DW3_HALT_BIT
)) {
1003 /* according to ppriv code, we have to
1004 * reload this one if trasfered bytes != requested bytes
1005 * else act like everything went smooth..
1006 * XXX This just doesn't feel right and hasn't
1010 length
= PTD_XFERRED_LENGTH(dw3
);
1011 printk(KERN_ERR
"Should reload now.... transfered %d "
1012 "of %zu\n", length
, qtd
->length
);
1016 if (!nakcount
&& (dw3
& DW3_QTD_ACTIVE
)) {
1020 * NAKs are handled in HW by the chip. Usually if the
1021 * device is not able to send data fast enough.
1022 * This did not trigger for a long time now.
1024 printk(KERN_ERR
"Reloading ptd %p/%p... qh %p readed: "
1025 "%d of %zu done: %08x cur: %08x\n", qtd
,
1026 urb
, qh
, PTD_XFERRED_LENGTH(dw3
),
1027 qtd
->length
, done_map
,
1028 (1 << queue_entry
));
1030 /* RL counter = ERR counter */
1031 dw3
&= ~(0xf << 19);
1033 dw3
&= ~(3 << (55 - 32));
1034 dw3
|= ERR_COUNTER
<< (55 - 32);
1037 * It is not needed to write skip map back because it
1038 * is unchanged. Just make sure that this entry is
1039 * unskipped once it gets written to the HW.
1041 skip_map
&= ~(1 << queue_entry
);
1042 or_map
= isp1760_readl(usb_hcd
->regs
+
1043 HC_ATL_IRQ_MASK_OR_REG
);
1044 or_map
|= 1 << queue_entry
;
1045 isp1760_writel(or_map
, usb_hcd
->regs
+
1046 HC_ATL_IRQ_MASK_OR_REG
);
1048 ptd
.dw3
= cpu_to_le32(dw3
);
1049 priv_write_copy(priv
, (u32
*)&ptd
, usb_hcd
->regs
+
1050 atl_regs
, sizeof(ptd
));
1052 ptd
.dw0
|= __constant_cpu_to_le32(PTD_VALID
);
1053 priv_write_copy(priv
, (u32
*)&ptd
, usb_hcd
->regs
+
1054 atl_regs
, sizeof(ptd
));
1056 buffstatus
= isp1760_readl(usb_hcd
->regs
+
1057 HC_BUFFER_STATUS_REG
);
1058 buffstatus
|= ATL_BUFFER
;
1059 isp1760_writel(buffstatus
, usb_hcd
->regs
+
1060 HC_BUFFER_STATUS_REG
);
1064 error
= check_error(&ptd
);
1067 priv
->atl_ints
[queue_entry
].qh
->toggle
= 0;
1068 priv
->atl_ints
[queue_entry
].qh
->ping
= 0;
1069 urb
->status
= -EPIPE
;
1072 printk(KERN_ERR
"Error in %s().\n", __func__
);
1073 printk(KERN_ERR
"IN dw0: %08x dw1: %08x dw2: %08x "
1074 "dw3: %08x dw4: %08x dw5: %08x dw6: "
1076 ptd
.dw0
, ptd
.dw1
, ptd
.dw2
, ptd
.dw3
,
1077 ptd
.dw4
, ptd
.dw5
, ptd
.dw6
, ptd
.dw7
);
1080 if (usb_pipetype(urb
->pipe
) == PIPE_BULK
) {
1081 priv
->atl_ints
[queue_entry
].qh
->toggle
= dw3
&
1083 priv
->atl_ints
[queue_entry
].qh
->ping
= dw3
&
1088 length
= PTD_XFERRED_LENGTH(dw3
);
1090 switch (DW1_GET_PID(dw1
)) {
1092 priv_read_copy(priv
,
1093 priv
->atl_ints
[queue_entry
].data_buffer
,
1094 usb_hcd
->regs
+ payload
, payload
,
1099 urb
->actual_length
+= length
;
1106 priv
->atl_ints
[queue_entry
].data_buffer
= NULL
;
1107 priv
->atl_ints
[queue_entry
].urb
= NULL
;
1108 priv
->atl_ints
[queue_entry
].qtd
= NULL
;
1109 priv
->atl_ints
[queue_entry
].qh
= NULL
;
1111 free_mem(priv
, payload
);
1113 isp1760_writel(skip_map
, usb_hcd
->regs
+
1114 HC_ATL_PTD_SKIPMAP_REG
);
1116 if (urb
->status
== -EPIPE
) {
1117 /* HALT was received */
1119 qtd
= clean_up_qtdlist(qtd
);
1120 isp1760_urb_done(priv
, urb
, urb
->status
);
1122 } else if (usb_pipebulk(urb
->pipe
) && (length
< qtd
->length
)) {
1123 /* short BULK received */
1125 printk(KERN_ERR
"short bulk, %d instead %zu\n", length
,
1127 if (urb
->transfer_flags
& URB_SHORT_NOT_OK
) {
1128 urb
->status
= -EREMOTEIO
;
1129 printk(KERN_ERR
"not okey\n");
1132 if (urb
->status
== -EINPROGRESS
)
1135 qtd
= clean_up_qtdlist(qtd
);
1137 isp1760_urb_done(priv
, urb
, urb
->status
);
1139 } else if (qtd
->status
& URB_COMPLETE_NOTIFY
) {
1140 /* that was the last qtd of that URB */
1142 if (urb
->status
== -EINPROGRESS
)
1145 qtd
= clean_this_qtd(qtd
);
1146 isp1760_urb_done(priv
, urb
, urb
->status
);
1149 /* next QTD of this URB */
1151 qtd
= clean_this_qtd(qtd
);
1156 enqueue_an_ATL_packet(usb_hcd
, qh
, qtd
);
1158 skip_map
= isp1760_readl(usb_hcd
->regs
+
1159 HC_ATL_PTD_SKIPMAP_REG
);
1163 static void do_intl_int(struct usb_hcd
*usb_hcd
)
1165 struct isp1760_hcd
*priv
= hcd_to_priv(usb_hcd
);
1166 u32 done_map
, skip_map
;
1168 struct urb
*urb
= NULL
;
1176 struct isp1760_qtd
*qtd
;
1177 struct isp1760_qh
*qh
;
1179 done_map
= isp1760_readl(usb_hcd
->regs
+
1180 HC_INT_PTD_DONEMAP_REG
);
1181 skip_map
= isp1760_readl(usb_hcd
->regs
+
1182 HC_INT_PTD_SKIPMAP_REG
);
1184 or_map
= isp1760_readl(usb_hcd
->regs
+ HC_INT_IRQ_MASK_OR_REG
);
1185 or_map
&= ~done_map
;
1186 isp1760_writel(or_map
, usb_hcd
->regs
+ HC_INT_IRQ_MASK_OR_REG
);
1188 int_regs_base
= INT_REGS_OFFSET
;
1194 queue_entry
= __ffs(done_map
);
1195 done_map
&= ~(1 << queue_entry
);
1196 skip_map
|= 1 << queue_entry
;
1198 int_regs
= int_regs_base
+ queue_entry
* sizeof(struct ptd
);
1199 urb
= priv
->int_ints
[queue_entry
].urb
;
1200 qtd
= priv
->int_ints
[queue_entry
].qtd
;
1201 qh
= priv
->int_ints
[queue_entry
].qh
;
1202 payload
= priv
->int_ints
[queue_entry
].payload
;
1205 printk(KERN_ERR
"(INT) qh is 0\n");
1209 priv_read_copy(priv
, (u32
*)&ptd
, usb_hcd
->regs
+ int_regs
,
1210 int_regs
, sizeof(ptd
));
1211 dw1
= le32_to_cpu(ptd
.dw1
);
1212 dw3
= le32_to_cpu(ptd
.dw3
);
1213 check_int_err_status(le32_to_cpu(ptd
.dw4
));
1215 error
= check_error(&ptd
);
1218 printk(KERN_ERR
"Error in %s().\n", __func__
);
1219 printk(KERN_ERR
"IN dw0: %08x dw1: %08x dw2: %08x "
1220 "dw3: %08x dw4: %08x dw5: %08x dw6: "
1222 ptd
.dw0
, ptd
.dw1
, ptd
.dw2
, ptd
.dw3
,
1223 ptd
.dw4
, ptd
.dw5
, ptd
.dw6
, ptd
.dw7
);
1225 urb
->status
= -EPIPE
;
1226 priv
->int_ints
[queue_entry
].qh
->toggle
= 0;
1227 priv
->int_ints
[queue_entry
].qh
->ping
= 0;
1230 priv
->int_ints
[queue_entry
].qh
->toggle
=
1232 priv
->int_ints
[queue_entry
].qh
->ping
= dw3
& (1 << 26);
1235 if (urb
->dev
->speed
!= USB_SPEED_HIGH
)
1236 length
= PTD_XFERRED_LENGTH_LO(dw3
);
1238 length
= PTD_XFERRED_LENGTH(dw3
);
1241 switch (DW1_GET_PID(dw1
)) {
1243 priv_read_copy(priv
,
1244 priv
->int_ints
[queue_entry
].data_buffer
,
1245 usb_hcd
->regs
+ payload
, payload
,
1249 urb
->actual_length
+= length
;
1256 priv
->int_ints
[queue_entry
].data_buffer
= NULL
;
1257 priv
->int_ints
[queue_entry
].urb
= NULL
;
1258 priv
->int_ints
[queue_entry
].qtd
= NULL
;
1259 priv
->int_ints
[queue_entry
].qh
= NULL
;
1261 isp1760_writel(skip_map
, usb_hcd
->regs
+
1262 HC_INT_PTD_SKIPMAP_REG
);
1263 free_mem(priv
, payload
);
1265 if (urb
->status
== -EPIPE
) {
1268 qtd
= clean_up_qtdlist(qtd
);
1269 isp1760_urb_done(priv
, urb
, urb
->status
);
1271 } else if (qtd
->status
& URB_COMPLETE_NOTIFY
) {
1273 if (urb
->status
== -EINPROGRESS
)
1276 qtd
= clean_this_qtd(qtd
);
1277 isp1760_urb_done(priv
, urb
, urb
->status
);
1280 /* next QTD of this URB */
1282 qtd
= clean_this_qtd(qtd
);
1287 enqueue_an_INT_packet(usb_hcd
, qh
, qtd
);
1289 skip_map
= isp1760_readl(usb_hcd
->regs
+
1290 HC_INT_PTD_SKIPMAP_REG
);
1294 #define max_packet(wMaxPacketSize) ((wMaxPacketSize) & 0x07ff)
1295 static struct isp1760_qh
*qh_make(struct isp1760_hcd
*priv
, struct urb
*urb
,
1298 struct isp1760_qh
*qh
;
1301 qh
= isp1760_qh_alloc(priv
, flags
);
1306 * init endpoint/device data for this QH
1308 is_input
= usb_pipein(urb
->pipe
);
1309 type
= usb_pipetype(urb
->pipe
);
1311 if (type
== PIPE_INTERRUPT
) {
1313 if (urb
->dev
->speed
== USB_SPEED_HIGH
) {
1315 qh
->period
= urb
->interval
>> 3;
1316 if (qh
->period
== 0 && urb
->interval
!= 1) {
1317 /* NOTE interval 2 or 4 uframes could work.
1318 * But interval 1 scheduling is simpler, and
1319 * includes high bandwidth.
1321 printk(KERN_ERR
"intr period %d uframes, NYET!",
1327 qh
->period
= urb
->interval
;
1331 /* support for tt scheduling, and access to toggles */
1334 if (!usb_pipecontrol(urb
->pipe
))
1335 usb_settoggle(urb
->dev
, usb_pipeendpoint(urb
->pipe
), !is_input
,
1341 * For control/bulk/interrupt, return QH with these TDs appended.
1342 * Allocates and initializes the QH if necessary.
1343 * Returns null if it can't allocate a QH it needs to.
1344 * If the QH has TDs (urbs) already, that's great.
1346 static struct isp1760_qh
*qh_append_tds(struct isp1760_hcd
*priv
,
1347 struct urb
*urb
, struct list_head
*qtd_list
, int epnum
,
1350 struct isp1760_qh
*qh
;
1351 struct isp1760_qtd
*qtd
;
1352 struct isp1760_qtd
*prev_qtd
;
1354 qh
= (struct isp1760_qh
*)*ptr
;
1356 /* can't sleep here, we have priv->lock... */
1357 qh
= qh_make(priv
, urb
, GFP_ATOMIC
);
1363 qtd
= list_entry(qtd_list
->next
, struct isp1760_qtd
,
1365 if (!list_empty(&qh
->qtd_list
))
1366 prev_qtd
= list_entry(qh
->qtd_list
.prev
,
1367 struct isp1760_qtd
, qtd_list
);
1371 list_splice(qtd_list
, qh
->qtd_list
.prev
);
1373 BUG_ON(prev_qtd
->hw_next
);
1374 prev_qtd
->hw_next
= qtd
;
1381 static void qtd_list_free(struct isp1760_hcd
*priv
, struct urb
*urb
,
1382 struct list_head
*qtd_list
)
1384 struct list_head
*entry
, *temp
;
1386 list_for_each_safe(entry
, temp
, qtd_list
) {
1387 struct isp1760_qtd
*qtd
;
1389 qtd
= list_entry(entry
, struct isp1760_qtd
, qtd_list
);
1390 list_del(&qtd
->qtd_list
);
1391 isp1760_qtd_free(qtd
);
1395 static int isp1760_prepare_enqueue(struct isp1760_hcd
*priv
, struct urb
*urb
,
1396 struct list_head
*qtd_list
, gfp_t mem_flags
, packet_enqueue
*p
)
1398 struct isp1760_qtd
*qtd
;
1400 unsigned long flags
;
1401 struct isp1760_qh
*qh
= NULL
;
1405 qtd
= list_entry(qtd_list
->next
, struct isp1760_qtd
, qtd_list
);
1406 epnum
= urb
->ep
->desc
.bEndpointAddress
;
1408 spin_lock_irqsave(&priv
->lock
, flags
);
1409 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE
, &priv_to_hcd(priv
)->flags
)) {
1413 rc
= usb_hcd_link_urb_to_ep(priv_to_hcd(priv
), urb
);
1417 qh
= urb
->ep
->hcpriv
;
1419 qh_busy
= !list_empty(&qh
->qtd_list
);
1423 qh
= qh_append_tds(priv
, urb
, qtd_list
, epnum
, &urb
->ep
->hcpriv
);
1425 usb_hcd_unlink_urb_from_ep(priv_to_hcd(priv
), urb
);
1431 p(priv_to_hcd(priv
), qh
, qtd
);
1434 spin_unlock_irqrestore(&priv
->lock
, flags
);
1436 qtd_list_free(priv
, urb
, qtd_list
);
1440 static struct isp1760_qtd
*isp1760_qtd_alloc(struct isp1760_hcd
*priv
,
1443 struct isp1760_qtd
*qtd
;
1445 qtd
= kmem_cache_zalloc(qtd_cachep
, flags
);
1447 INIT_LIST_HEAD(&qtd
->qtd_list
);
1453 * create a list of filled qtds for this URB; won't link into qh.
1455 static struct list_head
*qh_urb_transaction(struct isp1760_hcd
*priv
,
1456 struct urb
*urb
, struct list_head
*head
, gfp_t flags
)
1458 struct isp1760_qtd
*qtd
, *qtd_prev
;
1465 * URBs map to sequences of QTDs: one logical transaction
1467 qtd
= isp1760_qtd_alloc(priv
, flags
);
1471 list_add_tail(&qtd
->qtd_list
, head
);
1473 urb
->status
= -EINPROGRESS
;
1476 /* for split transactions, SplitXState initialized to zero */
1478 len
= urb
->transfer_buffer_length
;
1479 is_input
= usb_pipein(urb
->pipe
);
1480 if (usb_pipecontrol(urb
->pipe
)) {
1482 qtd_fill(qtd
, urb
->setup_packet
,
1483 sizeof(struct usb_ctrlrequest
),
1486 /* ... and always at least one more pid */
1487 token
^= DATA_TOGGLE
;
1489 qtd
= isp1760_qtd_alloc(priv
, flags
);
1493 qtd_prev
->hw_next
= qtd
;
1494 list_add_tail(&qtd
->qtd_list
, head
);
1496 /* for zero length DATA stages, STATUS is always IN */
1502 * data transfer stage: buffer setup
1504 buf
= urb
->transfer_buffer
;
1511 maxpacket
= max_packet(usb_maxpacket(urb
->dev
, urb
->pipe
, !is_input
));
1514 * buffer gets wrapped in one or more qtds;
1515 * last one may be "short" (including zero len)
1516 * and may serve as a control status ack
1522 /* XXX This looks like usb storage / SCSI bug */
1523 printk(KERN_ERR
"buf is null, dma is %08lx len is %d\n",
1524 (long unsigned)urb
->transfer_dma
, len
);
1528 this_qtd_len
= qtd_fill(qtd
, buf
, len
, token
);
1529 len
-= this_qtd_len
;
1530 buf
+= this_qtd_len
;
1532 /* qh makes control packets use qtd toggle; maybe switch it */
1533 if ((maxpacket
& (this_qtd_len
+ (maxpacket
- 1))) == 0)
1534 token
^= DATA_TOGGLE
;
1540 qtd
= isp1760_qtd_alloc(priv
, flags
);
1544 qtd_prev
->hw_next
= qtd
;
1545 list_add_tail(&qtd
->qtd_list
, head
);
1549 * control requests may need a terminating data "status" ack;
1550 * bulk ones may need a terminating short packet (zero length).
1552 if (urb
->transfer_buffer_length
!= 0) {
1555 if (usb_pipecontrol(urb
->pipe
)) {
1557 /* "in" <--> "out" */
1560 token
|= DATA_TOGGLE
;
1561 } else if (usb_pipebulk(urb
->pipe
)
1562 && (urb
->transfer_flags
& URB_ZERO_PACKET
)
1563 && !(urb
->transfer_buffer_length
% maxpacket
)) {
1568 qtd
= isp1760_qtd_alloc(priv
, flags
);
1572 qtd_prev
->hw_next
= qtd
;
1573 list_add_tail(&qtd
->qtd_list
, head
);
1575 /* never any data in such packets */
1576 qtd_fill(qtd
, NULL
, 0, token
);
1580 qtd
->status
= URB_COMPLETE_NOTIFY
;
1584 qtd_list_free(priv
, urb
, head
);
1588 static int isp1760_urb_enqueue(struct usb_hcd
*hcd
, struct urb
*urb
,
1591 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
1592 struct list_head qtd_list
;
1595 INIT_LIST_HEAD(&qtd_list
);
1597 switch (usb_pipetype(urb
->pipe
)) {
1601 if (!qh_urb_transaction(priv
, urb
, &qtd_list
, mem_flags
))
1603 pe
= enqueue_an_ATL_packet
;
1606 case PIPE_INTERRUPT
:
1607 if (!qh_urb_transaction(priv
, urb
, &qtd_list
, mem_flags
))
1609 pe
= enqueue_an_INT_packet
;
1612 case PIPE_ISOCHRONOUS
:
1613 printk(KERN_ERR
"PIPE_ISOCHRONOUS ain't supported\n");
1618 isp1760_prepare_enqueue(priv
, urb
, &qtd_list
, mem_flags
, pe
);
1622 static int isp1760_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
,
1625 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
1626 struct inter_packet_info
*ints
;
1628 u32 reg_base
, or_reg
, skip_reg
;
1629 unsigned long flags
;
1632 switch (usb_pipetype(urb
->pipe
)) {
1633 case PIPE_ISOCHRONOUS
:
1637 case PIPE_INTERRUPT
:
1638 ints
= priv
->int_ints
;
1639 reg_base
= INT_REGS_OFFSET
;
1640 or_reg
= HC_INT_IRQ_MASK_OR_REG
;
1641 skip_reg
= HC_INT_PTD_SKIPMAP_REG
;
1645 ints
= priv
->atl_ints
;
1646 reg_base
= ATL_REGS_OFFSET
;
1647 or_reg
= HC_ATL_IRQ_MASK_OR_REG
;
1648 skip_reg
= HC_ATL_PTD_SKIPMAP_REG
;
1652 memset(&ptd
, 0, sizeof(ptd
));
1653 spin_lock_irqsave(&priv
->lock
, flags
);
1655 for (i
= 0; i
< 32; i
++) {
1656 if (ints
->urb
== urb
) {
1659 struct isp1760_qtd
*qtd
;
1661 skip_map
= isp1760_readl(hcd
->regs
+ skip_reg
);
1663 isp1760_writel(skip_map
, hcd
->regs
+ skip_reg
);
1665 or_map
= isp1760_readl(hcd
->regs
+ or_reg
);
1666 or_map
&= ~(1 << i
);
1667 isp1760_writel(or_map
, hcd
->regs
+ or_reg
);
1669 priv_write_copy(priv
, (u32
*)&ptd
, hcd
->regs
+ reg_base
1670 + i
* sizeof(ptd
), sizeof(ptd
));
1673 clean_up_qtdlist(qtd
);
1675 free_mem(priv
, ints
->payload
);
1680 ints
->data_buffer
= NULL
;
1683 isp1760_urb_done(priv
, urb
, status
);
1689 spin_unlock_irqrestore(&priv
->lock
, flags
);
1693 static irqreturn_t
isp1760_irq(struct usb_hcd
*usb_hcd
)
1695 struct isp1760_hcd
*priv
= hcd_to_priv(usb_hcd
);
1697 irqreturn_t irqret
= IRQ_NONE
;
1699 spin_lock(&priv
->lock
);
1701 if (!(usb_hcd
->state
& HC_STATE_RUNNING
))
1704 imask
= isp1760_readl(usb_hcd
->regs
+ HC_INTERRUPT_REG
);
1705 if (unlikely(!imask
))
1708 isp1760_writel(imask
, usb_hcd
->regs
+ HC_INTERRUPT_REG
);
1709 if (imask
& HC_ATL_INT
)
1710 do_atl_int(usb_hcd
);
1712 if (imask
& HC_INTL_INT
)
1713 do_intl_int(usb_hcd
);
1715 irqret
= IRQ_HANDLED
;
1717 spin_unlock(&priv
->lock
);
1721 static int isp1760_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
1723 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
1724 u32 temp
, status
= 0;
1727 unsigned long flags
;
1729 /* if !USB_SUSPEND, root hub timers won't get shut down ... */
1730 if (!HC_IS_RUNNING(hcd
->state
))
1733 /* init status to no-changes */
1737 spin_lock_irqsave(&priv
->lock
, flags
);
1738 temp
= isp1760_readl(hcd
->regs
+ HC_PORTSC1
);
1740 if (temp
& PORT_OWNER
) {
1741 if (temp
& PORT_CSC
) {
1743 isp1760_writel(temp
, hcd
->regs
+ HC_PORTSC1
);
1749 * Return status information even for ports with OWNER set.
1750 * Otherwise khubd wouldn't see the disconnect event when a
1751 * high-speed device is switched over to the companion
1752 * controller by the user.
1755 if ((temp
& mask
) != 0
1756 || ((temp
& PORT_RESUME
) != 0
1757 && time_after_eq(jiffies
,
1758 priv
->reset_done
))) {
1759 buf
[0] |= 1 << (0 + 1);
1762 /* FIXME autosuspend idle root hubs */
1764 spin_unlock_irqrestore(&priv
->lock
, flags
);
1765 return status
? retval
: 0;
1768 static void isp1760_hub_descriptor(struct isp1760_hcd
*priv
,
1769 struct usb_hub_descriptor
*desc
)
1771 int ports
= HCS_N_PORTS(priv
->hcs_params
);
1774 desc
->bDescriptorType
= 0x29;
1775 /* priv 1.0, 2.3.9 says 20ms max */
1776 desc
->bPwrOn2PwrGood
= 10;
1777 desc
->bHubContrCurrent
= 0;
1779 desc
->bNbrPorts
= ports
;
1780 temp
= 1 + (ports
/ 8);
1781 desc
->bDescLength
= 7 + 2 * temp
;
1783 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
1784 memset(&desc
->bitmap
[0], 0, temp
);
1785 memset(&desc
->bitmap
[temp
], 0xff, temp
);
1787 /* per-port overcurrent reporting */
1789 if (HCS_PPC(priv
->hcs_params
))
1790 /* per-port power control */
1793 /* no power switching */
1795 desc
->wHubCharacteristics
= cpu_to_le16(temp
);
1798 #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
1800 static int check_reset_complete(struct isp1760_hcd
*priv
, int index
,
1801 u32 __iomem
*status_reg
, int port_status
)
1803 if (!(port_status
& PORT_CONNECT
))
1806 /* if reset finished and it's still not enabled -- handoff */
1807 if (!(port_status
& PORT_PE
)) {
1809 printk(KERN_ERR
"port %d full speed --> companion\n",
1812 port_status
|= PORT_OWNER
;
1813 port_status
&= ~PORT_RWC_BITS
;
1814 isp1760_writel(port_status
, status_reg
);
1817 printk(KERN_ERR
"port %d high speed\n", index
+ 1);
1822 static int isp1760_hub_control(struct usb_hcd
*hcd
, u16 typeReq
,
1823 u16 wValue
, u16 wIndex
, char *buf
, u16 wLength
)
1825 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
1826 int ports
= HCS_N_PORTS(priv
->hcs_params
);
1827 u32 __iomem
*status_reg
= hcd
->regs
+ HC_PORTSC1
;
1829 unsigned long flags
;
1834 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
1835 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
1836 * (track current state ourselves) ... blink for diagnostics,
1837 * power, "this is the one", etc. EHCI spec supports this.
1840 spin_lock_irqsave(&priv
->lock
, flags
);
1842 case ClearHubFeature
:
1844 case C_HUB_LOCAL_POWER
:
1845 case C_HUB_OVER_CURRENT
:
1846 /* no hub-wide feature/status flags */
1852 case ClearPortFeature
:
1853 if (!wIndex
|| wIndex
> ports
)
1856 temp
= isp1760_readl(status_reg
);
1859 * Even if OWNER is set, so the port is owned by the
1860 * companion controller, khubd needs to be able to clear
1861 * the port-change status bits (especially
1862 * USB_PORT_FEAT_C_CONNECTION).
1866 case USB_PORT_FEAT_ENABLE
:
1867 isp1760_writel(temp
& ~PORT_PE
, status_reg
);
1869 case USB_PORT_FEAT_C_ENABLE
:
1872 case USB_PORT_FEAT_SUSPEND
:
1873 if (temp
& PORT_RESET
)
1876 if (temp
& PORT_SUSPEND
) {
1877 if ((temp
& PORT_PE
) == 0)
1879 /* resume signaling for 20 msec */
1880 temp
&= ~(PORT_RWC_BITS
);
1881 isp1760_writel(temp
| PORT_RESUME
,
1883 priv
->reset_done
= jiffies
+
1884 msecs_to_jiffies(20);
1887 case USB_PORT_FEAT_C_SUSPEND
:
1888 /* we auto-clear this feature */
1890 case USB_PORT_FEAT_POWER
:
1891 if (HCS_PPC(priv
->hcs_params
))
1892 isp1760_writel(temp
& ~PORT_POWER
, status_reg
);
1894 case USB_PORT_FEAT_C_CONNECTION
:
1895 isp1760_writel(temp
| PORT_CSC
,
1898 case USB_PORT_FEAT_C_OVER_CURRENT
:
1901 case USB_PORT_FEAT_C_RESET
:
1902 /* GetPortStatus clears reset */
1907 isp1760_readl(hcd
->regs
+ HC_USBCMD
);
1909 case GetHubDescriptor
:
1910 isp1760_hub_descriptor(priv
, (struct usb_hub_descriptor
*)
1914 /* no hub-wide feature/status flags */
1918 if (!wIndex
|| wIndex
> ports
)
1922 temp
= isp1760_readl(status_reg
);
1924 /* wPortChange bits */
1925 if (temp
& PORT_CSC
)
1926 status
|= 1 << USB_PORT_FEAT_C_CONNECTION
;
1929 /* whoever resumes must GetPortStatus to complete it!! */
1930 if (temp
& PORT_RESUME
) {
1931 printk(KERN_ERR
"Port resume should be skipped.\n");
1933 /* Remote Wakeup received? */
1934 if (!priv
->reset_done
) {
1935 /* resume signaling for 20 msec */
1936 priv
->reset_done
= jiffies
1937 + msecs_to_jiffies(20);
1938 /* check the port again */
1939 mod_timer(&priv_to_hcd(priv
)->rh_timer
,
1943 /* resume completed? */
1944 else if (time_after_eq(jiffies
,
1945 priv
->reset_done
)) {
1946 status
|= 1 << USB_PORT_FEAT_C_SUSPEND
;
1947 priv
->reset_done
= 0;
1949 /* stop resume signaling */
1950 temp
= isp1760_readl(status_reg
);
1952 temp
& ~(PORT_RWC_BITS
| PORT_RESUME
),
1954 retval
= handshake(priv
, status_reg
,
1955 PORT_RESUME
, 0, 2000 /* 2msec */);
1958 "port %d resume error %d\n",
1959 wIndex
+ 1, retval
);
1962 temp
&= ~(PORT_SUSPEND
|PORT_RESUME
|(3<<10));
1966 /* whoever resets must GetPortStatus to complete it!! */
1967 if ((temp
& PORT_RESET
)
1968 && time_after_eq(jiffies
,
1969 priv
->reset_done
)) {
1970 status
|= 1 << USB_PORT_FEAT_C_RESET
;
1971 priv
->reset_done
= 0;
1973 /* force reset to complete */
1974 isp1760_writel(temp
& ~PORT_RESET
,
1976 /* REVISIT: some hardware needs 550+ usec to clear
1977 * this bit; seems too long to spin routinely...
1979 retval
= handshake(priv
, status_reg
,
1980 PORT_RESET
, 0, 750);
1982 isp1760_err(priv
, "port %d reset error %d\n",
1983 wIndex
+ 1, retval
);
1987 /* see what we found out */
1988 temp
= check_reset_complete(priv
, wIndex
, status_reg
,
1989 isp1760_readl(status_reg
));
1992 * Even if OWNER is set, there's no harm letting khubd
1993 * see the wPortStatus values (they should all be 0 except
1994 * for PORT_POWER anyway).
1997 if (temp
& PORT_OWNER
)
1998 printk(KERN_ERR
"Warning: PORT_OWNER is set\n");
2000 if (temp
& PORT_CONNECT
) {
2001 status
|= 1 << USB_PORT_FEAT_CONNECTION
;
2002 /* status may be from integrated TT */
2003 status
|= ehci_port_speed(priv
, temp
);
2006 status
|= 1 << USB_PORT_FEAT_ENABLE
;
2007 if (temp
& (PORT_SUSPEND
|PORT_RESUME
))
2008 status
|= 1 << USB_PORT_FEAT_SUSPEND
;
2009 if (temp
& PORT_RESET
)
2010 status
|= 1 << USB_PORT_FEAT_RESET
;
2011 if (temp
& PORT_POWER
)
2012 status
|= 1 << USB_PORT_FEAT_POWER
;
2014 put_unaligned(cpu_to_le32(status
), (__le32
*) buf
);
2018 case C_HUB_LOCAL_POWER
:
2019 case C_HUB_OVER_CURRENT
:
2020 /* no hub-wide feature/status flags */
2026 case SetPortFeature
:
2027 selector
= wIndex
>> 8;
2029 if (!wIndex
|| wIndex
> ports
)
2032 temp
= isp1760_readl(status_reg
);
2033 if (temp
& PORT_OWNER
)
2036 /* temp &= ~PORT_RWC_BITS; */
2038 case USB_PORT_FEAT_ENABLE
:
2039 isp1760_writel(temp
| PORT_PE
, status_reg
);
2042 case USB_PORT_FEAT_SUSPEND
:
2043 if ((temp
& PORT_PE
) == 0
2044 || (temp
& PORT_RESET
) != 0)
2047 isp1760_writel(temp
| PORT_SUSPEND
, status_reg
);
2049 case USB_PORT_FEAT_POWER
:
2050 if (HCS_PPC(priv
->hcs_params
))
2051 isp1760_writel(temp
| PORT_POWER
,
2054 case USB_PORT_FEAT_RESET
:
2055 if (temp
& PORT_RESUME
)
2057 /* line status bits may report this as low speed,
2058 * which can be fine if this root hub has a
2059 * transaction translator built in.
2061 if ((temp
& (PORT_PE
|PORT_CONNECT
)) == PORT_CONNECT
2062 && PORT_USB11(temp
)) {
2069 * caller must wait, then call GetPortStatus
2070 * usb 2.0 spec says 50 ms resets on root
2072 priv
->reset_done
= jiffies
+
2073 msecs_to_jiffies(50);
2075 isp1760_writel(temp
, status_reg
);
2080 isp1760_readl(hcd
->regs
+ HC_USBCMD
);
2085 /* "stall" on error */
2088 spin_unlock_irqrestore(&priv
->lock
, flags
);
2092 static void isp1760_endpoint_disable(struct usb_hcd
*usb_hcd
,
2093 struct usb_host_endpoint
*ep
)
2095 struct isp1760_hcd
*priv
= hcd_to_priv(usb_hcd
);
2096 struct isp1760_qh
*qh
;
2097 struct isp1760_qtd
*qtd
;
2098 unsigned long flags
;
2100 spin_lock_irqsave(&priv
->lock
, flags
);
2107 /* more than entry might get removed */
2108 if (list_empty(&qh
->qtd_list
))
2111 qtd
= list_first_entry(&qh
->qtd_list
, struct isp1760_qtd
,
2114 if (qtd
->status
& URB_ENQUEUED
) {
2116 spin_unlock_irqrestore(&priv
->lock
, flags
);
2117 isp1760_urb_dequeue(usb_hcd
, qtd
->urb
, -ECONNRESET
);
2118 spin_lock_irqsave(&priv
->lock
, flags
);
2123 clean_up_qtdlist(qtd
);
2124 isp1760_urb_done(priv
, urb
, -ECONNRESET
);
2129 /* remove requests and leak them.
2130 * ATL are pretty fast done, INT could take a while...
2131 * The latter shoule be removed
2134 spin_unlock_irqrestore(&priv
->lock
, flags
);
2137 static int isp1760_get_frame(struct usb_hcd
*hcd
)
2139 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
2142 fr
= isp1760_readl(hcd
->regs
+ HC_FRINDEX
);
2143 return (fr
>> 3) % priv
->periodic_size
;
2146 static void isp1760_stop(struct usb_hcd
*hcd
)
2148 struct isp1760_hcd
*priv
= hcd_to_priv(hcd
);
2151 isp1760_hub_control(hcd
, ClearPortFeature
, USB_PORT_FEAT_POWER
, 1,
2155 spin_lock_irq(&priv
->lock
);
2158 temp
= isp1760_readl(hcd
->regs
+ HC_HW_MODE_CTRL
);
2159 isp1760_writel(temp
&= ~HW_GLOBAL_INTR_EN
, hcd
->regs
+ HC_HW_MODE_CTRL
);
2160 spin_unlock_irq(&priv
->lock
);
2162 isp1760_writel(0, hcd
->regs
+ HC_CONFIGFLAG
);
2165 static void isp1760_shutdown(struct usb_hcd
*hcd
)
2170 temp
= isp1760_readl(hcd
->regs
+ HC_HW_MODE_CTRL
);
2171 isp1760_writel(temp
&= ~HW_GLOBAL_INTR_EN
, hcd
->regs
+ HC_HW_MODE_CTRL
);
2173 command
= isp1760_readl(hcd
->regs
+ HC_USBCMD
);
2174 command
&= ~CMD_RUN
;
2175 isp1760_writel(command
, hcd
->regs
+ HC_USBCMD
);
2178 static const struct hc_driver isp1760_hc_driver
= {
2179 .description
= "isp1760-hcd",
2180 .product_desc
= "NXP ISP1760 USB Host Controller",
2181 .hcd_priv_size
= sizeof(struct isp1760_hcd
),
2183 .flags
= HCD_MEMORY
| HCD_USB2
,
2184 .reset
= isp1760_hc_setup
,
2185 .start
= isp1760_run
,
2186 .stop
= isp1760_stop
,
2187 .shutdown
= isp1760_shutdown
,
2188 .urb_enqueue
= isp1760_urb_enqueue
,
2189 .urb_dequeue
= isp1760_urb_dequeue
,
2190 .endpoint_disable
= isp1760_endpoint_disable
,
2191 .get_frame_number
= isp1760_get_frame
,
2192 .hub_status_data
= isp1760_hub_status_data
,
2193 .hub_control
= isp1760_hub_control
,
2196 int __init
init_kmem_once(void)
2198 qtd_cachep
= kmem_cache_create("isp1760_qtd",
2199 sizeof(struct isp1760_qtd
), 0, SLAB_TEMPORARY
|
2200 SLAB_MEM_SPREAD
, NULL
);
2205 qh_cachep
= kmem_cache_create("isp1760_qh", sizeof(struct isp1760_qh
),
2206 0, SLAB_TEMPORARY
| SLAB_MEM_SPREAD
, NULL
);
2209 kmem_cache_destroy(qtd_cachep
);
2216 void deinit_kmem_cache(void)
2218 kmem_cache_destroy(qtd_cachep
);
2219 kmem_cache_destroy(qh_cachep
);
2222 struct usb_hcd
*isp1760_register(u64 res_start
, u64 res_len
, int irq
,
2223 u64 irqflags
, struct device
*dev
, const char *busname
,
2224 unsigned int devflags
)
2226 struct usb_hcd
*hcd
;
2227 struct isp1760_hcd
*priv
;
2231 return ERR_PTR(-ENODEV
);
2233 /* prevent usb-core allocating DMA pages */
2234 dev
->dma_mask
= NULL
;
2236 hcd
= usb_create_hcd(&isp1760_hc_driver
, dev
, dev_name(dev
));
2238 return ERR_PTR(-ENOMEM
);
2240 priv
= hcd_to_priv(hcd
);
2241 priv
->devflags
= devflags
;
2243 hcd
->regs
= ioremap(res_start
, res_len
);
2250 hcd
->rsrc_start
= res_start
;
2251 hcd
->rsrc_len
= res_len
;
2253 ret
= usb_add_hcd(hcd
, irq
, irqflags
);
2265 return ERR_PTR(ret
);
2268 MODULE_DESCRIPTION("Driver for the ISP1760 USB-controller from NXP");
2269 MODULE_AUTHOR("Sebastian Siewior <bigeasy@linuxtronix.de>");
2270 MODULE_LICENSE("GPL v2");