2 * Driver for the Atmel USBA high speed USB device controller
4 * Copyright (C) 2005-2007 Atmel Corporation
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 #include <linux/clk.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/interrupt.h>
15 #include <linux/slab.h>
16 #include <linux/device.h>
17 #include <linux/dma-mapping.h>
18 #include <linux/list.h>
19 #include <linux/platform_device.h>
20 #include <linux/usb/ch9.h>
21 #include <linux/usb/gadget.h>
22 #include <linux/usb/atmel_usba_udc.h>
23 #include <linux/delay.h>
26 #include <mach/board.h>
28 #include "atmel_usba_udc.h"
31 static struct usba_udc the_udc
;
32 static struct usba_ep
*usba_ep
;
34 #ifdef CONFIG_USB_GADGET_DEBUG_FS
35 #include <linux/debugfs.h>
36 #include <linux/uaccess.h>
38 static int queue_dbg_open(struct inode
*inode
, struct file
*file
)
40 struct usba_ep
*ep
= inode
->i_private
;
41 struct usba_request
*req
, *req_copy
;
42 struct list_head
*queue_data
;
44 queue_data
= kmalloc(sizeof(*queue_data
), GFP_KERNEL
);
47 INIT_LIST_HEAD(queue_data
);
49 spin_lock_irq(&ep
->udc
->lock
);
50 list_for_each_entry(req
, &ep
->queue
, queue
) {
51 req_copy
= kmemdup(req
, sizeof(*req_copy
), GFP_ATOMIC
);
54 list_add_tail(&req_copy
->queue
, queue_data
);
56 spin_unlock_irq(&ep
->udc
->lock
);
58 file
->private_data
= queue_data
;
62 spin_unlock_irq(&ep
->udc
->lock
);
63 list_for_each_entry_safe(req
, req_copy
, queue_data
, queue
) {
64 list_del(&req
->queue
);
72 * bbbbbbbb llllllll IZS sssss nnnn FDL\n\0
76 * I/i: interrupt/no interrupt
78 * S/s: short ok/short not ok
81 * F/f: submitted/not submitted to FIFO
82 * D/d: using/not using DMA
83 * L/l: last transaction/not last transaction
85 static ssize_t
queue_dbg_read(struct file
*file
, char __user
*buf
,
86 size_t nbytes
, loff_t
*ppos
)
88 struct list_head
*queue
= file
->private_data
;
89 struct usba_request
*req
, *tmp_req
;
90 size_t len
, remaining
, actual
= 0;
93 if (!access_ok(VERIFY_WRITE
, buf
, nbytes
))
96 mutex_lock(&file
->f_dentry
->d_inode
->i_mutex
);
97 list_for_each_entry_safe(req
, tmp_req
, queue
, queue
) {
98 len
= snprintf(tmpbuf
, sizeof(tmpbuf
),
99 "%8p %08x %c%c%c %5d %c%c%c\n",
100 req
->req
.buf
, req
->req
.length
,
101 req
->req
.no_interrupt
? 'i' : 'I',
102 req
->req
.zero
? 'Z' : 'z',
103 req
->req
.short_not_ok
? 's' : 'S',
105 req
->submitted
? 'F' : 'f',
106 req
->using_dma
? 'D' : 'd',
107 req
->last_transaction
? 'L' : 'l');
108 len
= min(len
, sizeof(tmpbuf
));
112 list_del(&req
->queue
);
115 remaining
= __copy_to_user(buf
, tmpbuf
, len
);
116 actual
+= len
- remaining
;
123 mutex_unlock(&file
->f_dentry
->d_inode
->i_mutex
);
128 static int queue_dbg_release(struct inode
*inode
, struct file
*file
)
130 struct list_head
*queue_data
= file
->private_data
;
131 struct usba_request
*req
, *tmp_req
;
133 list_for_each_entry_safe(req
, tmp_req
, queue_data
, queue
) {
134 list_del(&req
->queue
);
141 static int regs_dbg_open(struct inode
*inode
, struct file
*file
)
143 struct usba_udc
*udc
;
148 mutex_lock(&inode
->i_mutex
);
149 udc
= inode
->i_private
;
150 data
= kmalloc(inode
->i_size
, GFP_KERNEL
);
154 spin_lock_irq(&udc
->lock
);
155 for (i
= 0; i
< inode
->i_size
/ 4; i
++)
156 data
[i
] = __raw_readl(udc
->regs
+ i
* 4);
157 spin_unlock_irq(&udc
->lock
);
159 file
->private_data
= data
;
163 mutex_unlock(&inode
->i_mutex
);
168 static ssize_t
regs_dbg_read(struct file
*file
, char __user
*buf
,
169 size_t nbytes
, loff_t
*ppos
)
171 struct inode
*inode
= file
->f_dentry
->d_inode
;
174 mutex_lock(&inode
->i_mutex
);
175 ret
= simple_read_from_buffer(buf
, nbytes
, ppos
,
177 file
->f_dentry
->d_inode
->i_size
);
178 mutex_unlock(&inode
->i_mutex
);
183 static int regs_dbg_release(struct inode
*inode
, struct file
*file
)
185 kfree(file
->private_data
);
189 const struct file_operations queue_dbg_fops
= {
190 .owner
= THIS_MODULE
,
191 .open
= queue_dbg_open
,
193 .read
= queue_dbg_read
,
194 .release
= queue_dbg_release
,
197 const struct file_operations regs_dbg_fops
= {
198 .owner
= THIS_MODULE
,
199 .open
= regs_dbg_open
,
200 .llseek
= generic_file_llseek
,
201 .read
= regs_dbg_read
,
202 .release
= regs_dbg_release
,
205 static void usba_ep_init_debugfs(struct usba_udc
*udc
,
208 struct dentry
*ep_root
;
210 ep_root
= debugfs_create_dir(ep
->ep
.name
, udc
->debugfs_root
);
213 ep
->debugfs_dir
= ep_root
;
215 ep
->debugfs_queue
= debugfs_create_file("queue", 0400, ep_root
,
216 ep
, &queue_dbg_fops
);
217 if (!ep
->debugfs_queue
)
221 ep
->debugfs_dma_status
222 = debugfs_create_u32("dma_status", 0400, ep_root
,
223 &ep
->last_dma_status
);
224 if (!ep
->debugfs_dma_status
)
227 if (ep_is_control(ep
)) {
229 = debugfs_create_u32("state", 0400, ep_root
,
231 if (!ep
->debugfs_state
)
239 debugfs_remove(ep
->debugfs_dma_status
);
241 debugfs_remove(ep
->debugfs_queue
);
243 debugfs_remove(ep_root
);
245 dev_err(&ep
->udc
->pdev
->dev
,
246 "failed to create debugfs directory for %s\n", ep
->ep
.name
);
249 static void usba_ep_cleanup_debugfs(struct usba_ep
*ep
)
251 debugfs_remove(ep
->debugfs_queue
);
252 debugfs_remove(ep
->debugfs_dma_status
);
253 debugfs_remove(ep
->debugfs_state
);
254 debugfs_remove(ep
->debugfs_dir
);
255 ep
->debugfs_dma_status
= NULL
;
256 ep
->debugfs_dir
= NULL
;
259 static void usba_init_debugfs(struct usba_udc
*udc
)
261 struct dentry
*root
, *regs
;
262 struct resource
*regs_resource
;
264 root
= debugfs_create_dir(udc
->gadget
.name
, NULL
);
265 if (IS_ERR(root
) || !root
)
267 udc
->debugfs_root
= root
;
269 regs
= debugfs_create_file("regs", 0400, root
, udc
, ®s_dbg_fops
);
273 regs_resource
= platform_get_resource(udc
->pdev
, IORESOURCE_MEM
,
275 regs
->d_inode
->i_size
= regs_resource
->end
- regs_resource
->start
+ 1;
276 udc
->debugfs_regs
= regs
;
278 usba_ep_init_debugfs(udc
, to_usba_ep(udc
->gadget
.ep0
));
283 debugfs_remove(root
);
285 udc
->debugfs_root
= NULL
;
286 dev_err(&udc
->pdev
->dev
, "debugfs is not available\n");
289 static void usba_cleanup_debugfs(struct usba_udc
*udc
)
291 usba_ep_cleanup_debugfs(to_usba_ep(udc
->gadget
.ep0
));
292 debugfs_remove(udc
->debugfs_regs
);
293 debugfs_remove(udc
->debugfs_root
);
294 udc
->debugfs_regs
= NULL
;
295 udc
->debugfs_root
= NULL
;
298 static inline void usba_ep_init_debugfs(struct usba_udc
*udc
,
304 static inline void usba_ep_cleanup_debugfs(struct usba_ep
*ep
)
309 static inline void usba_init_debugfs(struct usba_udc
*udc
)
314 static inline void usba_cleanup_debugfs(struct usba_udc
*udc
)
320 static int vbus_is_present(struct usba_udc
*udc
)
322 if (gpio_is_valid(udc
->vbus_pin
))
323 return gpio_get_value(udc
->vbus_pin
) ^ udc
->vbus_pin_inverted
;
325 /* No Vbus detection: Assume always present */
329 #if defined(CONFIG_ARCH_AT91SAM9RL)
331 #include <mach/at91_pmc.h>
333 static void toggle_bias(int is_on
)
335 unsigned int uckr
= at91_sys_read(AT91_CKGR_UCKR
);
338 at91_sys_write(AT91_CKGR_UCKR
, uckr
| AT91_PMC_BIASEN
);
340 at91_sys_write(AT91_CKGR_UCKR
, uckr
& ~(AT91_PMC_BIASEN
));
345 static void toggle_bias(int is_on
)
349 #endif /* CONFIG_ARCH_AT91SAM9RL */
351 static void next_fifo_transaction(struct usba_ep
*ep
, struct usba_request
*req
)
353 unsigned int transaction_len
;
355 transaction_len
= req
->req
.length
- req
->req
.actual
;
356 req
->last_transaction
= 1;
357 if (transaction_len
> ep
->ep
.maxpacket
) {
358 transaction_len
= ep
->ep
.maxpacket
;
359 req
->last_transaction
= 0;
360 } else if (transaction_len
== ep
->ep
.maxpacket
&& req
->req
.zero
)
361 req
->last_transaction
= 0;
363 DBG(DBG_QUEUE
, "%s: submit_transaction, req %p (length %d)%s\n",
364 ep
->ep
.name
, req
, transaction_len
,
365 req
->last_transaction
? ", done" : "");
367 memcpy_toio(ep
->fifo
, req
->req
.buf
+ req
->req
.actual
, transaction_len
);
368 usba_ep_writel(ep
, SET_STA
, USBA_TX_PK_RDY
);
369 req
->req
.actual
+= transaction_len
;
372 static void submit_request(struct usba_ep
*ep
, struct usba_request
*req
)
374 DBG(DBG_QUEUE
, "%s: submit_request: req %p (length %d)\n",
375 ep
->ep
.name
, req
, req
->req
.length
);
380 if (req
->using_dma
) {
381 if (req
->req
.length
== 0) {
382 usba_ep_writel(ep
, CTL_ENB
, USBA_TX_PK_RDY
);
387 usba_ep_writel(ep
, CTL_ENB
, USBA_SHORT_PACKET
);
389 usba_ep_writel(ep
, CTL_DIS
, USBA_SHORT_PACKET
);
391 usba_dma_writel(ep
, ADDRESS
, req
->req
.dma
);
392 usba_dma_writel(ep
, CONTROL
, req
->ctrl
);
394 next_fifo_transaction(ep
, req
);
395 if (req
->last_transaction
) {
396 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_PK_RDY
);
397 usba_ep_writel(ep
, CTL_ENB
, USBA_TX_COMPLETE
);
399 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_COMPLETE
);
400 usba_ep_writel(ep
, CTL_ENB
, USBA_TX_PK_RDY
);
405 static void submit_next_request(struct usba_ep
*ep
)
407 struct usba_request
*req
;
409 if (list_empty(&ep
->queue
)) {
410 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_PK_RDY
| USBA_RX_BK_RDY
);
414 req
= list_entry(ep
->queue
.next
, struct usba_request
, queue
);
416 submit_request(ep
, req
);
419 static void send_status(struct usba_udc
*udc
, struct usba_ep
*ep
)
421 ep
->state
= STATUS_STAGE_IN
;
422 usba_ep_writel(ep
, SET_STA
, USBA_TX_PK_RDY
);
423 usba_ep_writel(ep
, CTL_ENB
, USBA_TX_COMPLETE
);
426 static void receive_data(struct usba_ep
*ep
)
428 struct usba_udc
*udc
= ep
->udc
;
429 struct usba_request
*req
;
430 unsigned long status
;
431 unsigned int bytecount
, nr_busy
;
434 status
= usba_ep_readl(ep
, STA
);
435 nr_busy
= USBA_BFEXT(BUSY_BANKS
, status
);
437 DBG(DBG_QUEUE
, "receive data: nr_busy=%u\n", nr_busy
);
439 while (nr_busy
> 0) {
440 if (list_empty(&ep
->queue
)) {
441 usba_ep_writel(ep
, CTL_DIS
, USBA_RX_BK_RDY
);
444 req
= list_entry(ep
->queue
.next
,
445 struct usba_request
, queue
);
447 bytecount
= USBA_BFEXT(BYTE_COUNT
, status
);
449 if (status
& (1 << 31))
451 if (req
->req
.actual
+ bytecount
>= req
->req
.length
) {
453 bytecount
= req
->req
.length
- req
->req
.actual
;
456 memcpy_fromio(req
->req
.buf
+ req
->req
.actual
,
457 ep
->fifo
, bytecount
);
458 req
->req
.actual
+= bytecount
;
460 usba_ep_writel(ep
, CLR_STA
, USBA_RX_BK_RDY
);
463 DBG(DBG_QUEUE
, "%s: request done\n", ep
->ep
.name
);
465 list_del_init(&req
->queue
);
466 usba_ep_writel(ep
, CTL_DIS
, USBA_RX_BK_RDY
);
467 spin_unlock(&udc
->lock
);
468 req
->req
.complete(&ep
->ep
, &req
->req
);
469 spin_lock(&udc
->lock
);
472 status
= usba_ep_readl(ep
, STA
);
473 nr_busy
= USBA_BFEXT(BUSY_BANKS
, status
);
475 if (is_complete
&& ep_is_control(ep
)) {
476 send_status(udc
, ep
);
483 request_complete(struct usba_ep
*ep
, struct usba_request
*req
, int status
)
485 struct usba_udc
*udc
= ep
->udc
;
487 WARN_ON(!list_empty(&req
->queue
));
489 if (req
->req
.status
== -EINPROGRESS
)
490 req
->req
.status
= status
;
494 &udc
->pdev
->dev
, req
->req
.dma
, req
->req
.length
,
495 ep
->is_in
? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
496 req
->req
.dma
= DMA_ADDR_INVALID
;
500 DBG(DBG_GADGET
| DBG_REQ
,
501 "%s: req %p complete: status %d, actual %u\n",
502 ep
->ep
.name
, req
, req
->req
.status
, req
->req
.actual
);
504 spin_unlock(&udc
->lock
);
505 req
->req
.complete(&ep
->ep
, &req
->req
);
506 spin_lock(&udc
->lock
);
510 request_complete_list(struct usba_ep
*ep
, struct list_head
*list
, int status
)
512 struct usba_request
*req
, *tmp_req
;
514 list_for_each_entry_safe(req
, tmp_req
, list
, queue
) {
515 list_del_init(&req
->queue
);
516 request_complete(ep
, req
, status
);
521 usba_ep_enable(struct usb_ep
*_ep
, const struct usb_endpoint_descriptor
*desc
)
523 struct usba_ep
*ep
= to_usba_ep(_ep
);
524 struct usba_udc
*udc
= ep
->udc
;
525 unsigned long flags
, ept_cfg
, maxpacket
;
526 unsigned int nr_trans
;
528 DBG(DBG_GADGET
, "%s: ep_enable: desc=%p\n", ep
->ep
.name
, desc
);
530 maxpacket
= le16_to_cpu(desc
->wMaxPacketSize
) & 0x7ff;
532 if (((desc
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
) != ep
->index
)
534 || desc
->bDescriptorType
!= USB_DT_ENDPOINT
536 || maxpacket
> ep
->fifo_size
) {
537 DBG(DBG_ERR
, "ep_enable: Invalid argument");
545 ept_cfg
= USBA_BF(EPT_SIZE
, USBA_EPT_SIZE_8
);
547 /* LSB is bit 1, not 0 */
548 ept_cfg
= USBA_BF(EPT_SIZE
, fls(maxpacket
- 1) - 3);
550 DBG(DBG_HW
, "%s: EPT_SIZE = %lu (maxpacket = %lu)\n",
551 ep
->ep
.name
, ept_cfg
, maxpacket
);
553 if (usb_endpoint_dir_in(desc
)) {
555 ept_cfg
|= USBA_EPT_DIR_IN
;
558 switch (usb_endpoint_type(desc
)) {
559 case USB_ENDPOINT_XFER_CONTROL
:
560 ept_cfg
|= USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_CONTROL
);
561 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_ONE
);
563 case USB_ENDPOINT_XFER_ISOC
:
565 DBG(DBG_ERR
, "ep_enable: %s is not isoc capable\n",
571 * Bits 11:12 specify number of _additional_
572 * transactions per microframe.
574 nr_trans
= ((le16_to_cpu(desc
->wMaxPacketSize
) >> 11) & 3) + 1;
579 ept_cfg
|= USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_ISO
);
582 * Do triple-buffering on high-bandwidth iso endpoints.
584 if (nr_trans
> 1 && ep
->nr_banks
== 3)
585 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_TRIPLE
);
587 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_DOUBLE
);
588 ept_cfg
|= USBA_BF(NB_TRANS
, nr_trans
);
590 case USB_ENDPOINT_XFER_BULK
:
591 ept_cfg
|= USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_BULK
);
592 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_DOUBLE
);
594 case USB_ENDPOINT_XFER_INT
:
595 ept_cfg
|= USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_INT
);
596 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_DOUBLE
);
600 spin_lock_irqsave(&ep
->udc
->lock
, flags
);
603 spin_unlock_irqrestore(&ep
->udc
->lock
, flags
);
604 DBG(DBG_ERR
, "ep%d already enabled\n", ep
->index
);
609 ep
->ep
.maxpacket
= maxpacket
;
611 usba_ep_writel(ep
, CFG
, ept_cfg
);
612 usba_ep_writel(ep
, CTL_ENB
, USBA_EPT_ENABLE
);
617 usba_writel(udc
, INT_ENB
,
618 (usba_readl(udc
, INT_ENB
)
619 | USBA_BF(EPT_INT
, 1 << ep
->index
)
620 | USBA_BF(DMA_INT
, 1 << ep
->index
)));
621 ctrl
= USBA_AUTO_VALID
| USBA_INTDIS_DMA
;
622 usba_ep_writel(ep
, CTL_ENB
, ctrl
);
624 usba_writel(udc
, INT_ENB
,
625 (usba_readl(udc
, INT_ENB
)
626 | USBA_BF(EPT_INT
, 1 << ep
->index
)));
629 spin_unlock_irqrestore(&udc
->lock
, flags
);
631 DBG(DBG_HW
, "EPT_CFG%d after init: %#08lx\n", ep
->index
,
632 (unsigned long)usba_ep_readl(ep
, CFG
));
633 DBG(DBG_HW
, "INT_ENB after init: %#08lx\n",
634 (unsigned long)usba_readl(udc
, INT_ENB
));
639 static int usba_ep_disable(struct usb_ep
*_ep
)
641 struct usba_ep
*ep
= to_usba_ep(_ep
);
642 struct usba_udc
*udc
= ep
->udc
;
646 DBG(DBG_GADGET
, "ep_disable: %s\n", ep
->ep
.name
);
648 spin_lock_irqsave(&udc
->lock
, flags
);
651 spin_unlock_irqrestore(&udc
->lock
, flags
);
652 /* REVISIT because this driver disables endpoints in
653 * reset_all_endpoints() before calling disconnect(),
654 * most gadget drivers would trigger this non-error ...
656 if (udc
->gadget
.speed
!= USB_SPEED_UNKNOWN
)
657 DBG(DBG_ERR
, "ep_disable: %s not enabled\n",
663 list_splice_init(&ep
->queue
, &req_list
);
665 usba_dma_writel(ep
, CONTROL
, 0);
666 usba_dma_writel(ep
, ADDRESS
, 0);
667 usba_dma_readl(ep
, STATUS
);
669 usba_ep_writel(ep
, CTL_DIS
, USBA_EPT_ENABLE
);
670 usba_writel(udc
, INT_ENB
,
671 usba_readl(udc
, INT_ENB
)
672 & ~USBA_BF(EPT_INT
, 1 << ep
->index
));
674 request_complete_list(ep
, &req_list
, -ESHUTDOWN
);
676 spin_unlock_irqrestore(&udc
->lock
, flags
);
681 static struct usb_request
*
682 usba_ep_alloc_request(struct usb_ep
*_ep
, gfp_t gfp_flags
)
684 struct usba_request
*req
;
686 DBG(DBG_GADGET
, "ep_alloc_request: %p, 0x%x\n", _ep
, gfp_flags
);
688 req
= kzalloc(sizeof(*req
), gfp_flags
);
692 INIT_LIST_HEAD(&req
->queue
);
693 req
->req
.dma
= DMA_ADDR_INVALID
;
699 usba_ep_free_request(struct usb_ep
*_ep
, struct usb_request
*_req
)
701 struct usba_request
*req
= to_usba_req(_req
);
703 DBG(DBG_GADGET
, "ep_free_request: %p, %p\n", _ep
, _req
);
708 static int queue_dma(struct usba_udc
*udc
, struct usba_ep
*ep
,
709 struct usba_request
*req
, gfp_t gfp_flags
)
714 DBG(DBG_DMA
, "%s: req l/%u d/%08x %c%c%c\n",
715 ep
->ep
.name
, req
->req
.length
, req
->req
.dma
,
716 req
->req
.zero
? 'Z' : 'z',
717 req
->req
.short_not_ok
? 'S' : 's',
718 req
->req
.no_interrupt
? 'I' : 'i');
720 if (req
->req
.length
> 0x10000) {
721 /* Lengths from 0 to 65536 (inclusive) are supported */
722 DBG(DBG_ERR
, "invalid request length %u\n", req
->req
.length
);
728 if (req
->req
.dma
== DMA_ADDR_INVALID
) {
729 req
->req
.dma
= dma_map_single(
730 &udc
->pdev
->dev
, req
->req
.buf
, req
->req
.length
,
731 ep
->is_in
? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
734 dma_sync_single_for_device(
735 &udc
->pdev
->dev
, req
->req
.dma
, req
->req
.length
,
736 ep
->is_in
? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
740 req
->ctrl
= USBA_BF(DMA_BUF_LEN
, req
->req
.length
)
741 | USBA_DMA_CH_EN
| USBA_DMA_END_BUF_IE
742 | USBA_DMA_END_TR_EN
| USBA_DMA_END_TR_IE
;
745 req
->ctrl
|= USBA_DMA_END_BUF_EN
;
748 * Add this request to the queue and submit for DMA if
749 * possible. Check if we're still alive first -- we may have
750 * received a reset since last time we checked.
753 spin_lock_irqsave(&udc
->lock
, flags
);
755 if (list_empty(&ep
->queue
))
756 submit_request(ep
, req
);
758 list_add_tail(&req
->queue
, &ep
->queue
);
761 spin_unlock_irqrestore(&udc
->lock
, flags
);
767 usba_ep_queue(struct usb_ep
*_ep
, struct usb_request
*_req
, gfp_t gfp_flags
)
769 struct usba_request
*req
= to_usba_req(_req
);
770 struct usba_ep
*ep
= to_usba_ep(_ep
);
771 struct usba_udc
*udc
= ep
->udc
;
775 DBG(DBG_GADGET
| DBG_QUEUE
| DBG_REQ
, "%s: queue req %p, len %u\n",
776 ep
->ep
.name
, req
, _req
->length
);
778 if (!udc
->driver
|| udc
->gadget
.speed
== USB_SPEED_UNKNOWN
|| !ep
->desc
)
783 req
->last_transaction
= 0;
785 _req
->status
= -EINPROGRESS
;
789 return queue_dma(udc
, ep
, req
, gfp_flags
);
791 /* May have received a reset since last time we checked */
793 spin_lock_irqsave(&udc
->lock
, flags
);
795 list_add_tail(&req
->queue
, &ep
->queue
);
797 if ((!ep_is_control(ep
) && ep
->is_in
) ||
799 && (ep
->state
== DATA_STAGE_IN
800 || ep
->state
== STATUS_STAGE_IN
)))
801 usba_ep_writel(ep
, CTL_ENB
, USBA_TX_PK_RDY
);
803 usba_ep_writel(ep
, CTL_ENB
, USBA_RX_BK_RDY
);
806 spin_unlock_irqrestore(&udc
->lock
, flags
);
812 usba_update_req(struct usba_ep
*ep
, struct usba_request
*req
, u32 status
)
814 req
->req
.actual
= req
->req
.length
- USBA_BFEXT(DMA_BUF_LEN
, status
);
817 static int stop_dma(struct usba_ep
*ep
, u32
*pstatus
)
819 unsigned int timeout
;
823 * Stop the DMA controller. When writing both CH_EN
824 * and LINK to 0, the other bits are not affected.
826 usba_dma_writel(ep
, CONTROL
, 0);
828 /* Wait for the FIFO to empty */
829 for (timeout
= 40; timeout
; --timeout
) {
830 status
= usba_dma_readl(ep
, STATUS
);
831 if (!(status
& USBA_DMA_CH_EN
))
840 dev_err(&ep
->udc
->pdev
->dev
,
841 "%s: timed out waiting for DMA FIFO to empty\n",
849 static int usba_ep_dequeue(struct usb_ep
*_ep
, struct usb_request
*_req
)
851 struct usba_ep
*ep
= to_usba_ep(_ep
);
852 struct usba_udc
*udc
= ep
->udc
;
853 struct usba_request
*req
= to_usba_req(_req
);
857 DBG(DBG_GADGET
| DBG_QUEUE
, "ep_dequeue: %s, req %p\n",
860 spin_lock_irqsave(&udc
->lock
, flags
);
862 if (req
->using_dma
) {
864 * If this request is currently being transferred,
865 * stop the DMA controller and reset the FIFO.
867 if (ep
->queue
.next
== &req
->queue
) {
868 status
= usba_dma_readl(ep
, STATUS
);
869 if (status
& USBA_DMA_CH_EN
)
870 stop_dma(ep
, &status
);
872 #ifdef CONFIG_USB_GADGET_DEBUG_FS
873 ep
->last_dma_status
= status
;
876 usba_writel(udc
, EPT_RST
, 1 << ep
->index
);
878 usba_update_req(ep
, req
, status
);
883 * Errors should stop the queue from advancing until the
884 * completion function returns.
886 list_del_init(&req
->queue
);
888 request_complete(ep
, req
, -ECONNRESET
);
890 /* Process the next request if any */
891 submit_next_request(ep
);
892 spin_unlock_irqrestore(&udc
->lock
, flags
);
897 static int usba_ep_set_halt(struct usb_ep
*_ep
, int value
)
899 struct usba_ep
*ep
= to_usba_ep(_ep
);
900 struct usba_udc
*udc
= ep
->udc
;
904 DBG(DBG_GADGET
, "endpoint %s: %s HALT\n", ep
->ep
.name
,
905 value
? "set" : "clear");
908 DBG(DBG_ERR
, "Attempted to halt uninitialized ep %s\n",
913 DBG(DBG_ERR
, "Attempted to halt isochronous ep %s\n",
918 spin_lock_irqsave(&udc
->lock
, flags
);
921 * We can't halt IN endpoints while there are still data to be
924 if (!list_empty(&ep
->queue
)
925 || ((value
&& ep
->is_in
&& (usba_ep_readl(ep
, STA
)
926 & USBA_BF(BUSY_BANKS
, -1L))))) {
930 usba_ep_writel(ep
, SET_STA
, USBA_FORCE_STALL
);
932 usba_ep_writel(ep
, CLR_STA
,
933 USBA_FORCE_STALL
| USBA_TOGGLE_CLR
);
934 usba_ep_readl(ep
, STA
);
937 spin_unlock_irqrestore(&udc
->lock
, flags
);
942 static int usba_ep_fifo_status(struct usb_ep
*_ep
)
944 struct usba_ep
*ep
= to_usba_ep(_ep
);
946 return USBA_BFEXT(BYTE_COUNT
, usba_ep_readl(ep
, STA
));
949 static void usba_ep_fifo_flush(struct usb_ep
*_ep
)
951 struct usba_ep
*ep
= to_usba_ep(_ep
);
952 struct usba_udc
*udc
= ep
->udc
;
954 usba_writel(udc
, EPT_RST
, 1 << ep
->index
);
957 static const struct usb_ep_ops usba_ep_ops
= {
958 .enable
= usba_ep_enable
,
959 .disable
= usba_ep_disable
,
960 .alloc_request
= usba_ep_alloc_request
,
961 .free_request
= usba_ep_free_request
,
962 .queue
= usba_ep_queue
,
963 .dequeue
= usba_ep_dequeue
,
964 .set_halt
= usba_ep_set_halt
,
965 .fifo_status
= usba_ep_fifo_status
,
966 .fifo_flush
= usba_ep_fifo_flush
,
969 static int usba_udc_get_frame(struct usb_gadget
*gadget
)
971 struct usba_udc
*udc
= to_usba_udc(gadget
);
973 return USBA_BFEXT(FRAME_NUMBER
, usba_readl(udc
, FNUM
));
976 static int usba_udc_wakeup(struct usb_gadget
*gadget
)
978 struct usba_udc
*udc
= to_usba_udc(gadget
);
983 spin_lock_irqsave(&udc
->lock
, flags
);
984 if (udc
->devstatus
& (1 << USB_DEVICE_REMOTE_WAKEUP
)) {
985 ctrl
= usba_readl(udc
, CTRL
);
986 usba_writel(udc
, CTRL
, ctrl
| USBA_REMOTE_WAKE_UP
);
989 spin_unlock_irqrestore(&udc
->lock
, flags
);
995 usba_udc_set_selfpowered(struct usb_gadget
*gadget
, int is_selfpowered
)
997 struct usba_udc
*udc
= to_usba_udc(gadget
);
1000 spin_lock_irqsave(&udc
->lock
, flags
);
1002 udc
->devstatus
|= 1 << USB_DEVICE_SELF_POWERED
;
1004 udc
->devstatus
&= ~(1 << USB_DEVICE_SELF_POWERED
);
1005 spin_unlock_irqrestore(&udc
->lock
, flags
);
1010 static const struct usb_gadget_ops usba_udc_ops
= {
1011 .get_frame
= usba_udc_get_frame
,
1012 .wakeup
= usba_udc_wakeup
,
1013 .set_selfpowered
= usba_udc_set_selfpowered
,
1016 static struct usb_endpoint_descriptor usba_ep0_desc
= {
1017 .bLength
= USB_DT_ENDPOINT_SIZE
,
1018 .bDescriptorType
= USB_DT_ENDPOINT
,
1019 .bEndpointAddress
= 0,
1020 .bmAttributes
= USB_ENDPOINT_XFER_CONTROL
,
1021 .wMaxPacketSize
= cpu_to_le16(64),
1025 static void nop_release(struct device
*dev
)
1030 static struct usba_udc the_udc
= {
1032 .ops
= &usba_udc_ops
,
1033 .ep_list
= LIST_HEAD_INIT(the_udc
.gadget
.ep_list
),
1035 .name
= "atmel_usba_udc",
1037 .init_name
= "gadget",
1038 .release
= nop_release
,
1044 * Called with interrupts disabled and udc->lock held.
1046 static void reset_all_endpoints(struct usba_udc
*udc
)
1049 struct usba_request
*req
, *tmp_req
;
1051 usba_writel(udc
, EPT_RST
, ~0UL);
1053 ep
= to_usba_ep(udc
->gadget
.ep0
);
1054 list_for_each_entry_safe(req
, tmp_req
, &ep
->queue
, queue
) {
1055 list_del_init(&req
->queue
);
1056 request_complete(ep
, req
, -ECONNRESET
);
1059 list_for_each_entry(ep
, &udc
->gadget
.ep_list
, ep
.ep_list
) {
1061 spin_unlock(&udc
->lock
);
1062 usba_ep_disable(&ep
->ep
);
1063 spin_lock(&udc
->lock
);
1068 static struct usba_ep
*get_ep_by_addr(struct usba_udc
*udc
, u16 wIndex
)
1072 if ((wIndex
& USB_ENDPOINT_NUMBER_MASK
) == 0)
1073 return to_usba_ep(udc
->gadget
.ep0
);
1075 list_for_each_entry (ep
, &udc
->gadget
.ep_list
, ep
.ep_list
) {
1076 u8 bEndpointAddress
;
1080 bEndpointAddress
= ep
->desc
->bEndpointAddress
;
1081 if ((wIndex
^ bEndpointAddress
) & USB_DIR_IN
)
1083 if ((bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
)
1084 == (wIndex
& USB_ENDPOINT_NUMBER_MASK
))
1091 /* Called with interrupts disabled and udc->lock held */
1092 static inline void set_protocol_stall(struct usba_udc
*udc
, struct usba_ep
*ep
)
1094 usba_ep_writel(ep
, SET_STA
, USBA_FORCE_STALL
);
1095 ep
->state
= WAIT_FOR_SETUP
;
1098 static inline int is_stalled(struct usba_udc
*udc
, struct usba_ep
*ep
)
1100 if (usba_ep_readl(ep
, STA
) & USBA_FORCE_STALL
)
1105 static inline void set_address(struct usba_udc
*udc
, unsigned int addr
)
1109 DBG(DBG_BUS
, "setting address %u...\n", addr
);
1110 regval
= usba_readl(udc
, CTRL
);
1111 regval
= USBA_BFINS(DEV_ADDR
, addr
, regval
);
1112 usba_writel(udc
, CTRL
, regval
);
1115 static int do_test_mode(struct usba_udc
*udc
)
1117 static const char test_packet_buffer
[] = {
1119 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1121 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
1123 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
1124 /* JJJJJJJKKKKKKK * 8 */
1125 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1126 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1128 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD,
1129 /* {JKKKKKKK * 10}, JK */
1130 0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0x7E
1133 struct device
*dev
= &udc
->pdev
->dev
;
1136 test_mode
= udc
->test_mode
;
1138 /* Start from a clean slate */
1139 reset_all_endpoints(udc
);
1141 switch (test_mode
) {
1144 usba_writel(udc
, TST
, USBA_TST_J_MODE
);
1145 dev_info(dev
, "Entering Test_J mode...\n");
1149 usba_writel(udc
, TST
, USBA_TST_K_MODE
);
1150 dev_info(dev
, "Entering Test_K mode...\n");
1154 * Test_SE0_NAK: Force high-speed mode and set up ep0
1155 * for Bulk IN transfers
1158 usba_writel(udc
, TST
,
1159 USBA_BF(SPEED_CFG
, USBA_SPEED_CFG_FORCE_HIGH
));
1160 usba_ep_writel(ep
, CFG
,
1161 USBA_BF(EPT_SIZE
, USBA_EPT_SIZE_64
)
1163 | USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_BULK
)
1164 | USBA_BF(BK_NUMBER
, 1));
1165 if (!(usba_ep_readl(ep
, CFG
) & USBA_EPT_MAPPED
)) {
1166 set_protocol_stall(udc
, ep
);
1167 dev_err(dev
, "Test_SE0_NAK: ep0 not mapped\n");
1169 usba_ep_writel(ep
, CTL_ENB
, USBA_EPT_ENABLE
);
1170 dev_info(dev
, "Entering Test_SE0_NAK mode...\n");
1176 usba_ep_writel(ep
, CFG
,
1177 USBA_BF(EPT_SIZE
, USBA_EPT_SIZE_64
)
1179 | USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_BULK
)
1180 | USBA_BF(BK_NUMBER
, 1));
1181 if (!(usba_ep_readl(ep
, CFG
) & USBA_EPT_MAPPED
)) {
1182 set_protocol_stall(udc
, ep
);
1183 dev_err(dev
, "Test_Packet: ep0 not mapped\n");
1185 usba_ep_writel(ep
, CTL_ENB
, USBA_EPT_ENABLE
);
1186 usba_writel(udc
, TST
, USBA_TST_PKT_MODE
);
1187 memcpy_toio(ep
->fifo
, test_packet_buffer
,
1188 sizeof(test_packet_buffer
));
1189 usba_ep_writel(ep
, SET_STA
, USBA_TX_PK_RDY
);
1190 dev_info(dev
, "Entering Test_Packet mode...\n");
1194 dev_err(dev
, "Invalid test mode: 0x%04x\n", test_mode
);
1201 /* Avoid overly long expressions */
1202 static inline bool feature_is_dev_remote_wakeup(struct usb_ctrlrequest
*crq
)
1204 if (crq
->wValue
== cpu_to_le16(USB_DEVICE_REMOTE_WAKEUP
))
1209 static inline bool feature_is_dev_test_mode(struct usb_ctrlrequest
*crq
)
1211 if (crq
->wValue
== cpu_to_le16(USB_DEVICE_TEST_MODE
))
1216 static inline bool feature_is_ep_halt(struct usb_ctrlrequest
*crq
)
1218 if (crq
->wValue
== cpu_to_le16(USB_ENDPOINT_HALT
))
1223 static int handle_ep0_setup(struct usba_udc
*udc
, struct usba_ep
*ep
,
1224 struct usb_ctrlrequest
*crq
)
1228 switch (crq
->bRequest
) {
1229 case USB_REQ_GET_STATUS
: {
1232 if (crq
->bRequestType
== (USB_DIR_IN
| USB_RECIP_DEVICE
)) {
1233 status
= cpu_to_le16(udc
->devstatus
);
1234 } else if (crq
->bRequestType
1235 == (USB_DIR_IN
| USB_RECIP_INTERFACE
)) {
1236 status
= cpu_to_le16(0);
1237 } else if (crq
->bRequestType
1238 == (USB_DIR_IN
| USB_RECIP_ENDPOINT
)) {
1239 struct usba_ep
*target
;
1241 target
= get_ep_by_addr(udc
, le16_to_cpu(crq
->wIndex
));
1246 if (is_stalled(udc
, target
))
1247 status
|= cpu_to_le16(1);
1251 /* Write directly to the FIFO. No queueing is done. */
1252 if (crq
->wLength
!= cpu_to_le16(sizeof(status
)))
1254 ep
->state
= DATA_STAGE_IN
;
1255 __raw_writew(status
, ep
->fifo
);
1256 usba_ep_writel(ep
, SET_STA
, USBA_TX_PK_RDY
);
1260 case USB_REQ_CLEAR_FEATURE
: {
1261 if (crq
->bRequestType
== USB_RECIP_DEVICE
) {
1262 if (feature_is_dev_remote_wakeup(crq
))
1264 &= ~(1 << USB_DEVICE_REMOTE_WAKEUP
);
1266 /* Can't CLEAR_FEATURE TEST_MODE */
1268 } else if (crq
->bRequestType
== USB_RECIP_ENDPOINT
) {
1269 struct usba_ep
*target
;
1271 if (crq
->wLength
!= cpu_to_le16(0)
1272 || !feature_is_ep_halt(crq
))
1274 target
= get_ep_by_addr(udc
, le16_to_cpu(crq
->wIndex
));
1278 usba_ep_writel(target
, CLR_STA
, USBA_FORCE_STALL
);
1279 if (target
->index
!= 0)
1280 usba_ep_writel(target
, CLR_STA
,
1286 send_status(udc
, ep
);
1290 case USB_REQ_SET_FEATURE
: {
1291 if (crq
->bRequestType
== USB_RECIP_DEVICE
) {
1292 if (feature_is_dev_test_mode(crq
)) {
1293 send_status(udc
, ep
);
1294 ep
->state
= STATUS_STAGE_TEST
;
1295 udc
->test_mode
= le16_to_cpu(crq
->wIndex
);
1297 } else if (feature_is_dev_remote_wakeup(crq
)) {
1298 udc
->devstatus
|= 1 << USB_DEVICE_REMOTE_WAKEUP
;
1302 } else if (crq
->bRequestType
== USB_RECIP_ENDPOINT
) {
1303 struct usba_ep
*target
;
1305 if (crq
->wLength
!= cpu_to_le16(0)
1306 || !feature_is_ep_halt(crq
))
1309 target
= get_ep_by_addr(udc
, le16_to_cpu(crq
->wIndex
));
1313 usba_ep_writel(target
, SET_STA
, USBA_FORCE_STALL
);
1317 send_status(udc
, ep
);
1321 case USB_REQ_SET_ADDRESS
:
1322 if (crq
->bRequestType
!= (USB_DIR_OUT
| USB_RECIP_DEVICE
))
1325 set_address(udc
, le16_to_cpu(crq
->wValue
));
1326 send_status(udc
, ep
);
1327 ep
->state
= STATUS_STAGE_ADDR
;
1332 spin_unlock(&udc
->lock
);
1333 retval
= udc
->driver
->setup(&udc
->gadget
, crq
);
1334 spin_lock(&udc
->lock
);
1340 pr_err("udc: %s: Invalid setup request: %02x.%02x v%04x i%04x l%d, "
1341 "halting endpoint...\n",
1342 ep
->ep
.name
, crq
->bRequestType
, crq
->bRequest
,
1343 le16_to_cpu(crq
->wValue
), le16_to_cpu(crq
->wIndex
),
1344 le16_to_cpu(crq
->wLength
));
1345 set_protocol_stall(udc
, ep
);
1349 static void usba_control_irq(struct usba_udc
*udc
, struct usba_ep
*ep
)
1351 struct usba_request
*req
;
1356 epstatus
= usba_ep_readl(ep
, STA
);
1357 epctrl
= usba_ep_readl(ep
, CTL
);
1359 DBG(DBG_INT
, "%s [%d]: s/%08x c/%08x\n",
1360 ep
->ep
.name
, ep
->state
, epstatus
, epctrl
);
1363 if (!list_empty(&ep
->queue
))
1364 req
= list_entry(ep
->queue
.next
,
1365 struct usba_request
, queue
);
1367 if ((epctrl
& USBA_TX_PK_RDY
) && !(epstatus
& USBA_TX_PK_RDY
)) {
1369 next_fifo_transaction(ep
, req
);
1371 submit_request(ep
, req
);
1373 if (req
->last_transaction
) {
1374 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_PK_RDY
);
1375 usba_ep_writel(ep
, CTL_ENB
, USBA_TX_COMPLETE
);
1379 if ((epstatus
& epctrl
) & USBA_TX_COMPLETE
) {
1380 usba_ep_writel(ep
, CLR_STA
, USBA_TX_COMPLETE
);
1382 switch (ep
->state
) {
1384 usba_ep_writel(ep
, CTL_ENB
, USBA_RX_BK_RDY
);
1385 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_COMPLETE
);
1386 ep
->state
= STATUS_STAGE_OUT
;
1388 case STATUS_STAGE_ADDR
:
1389 /* Activate our new address */
1390 usba_writel(udc
, CTRL
, (usba_readl(udc
, CTRL
)
1392 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_COMPLETE
);
1393 ep
->state
= WAIT_FOR_SETUP
;
1395 case STATUS_STAGE_IN
:
1397 list_del_init(&req
->queue
);
1398 request_complete(ep
, req
, 0);
1399 submit_next_request(ep
);
1401 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_COMPLETE
);
1402 ep
->state
= WAIT_FOR_SETUP
;
1404 case STATUS_STAGE_TEST
:
1405 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_COMPLETE
);
1406 ep
->state
= WAIT_FOR_SETUP
;
1407 if (do_test_mode(udc
))
1408 set_protocol_stall(udc
, ep
);
1411 pr_err("udc: %s: TXCOMP: Invalid endpoint state %d, "
1412 "halting endpoint...\n",
1413 ep
->ep
.name
, ep
->state
);
1414 set_protocol_stall(udc
, ep
);
1420 if ((epstatus
& epctrl
) & USBA_RX_BK_RDY
) {
1421 switch (ep
->state
) {
1422 case STATUS_STAGE_OUT
:
1423 usba_ep_writel(ep
, CLR_STA
, USBA_RX_BK_RDY
);
1424 usba_ep_writel(ep
, CTL_DIS
, USBA_RX_BK_RDY
);
1427 list_del_init(&req
->queue
);
1428 request_complete(ep
, req
, 0);
1430 ep
->state
= WAIT_FOR_SETUP
;
1433 case DATA_STAGE_OUT
:
1438 usba_ep_writel(ep
, CLR_STA
, USBA_RX_BK_RDY
);
1439 usba_ep_writel(ep
, CTL_DIS
, USBA_RX_BK_RDY
);
1440 pr_err("udc: %s: RXRDY: Invalid endpoint state %d, "
1441 "halting endpoint...\n",
1442 ep
->ep
.name
, ep
->state
);
1443 set_protocol_stall(udc
, ep
);
1449 if (epstatus
& USBA_RX_SETUP
) {
1451 struct usb_ctrlrequest crq
;
1452 unsigned long data
[2];
1454 unsigned int pkt_len
;
1457 if (ep
->state
!= WAIT_FOR_SETUP
) {
1459 * Didn't expect a SETUP packet at this
1460 * point. Clean up any pending requests (which
1461 * may be successful).
1463 int status
= -EPROTO
;
1466 * RXRDY and TXCOMP are dropped when SETUP
1467 * packets arrive. Just pretend we received
1468 * the status packet.
1470 if (ep
->state
== STATUS_STAGE_OUT
1471 || ep
->state
== STATUS_STAGE_IN
) {
1472 usba_ep_writel(ep
, CTL_DIS
, USBA_RX_BK_RDY
);
1477 list_del_init(&req
->queue
);
1478 request_complete(ep
, req
, status
);
1482 pkt_len
= USBA_BFEXT(BYTE_COUNT
, usba_ep_readl(ep
, STA
));
1483 DBG(DBG_HW
, "Packet length: %u\n", pkt_len
);
1484 if (pkt_len
!= sizeof(crq
)) {
1485 pr_warning("udc: Invalid packet length %u "
1486 "(expected %zu)\n", pkt_len
, sizeof(crq
));
1487 set_protocol_stall(udc
, ep
);
1491 DBG(DBG_FIFO
, "Copying ctrl request from 0x%p:\n", ep
->fifo
);
1492 memcpy_fromio(crq
.data
, ep
->fifo
, sizeof(crq
));
1494 /* Free up one bank in the FIFO so that we can
1495 * generate or receive a reply right away. */
1496 usba_ep_writel(ep
, CLR_STA
, USBA_RX_SETUP
);
1498 /* printk(KERN_DEBUG "setup: %d: %02x.%02x\n",
1499 ep->state, crq.crq.bRequestType,
1500 crq.crq.bRequest); */
1502 if (crq
.crq
.bRequestType
& USB_DIR_IN
) {
1504 * The USB 2.0 spec states that "if wLength is
1505 * zero, there is no data transfer phase."
1506 * However, testusb #14 seems to actually
1507 * expect a data phase even if wLength = 0...
1509 ep
->state
= DATA_STAGE_IN
;
1511 if (crq
.crq
.wLength
!= cpu_to_le16(0))
1512 ep
->state
= DATA_STAGE_OUT
;
1514 ep
->state
= STATUS_STAGE_IN
;
1519 ret
= handle_ep0_setup(udc
, ep
, &crq
.crq
);
1521 spin_unlock(&udc
->lock
);
1522 ret
= udc
->driver
->setup(&udc
->gadget
, &crq
.crq
);
1523 spin_lock(&udc
->lock
);
1526 DBG(DBG_BUS
, "req %02x.%02x, length %d, state %d, ret %d\n",
1527 crq
.crq
.bRequestType
, crq
.crq
.bRequest
,
1528 le16_to_cpu(crq
.crq
.wLength
), ep
->state
, ret
);
1531 /* Let the host know that we failed */
1532 set_protocol_stall(udc
, ep
);
1537 static void usba_ep_irq(struct usba_udc
*udc
, struct usba_ep
*ep
)
1539 struct usba_request
*req
;
1543 epstatus
= usba_ep_readl(ep
, STA
);
1544 epctrl
= usba_ep_readl(ep
, CTL
);
1546 DBG(DBG_INT
, "%s: interrupt, status: 0x%08x\n", ep
->ep
.name
, epstatus
);
1548 while ((epctrl
& USBA_TX_PK_RDY
) && !(epstatus
& USBA_TX_PK_RDY
)) {
1549 DBG(DBG_BUS
, "%s: TX PK ready\n", ep
->ep
.name
);
1551 if (list_empty(&ep
->queue
)) {
1552 dev_warn(&udc
->pdev
->dev
, "ep_irq: queue empty\n");
1553 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_PK_RDY
);
1557 req
= list_entry(ep
->queue
.next
, struct usba_request
, queue
);
1559 if (req
->using_dma
) {
1560 /* Send a zero-length packet */
1561 usba_ep_writel(ep
, SET_STA
,
1563 usba_ep_writel(ep
, CTL_DIS
,
1565 list_del_init(&req
->queue
);
1566 submit_next_request(ep
);
1567 request_complete(ep
, req
, 0);
1570 next_fifo_transaction(ep
, req
);
1572 submit_request(ep
, req
);
1574 if (req
->last_transaction
) {
1575 list_del_init(&req
->queue
);
1576 submit_next_request(ep
);
1577 request_complete(ep
, req
, 0);
1581 epstatus
= usba_ep_readl(ep
, STA
);
1582 epctrl
= usba_ep_readl(ep
, CTL
);
1584 if ((epstatus
& epctrl
) & USBA_RX_BK_RDY
) {
1585 DBG(DBG_BUS
, "%s: RX data ready\n", ep
->ep
.name
);
1587 usba_ep_writel(ep
, CLR_STA
, USBA_RX_BK_RDY
);
1591 static void usba_dma_irq(struct usba_udc
*udc
, struct usba_ep
*ep
)
1593 struct usba_request
*req
;
1594 u32 status
, control
, pending
;
1596 status
= usba_dma_readl(ep
, STATUS
);
1597 control
= usba_dma_readl(ep
, CONTROL
);
1598 #ifdef CONFIG_USB_GADGET_DEBUG_FS
1599 ep
->last_dma_status
= status
;
1601 pending
= status
& control
;
1602 DBG(DBG_INT
| DBG_DMA
, "dma irq, s/%#08x, c/%#08x\n", status
, control
);
1604 if (status
& USBA_DMA_CH_EN
) {
1605 dev_err(&udc
->pdev
->dev
,
1606 "DMA_CH_EN is set after transfer is finished!\n");
1607 dev_err(&udc
->pdev
->dev
,
1608 "status=%#08x, pending=%#08x, control=%#08x\n",
1609 status
, pending
, control
);
1612 * try to pretend nothing happened. We might have to
1613 * do something here...
1617 if (list_empty(&ep
->queue
))
1618 /* Might happen if a reset comes along at the right moment */
1621 if (pending
& (USBA_DMA_END_TR_ST
| USBA_DMA_END_BUF_ST
)) {
1622 req
= list_entry(ep
->queue
.next
, struct usba_request
, queue
);
1623 usba_update_req(ep
, req
, status
);
1625 list_del_init(&req
->queue
);
1626 submit_next_request(ep
);
1627 request_complete(ep
, req
, 0);
1631 static irqreturn_t
usba_udc_irq(int irq
, void *devid
)
1633 struct usba_udc
*udc
= devid
;
1638 spin_lock(&udc
->lock
);
1640 status
= usba_readl(udc
, INT_STA
);
1641 DBG(DBG_INT
, "irq, status=%#08x\n", status
);
1643 if (status
& USBA_DET_SUSPEND
) {
1645 usba_writel(udc
, INT_CLR
, USBA_DET_SUSPEND
);
1646 DBG(DBG_BUS
, "Suspend detected\n");
1647 if (udc
->gadget
.speed
!= USB_SPEED_UNKNOWN
1648 && udc
->driver
&& udc
->driver
->suspend
) {
1649 spin_unlock(&udc
->lock
);
1650 udc
->driver
->suspend(&udc
->gadget
);
1651 spin_lock(&udc
->lock
);
1655 if (status
& USBA_WAKE_UP
) {
1657 usba_writel(udc
, INT_CLR
, USBA_WAKE_UP
);
1658 DBG(DBG_BUS
, "Wake Up CPU detected\n");
1661 if (status
& USBA_END_OF_RESUME
) {
1662 usba_writel(udc
, INT_CLR
, USBA_END_OF_RESUME
);
1663 DBG(DBG_BUS
, "Resume detected\n");
1664 if (udc
->gadget
.speed
!= USB_SPEED_UNKNOWN
1665 && udc
->driver
&& udc
->driver
->resume
) {
1666 spin_unlock(&udc
->lock
);
1667 udc
->driver
->resume(&udc
->gadget
);
1668 spin_lock(&udc
->lock
);
1672 dma_status
= USBA_BFEXT(DMA_INT
, status
);
1676 for (i
= 1; i
< USBA_NR_ENDPOINTS
; i
++)
1677 if (dma_status
& (1 << i
))
1678 usba_dma_irq(udc
, &usba_ep
[i
]);
1681 ep_status
= USBA_BFEXT(EPT_INT
, status
);
1685 for (i
= 0; i
< USBA_NR_ENDPOINTS
; i
++)
1686 if (ep_status
& (1 << i
)) {
1687 if (ep_is_control(&usba_ep
[i
]))
1688 usba_control_irq(udc
, &usba_ep
[i
]);
1690 usba_ep_irq(udc
, &usba_ep
[i
]);
1694 if (status
& USBA_END_OF_RESET
) {
1695 struct usba_ep
*ep0
;
1697 usba_writel(udc
, INT_CLR
, USBA_END_OF_RESET
);
1698 reset_all_endpoints(udc
);
1700 if (udc
->gadget
.speed
!= USB_SPEED_UNKNOWN
1701 && udc
->driver
->disconnect
) {
1702 udc
->gadget
.speed
= USB_SPEED_UNKNOWN
;
1703 spin_unlock(&udc
->lock
);
1704 udc
->driver
->disconnect(&udc
->gadget
);
1705 spin_lock(&udc
->lock
);
1708 if (status
& USBA_HIGH_SPEED
) {
1709 DBG(DBG_BUS
, "High-speed bus reset detected\n");
1710 udc
->gadget
.speed
= USB_SPEED_HIGH
;
1712 DBG(DBG_BUS
, "Full-speed bus reset detected\n");
1713 udc
->gadget
.speed
= USB_SPEED_FULL
;
1717 ep0
->desc
= &usba_ep0_desc
;
1718 ep0
->state
= WAIT_FOR_SETUP
;
1719 usba_ep_writel(ep0
, CFG
,
1720 (USBA_BF(EPT_SIZE
, EP0_EPT_SIZE
)
1721 | USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_CONTROL
)
1722 | USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_ONE
)));
1723 usba_ep_writel(ep0
, CTL_ENB
,
1724 USBA_EPT_ENABLE
| USBA_RX_SETUP
);
1725 usba_writel(udc
, INT_ENB
,
1726 (usba_readl(udc
, INT_ENB
)
1727 | USBA_BF(EPT_INT
, 1)
1729 | USBA_END_OF_RESUME
));
1732 * Unclear why we hit this irregularly, e.g. in usbtest,
1733 * but it's clearly harmless...
1735 if (!(usba_ep_readl(ep0
, CFG
) & USBA_EPT_MAPPED
))
1736 dev_dbg(&udc
->pdev
->dev
,
1737 "ODD: EP0 configuration is invalid!\n");
1740 spin_unlock(&udc
->lock
);
1745 static irqreturn_t
usba_vbus_irq(int irq
, void *devid
)
1747 struct usba_udc
*udc
= devid
;
1753 spin_lock(&udc
->lock
);
1755 /* May happen if Vbus pin toggles during probe() */
1759 vbus
= vbus_is_present(udc
);
1760 if (vbus
!= udc
->vbus_prev
) {
1763 usba_writel(udc
, CTRL
, USBA_ENABLE_MASK
);
1764 usba_writel(udc
, INT_ENB
, USBA_END_OF_RESET
);
1766 udc
->gadget
.speed
= USB_SPEED_UNKNOWN
;
1767 reset_all_endpoints(udc
);
1769 usba_writel(udc
, CTRL
, USBA_DISABLE_MASK
);
1770 if (udc
->driver
->disconnect
) {
1771 spin_unlock(&udc
->lock
);
1772 udc
->driver
->disconnect(&udc
->gadget
);
1773 spin_lock(&udc
->lock
);
1776 udc
->vbus_prev
= vbus
;
1780 spin_unlock(&udc
->lock
);
1785 int usb_gadget_register_driver(struct usb_gadget_driver
*driver
)
1787 struct usba_udc
*udc
= &the_udc
;
1788 unsigned long flags
;
1794 spin_lock_irqsave(&udc
->lock
, flags
);
1796 spin_unlock_irqrestore(&udc
->lock
, flags
);
1800 udc
->devstatus
= 1 << USB_DEVICE_SELF_POWERED
;
1801 udc
->driver
= driver
;
1802 udc
->gadget
.dev
.driver
= &driver
->driver
;
1803 spin_unlock_irqrestore(&udc
->lock
, flags
);
1805 clk_enable(udc
->pclk
);
1806 clk_enable(udc
->hclk
);
1808 ret
= driver
->bind(&udc
->gadget
);
1810 DBG(DBG_ERR
, "Could not bind to driver %s: error %d\n",
1811 driver
->driver
.name
, ret
);
1812 goto err_driver_bind
;
1815 DBG(DBG_GADGET
, "registered driver `%s'\n", driver
->driver
.name
);
1818 if (gpio_is_valid(udc
->vbus_pin
))
1819 enable_irq(gpio_to_irq(udc
->vbus_pin
));
1821 /* If Vbus is present, enable the controller and wait for reset */
1822 spin_lock_irqsave(&udc
->lock
, flags
);
1823 if (vbus_is_present(udc
) && udc
->vbus_prev
== 0) {
1825 usba_writel(udc
, CTRL
, USBA_ENABLE_MASK
);
1826 usba_writel(udc
, INT_ENB
, USBA_END_OF_RESET
);
1828 spin_unlock_irqrestore(&udc
->lock
, flags
);
1834 udc
->gadget
.dev
.driver
= NULL
;
1837 EXPORT_SYMBOL(usb_gadget_register_driver
);
1839 int usb_gadget_unregister_driver(struct usb_gadget_driver
*driver
)
1841 struct usba_udc
*udc
= &the_udc
;
1842 unsigned long flags
;
1846 if (driver
!= udc
->driver
|| !driver
->unbind
)
1849 if (gpio_is_valid(udc
->vbus_pin
))
1850 disable_irq(gpio_to_irq(udc
->vbus_pin
));
1852 spin_lock_irqsave(&udc
->lock
, flags
);
1853 udc
->gadget
.speed
= USB_SPEED_UNKNOWN
;
1854 reset_all_endpoints(udc
);
1855 spin_unlock_irqrestore(&udc
->lock
, flags
);
1857 /* This will also disable the DP pullup */
1859 usba_writel(udc
, CTRL
, USBA_DISABLE_MASK
);
1861 if (udc
->driver
->disconnect
)
1862 udc
->driver
->disconnect(&udc
->gadget
);
1864 driver
->unbind(&udc
->gadget
);
1865 udc
->gadget
.dev
.driver
= NULL
;
1868 clk_disable(udc
->hclk
);
1869 clk_disable(udc
->pclk
);
1871 DBG(DBG_GADGET
, "unregistered driver `%s'\n", driver
->driver
.name
);
1875 EXPORT_SYMBOL(usb_gadget_unregister_driver
);
1877 static int __init
usba_udc_probe(struct platform_device
*pdev
)
1879 struct usba_platform_data
*pdata
= pdev
->dev
.platform_data
;
1880 struct resource
*regs
, *fifo
;
1881 struct clk
*pclk
, *hclk
;
1882 struct usba_udc
*udc
= &the_udc
;
1885 regs
= platform_get_resource(pdev
, IORESOURCE_MEM
, CTRL_IOMEM_ID
);
1886 fifo
= platform_get_resource(pdev
, IORESOURCE_MEM
, FIFO_IOMEM_ID
);
1887 if (!regs
|| !fifo
|| !pdata
)
1890 irq
= platform_get_irq(pdev
, 0);
1894 pclk
= clk_get(&pdev
->dev
, "pclk");
1896 return PTR_ERR(pclk
);
1897 hclk
= clk_get(&pdev
->dev
, "hclk");
1899 ret
= PTR_ERR(hclk
);
1903 spin_lock_init(&udc
->lock
);
1907 udc
->vbus_pin
= -ENODEV
;
1910 udc
->regs
= ioremap(regs
->start
, resource_size(regs
));
1912 dev_err(&pdev
->dev
, "Unable to map I/O memory, aborting.\n");
1915 dev_info(&pdev
->dev
, "MMIO registers at 0x%08lx mapped at %p\n",
1916 (unsigned long)regs
->start
, udc
->regs
);
1917 udc
->fifo
= ioremap(fifo
->start
, resource_size(fifo
));
1919 dev_err(&pdev
->dev
, "Unable to map FIFO, aborting.\n");
1922 dev_info(&pdev
->dev
, "FIFO at 0x%08lx mapped at %p\n",
1923 (unsigned long)fifo
->start
, udc
->fifo
);
1925 device_initialize(&udc
->gadget
.dev
);
1926 udc
->gadget
.dev
.parent
= &pdev
->dev
;
1927 udc
->gadget
.dev
.dma_mask
= pdev
->dev
.dma_mask
;
1929 platform_set_drvdata(pdev
, udc
);
1931 /* Make sure we start from a clean slate */
1934 usba_writel(udc
, CTRL
, USBA_DISABLE_MASK
);
1937 usba_ep
= kzalloc(sizeof(struct usba_ep
) * pdata
->num_ep
,
1942 the_udc
.gadget
.ep0
= &usba_ep
[0].ep
;
1944 INIT_LIST_HEAD(&usba_ep
[0].ep
.ep_list
);
1945 usba_ep
[0].ep_regs
= udc
->regs
+ USBA_EPT_BASE(0);
1946 usba_ep
[0].dma_regs
= udc
->regs
+ USBA_DMA_BASE(0);
1947 usba_ep
[0].fifo
= udc
->fifo
+ USBA_FIFO_BASE(0);
1948 usba_ep
[0].ep
.ops
= &usba_ep_ops
;
1949 usba_ep
[0].ep
.name
= pdata
->ep
[0].name
;
1950 usba_ep
[0].ep
.maxpacket
= pdata
->ep
[0].fifo_size
;
1951 usba_ep
[0].udc
= &the_udc
;
1952 INIT_LIST_HEAD(&usba_ep
[0].queue
);
1953 usba_ep
[0].fifo_size
= pdata
->ep
[0].fifo_size
;
1954 usba_ep
[0].nr_banks
= pdata
->ep
[0].nr_banks
;
1955 usba_ep
[0].index
= pdata
->ep
[0].index
;
1956 usba_ep
[0].can_dma
= pdata
->ep
[0].can_dma
;
1957 usba_ep
[0].can_isoc
= pdata
->ep
[0].can_isoc
;
1959 for (i
= 1; i
< pdata
->num_ep
; i
++) {
1960 struct usba_ep
*ep
= &usba_ep
[i
];
1962 ep
->ep_regs
= udc
->regs
+ USBA_EPT_BASE(i
);
1963 ep
->dma_regs
= udc
->regs
+ USBA_DMA_BASE(i
);
1964 ep
->fifo
= udc
->fifo
+ USBA_FIFO_BASE(i
);
1965 ep
->ep
.ops
= &usba_ep_ops
;
1966 ep
->ep
.name
= pdata
->ep
[i
].name
;
1967 ep
->ep
.maxpacket
= pdata
->ep
[i
].fifo_size
;
1969 INIT_LIST_HEAD(&ep
->queue
);
1970 ep
->fifo_size
= pdata
->ep
[i
].fifo_size
;
1971 ep
->nr_banks
= pdata
->ep
[i
].nr_banks
;
1972 ep
->index
= pdata
->ep
[i
].index
;
1973 ep
->can_dma
= pdata
->ep
[i
].can_dma
;
1974 ep
->can_isoc
= pdata
->ep
[i
].can_isoc
;
1976 list_add_tail(&ep
->ep
.ep_list
, &udc
->gadget
.ep_list
);
1979 ret
= request_irq(irq
, usba_udc_irq
, 0, "atmel_usba_udc", udc
);
1981 dev_err(&pdev
->dev
, "Cannot request irq %d (error %d)\n",
1983 goto err_request_irq
;
1987 ret
= device_add(&udc
->gadget
.dev
);
1989 dev_dbg(&pdev
->dev
, "Could not add gadget: %d\n", ret
);
1990 goto err_device_add
;
1993 if (gpio_is_valid(pdata
->vbus_pin
)) {
1994 if (!gpio_request(pdata
->vbus_pin
, "atmel_usba_udc")) {
1995 udc
->vbus_pin
= pdata
->vbus_pin
;
1996 udc
->vbus_pin_inverted
= pdata
->vbus_pin_inverted
;
1998 ret
= request_irq(gpio_to_irq(udc
->vbus_pin
),
2000 "atmel_usba_udc", udc
);
2002 gpio_free(udc
->vbus_pin
);
2003 udc
->vbus_pin
= -ENODEV
;
2004 dev_warn(&udc
->pdev
->dev
,
2005 "failed to request vbus irq; "
2006 "assuming always on\n");
2008 disable_irq(gpio_to_irq(udc
->vbus_pin
));
2011 /* gpio_request fail so use -EINVAL for gpio_is_valid */
2012 udc
->vbus_pin
= -EINVAL
;
2016 usba_init_debugfs(udc
);
2017 for (i
= 1; i
< pdata
->num_ep
; i
++)
2018 usba_ep_init_debugfs(udc
, &usba_ep
[i
]);
2035 platform_set_drvdata(pdev
, NULL
);
2040 static int __exit
usba_udc_remove(struct platform_device
*pdev
)
2042 struct usba_udc
*udc
;
2044 struct usba_platform_data
*pdata
= pdev
->dev
.platform_data
;
2046 udc
= platform_get_drvdata(pdev
);
2048 for (i
= 1; i
< pdata
->num_ep
; i
++)
2049 usba_ep_cleanup_debugfs(&usba_ep
[i
]);
2050 usba_cleanup_debugfs(udc
);
2052 if (gpio_is_valid(udc
->vbus_pin
))
2053 gpio_free(udc
->vbus_pin
);
2055 free_irq(udc
->irq
, udc
);
2062 device_unregister(&udc
->gadget
.dev
);
2067 static struct platform_driver udc_driver
= {
2068 .remove
= __exit_p(usba_udc_remove
),
2070 .name
= "atmel_usba_udc",
2071 .owner
= THIS_MODULE
,
2075 static int __init
udc_init(void)
2077 return platform_driver_probe(&udc_driver
, usba_udc_probe
);
2079 module_init(udc_init
);
2081 static void __exit
udc_exit(void)
2083 platform_driver_unregister(&udc_driver
);
2085 module_exit(udc_exit
);
2087 MODULE_DESCRIPTION("Atmel USBA UDC driver");
2088 MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>");
2089 MODULE_LICENSE("GPL");
2090 MODULE_ALIAS("platform:atmel_usba_udc");