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>
24 #include <linux/platform_data/atmel.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_inode(file
)->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_inode(file
)->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_inode(file
);
174 mutex_lock(&inode
->i_mutex
);
175 ret
= simple_read_from_buffer(buf
, nbytes
, ppos
,
177 file_inode(file
)->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
= resource_size(regs_resource
);
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_pmc_read(AT91_CKGR_UCKR
);
338 at91_pmc_write(AT91_CKGR_UCKR
, uckr
| AT91_PMC_BIASEN
);
340 at91_pmc_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
;
493 usb_gadget_unmap_request(&udc
->gadget
, &req
->req
, ep
->is_in
);
495 DBG(DBG_GADGET
| DBG_REQ
,
496 "%s: req %p complete: status %d, actual %u\n",
497 ep
->ep
.name
, req
, req
->req
.status
, req
->req
.actual
);
499 spin_unlock(&udc
->lock
);
500 req
->req
.complete(&ep
->ep
, &req
->req
);
501 spin_lock(&udc
->lock
);
505 request_complete_list(struct usba_ep
*ep
, struct list_head
*list
, int status
)
507 struct usba_request
*req
, *tmp_req
;
509 list_for_each_entry_safe(req
, tmp_req
, list
, queue
) {
510 list_del_init(&req
->queue
);
511 request_complete(ep
, req
, status
);
516 usba_ep_enable(struct usb_ep
*_ep
, const struct usb_endpoint_descriptor
*desc
)
518 struct usba_ep
*ep
= to_usba_ep(_ep
);
519 struct usba_udc
*udc
= ep
->udc
;
520 unsigned long flags
, ept_cfg
, maxpacket
;
521 unsigned int nr_trans
;
523 DBG(DBG_GADGET
, "%s: ep_enable: desc=%p\n", ep
->ep
.name
, desc
);
525 maxpacket
= usb_endpoint_maxp(desc
) & 0x7ff;
527 if (((desc
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
) != ep
->index
)
529 || desc
->bDescriptorType
!= USB_DT_ENDPOINT
531 || maxpacket
> ep
->fifo_size
) {
532 DBG(DBG_ERR
, "ep_enable: Invalid argument");
540 ept_cfg
= USBA_BF(EPT_SIZE
, USBA_EPT_SIZE_8
);
542 /* LSB is bit 1, not 0 */
543 ept_cfg
= USBA_BF(EPT_SIZE
, fls(maxpacket
- 1) - 3);
545 DBG(DBG_HW
, "%s: EPT_SIZE = %lu (maxpacket = %lu)\n",
546 ep
->ep
.name
, ept_cfg
, maxpacket
);
548 if (usb_endpoint_dir_in(desc
)) {
550 ept_cfg
|= USBA_EPT_DIR_IN
;
553 switch (usb_endpoint_type(desc
)) {
554 case USB_ENDPOINT_XFER_CONTROL
:
555 ept_cfg
|= USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_CONTROL
);
556 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_ONE
);
558 case USB_ENDPOINT_XFER_ISOC
:
560 DBG(DBG_ERR
, "ep_enable: %s is not isoc capable\n",
566 * Bits 11:12 specify number of _additional_
567 * transactions per microframe.
569 nr_trans
= ((usb_endpoint_maxp(desc
) >> 11) & 3) + 1;
574 ept_cfg
|= USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_ISO
);
577 * Do triple-buffering on high-bandwidth iso endpoints.
579 if (nr_trans
> 1 && ep
->nr_banks
== 3)
580 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_TRIPLE
);
582 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_DOUBLE
);
583 ept_cfg
|= USBA_BF(NB_TRANS
, nr_trans
);
585 case USB_ENDPOINT_XFER_BULK
:
586 ept_cfg
|= USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_BULK
);
587 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_DOUBLE
);
589 case USB_ENDPOINT_XFER_INT
:
590 ept_cfg
|= USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_INT
);
591 ept_cfg
|= USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_DOUBLE
);
595 spin_lock_irqsave(&ep
->udc
->lock
, flags
);
598 ep
->ep
.maxpacket
= maxpacket
;
600 usba_ep_writel(ep
, CFG
, ept_cfg
);
601 usba_ep_writel(ep
, CTL_ENB
, USBA_EPT_ENABLE
);
606 usba_writel(udc
, INT_ENB
,
607 (usba_readl(udc
, INT_ENB
)
608 | USBA_BF(EPT_INT
, 1 << ep
->index
)
609 | USBA_BF(DMA_INT
, 1 << ep
->index
)));
610 ctrl
= USBA_AUTO_VALID
| USBA_INTDIS_DMA
;
611 usba_ep_writel(ep
, CTL_ENB
, ctrl
);
613 usba_writel(udc
, INT_ENB
,
614 (usba_readl(udc
, INT_ENB
)
615 | USBA_BF(EPT_INT
, 1 << ep
->index
)));
618 spin_unlock_irqrestore(&udc
->lock
, flags
);
620 DBG(DBG_HW
, "EPT_CFG%d after init: %#08lx\n", ep
->index
,
621 (unsigned long)usba_ep_readl(ep
, CFG
));
622 DBG(DBG_HW
, "INT_ENB after init: %#08lx\n",
623 (unsigned long)usba_readl(udc
, INT_ENB
));
628 static int usba_ep_disable(struct usb_ep
*_ep
)
630 struct usba_ep
*ep
= to_usba_ep(_ep
);
631 struct usba_udc
*udc
= ep
->udc
;
635 DBG(DBG_GADGET
, "ep_disable: %s\n", ep
->ep
.name
);
637 spin_lock_irqsave(&udc
->lock
, flags
);
640 spin_unlock_irqrestore(&udc
->lock
, flags
);
641 /* REVISIT because this driver disables endpoints in
642 * reset_all_endpoints() before calling disconnect(),
643 * most gadget drivers would trigger this non-error ...
645 if (udc
->gadget
.speed
!= USB_SPEED_UNKNOWN
)
646 DBG(DBG_ERR
, "ep_disable: %s not enabled\n",
652 list_splice_init(&ep
->queue
, &req_list
);
654 usba_dma_writel(ep
, CONTROL
, 0);
655 usba_dma_writel(ep
, ADDRESS
, 0);
656 usba_dma_readl(ep
, STATUS
);
658 usba_ep_writel(ep
, CTL_DIS
, USBA_EPT_ENABLE
);
659 usba_writel(udc
, INT_ENB
,
660 usba_readl(udc
, INT_ENB
)
661 & ~USBA_BF(EPT_INT
, 1 << ep
->index
));
663 request_complete_list(ep
, &req_list
, -ESHUTDOWN
);
665 spin_unlock_irqrestore(&udc
->lock
, flags
);
670 static struct usb_request
*
671 usba_ep_alloc_request(struct usb_ep
*_ep
, gfp_t gfp_flags
)
673 struct usba_request
*req
;
675 DBG(DBG_GADGET
, "ep_alloc_request: %p, 0x%x\n", _ep
, gfp_flags
);
677 req
= kzalloc(sizeof(*req
), gfp_flags
);
681 INIT_LIST_HEAD(&req
->queue
);
687 usba_ep_free_request(struct usb_ep
*_ep
, struct usb_request
*_req
)
689 struct usba_request
*req
= to_usba_req(_req
);
691 DBG(DBG_GADGET
, "ep_free_request: %p, %p\n", _ep
, _req
);
696 static int queue_dma(struct usba_udc
*udc
, struct usba_ep
*ep
,
697 struct usba_request
*req
, gfp_t gfp_flags
)
702 DBG(DBG_DMA
, "%s: req l/%u d/%08x %c%c%c\n",
703 ep
->ep
.name
, req
->req
.length
, req
->req
.dma
,
704 req
->req
.zero
? 'Z' : 'z',
705 req
->req
.short_not_ok
? 'S' : 's',
706 req
->req
.no_interrupt
? 'I' : 'i');
708 if (req
->req
.length
> 0x10000) {
709 /* Lengths from 0 to 65536 (inclusive) are supported */
710 DBG(DBG_ERR
, "invalid request length %u\n", req
->req
.length
);
714 ret
= usb_gadget_map_request(&udc
->gadget
, &req
->req
, ep
->is_in
);
719 req
->ctrl
= USBA_BF(DMA_BUF_LEN
, req
->req
.length
)
720 | USBA_DMA_CH_EN
| USBA_DMA_END_BUF_IE
721 | USBA_DMA_END_TR_EN
| USBA_DMA_END_TR_IE
;
724 req
->ctrl
|= USBA_DMA_END_BUF_EN
;
727 * Add this request to the queue and submit for DMA if
728 * possible. Check if we're still alive first -- we may have
729 * received a reset since last time we checked.
732 spin_lock_irqsave(&udc
->lock
, flags
);
734 if (list_empty(&ep
->queue
))
735 submit_request(ep
, req
);
737 list_add_tail(&req
->queue
, &ep
->queue
);
740 spin_unlock_irqrestore(&udc
->lock
, flags
);
746 usba_ep_queue(struct usb_ep
*_ep
, struct usb_request
*_req
, gfp_t gfp_flags
)
748 struct usba_request
*req
= to_usba_req(_req
);
749 struct usba_ep
*ep
= to_usba_ep(_ep
);
750 struct usba_udc
*udc
= ep
->udc
;
754 DBG(DBG_GADGET
| DBG_QUEUE
| DBG_REQ
, "%s: queue req %p, len %u\n",
755 ep
->ep
.name
, req
, _req
->length
);
757 if (!udc
->driver
|| udc
->gadget
.speed
== USB_SPEED_UNKNOWN
||
763 req
->last_transaction
= 0;
765 _req
->status
= -EINPROGRESS
;
769 return queue_dma(udc
, ep
, req
, gfp_flags
);
771 /* May have received a reset since last time we checked */
773 spin_lock_irqsave(&udc
->lock
, flags
);
775 list_add_tail(&req
->queue
, &ep
->queue
);
777 if ((!ep_is_control(ep
) && ep
->is_in
) ||
779 && (ep
->state
== DATA_STAGE_IN
780 || ep
->state
== STATUS_STAGE_IN
)))
781 usba_ep_writel(ep
, CTL_ENB
, USBA_TX_PK_RDY
);
783 usba_ep_writel(ep
, CTL_ENB
, USBA_RX_BK_RDY
);
786 spin_unlock_irqrestore(&udc
->lock
, flags
);
792 usba_update_req(struct usba_ep
*ep
, struct usba_request
*req
, u32 status
)
794 req
->req
.actual
= req
->req
.length
- USBA_BFEXT(DMA_BUF_LEN
, status
);
797 static int stop_dma(struct usba_ep
*ep
, u32
*pstatus
)
799 unsigned int timeout
;
803 * Stop the DMA controller. When writing both CH_EN
804 * and LINK to 0, the other bits are not affected.
806 usba_dma_writel(ep
, CONTROL
, 0);
808 /* Wait for the FIFO to empty */
809 for (timeout
= 40; timeout
; --timeout
) {
810 status
= usba_dma_readl(ep
, STATUS
);
811 if (!(status
& USBA_DMA_CH_EN
))
820 dev_err(&ep
->udc
->pdev
->dev
,
821 "%s: timed out waiting for DMA FIFO to empty\n",
829 static int usba_ep_dequeue(struct usb_ep
*_ep
, struct usb_request
*_req
)
831 struct usba_ep
*ep
= to_usba_ep(_ep
);
832 struct usba_udc
*udc
= ep
->udc
;
833 struct usba_request
*req
= to_usba_req(_req
);
837 DBG(DBG_GADGET
| DBG_QUEUE
, "ep_dequeue: %s, req %p\n",
840 spin_lock_irqsave(&udc
->lock
, flags
);
842 if (req
->using_dma
) {
844 * If this request is currently being transferred,
845 * stop the DMA controller and reset the FIFO.
847 if (ep
->queue
.next
== &req
->queue
) {
848 status
= usba_dma_readl(ep
, STATUS
);
849 if (status
& USBA_DMA_CH_EN
)
850 stop_dma(ep
, &status
);
852 #ifdef CONFIG_USB_GADGET_DEBUG_FS
853 ep
->last_dma_status
= status
;
856 usba_writel(udc
, EPT_RST
, 1 << ep
->index
);
858 usba_update_req(ep
, req
, status
);
863 * Errors should stop the queue from advancing until the
864 * completion function returns.
866 list_del_init(&req
->queue
);
868 request_complete(ep
, req
, -ECONNRESET
);
870 /* Process the next request if any */
871 submit_next_request(ep
);
872 spin_unlock_irqrestore(&udc
->lock
, flags
);
877 static int usba_ep_set_halt(struct usb_ep
*_ep
, int value
)
879 struct usba_ep
*ep
= to_usba_ep(_ep
);
880 struct usba_udc
*udc
= ep
->udc
;
884 DBG(DBG_GADGET
, "endpoint %s: %s HALT\n", ep
->ep
.name
,
885 value
? "set" : "clear");
888 DBG(DBG_ERR
, "Attempted to halt uninitialized ep %s\n",
893 DBG(DBG_ERR
, "Attempted to halt isochronous ep %s\n",
898 spin_lock_irqsave(&udc
->lock
, flags
);
901 * We can't halt IN endpoints while there are still data to be
904 if (!list_empty(&ep
->queue
)
905 || ((value
&& ep
->is_in
&& (usba_ep_readl(ep
, STA
)
906 & USBA_BF(BUSY_BANKS
, -1L))))) {
910 usba_ep_writel(ep
, SET_STA
, USBA_FORCE_STALL
);
912 usba_ep_writel(ep
, CLR_STA
,
913 USBA_FORCE_STALL
| USBA_TOGGLE_CLR
);
914 usba_ep_readl(ep
, STA
);
917 spin_unlock_irqrestore(&udc
->lock
, flags
);
922 static int usba_ep_fifo_status(struct usb_ep
*_ep
)
924 struct usba_ep
*ep
= to_usba_ep(_ep
);
926 return USBA_BFEXT(BYTE_COUNT
, usba_ep_readl(ep
, STA
));
929 static void usba_ep_fifo_flush(struct usb_ep
*_ep
)
931 struct usba_ep
*ep
= to_usba_ep(_ep
);
932 struct usba_udc
*udc
= ep
->udc
;
934 usba_writel(udc
, EPT_RST
, 1 << ep
->index
);
937 static const struct usb_ep_ops usba_ep_ops
= {
938 .enable
= usba_ep_enable
,
939 .disable
= usba_ep_disable
,
940 .alloc_request
= usba_ep_alloc_request
,
941 .free_request
= usba_ep_free_request
,
942 .queue
= usba_ep_queue
,
943 .dequeue
= usba_ep_dequeue
,
944 .set_halt
= usba_ep_set_halt
,
945 .fifo_status
= usba_ep_fifo_status
,
946 .fifo_flush
= usba_ep_fifo_flush
,
949 static int usba_udc_get_frame(struct usb_gadget
*gadget
)
951 struct usba_udc
*udc
= to_usba_udc(gadget
);
953 return USBA_BFEXT(FRAME_NUMBER
, usba_readl(udc
, FNUM
));
956 static int usba_udc_wakeup(struct usb_gadget
*gadget
)
958 struct usba_udc
*udc
= to_usba_udc(gadget
);
963 spin_lock_irqsave(&udc
->lock
, flags
);
964 if (udc
->devstatus
& (1 << USB_DEVICE_REMOTE_WAKEUP
)) {
965 ctrl
= usba_readl(udc
, CTRL
);
966 usba_writel(udc
, CTRL
, ctrl
| USBA_REMOTE_WAKE_UP
);
969 spin_unlock_irqrestore(&udc
->lock
, flags
);
975 usba_udc_set_selfpowered(struct usb_gadget
*gadget
, int is_selfpowered
)
977 struct usba_udc
*udc
= to_usba_udc(gadget
);
980 spin_lock_irqsave(&udc
->lock
, flags
);
982 udc
->devstatus
|= 1 << USB_DEVICE_SELF_POWERED
;
984 udc
->devstatus
&= ~(1 << USB_DEVICE_SELF_POWERED
);
985 spin_unlock_irqrestore(&udc
->lock
, flags
);
990 static int atmel_usba_start(struct usb_gadget
*gadget
,
991 struct usb_gadget_driver
*driver
);
992 static int atmel_usba_stop(struct usb_gadget
*gadget
,
993 struct usb_gadget_driver
*driver
);
994 static const struct usb_gadget_ops usba_udc_ops
= {
995 .get_frame
= usba_udc_get_frame
,
996 .wakeup
= usba_udc_wakeup
,
997 .set_selfpowered
= usba_udc_set_selfpowered
,
998 .udc_start
= atmel_usba_start
,
999 .udc_stop
= atmel_usba_stop
,
1002 static struct usb_endpoint_descriptor usba_ep0_desc
= {
1003 .bLength
= USB_DT_ENDPOINT_SIZE
,
1004 .bDescriptorType
= USB_DT_ENDPOINT
,
1005 .bEndpointAddress
= 0,
1006 .bmAttributes
= USB_ENDPOINT_XFER_CONTROL
,
1007 .wMaxPacketSize
= cpu_to_le16(64),
1008 /* FIXME: I have no idea what to put here */
1012 static void nop_release(struct device
*dev
)
1017 static struct usba_udc the_udc
= {
1019 .ops
= &usba_udc_ops
,
1020 .ep_list
= LIST_HEAD_INIT(the_udc
.gadget
.ep_list
),
1021 .max_speed
= USB_SPEED_HIGH
,
1022 .name
= "atmel_usba_udc",
1024 .init_name
= "gadget",
1025 .release
= nop_release
,
1031 * Called with interrupts disabled and udc->lock held.
1033 static void reset_all_endpoints(struct usba_udc
*udc
)
1036 struct usba_request
*req
, *tmp_req
;
1038 usba_writel(udc
, EPT_RST
, ~0UL);
1040 ep
= to_usba_ep(udc
->gadget
.ep0
);
1041 list_for_each_entry_safe(req
, tmp_req
, &ep
->queue
, queue
) {
1042 list_del_init(&req
->queue
);
1043 request_complete(ep
, req
, -ECONNRESET
);
1046 /* NOTE: normally, the next call to the gadget driver is in
1047 * charge of disabling endpoints... usually disconnect().
1048 * The exception would be entering a high speed test mode.
1050 * FIXME remove this code ... and retest thoroughly.
1052 list_for_each_entry(ep
, &udc
->gadget
.ep_list
, ep
.ep_list
) {
1054 spin_unlock(&udc
->lock
);
1055 usba_ep_disable(&ep
->ep
);
1056 spin_lock(&udc
->lock
);
1061 static struct usba_ep
*get_ep_by_addr(struct usba_udc
*udc
, u16 wIndex
)
1065 if ((wIndex
& USB_ENDPOINT_NUMBER_MASK
) == 0)
1066 return to_usba_ep(udc
->gadget
.ep0
);
1068 list_for_each_entry (ep
, &udc
->gadget
.ep_list
, ep
.ep_list
) {
1069 u8 bEndpointAddress
;
1073 bEndpointAddress
= ep
->ep
.desc
->bEndpointAddress
;
1074 if ((wIndex
^ bEndpointAddress
) & USB_DIR_IN
)
1076 if ((bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
)
1077 == (wIndex
& USB_ENDPOINT_NUMBER_MASK
))
1084 /* Called with interrupts disabled and udc->lock held */
1085 static inline void set_protocol_stall(struct usba_udc
*udc
, struct usba_ep
*ep
)
1087 usba_ep_writel(ep
, SET_STA
, USBA_FORCE_STALL
);
1088 ep
->state
= WAIT_FOR_SETUP
;
1091 static inline int is_stalled(struct usba_udc
*udc
, struct usba_ep
*ep
)
1093 if (usba_ep_readl(ep
, STA
) & USBA_FORCE_STALL
)
1098 static inline void set_address(struct usba_udc
*udc
, unsigned int addr
)
1102 DBG(DBG_BUS
, "setting address %u...\n", addr
);
1103 regval
= usba_readl(udc
, CTRL
);
1104 regval
= USBA_BFINS(DEV_ADDR
, addr
, regval
);
1105 usba_writel(udc
, CTRL
, regval
);
1108 static int do_test_mode(struct usba_udc
*udc
)
1110 static const char test_packet_buffer
[] = {
1112 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1114 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
1116 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
1117 /* JJJJJJJKKKKKKK * 8 */
1118 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1119 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1121 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD,
1122 /* {JKKKKKKK * 10}, JK */
1123 0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0x7E
1126 struct device
*dev
= &udc
->pdev
->dev
;
1129 test_mode
= udc
->test_mode
;
1131 /* Start from a clean slate */
1132 reset_all_endpoints(udc
);
1134 switch (test_mode
) {
1137 usba_writel(udc
, TST
, USBA_TST_J_MODE
);
1138 dev_info(dev
, "Entering Test_J mode...\n");
1142 usba_writel(udc
, TST
, USBA_TST_K_MODE
);
1143 dev_info(dev
, "Entering Test_K mode...\n");
1147 * Test_SE0_NAK: Force high-speed mode and set up ep0
1148 * for Bulk IN transfers
1151 usba_writel(udc
, TST
,
1152 USBA_BF(SPEED_CFG
, USBA_SPEED_CFG_FORCE_HIGH
));
1153 usba_ep_writel(ep
, CFG
,
1154 USBA_BF(EPT_SIZE
, USBA_EPT_SIZE_64
)
1156 | USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_BULK
)
1157 | USBA_BF(BK_NUMBER
, 1));
1158 if (!(usba_ep_readl(ep
, CFG
) & USBA_EPT_MAPPED
)) {
1159 set_protocol_stall(udc
, ep
);
1160 dev_err(dev
, "Test_SE0_NAK: ep0 not mapped\n");
1162 usba_ep_writel(ep
, CTL_ENB
, USBA_EPT_ENABLE
);
1163 dev_info(dev
, "Entering Test_SE0_NAK mode...\n");
1169 usba_ep_writel(ep
, CFG
,
1170 USBA_BF(EPT_SIZE
, USBA_EPT_SIZE_64
)
1172 | USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_BULK
)
1173 | USBA_BF(BK_NUMBER
, 1));
1174 if (!(usba_ep_readl(ep
, CFG
) & USBA_EPT_MAPPED
)) {
1175 set_protocol_stall(udc
, ep
);
1176 dev_err(dev
, "Test_Packet: ep0 not mapped\n");
1178 usba_ep_writel(ep
, CTL_ENB
, USBA_EPT_ENABLE
);
1179 usba_writel(udc
, TST
, USBA_TST_PKT_MODE
);
1180 memcpy_toio(ep
->fifo
, test_packet_buffer
,
1181 sizeof(test_packet_buffer
));
1182 usba_ep_writel(ep
, SET_STA
, USBA_TX_PK_RDY
);
1183 dev_info(dev
, "Entering Test_Packet mode...\n");
1187 dev_err(dev
, "Invalid test mode: 0x%04x\n", test_mode
);
1194 /* Avoid overly long expressions */
1195 static inline bool feature_is_dev_remote_wakeup(struct usb_ctrlrequest
*crq
)
1197 if (crq
->wValue
== cpu_to_le16(USB_DEVICE_REMOTE_WAKEUP
))
1202 static inline bool feature_is_dev_test_mode(struct usb_ctrlrequest
*crq
)
1204 if (crq
->wValue
== cpu_to_le16(USB_DEVICE_TEST_MODE
))
1209 static inline bool feature_is_ep_halt(struct usb_ctrlrequest
*crq
)
1211 if (crq
->wValue
== cpu_to_le16(USB_ENDPOINT_HALT
))
1216 static int handle_ep0_setup(struct usba_udc
*udc
, struct usba_ep
*ep
,
1217 struct usb_ctrlrequest
*crq
)
1221 switch (crq
->bRequest
) {
1222 case USB_REQ_GET_STATUS
: {
1225 if (crq
->bRequestType
== (USB_DIR_IN
| USB_RECIP_DEVICE
)) {
1226 status
= cpu_to_le16(udc
->devstatus
);
1227 } else if (crq
->bRequestType
1228 == (USB_DIR_IN
| USB_RECIP_INTERFACE
)) {
1229 status
= cpu_to_le16(0);
1230 } else if (crq
->bRequestType
1231 == (USB_DIR_IN
| USB_RECIP_ENDPOINT
)) {
1232 struct usba_ep
*target
;
1234 target
= get_ep_by_addr(udc
, le16_to_cpu(crq
->wIndex
));
1239 if (is_stalled(udc
, target
))
1240 status
|= cpu_to_le16(1);
1244 /* Write directly to the FIFO. No queueing is done. */
1245 if (crq
->wLength
!= cpu_to_le16(sizeof(status
)))
1247 ep
->state
= DATA_STAGE_IN
;
1248 __raw_writew(status
, ep
->fifo
);
1249 usba_ep_writel(ep
, SET_STA
, USBA_TX_PK_RDY
);
1253 case USB_REQ_CLEAR_FEATURE
: {
1254 if (crq
->bRequestType
== USB_RECIP_DEVICE
) {
1255 if (feature_is_dev_remote_wakeup(crq
))
1257 &= ~(1 << USB_DEVICE_REMOTE_WAKEUP
);
1259 /* Can't CLEAR_FEATURE TEST_MODE */
1261 } else if (crq
->bRequestType
== USB_RECIP_ENDPOINT
) {
1262 struct usba_ep
*target
;
1264 if (crq
->wLength
!= cpu_to_le16(0)
1265 || !feature_is_ep_halt(crq
))
1267 target
= get_ep_by_addr(udc
, le16_to_cpu(crq
->wIndex
));
1271 usba_ep_writel(target
, CLR_STA
, USBA_FORCE_STALL
);
1272 if (target
->index
!= 0)
1273 usba_ep_writel(target
, CLR_STA
,
1279 send_status(udc
, ep
);
1283 case USB_REQ_SET_FEATURE
: {
1284 if (crq
->bRequestType
== USB_RECIP_DEVICE
) {
1285 if (feature_is_dev_test_mode(crq
)) {
1286 send_status(udc
, ep
);
1287 ep
->state
= STATUS_STAGE_TEST
;
1288 udc
->test_mode
= le16_to_cpu(crq
->wIndex
);
1290 } else if (feature_is_dev_remote_wakeup(crq
)) {
1291 udc
->devstatus
|= 1 << USB_DEVICE_REMOTE_WAKEUP
;
1295 } else if (crq
->bRequestType
== USB_RECIP_ENDPOINT
) {
1296 struct usba_ep
*target
;
1298 if (crq
->wLength
!= cpu_to_le16(0)
1299 || !feature_is_ep_halt(crq
))
1302 target
= get_ep_by_addr(udc
, le16_to_cpu(crq
->wIndex
));
1306 usba_ep_writel(target
, SET_STA
, USBA_FORCE_STALL
);
1310 send_status(udc
, ep
);
1314 case USB_REQ_SET_ADDRESS
:
1315 if (crq
->bRequestType
!= (USB_DIR_OUT
| USB_RECIP_DEVICE
))
1318 set_address(udc
, le16_to_cpu(crq
->wValue
));
1319 send_status(udc
, ep
);
1320 ep
->state
= STATUS_STAGE_ADDR
;
1325 spin_unlock(&udc
->lock
);
1326 retval
= udc
->driver
->setup(&udc
->gadget
, crq
);
1327 spin_lock(&udc
->lock
);
1333 pr_err("udc: %s: Invalid setup request: %02x.%02x v%04x i%04x l%d, "
1334 "halting endpoint...\n",
1335 ep
->ep
.name
, crq
->bRequestType
, crq
->bRequest
,
1336 le16_to_cpu(crq
->wValue
), le16_to_cpu(crq
->wIndex
),
1337 le16_to_cpu(crq
->wLength
));
1338 set_protocol_stall(udc
, ep
);
1342 static void usba_control_irq(struct usba_udc
*udc
, struct usba_ep
*ep
)
1344 struct usba_request
*req
;
1349 epstatus
= usba_ep_readl(ep
, STA
);
1350 epctrl
= usba_ep_readl(ep
, CTL
);
1352 DBG(DBG_INT
, "%s [%d]: s/%08x c/%08x\n",
1353 ep
->ep
.name
, ep
->state
, epstatus
, epctrl
);
1356 if (!list_empty(&ep
->queue
))
1357 req
= list_entry(ep
->queue
.next
,
1358 struct usba_request
, queue
);
1360 if ((epctrl
& USBA_TX_PK_RDY
) && !(epstatus
& USBA_TX_PK_RDY
)) {
1362 next_fifo_transaction(ep
, req
);
1364 submit_request(ep
, req
);
1366 if (req
->last_transaction
) {
1367 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_PK_RDY
);
1368 usba_ep_writel(ep
, CTL_ENB
, USBA_TX_COMPLETE
);
1372 if ((epstatus
& epctrl
) & USBA_TX_COMPLETE
) {
1373 usba_ep_writel(ep
, CLR_STA
, USBA_TX_COMPLETE
);
1375 switch (ep
->state
) {
1377 usba_ep_writel(ep
, CTL_ENB
, USBA_RX_BK_RDY
);
1378 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_COMPLETE
);
1379 ep
->state
= STATUS_STAGE_OUT
;
1381 case STATUS_STAGE_ADDR
:
1382 /* Activate our new address */
1383 usba_writel(udc
, CTRL
, (usba_readl(udc
, CTRL
)
1385 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_COMPLETE
);
1386 ep
->state
= WAIT_FOR_SETUP
;
1388 case STATUS_STAGE_IN
:
1390 list_del_init(&req
->queue
);
1391 request_complete(ep
, req
, 0);
1392 submit_next_request(ep
);
1394 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_COMPLETE
);
1395 ep
->state
= WAIT_FOR_SETUP
;
1397 case STATUS_STAGE_TEST
:
1398 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_COMPLETE
);
1399 ep
->state
= WAIT_FOR_SETUP
;
1400 if (do_test_mode(udc
))
1401 set_protocol_stall(udc
, ep
);
1404 pr_err("udc: %s: TXCOMP: Invalid endpoint state %d, "
1405 "halting endpoint...\n",
1406 ep
->ep
.name
, ep
->state
);
1407 set_protocol_stall(udc
, ep
);
1413 if ((epstatus
& epctrl
) & USBA_RX_BK_RDY
) {
1414 switch (ep
->state
) {
1415 case STATUS_STAGE_OUT
:
1416 usba_ep_writel(ep
, CLR_STA
, USBA_RX_BK_RDY
);
1417 usba_ep_writel(ep
, CTL_DIS
, USBA_RX_BK_RDY
);
1420 list_del_init(&req
->queue
);
1421 request_complete(ep
, req
, 0);
1423 ep
->state
= WAIT_FOR_SETUP
;
1426 case DATA_STAGE_OUT
:
1431 usba_ep_writel(ep
, CLR_STA
, USBA_RX_BK_RDY
);
1432 usba_ep_writel(ep
, CTL_DIS
, USBA_RX_BK_RDY
);
1433 pr_err("udc: %s: RXRDY: Invalid endpoint state %d, "
1434 "halting endpoint...\n",
1435 ep
->ep
.name
, ep
->state
);
1436 set_protocol_stall(udc
, ep
);
1442 if (epstatus
& USBA_RX_SETUP
) {
1444 struct usb_ctrlrequest crq
;
1445 unsigned long data
[2];
1447 unsigned int pkt_len
;
1450 if (ep
->state
!= WAIT_FOR_SETUP
) {
1452 * Didn't expect a SETUP packet at this
1453 * point. Clean up any pending requests (which
1454 * may be successful).
1456 int status
= -EPROTO
;
1459 * RXRDY and TXCOMP are dropped when SETUP
1460 * packets arrive. Just pretend we received
1461 * the status packet.
1463 if (ep
->state
== STATUS_STAGE_OUT
1464 || ep
->state
== STATUS_STAGE_IN
) {
1465 usba_ep_writel(ep
, CTL_DIS
, USBA_RX_BK_RDY
);
1470 list_del_init(&req
->queue
);
1471 request_complete(ep
, req
, status
);
1475 pkt_len
= USBA_BFEXT(BYTE_COUNT
, usba_ep_readl(ep
, STA
));
1476 DBG(DBG_HW
, "Packet length: %u\n", pkt_len
);
1477 if (pkt_len
!= sizeof(crq
)) {
1478 pr_warning("udc: Invalid packet length %u "
1479 "(expected %zu)\n", pkt_len
, sizeof(crq
));
1480 set_protocol_stall(udc
, ep
);
1484 DBG(DBG_FIFO
, "Copying ctrl request from 0x%p:\n", ep
->fifo
);
1485 memcpy_fromio(crq
.data
, ep
->fifo
, sizeof(crq
));
1487 /* Free up one bank in the FIFO so that we can
1488 * generate or receive a reply right away. */
1489 usba_ep_writel(ep
, CLR_STA
, USBA_RX_SETUP
);
1491 /* printk(KERN_DEBUG "setup: %d: %02x.%02x\n",
1492 ep->state, crq.crq.bRequestType,
1493 crq.crq.bRequest); */
1495 if (crq
.crq
.bRequestType
& USB_DIR_IN
) {
1497 * The USB 2.0 spec states that "if wLength is
1498 * zero, there is no data transfer phase."
1499 * However, testusb #14 seems to actually
1500 * expect a data phase even if wLength = 0...
1502 ep
->state
= DATA_STAGE_IN
;
1504 if (crq
.crq
.wLength
!= cpu_to_le16(0))
1505 ep
->state
= DATA_STAGE_OUT
;
1507 ep
->state
= STATUS_STAGE_IN
;
1512 ret
= handle_ep0_setup(udc
, ep
, &crq
.crq
);
1514 spin_unlock(&udc
->lock
);
1515 ret
= udc
->driver
->setup(&udc
->gadget
, &crq
.crq
);
1516 spin_lock(&udc
->lock
);
1519 DBG(DBG_BUS
, "req %02x.%02x, length %d, state %d, ret %d\n",
1520 crq
.crq
.bRequestType
, crq
.crq
.bRequest
,
1521 le16_to_cpu(crq
.crq
.wLength
), ep
->state
, ret
);
1524 /* Let the host know that we failed */
1525 set_protocol_stall(udc
, ep
);
1530 static void usba_ep_irq(struct usba_udc
*udc
, struct usba_ep
*ep
)
1532 struct usba_request
*req
;
1536 epstatus
= usba_ep_readl(ep
, STA
);
1537 epctrl
= usba_ep_readl(ep
, CTL
);
1539 DBG(DBG_INT
, "%s: interrupt, status: 0x%08x\n", ep
->ep
.name
, epstatus
);
1541 while ((epctrl
& USBA_TX_PK_RDY
) && !(epstatus
& USBA_TX_PK_RDY
)) {
1542 DBG(DBG_BUS
, "%s: TX PK ready\n", ep
->ep
.name
);
1544 if (list_empty(&ep
->queue
)) {
1545 dev_warn(&udc
->pdev
->dev
, "ep_irq: queue empty\n");
1546 usba_ep_writel(ep
, CTL_DIS
, USBA_TX_PK_RDY
);
1550 req
= list_entry(ep
->queue
.next
, struct usba_request
, queue
);
1552 if (req
->using_dma
) {
1553 /* Send a zero-length packet */
1554 usba_ep_writel(ep
, SET_STA
,
1556 usba_ep_writel(ep
, CTL_DIS
,
1558 list_del_init(&req
->queue
);
1559 submit_next_request(ep
);
1560 request_complete(ep
, req
, 0);
1563 next_fifo_transaction(ep
, req
);
1565 submit_request(ep
, req
);
1567 if (req
->last_transaction
) {
1568 list_del_init(&req
->queue
);
1569 submit_next_request(ep
);
1570 request_complete(ep
, req
, 0);
1574 epstatus
= usba_ep_readl(ep
, STA
);
1575 epctrl
= usba_ep_readl(ep
, CTL
);
1577 if ((epstatus
& epctrl
) & USBA_RX_BK_RDY
) {
1578 DBG(DBG_BUS
, "%s: RX data ready\n", ep
->ep
.name
);
1580 usba_ep_writel(ep
, CLR_STA
, USBA_RX_BK_RDY
);
1584 static void usba_dma_irq(struct usba_udc
*udc
, struct usba_ep
*ep
)
1586 struct usba_request
*req
;
1587 u32 status
, control
, pending
;
1589 status
= usba_dma_readl(ep
, STATUS
);
1590 control
= usba_dma_readl(ep
, CONTROL
);
1591 #ifdef CONFIG_USB_GADGET_DEBUG_FS
1592 ep
->last_dma_status
= status
;
1594 pending
= status
& control
;
1595 DBG(DBG_INT
| DBG_DMA
, "dma irq, s/%#08x, c/%#08x\n", status
, control
);
1597 if (status
& USBA_DMA_CH_EN
) {
1598 dev_err(&udc
->pdev
->dev
,
1599 "DMA_CH_EN is set after transfer is finished!\n");
1600 dev_err(&udc
->pdev
->dev
,
1601 "status=%#08x, pending=%#08x, control=%#08x\n",
1602 status
, pending
, control
);
1605 * try to pretend nothing happened. We might have to
1606 * do something here...
1610 if (list_empty(&ep
->queue
))
1611 /* Might happen if a reset comes along at the right moment */
1614 if (pending
& (USBA_DMA_END_TR_ST
| USBA_DMA_END_BUF_ST
)) {
1615 req
= list_entry(ep
->queue
.next
, struct usba_request
, queue
);
1616 usba_update_req(ep
, req
, status
);
1618 list_del_init(&req
->queue
);
1619 submit_next_request(ep
);
1620 request_complete(ep
, req
, 0);
1624 static irqreturn_t
usba_udc_irq(int irq
, void *devid
)
1626 struct usba_udc
*udc
= devid
;
1631 spin_lock(&udc
->lock
);
1633 status
= usba_readl(udc
, INT_STA
);
1634 DBG(DBG_INT
, "irq, status=%#08x\n", status
);
1636 if (status
& USBA_DET_SUSPEND
) {
1638 usba_writel(udc
, INT_CLR
, USBA_DET_SUSPEND
);
1639 DBG(DBG_BUS
, "Suspend detected\n");
1640 if (udc
->gadget
.speed
!= USB_SPEED_UNKNOWN
1641 && udc
->driver
&& udc
->driver
->suspend
) {
1642 spin_unlock(&udc
->lock
);
1643 udc
->driver
->suspend(&udc
->gadget
);
1644 spin_lock(&udc
->lock
);
1648 if (status
& USBA_WAKE_UP
) {
1650 usba_writel(udc
, INT_CLR
, USBA_WAKE_UP
);
1651 DBG(DBG_BUS
, "Wake Up CPU detected\n");
1654 if (status
& USBA_END_OF_RESUME
) {
1655 usba_writel(udc
, INT_CLR
, USBA_END_OF_RESUME
);
1656 DBG(DBG_BUS
, "Resume detected\n");
1657 if (udc
->gadget
.speed
!= USB_SPEED_UNKNOWN
1658 && udc
->driver
&& udc
->driver
->resume
) {
1659 spin_unlock(&udc
->lock
);
1660 udc
->driver
->resume(&udc
->gadget
);
1661 spin_lock(&udc
->lock
);
1665 dma_status
= USBA_BFEXT(DMA_INT
, status
);
1669 for (i
= 1; i
< USBA_NR_ENDPOINTS
; i
++)
1670 if (dma_status
& (1 << i
))
1671 usba_dma_irq(udc
, &usba_ep
[i
]);
1674 ep_status
= USBA_BFEXT(EPT_INT
, status
);
1678 for (i
= 0; i
< USBA_NR_ENDPOINTS
; i
++)
1679 if (ep_status
& (1 << i
)) {
1680 if (ep_is_control(&usba_ep
[i
]))
1681 usba_control_irq(udc
, &usba_ep
[i
]);
1683 usba_ep_irq(udc
, &usba_ep
[i
]);
1687 if (status
& USBA_END_OF_RESET
) {
1688 struct usba_ep
*ep0
;
1690 usba_writel(udc
, INT_CLR
, USBA_END_OF_RESET
);
1691 reset_all_endpoints(udc
);
1693 if (udc
->gadget
.speed
!= USB_SPEED_UNKNOWN
1694 && udc
->driver
->disconnect
) {
1695 udc
->gadget
.speed
= USB_SPEED_UNKNOWN
;
1696 spin_unlock(&udc
->lock
);
1697 udc
->driver
->disconnect(&udc
->gadget
);
1698 spin_lock(&udc
->lock
);
1701 if (status
& USBA_HIGH_SPEED
)
1702 udc
->gadget
.speed
= USB_SPEED_HIGH
;
1704 udc
->gadget
.speed
= USB_SPEED_FULL
;
1705 DBG(DBG_BUS
, "%s bus reset detected\n",
1706 usb_speed_string(udc
->gadget
.speed
));
1709 ep0
->ep
.desc
= &usba_ep0_desc
;
1710 ep0
->state
= WAIT_FOR_SETUP
;
1711 usba_ep_writel(ep0
, CFG
,
1712 (USBA_BF(EPT_SIZE
, EP0_EPT_SIZE
)
1713 | USBA_BF(EPT_TYPE
, USBA_EPT_TYPE_CONTROL
)
1714 | USBA_BF(BK_NUMBER
, USBA_BK_NUMBER_ONE
)));
1715 usba_ep_writel(ep0
, CTL_ENB
,
1716 USBA_EPT_ENABLE
| USBA_RX_SETUP
);
1717 usba_writel(udc
, INT_ENB
,
1718 (usba_readl(udc
, INT_ENB
)
1719 | USBA_BF(EPT_INT
, 1)
1721 | USBA_END_OF_RESUME
));
1724 * Unclear why we hit this irregularly, e.g. in usbtest,
1725 * but it's clearly harmless...
1727 if (!(usba_ep_readl(ep0
, CFG
) & USBA_EPT_MAPPED
))
1728 dev_dbg(&udc
->pdev
->dev
,
1729 "ODD: EP0 configuration is invalid!\n");
1732 spin_unlock(&udc
->lock
);
1737 static irqreturn_t
usba_vbus_irq(int irq
, void *devid
)
1739 struct usba_udc
*udc
= devid
;
1745 spin_lock(&udc
->lock
);
1747 /* May happen if Vbus pin toggles during probe() */
1751 vbus
= vbus_is_present(udc
);
1752 if (vbus
!= udc
->vbus_prev
) {
1755 usba_writel(udc
, CTRL
, USBA_ENABLE_MASK
);
1756 usba_writel(udc
, INT_ENB
, USBA_END_OF_RESET
);
1758 udc
->gadget
.speed
= USB_SPEED_UNKNOWN
;
1759 reset_all_endpoints(udc
);
1761 usba_writel(udc
, CTRL
, USBA_DISABLE_MASK
);
1762 if (udc
->driver
->disconnect
) {
1763 spin_unlock(&udc
->lock
);
1764 udc
->driver
->disconnect(&udc
->gadget
);
1765 spin_lock(&udc
->lock
);
1768 udc
->vbus_prev
= vbus
;
1772 spin_unlock(&udc
->lock
);
1777 static int atmel_usba_start(struct usb_gadget
*gadget
,
1778 struct usb_gadget_driver
*driver
)
1780 struct usba_udc
*udc
= container_of(gadget
, struct usba_udc
, gadget
);
1781 unsigned long flags
;
1783 spin_lock_irqsave(&udc
->lock
, flags
);
1785 udc
->devstatus
= 1 << USB_DEVICE_SELF_POWERED
;
1786 udc
->driver
= driver
;
1787 spin_unlock_irqrestore(&udc
->lock
, flags
);
1789 clk_enable(udc
->pclk
);
1790 clk_enable(udc
->hclk
);
1792 DBG(DBG_GADGET
, "registered driver `%s'\n", driver
->driver
.name
);
1795 if (gpio_is_valid(udc
->vbus_pin
))
1796 enable_irq(gpio_to_irq(udc
->vbus_pin
));
1798 /* If Vbus is present, enable the controller and wait for reset */
1799 spin_lock_irqsave(&udc
->lock
, flags
);
1800 if (vbus_is_present(udc
) && udc
->vbus_prev
== 0) {
1802 usba_writel(udc
, CTRL
, USBA_ENABLE_MASK
);
1803 usba_writel(udc
, INT_ENB
, USBA_END_OF_RESET
);
1805 spin_unlock_irqrestore(&udc
->lock
, flags
);
1810 static int atmel_usba_stop(struct usb_gadget
*gadget
,
1811 struct usb_gadget_driver
*driver
)
1813 struct usba_udc
*udc
= container_of(gadget
, struct usba_udc
, gadget
);
1814 unsigned long flags
;
1816 if (gpio_is_valid(udc
->vbus_pin
))
1817 disable_irq(gpio_to_irq(udc
->vbus_pin
));
1819 spin_lock_irqsave(&udc
->lock
, flags
);
1820 udc
->gadget
.speed
= USB_SPEED_UNKNOWN
;
1821 reset_all_endpoints(udc
);
1822 spin_unlock_irqrestore(&udc
->lock
, flags
);
1824 /* This will also disable the DP pullup */
1826 usba_writel(udc
, CTRL
, USBA_DISABLE_MASK
);
1830 clk_disable(udc
->hclk
);
1831 clk_disable(udc
->pclk
);
1833 DBG(DBG_GADGET
, "unregistered driver `%s'\n", driver
->driver
.name
);
1838 static int __init
usba_udc_probe(struct platform_device
*pdev
)
1840 struct usba_platform_data
*pdata
= pdev
->dev
.platform_data
;
1841 struct resource
*regs
, *fifo
;
1842 struct clk
*pclk
, *hclk
;
1843 struct usba_udc
*udc
= &the_udc
;
1846 regs
= platform_get_resource(pdev
, IORESOURCE_MEM
, CTRL_IOMEM_ID
);
1847 fifo
= platform_get_resource(pdev
, IORESOURCE_MEM
, FIFO_IOMEM_ID
);
1848 if (!regs
|| !fifo
|| !pdata
)
1851 irq
= platform_get_irq(pdev
, 0);
1855 pclk
= clk_get(&pdev
->dev
, "pclk");
1857 return PTR_ERR(pclk
);
1858 hclk
= clk_get(&pdev
->dev
, "hclk");
1860 ret
= PTR_ERR(hclk
);
1864 spin_lock_init(&udc
->lock
);
1868 udc
->vbus_pin
= -ENODEV
;
1871 udc
->regs
= ioremap(regs
->start
, resource_size(regs
));
1873 dev_err(&pdev
->dev
, "Unable to map I/O memory, aborting.\n");
1876 dev_info(&pdev
->dev
, "MMIO registers at 0x%08lx mapped at %p\n",
1877 (unsigned long)regs
->start
, udc
->regs
);
1878 udc
->fifo
= ioremap(fifo
->start
, resource_size(fifo
));
1880 dev_err(&pdev
->dev
, "Unable to map FIFO, aborting.\n");
1883 dev_info(&pdev
->dev
, "FIFO at 0x%08lx mapped at %p\n",
1884 (unsigned long)fifo
->start
, udc
->fifo
);
1886 platform_set_drvdata(pdev
, udc
);
1888 /* Make sure we start from a clean slate */
1891 usba_writel(udc
, CTRL
, USBA_DISABLE_MASK
);
1894 usba_ep
= kzalloc(sizeof(struct usba_ep
) * pdata
->num_ep
,
1899 the_udc
.gadget
.ep0
= &usba_ep
[0].ep
;
1901 INIT_LIST_HEAD(&usba_ep
[0].ep
.ep_list
);
1902 usba_ep
[0].ep_regs
= udc
->regs
+ USBA_EPT_BASE(0);
1903 usba_ep
[0].dma_regs
= udc
->regs
+ USBA_DMA_BASE(0);
1904 usba_ep
[0].fifo
= udc
->fifo
+ USBA_FIFO_BASE(0);
1905 usba_ep
[0].ep
.ops
= &usba_ep_ops
;
1906 usba_ep
[0].ep
.name
= pdata
->ep
[0].name
;
1907 usba_ep
[0].ep
.maxpacket
= pdata
->ep
[0].fifo_size
;
1908 usba_ep
[0].udc
= &the_udc
;
1909 INIT_LIST_HEAD(&usba_ep
[0].queue
);
1910 usba_ep
[0].fifo_size
= pdata
->ep
[0].fifo_size
;
1911 usba_ep
[0].nr_banks
= pdata
->ep
[0].nr_banks
;
1912 usba_ep
[0].index
= pdata
->ep
[0].index
;
1913 usba_ep
[0].can_dma
= pdata
->ep
[0].can_dma
;
1914 usba_ep
[0].can_isoc
= pdata
->ep
[0].can_isoc
;
1916 for (i
= 1; i
< pdata
->num_ep
; i
++) {
1917 struct usba_ep
*ep
= &usba_ep
[i
];
1919 ep
->ep_regs
= udc
->regs
+ USBA_EPT_BASE(i
);
1920 ep
->dma_regs
= udc
->regs
+ USBA_DMA_BASE(i
);
1921 ep
->fifo
= udc
->fifo
+ USBA_FIFO_BASE(i
);
1922 ep
->ep
.ops
= &usba_ep_ops
;
1923 ep
->ep
.name
= pdata
->ep
[i
].name
;
1924 ep
->ep
.maxpacket
= pdata
->ep
[i
].fifo_size
;
1926 INIT_LIST_HEAD(&ep
->queue
);
1927 ep
->fifo_size
= pdata
->ep
[i
].fifo_size
;
1928 ep
->nr_banks
= pdata
->ep
[i
].nr_banks
;
1929 ep
->index
= pdata
->ep
[i
].index
;
1930 ep
->can_dma
= pdata
->ep
[i
].can_dma
;
1931 ep
->can_isoc
= pdata
->ep
[i
].can_isoc
;
1933 list_add_tail(&ep
->ep
.ep_list
, &udc
->gadget
.ep_list
);
1936 ret
= request_irq(irq
, usba_udc_irq
, 0, "atmel_usba_udc", udc
);
1938 dev_err(&pdev
->dev
, "Cannot request irq %d (error %d)\n",
1940 goto err_request_irq
;
1944 if (gpio_is_valid(pdata
->vbus_pin
)) {
1945 if (!gpio_request(pdata
->vbus_pin
, "atmel_usba_udc")) {
1946 udc
->vbus_pin
= pdata
->vbus_pin
;
1947 udc
->vbus_pin_inverted
= pdata
->vbus_pin_inverted
;
1949 ret
= request_irq(gpio_to_irq(udc
->vbus_pin
),
1951 "atmel_usba_udc", udc
);
1953 gpio_free(udc
->vbus_pin
);
1954 udc
->vbus_pin
= -ENODEV
;
1955 dev_warn(&udc
->pdev
->dev
,
1956 "failed to request vbus irq; "
1957 "assuming always on\n");
1959 disable_irq(gpio_to_irq(udc
->vbus_pin
));
1962 /* gpio_request fail so use -EINVAL for gpio_is_valid */
1963 udc
->vbus_pin
= -EINVAL
;
1967 ret
= usb_add_gadget_udc(&pdev
->dev
, &udc
->gadget
);
1971 usba_init_debugfs(udc
);
1972 for (i
= 1; i
< pdata
->num_ep
; i
++)
1973 usba_ep_init_debugfs(udc
, &usba_ep
[i
]);
1978 if (gpio_is_valid(pdata
->vbus_pin
)) {
1979 free_irq(gpio_to_irq(udc
->vbus_pin
), udc
);
1980 gpio_free(udc
->vbus_pin
);
1995 platform_set_drvdata(pdev
, NULL
);
2000 static int __exit
usba_udc_remove(struct platform_device
*pdev
)
2002 struct usba_udc
*udc
;
2004 struct usba_platform_data
*pdata
= pdev
->dev
.platform_data
;
2006 udc
= platform_get_drvdata(pdev
);
2008 usb_del_gadget_udc(&udc
->gadget
);
2010 for (i
= 1; i
< pdata
->num_ep
; i
++)
2011 usba_ep_cleanup_debugfs(&usba_ep
[i
]);
2012 usba_cleanup_debugfs(udc
);
2014 if (gpio_is_valid(udc
->vbus_pin
)) {
2015 free_irq(gpio_to_irq(udc
->vbus_pin
), udc
);
2016 gpio_free(udc
->vbus_pin
);
2019 free_irq(udc
->irq
, udc
);
2029 static struct platform_driver udc_driver
= {
2030 .remove
= __exit_p(usba_udc_remove
),
2032 .name
= "atmel_usba_udc",
2033 .owner
= THIS_MODULE
,
2037 module_platform_driver_probe(udc_driver
, usba_udc_probe
);
2039 MODULE_DESCRIPTION("Atmel USBA UDC driver");
2040 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
2041 MODULE_LICENSE("GPL");
2042 MODULE_ALIAS("platform:atmel_usba_udc");