2 * linux/drivers/usb/gadget/lh7a40x_udc.c
3 * Sharp LH7A40x on-chip full speed USB device controllers
5 * Copyright (C) 2004 Mikko Lahteenmaki, Nordic ID
6 * Copyright (C) 2004 Bo Henriksen, Nordic ID
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/platform_device.h>
26 #include "lh7a40x_udc.h"
28 //#define DEBUG printk
29 //#define DEBUG_EP0 printk
30 //#define DEBUG_SETUP printk
33 # define DEBUG_EP0(fmt,args...)
36 # define DEBUG_SETUP(fmt,args...)
40 # define DEBUG(fmt,args...)
43 #define DRIVER_DESC "LH7A40x USB Device Controller"
44 #define DRIVER_VERSION __DATE__
46 #ifndef _BIT /* FIXME - what happended to _BIT in 2.6.7bk18? */
47 #define _BIT(x) (1<<(x))
50 struct lh7a40x_udc
*the_controller
;
52 static const char driver_name
[] = "lh7a40x_udc";
53 static const char driver_desc
[] = DRIVER_DESC
;
54 static const char ep0name
[] = "ep0-control";
61 static char *state_names
[] = {
64 "DATA_STATE_NEED_ZLP",
65 "WAIT_FOR_OUT_STATUS",
73 static int lh7a40x_ep_enable(struct usb_ep
*ep
,
74 const struct usb_endpoint_descriptor
*);
75 static int lh7a40x_ep_disable(struct usb_ep
*ep
);
76 static struct usb_request
*lh7a40x_alloc_request(struct usb_ep
*ep
, gfp_t
);
77 static void lh7a40x_free_request(struct usb_ep
*ep
, struct usb_request
*);
78 static void *lh7a40x_alloc_buffer(struct usb_ep
*ep
, unsigned, dma_addr_t
*,
80 static void lh7a40x_free_buffer(struct usb_ep
*ep
, void *, dma_addr_t
,
82 static int lh7a40x_queue(struct usb_ep
*ep
, struct usb_request
*, gfp_t
);
83 static int lh7a40x_dequeue(struct usb_ep
*ep
, struct usb_request
*);
84 static int lh7a40x_set_halt(struct usb_ep
*ep
, int);
85 static int lh7a40x_fifo_status(struct usb_ep
*ep
);
86 static void lh7a40x_fifo_flush(struct usb_ep
*ep
);
87 static void lh7a40x_ep0_kick(struct lh7a40x_udc
*dev
, struct lh7a40x_ep
*ep
);
88 static void lh7a40x_handle_ep0(struct lh7a40x_udc
*dev
, u32 intr
);
90 static void done(struct lh7a40x_ep
*ep
, struct lh7a40x_request
*req
,
92 static void pio_irq_enable(int bEndpointAddress
);
93 static void pio_irq_disable(int bEndpointAddress
);
94 static void stop_activity(struct lh7a40x_udc
*dev
,
95 struct usb_gadget_driver
*driver
);
96 static void flush(struct lh7a40x_ep
*ep
);
97 static void udc_enable(struct lh7a40x_udc
*dev
);
98 static void udc_set_address(struct lh7a40x_udc
*dev
, unsigned char address
);
100 static struct usb_ep_ops lh7a40x_ep_ops
= {
101 .enable
= lh7a40x_ep_enable
,
102 .disable
= lh7a40x_ep_disable
,
104 .alloc_request
= lh7a40x_alloc_request
,
105 .free_request
= lh7a40x_free_request
,
107 .alloc_buffer
= lh7a40x_alloc_buffer
,
108 .free_buffer
= lh7a40x_free_buffer
,
110 .queue
= lh7a40x_queue
,
111 .dequeue
= lh7a40x_dequeue
,
113 .set_halt
= lh7a40x_set_halt
,
114 .fifo_status
= lh7a40x_fifo_status
,
115 .fifo_flush
= lh7a40x_fifo_flush
,
120 static __inline__
int write_packet(struct lh7a40x_ep
*ep
,
121 struct lh7a40x_request
*req
, int max
)
125 volatile u32
*fifo
= (volatile u32
*)ep
->fifo
;
127 buf
= req
->req
.buf
+ req
->req
.actual
;
130 length
= req
->req
.length
- req
->req
.actual
;
131 length
= min(length
, max
);
132 req
->req
.actual
+= length
;
134 DEBUG("Write %d (max %d), fifo %p\n", length
, max
, fifo
);
144 static __inline__
void usb_set_index(u32 ep
)
146 *(volatile u32
*)io_p2v(USB_INDEX
) = ep
;
149 static __inline__ u32
usb_read(u32 port
)
151 return *(volatile u32
*)io_p2v(port
);
154 static __inline__
void usb_write(u32 val
, u32 port
)
156 *(volatile u32
*)io_p2v(port
) = val
;
159 static __inline__
void usb_set(u32 val
, u32 port
)
161 volatile u32
*ioport
= (volatile u32
*)io_p2v(port
);
162 u32 after
= (*ioport
) | val
;
166 static __inline__
void usb_clear(u32 val
, u32 port
)
168 volatile u32
*ioport
= (volatile u32
*)io_p2v(port
);
169 u32 after
= (*ioport
) & ~val
;
173 /*-------------------------------------------------------------------------*/
175 #define GPIO_PORTC_DR (0x80000E08)
176 #define GPIO_PORTC_DDR (0x80000E18)
177 #define GPIO_PORTC_PDR (0x80000E70)
179 /* get port C pin data register */
180 #define get_portc_pdr(bit) ((usb_read(GPIO_PORTC_PDR) & _BIT(bit)) != 0)
181 /* get port C data direction register */
182 #define get_portc_ddr(bit) ((usb_read(GPIO_PORTC_DDR) & _BIT(bit)) != 0)
183 /* set port C data register */
184 #define set_portc_dr(bit, val) (val ? usb_set(_BIT(bit), GPIO_PORTC_DR) : usb_clear(_BIT(bit), GPIO_PORTC_DR))
185 /* set port C data direction register */
186 #define set_portc_ddr(bit, val) (val ? usb_set(_BIT(bit), GPIO_PORTC_DDR) : usb_clear(_BIT(bit), GPIO_PORTC_DDR))
190 * Port C bit 1 = USB Port 1 Power Enable
191 * Port C bit 2 = USB Port 1 Data Carrier Detect
193 #define is_usb_connected() get_portc_pdr(2)
195 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
197 static const char proc_node_name
[] = "driver/udc";
200 udc_proc_read(char *page
, char **start
, off_t off
, int count
,
201 int *eof
, void *_dev
)
204 struct lh7a40x_udc
*dev
= _dev
;
206 unsigned size
= count
;
213 local_irq_save(flags
);
215 /* basic device status */
216 t
= scnprintf(next
, size
,
219 "Gadget driver: %s\n"
221 driver_name
, DRIVER_VERSION
,
222 dev
->driver
? dev
->driver
->driver
.name
: "(none)",
223 is_usb_connected()? "full speed" : "disconnected");
227 t
= scnprintf(next
, size
,
229 " Port C bit 1: %d, dir %d\n"
230 " Port C bit 2: %d, dir %d\n\n",
231 get_portc_pdr(1), get_portc_ddr(1),
232 get_portc_pdr(2), get_portc_ddr(2)
237 t
= scnprintf(next
, size
,
238 "DCP pullup: %d\n\n",
239 (usb_read(USB_PM
) & PM_USB_DCP
) != 0);
243 local_irq_restore(flags
);
248 #define create_proc_files() create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev)
249 #define remove_proc_files() remove_proc_entry(proc_node_name, NULL)
251 #else /* !CONFIG_USB_GADGET_DEBUG_FILES */
253 #define create_proc_files() do {} while (0)
254 #define remove_proc_files() do {} while (0)
256 #endif /* CONFIG_USB_GADGET_DEBUG_FILES */
259 * udc_disable - disable USB device controller
261 static void udc_disable(struct lh7a40x_udc
*dev
)
263 DEBUG("%s, %p\n", __FUNCTION__
, dev
);
265 udc_set_address(dev
, 0);
267 /* Disable interrupts */
268 usb_write(0, USB_IN_INT_EN
);
269 usb_write(0, USB_OUT_INT_EN
);
270 usb_write(0, USB_INT_EN
);
272 /* Disable the USB */
273 usb_write(0, USB_PM
);
275 #ifdef CONFIG_ARCH_LH7A404
276 /* Disable USB power */
280 /* if hardware supports it, disconnect from usb */
281 /* make_usb_disappear(); */
283 dev
->ep0state
= WAIT_FOR_SETUP
;
284 dev
->gadget
.speed
= USB_SPEED_UNKNOWN
;
285 dev
->usb_address
= 0;
289 * udc_reinit - initialize software state
291 static void udc_reinit(struct lh7a40x_udc
*dev
)
295 DEBUG("%s, %p\n", __FUNCTION__
, dev
);
297 /* device/ep0 records init */
298 INIT_LIST_HEAD(&dev
->gadget
.ep_list
);
299 INIT_LIST_HEAD(&dev
->gadget
.ep0
->ep_list
);
300 dev
->ep0state
= WAIT_FOR_SETUP
;
302 /* basic endpoint records init */
303 for (i
= 0; i
< UDC_MAX_ENDPOINTS
; i
++) {
304 struct lh7a40x_ep
*ep
= &dev
->ep
[i
];
307 list_add_tail(&ep
->ep
.ep_list
, &dev
->gadget
.ep_list
);
311 INIT_LIST_HEAD(&ep
->queue
);
315 /* the rest was statically initialized, and is read-only */
318 #define BYTES2MAXP(x) (x / 8)
319 #define MAXP2BYTES(x) (x * 8)
321 /* until it's enabled, this UDC should be completely invisible
324 static void udc_enable(struct lh7a40x_udc
*dev
)
328 DEBUG("%s, %p\n", __FUNCTION__
, dev
);
330 dev
->gadget
.speed
= USB_SPEED_UNKNOWN
;
332 #ifdef CONFIG_ARCH_LH7A404
333 /* Set Port C bit 1 & 2 as output */
337 /* Enable USB power */
342 * C.f Chapter 18.1.3.1 Initializing the USB
345 /* Disable the USB */
346 usb_clear(PM_USB_ENABLE
, USB_PM
);
348 /* Reset APB & I/O sides of the USB */
349 usb_set(USB_RESET_APB
| USB_RESET_IO
, USB_RESET
);
351 usb_clear(USB_RESET_APB
| USB_RESET_IO
, USB_RESET
);
353 /* Set MAXP values for each */
354 for (ep
= 0; ep
< UDC_MAX_ENDPOINTS
; ep
++) {
355 struct lh7a40x_ep
*ep_reg
= &dev
->ep
[ep
];
360 switch (ep_reg
->ep_type
) {
363 usb_clear(USB_IN_CSR2_USB_DMA_EN
| USB_IN_CSR2_AUTO_SET
,
367 usb_write(BYTES2MAXP(ep_maxpacket(ep_reg
)),
371 usb_clear(USB_OUT_CSR2_USB_DMA_EN
|
372 USB_OUT_CSR2_AUTO_CLR
, ep_reg
->csr2
);
373 usb_write(BYTES2MAXP(ep_maxpacket(ep_reg
)),
378 /* Read & Write CSR1, just in case */
379 csr
= usb_read(ep_reg
->csr1
);
380 usb_write(csr
, ep_reg
->csr1
);
385 /* Disable interrupts */
386 usb_write(0, USB_IN_INT_EN
);
387 usb_write(0, USB_OUT_INT_EN
);
388 usb_write(0, USB_INT_EN
);
390 /* Enable interrupts */
391 usb_set(USB_IN_INT_EP0
, USB_IN_INT_EN
);
392 usb_set(USB_INT_RESET_INT
| USB_INT_RESUME_INT
, USB_INT_EN
);
393 /* Dont enable rest of the interrupts */
394 /* usb_set(USB_IN_INT_EP3 | USB_IN_INT_EP1 | USB_IN_INT_EP0, USB_IN_INT_EN);
395 usb_set(USB_OUT_INT_EP2, USB_OUT_INT_EN); */
398 usb_set(PM_ENABLE_SUSPEND
, USB_PM
);
401 usb_set(PM_USB_ENABLE
, USB_PM
);
403 #ifdef CONFIG_ARCH_LH7A404
404 /* NOTE: DOES NOT WORK! */
405 /* Let host detect UDC:
406 * Software must write a 0 to the PMR:DCP_CTRL bit to turn this
407 * transistor on and pull the USBDP pin HIGH.
409 /* usb_clear(PM_USB_DCP, USB_PM);
410 usb_set(PM_USB_DCP, USB_PM); */
415 Register entry point for the peripheral controller driver.
417 int usb_gadget_register_driver(struct usb_gadget_driver
*driver
)
419 struct lh7a40x_udc
*dev
= the_controller
;
422 DEBUG("%s: %s\n", __FUNCTION__
, driver
->driver
.name
);
425 || driver
->speed
!= USB_SPEED_FULL
427 || !driver
->unbind
|| !driver
->disconnect
|| !driver
->setup
)
434 /* first hook up the driver ... */
435 dev
->driver
= driver
;
436 dev
->gadget
.dev
.driver
= &driver
->driver
;
438 device_add(&dev
->gadget
.dev
);
439 retval
= driver
->bind(&dev
->gadget
);
441 printk("%s: bind to driver %s --> error %d\n", dev
->gadget
.name
,
442 driver
->driver
.name
, retval
);
443 device_del(&dev
->gadget
.dev
);
446 dev
->gadget
.dev
.driver
= 0;
450 /* ... then enable host detection and ep0; and we're ready
451 * for set_configuration as well as eventual disconnect.
452 * NOTE: this shouldn't power up until later.
454 printk("%s: registered gadget driver '%s'\n", dev
->gadget
.name
,
455 driver
->driver
.name
);
462 EXPORT_SYMBOL(usb_gadget_register_driver
);
465 Unregister entry point for the peripheral controller driver.
467 int usb_gadget_unregister_driver(struct usb_gadget_driver
*driver
)
469 struct lh7a40x_udc
*dev
= the_controller
;
474 if (!driver
|| driver
!= dev
->driver
)
477 spin_lock_irqsave(&dev
->lock
, flags
);
479 stop_activity(dev
, driver
);
480 spin_unlock_irqrestore(&dev
->lock
, flags
);
482 driver
->unbind(&dev
->gadget
);
483 device_del(&dev
->gadget
.dev
);
487 DEBUG("unregistered gadget driver '%s'\n", driver
->driver
.name
);
491 EXPORT_SYMBOL(usb_gadget_unregister_driver
);
493 /*-------------------------------------------------------------------------*/
495 /** Write request to FIFO (max write == maxp size)
496 * Return: 0 = still running, 1 = completed, negative = errno
497 * NOTE: INDEX register must be set for EP
499 static int write_fifo(struct lh7a40x_ep
*ep
, struct lh7a40x_request
*req
)
504 max
= le16_to_cpu(ep
->desc
->wMaxPacketSize
);
506 csr
= usb_read(ep
->csr1
);
507 DEBUG("CSR: %x %d\n", csr
, csr
& USB_IN_CSR1_FIFO_NOT_EMPTY
);
509 if (!(csr
& USB_IN_CSR1_FIFO_NOT_EMPTY
)) {
511 int is_last
, is_short
;
513 count
= write_packet(ep
, req
, max
);
514 usb_set(USB_IN_CSR1_IN_PKT_RDY
, ep
->csr1
);
516 /* last packet is usually short (or a zlp) */
517 if (unlikely(count
!= max
))
518 is_last
= is_short
= 1;
520 if (likely(req
->req
.length
!= req
->req
.actual
)
525 /* interrupt/iso maxpacket may not fill the fifo */
526 is_short
= unlikely(max
< ep_maxpacket(ep
));
529 DEBUG("%s: wrote %s %d bytes%s%s %d left %p\n", __FUNCTION__
,
531 is_last
? "/L" : "", is_short
? "/S" : "",
532 req
->req
.length
- req
->req
.actual
, req
);
534 /* requests complete when all IN data is in the FIFO */
537 if (list_empty(&ep
->queue
)) {
538 pio_irq_disable(ep_index(ep
));
543 DEBUG("Hmm.. %d ep FIFO is not empty!\n", ep_index(ep
));
549 /** Read to request from FIFO (max read == bytes in fifo)
550 * Return: 0 = still running, 1 = completed, negative = errno
551 * NOTE: INDEX register must be set for EP
553 static int read_fifo(struct lh7a40x_ep
*ep
, struct lh7a40x_request
*req
)
557 unsigned bufferspace
, count
, is_short
;
558 volatile u32
*fifo
= (volatile u32
*)ep
->fifo
;
560 /* make sure there's a packet in the FIFO. */
561 csr
= usb_read(ep
->csr1
);
562 if (!(csr
& USB_OUT_CSR1_OUT_PKT_RDY
)) {
563 DEBUG("%s: Packet NOT ready!\n", __FUNCTION__
);
567 buf
= req
->req
.buf
+ req
->req
.actual
;
569 bufferspace
= req
->req
.length
- req
->req
.actual
;
571 /* read all bytes from this packet */
572 count
= usb_read(USB_OUT_FIFO_WC1
);
573 req
->req
.actual
+= min(count
, bufferspace
);
575 is_short
= (count
< ep
->ep
.maxpacket
);
576 DEBUG("read %s %02x, %d bytes%s req %p %d/%d\n",
577 ep
->ep
.name
, csr
, count
,
578 is_short
? "/S" : "", req
, req
->req
.actual
, req
->req
.length
);
580 while (likely(count
-- != 0)) {
581 u8 byte
= (u8
) (*fifo
& 0xff);
583 if (unlikely(bufferspace
== 0)) {
584 /* this happens when the driver's buffer
585 * is smaller than what the host sent.
586 * discard the extra data.
588 if (req
->req
.status
!= -EOVERFLOW
)
589 printk("%s overflow %d\n", ep
->ep
.name
, count
);
590 req
->req
.status
= -EOVERFLOW
;
597 usb_clear(USB_OUT_CSR1_OUT_PKT_RDY
, ep
->csr1
);
600 if (is_short
|| req
->req
.actual
== req
->req
.length
) {
602 usb_set(USB_OUT_CSR1_FIFO_FLUSH
, ep
->csr1
);
604 if (list_empty(&ep
->queue
))
605 pio_irq_disable(ep_index(ep
));
609 /* finished that packet. the next one may be waiting... */
614 * done - retire a request; caller blocked irqs
615 * INDEX register is preserved to keep same
617 static void done(struct lh7a40x_ep
*ep
, struct lh7a40x_request
*req
, int status
)
619 unsigned int stopped
= ep
->stopped
;
622 DEBUG("%s, %p\n", __FUNCTION__
, ep
);
623 list_del_init(&req
->queue
);
625 if (likely(req
->req
.status
== -EINPROGRESS
))
626 req
->req
.status
= status
;
628 status
= req
->req
.status
;
630 if (status
&& status
!= -ESHUTDOWN
)
631 DEBUG("complete %s req %p stat %d len %u/%u\n",
632 ep
->ep
.name
, &req
->req
, status
,
633 req
->req
.actual
, req
->req
.length
);
635 /* don't modify queue heads during completion callback */
637 /* Read current index (completion may modify it) */
638 index
= usb_read(USB_INDEX
);
640 spin_unlock(&ep
->dev
->lock
);
641 req
->req
.complete(&ep
->ep
, &req
->req
);
642 spin_lock(&ep
->dev
->lock
);
645 usb_set_index(index
);
646 ep
->stopped
= stopped
;
649 /** Enable EP interrupt */
650 static void pio_irq_enable(int ep
)
652 DEBUG("%s: %d\n", __FUNCTION__
, ep
);
656 usb_set(USB_IN_INT_EP1
, USB_IN_INT_EN
);
659 usb_set(USB_OUT_INT_EP2
, USB_OUT_INT_EN
);
662 usb_set(USB_IN_INT_EP3
, USB_IN_INT_EN
);
665 DEBUG("Unknown endpoint: %d\n", ep
);
670 /** Disable EP interrupt */
671 static void pio_irq_disable(int ep
)
673 DEBUG("%s: %d\n", __FUNCTION__
, ep
);
677 usb_clear(USB_IN_INT_EP1
, USB_IN_INT_EN
);
680 usb_clear(USB_OUT_INT_EP2
, USB_OUT_INT_EN
);
683 usb_clear(USB_IN_INT_EP3
, USB_IN_INT_EN
);
686 DEBUG("Unknown endpoint: %d\n", ep
);
692 * nuke - dequeue ALL requests
694 void nuke(struct lh7a40x_ep
*ep
, int status
)
696 struct lh7a40x_request
*req
;
698 DEBUG("%s, %p\n", __FUNCTION__
, ep
);
703 /* called with irqs blocked */
704 while (!list_empty(&ep
->queue
)) {
705 req
= list_entry(ep
->queue
.next
, struct lh7a40x_request
, queue
);
706 done(ep
, req
, status
);
709 /* Disable IRQ if EP is enabled (has descriptor) */
711 pio_irq_disable(ep_index(ep
));
715 void nuke_all(struct lh7a40x_udc *dev)
718 for(n=0; n<UDC_MAX_ENDPOINTS; n++) {
719 struct lh7a40x_ep *ep = &dev->ep[n];
726 static void flush_all(struct lh7a40x_udc *dev)
729 for (n = 0; n < UDC_MAX_ENDPOINTS; n++)
731 struct lh7a40x_ep *ep = &dev->ep[n];
738 * NOTE: INDEX register must be set before this call
740 static void flush(struct lh7a40x_ep
*ep
)
742 DEBUG("%s, %p\n", __FUNCTION__
, ep
);
744 switch (ep
->ep_type
) {
746 /* check, by implication c.f. 15.1.2.11 */
751 /* if(csr & USB_IN_CSR1_IN_PKT_RDY) */
752 usb_set(USB_IN_CSR1_FIFO_FLUSH
, ep
->csr1
);
756 /* if(csr & USB_OUT_CSR1_OUT_PKT_RDY) */
757 usb_set(USB_OUT_CSR1_FIFO_FLUSH
, ep
->csr1
);
763 * lh7a40x_in_epn - handle IN interrupt
765 static void lh7a40x_in_epn(struct lh7a40x_udc
*dev
, u32 ep_idx
, u32 intr
)
768 struct lh7a40x_ep
*ep
= &dev
->ep
[ep_idx
];
769 struct lh7a40x_request
*req
;
771 usb_set_index(ep_idx
);
773 csr
= usb_read(ep
->csr1
);
774 DEBUG("%s: %d, csr %x\n", __FUNCTION__
, ep_idx
, csr
);
776 if (csr
& USB_IN_CSR1_SENT_STALL
) {
777 DEBUG("USB_IN_CSR1_SENT_STALL\n");
778 usb_set(USB_IN_CSR1_SENT_STALL
/*|USB_IN_CSR1_SEND_STALL */ ,
784 DEBUG("%s: NO EP DESC\n", __FUNCTION__
);
788 if (list_empty(&ep
->queue
))
791 req
= list_entry(ep
->queue
.next
, struct lh7a40x_request
, queue
);
793 DEBUG("req: %p\n", req
);
801 /* ********************************************************************************************* */
805 static void lh7a40x_out_epn(struct lh7a40x_udc
*dev
, u32 ep_idx
, u32 intr
)
807 struct lh7a40x_ep
*ep
= &dev
->ep
[ep_idx
];
808 struct lh7a40x_request
*req
;
810 DEBUG("%s: %d\n", __FUNCTION__
, ep_idx
);
812 usb_set_index(ep_idx
);
816 csr
= usb_read(ep
->csr1
);
820 csr1
)) & (USB_OUT_CSR1_OUT_PKT_RDY
|
821 USB_OUT_CSR1_SENT_STALL
)) {
822 DEBUG("%s: %x\n", __FUNCTION__
, csr
);
824 if (csr
& USB_OUT_CSR1_SENT_STALL
) {
825 DEBUG("%s: stall sent, flush fifo\n",
827 /* usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1); */
829 } else if (csr
& USB_OUT_CSR1_OUT_PKT_RDY
) {
830 if (list_empty(&ep
->queue
))
834 list_entry(ep
->queue
.next
,
835 struct lh7a40x_request
,
839 printk("%s: NULL REQ %d\n",
840 __FUNCTION__
, ep_idx
);
851 /* Throw packet away.. */
852 printk("%s: No descriptor?!?\n", __FUNCTION__
);
857 static void stop_activity(struct lh7a40x_udc
*dev
,
858 struct usb_gadget_driver
*driver
)
862 /* don't disconnect drivers more than once */
863 if (dev
->gadget
.speed
== USB_SPEED_UNKNOWN
)
865 dev
->gadget
.speed
= USB_SPEED_UNKNOWN
;
867 /* prevent new request submissions, kill any outstanding requests */
868 for (i
= 0; i
< UDC_MAX_ENDPOINTS
; i
++) {
869 struct lh7a40x_ep
*ep
= &dev
->ep
[i
];
873 nuke(ep
, -ESHUTDOWN
);
876 /* report disconnect; the driver is already quiesced */
878 spin_unlock(&dev
->lock
);
879 driver
->disconnect(&dev
->gadget
);
880 spin_lock(&dev
->lock
);
883 /* re-init driver-visible data structures */
887 /** Handle USB RESET interrupt
889 static void lh7a40x_reset_intr(struct lh7a40x_udc
*dev
)
891 #if 0 /* def CONFIG_ARCH_LH7A404 */
892 /* Does not work always... */
894 DEBUG("%s: %d\n", __FUNCTION__
, dev
->usb_address
);
896 if (!dev
->usb_address
) {
897 /*usb_set(USB_RESET_IO, USB_RESET);
899 usb_clear(USB_RESET_IO, USB_RESET); */
902 /* Put the USB controller into reset. */
903 usb_set(USB_RESET_IO
, USB_RESET
);
905 /* Set Device ID to 0 */
906 udc_set_address(dev
, 0);
908 /* Let PLL2 settle down */
911 /* Release the USB controller from reset */
912 usb_clear(USB_RESET_IO
, USB_RESET
);
918 dev
->gadget
.speed
= USB_SPEED_FULL
;
922 * lh7a40x usb client interrupt handler.
924 static irqreturn_t
lh7a40x_udc_irq(int irq
, void *_dev
)
926 struct lh7a40x_udc
*dev
= _dev
;
930 spin_lock(&dev
->lock
);
933 u32 intr_in
= usb_read(USB_IN_INT
);
934 u32 intr_out
= usb_read(USB_OUT_INT
);
935 u32 intr_int
= usb_read(USB_INT
);
937 /* Test also against enable bits.. (lh7a40x errata).. Sigh.. */
938 u32 in_en
= usb_read(USB_IN_INT_EN
);
939 u32 out_en
= usb_read(USB_OUT_INT_EN
);
941 if (!intr_out
&& !intr_in
&& !intr_int
)
944 DEBUG("%s (on state %s)\n", __FUNCTION__
,
945 state_names
[dev
->ep0state
]);
946 DEBUG("intr_out = %x\n", intr_out
);
947 DEBUG("intr_in = %x\n", intr_in
);
948 DEBUG("intr_int = %x\n", intr_int
);
951 usb_write(intr_in
, USB_IN_INT
);
953 if ((intr_in
& USB_IN_INT_EP1
)
954 && (in_en
& USB_IN_INT_EP1
)) {
955 DEBUG("USB_IN_INT_EP1\n");
956 lh7a40x_in_epn(dev
, 1, intr_in
);
958 if ((intr_in
& USB_IN_INT_EP3
)
959 && (in_en
& USB_IN_INT_EP3
)) {
960 DEBUG("USB_IN_INT_EP3\n");
961 lh7a40x_in_epn(dev
, 3, intr_in
);
963 if (intr_in
& USB_IN_INT_EP0
) {
964 DEBUG("USB_IN_INT_EP0 (control)\n");
965 lh7a40x_handle_ep0(dev
, intr_in
);
970 usb_write(intr_out
, USB_OUT_INT
);
972 if ((intr_out
& USB_OUT_INT_EP2
)
973 && (out_en
& USB_OUT_INT_EP2
)) {
974 DEBUG("USB_OUT_INT_EP2\n");
975 lh7a40x_out_epn(dev
, 2, intr_out
);
980 usb_write(intr_int
, USB_INT
);
982 if (intr_int
& USB_INT_RESET_INT
) {
983 lh7a40x_reset_intr(dev
);
986 if (intr_int
& USB_INT_RESUME_INT
) {
987 DEBUG("USB resume\n");
989 if (dev
->gadget
.speed
!= USB_SPEED_UNKNOWN
991 && dev
->driver
->resume
992 && is_usb_connected()) {
993 dev
->driver
->resume(&dev
->gadget
);
997 if (intr_int
& USB_INT_SUSPEND_INT
) {
998 DEBUG("USB suspend%s\n",
999 is_usb_connected()? "" : "+disconnect");
1000 if (!is_usb_connected()) {
1001 stop_activity(dev
, dev
->driver
);
1002 } else if (dev
->gadget
.speed
!=
1003 USB_SPEED_UNKNOWN
&& dev
->driver
1004 && dev
->driver
->suspend
) {
1005 dev
->driver
->suspend(&dev
->gadget
);
1012 spin_unlock(&dev
->lock
);
1017 static int lh7a40x_ep_enable(struct usb_ep
*_ep
,
1018 const struct usb_endpoint_descriptor
*desc
)
1020 struct lh7a40x_ep
*ep
;
1021 struct lh7a40x_udc
*dev
;
1022 unsigned long flags
;
1024 DEBUG("%s, %p\n", __FUNCTION__
, _ep
);
1026 ep
= container_of(_ep
, struct lh7a40x_ep
, ep
);
1027 if (!_ep
|| !desc
|| ep
->desc
|| _ep
->name
== ep0name
1028 || desc
->bDescriptorType
!= USB_DT_ENDPOINT
1029 || ep
->bEndpointAddress
!= desc
->bEndpointAddress
1030 || ep_maxpacket(ep
) < le16_to_cpu(desc
->wMaxPacketSize
)) {
1031 DEBUG("%s, bad ep or descriptor\n", __FUNCTION__
);
1035 /* xfer types must match, except that interrupt ~= bulk */
1036 if (ep
->bmAttributes
!= desc
->bmAttributes
1037 && ep
->bmAttributes
!= USB_ENDPOINT_XFER_BULK
1038 && desc
->bmAttributes
!= USB_ENDPOINT_XFER_INT
) {
1039 DEBUG("%s, %s type mismatch\n", __FUNCTION__
, _ep
->name
);
1043 /* hardware _could_ do smaller, but driver doesn't */
1044 if ((desc
->bmAttributes
== USB_ENDPOINT_XFER_BULK
1045 && le16_to_cpu(desc
->wMaxPacketSize
) != ep_maxpacket(ep
))
1046 || !desc
->wMaxPacketSize
) {
1047 DEBUG("%s, bad %s maxpacket\n", __FUNCTION__
, _ep
->name
);
1052 if (!dev
->driver
|| dev
->gadget
.speed
== USB_SPEED_UNKNOWN
) {
1053 DEBUG("%s, bogus device state\n", __FUNCTION__
);
1057 spin_lock_irqsave(&ep
->dev
->lock
, flags
);
1062 ep
->ep
.maxpacket
= le16_to_cpu(desc
->wMaxPacketSize
);
1064 spin_unlock_irqrestore(&ep
->dev
->lock
, flags
);
1066 /* Reset halt state (does flush) */
1067 lh7a40x_set_halt(_ep
, 0);
1069 DEBUG("%s: enabled %s\n", __FUNCTION__
, _ep
->name
);
1074 * NOTE: Sets INDEX register
1076 static int lh7a40x_ep_disable(struct usb_ep
*_ep
)
1078 struct lh7a40x_ep
*ep
;
1079 unsigned long flags
;
1081 DEBUG("%s, %p\n", __FUNCTION__
, _ep
);
1083 ep
= container_of(_ep
, struct lh7a40x_ep
, ep
);
1084 if (!_ep
|| !ep
->desc
) {
1085 DEBUG("%s, %s not enabled\n", __FUNCTION__
,
1086 _ep
? ep
->ep
.name
: NULL
);
1090 spin_lock_irqsave(&ep
->dev
->lock
, flags
);
1092 usb_set_index(ep_index(ep
));
1094 /* Nuke all pending requests (does flush) */
1095 nuke(ep
, -ESHUTDOWN
);
1097 /* Disable ep IRQ */
1098 pio_irq_disable(ep_index(ep
));
1103 spin_unlock_irqrestore(&ep
->dev
->lock
, flags
);
1105 DEBUG("%s: disabled %s\n", __FUNCTION__
, _ep
->name
);
1109 static struct usb_request
*lh7a40x_alloc_request(struct usb_ep
*ep
,
1112 struct lh7a40x_request
*req
;
1114 DEBUG("%s, %p\n", __FUNCTION__
, ep
);
1116 req
= kzalloc(sizeof(*req
), gfp_flags
);
1120 INIT_LIST_HEAD(&req
->queue
);
1125 static void lh7a40x_free_request(struct usb_ep
*ep
, struct usb_request
*_req
)
1127 struct lh7a40x_request
*req
;
1129 DEBUG("%s, %p\n", __FUNCTION__
, ep
);
1131 req
= container_of(_req
, struct lh7a40x_request
, req
);
1132 WARN_ON(!list_empty(&req
->queue
));
1136 static void *lh7a40x_alloc_buffer(struct usb_ep
*ep
, unsigned bytes
,
1137 dma_addr_t
* dma
, gfp_t gfp_flags
)
1141 DEBUG("%s (%p, %d, %d)\n", __FUNCTION__
, ep
, bytes
, gfp_flags
);
1143 retval
= kmalloc(bytes
, gfp_flags
& ~(__GFP_DMA
| __GFP_HIGHMEM
));
1145 *dma
= virt_to_bus(retval
);
1149 static void lh7a40x_free_buffer(struct usb_ep
*ep
, void *buf
, dma_addr_t dma
,
1152 DEBUG("%s, %p\n", __FUNCTION__
, ep
);
1156 /** Queue one request
1157 * Kickstart transfer if needed
1158 * NOTE: Sets INDEX register
1160 static int lh7a40x_queue(struct usb_ep
*_ep
, struct usb_request
*_req
,
1163 struct lh7a40x_request
*req
;
1164 struct lh7a40x_ep
*ep
;
1165 struct lh7a40x_udc
*dev
;
1166 unsigned long flags
;
1168 DEBUG("\n\n\n%s, %p\n", __FUNCTION__
, _ep
);
1170 req
= container_of(_req
, struct lh7a40x_request
, req
);
1172 (!_req
|| !_req
->complete
|| !_req
->buf
1173 || !list_empty(&req
->queue
))) {
1174 DEBUG("%s, bad params\n", __FUNCTION__
);
1178 ep
= container_of(_ep
, struct lh7a40x_ep
, ep
);
1179 if (unlikely(!_ep
|| (!ep
->desc
&& ep
->ep
.name
!= ep0name
))) {
1180 DEBUG("%s, bad ep\n", __FUNCTION__
);
1185 if (unlikely(!dev
->driver
|| dev
->gadget
.speed
== USB_SPEED_UNKNOWN
)) {
1186 DEBUG("%s, bogus device state %p\n", __FUNCTION__
, dev
->driver
);
1190 DEBUG("%s queue req %p, len %d buf %p\n", _ep
->name
, _req
, _req
->length
,
1193 spin_lock_irqsave(&dev
->lock
, flags
);
1195 _req
->status
= -EINPROGRESS
;
1198 /* kickstart this i/o queue? */
1199 DEBUG("Add to %d Q %d %d\n", ep_index(ep
), list_empty(&ep
->queue
),
1201 if (list_empty(&ep
->queue
) && likely(!ep
->stopped
)) {
1204 if (unlikely(ep_index(ep
) == 0)) {
1206 list_add_tail(&req
->queue
, &ep
->queue
);
1207 lh7a40x_ep0_kick(dev
, ep
);
1209 } else if (ep_is_in(ep
)) {
1211 usb_set_index(ep_index(ep
));
1212 csr
= usb_read(ep
->csr1
);
1213 pio_irq_enable(ep_index(ep
));
1214 if ((csr
& USB_IN_CSR1_FIFO_NOT_EMPTY
) == 0) {
1215 if (write_fifo(ep
, req
) == 1)
1220 usb_set_index(ep_index(ep
));
1221 csr
= usb_read(ep
->csr1
);
1222 pio_irq_enable(ep_index(ep
));
1223 if (!(csr
& USB_OUT_CSR1_FIFO_FULL
)) {
1224 if (read_fifo(ep
, req
) == 1)
1230 /* pio or dma irq handler advances the queue. */
1231 if (likely(req
!= 0))
1232 list_add_tail(&req
->queue
, &ep
->queue
);
1234 spin_unlock_irqrestore(&dev
->lock
, flags
);
1239 /* dequeue JUST ONE request */
1240 static int lh7a40x_dequeue(struct usb_ep
*_ep
, struct usb_request
*_req
)
1242 struct lh7a40x_ep
*ep
;
1243 struct lh7a40x_request
*req
;
1244 unsigned long flags
;
1246 DEBUG("%s, %p\n", __FUNCTION__
, _ep
);
1248 ep
= container_of(_ep
, struct lh7a40x_ep
, ep
);
1249 if (!_ep
|| ep
->ep
.name
== ep0name
)
1252 spin_lock_irqsave(&ep
->dev
->lock
, flags
);
1254 /* make sure it's actually queued on this endpoint */
1255 list_for_each_entry(req
, &ep
->queue
, queue
) {
1256 if (&req
->req
== _req
)
1259 if (&req
->req
!= _req
) {
1260 spin_unlock_irqrestore(&ep
->dev
->lock
, flags
);
1264 done(ep
, req
, -ECONNRESET
);
1266 spin_unlock_irqrestore(&ep
->dev
->lock
, flags
);
1270 /** Halt specific EP
1271 * Return 0 if success
1272 * NOTE: Sets INDEX register to EP !
1274 static int lh7a40x_set_halt(struct usb_ep
*_ep
, int value
)
1276 struct lh7a40x_ep
*ep
;
1277 unsigned long flags
;
1279 ep
= container_of(_ep
, struct lh7a40x_ep
, ep
);
1280 if (unlikely(!_ep
|| (!ep
->desc
&& ep
->ep
.name
!= ep0name
))) {
1281 DEBUG("%s, bad ep\n", __FUNCTION__
);
1285 usb_set_index(ep_index(ep
));
1287 DEBUG("%s, ep %d, val %d\n", __FUNCTION__
, ep_index(ep
), value
);
1289 spin_lock_irqsave(&ep
->dev
->lock
, flags
);
1291 if (ep_index(ep
) == 0) {
1293 usb_set(EP0_SEND_STALL
, ep
->csr1
);
1294 } else if (ep_is_in(ep
)) {
1295 u32 csr
= usb_read(ep
->csr1
);
1296 if (value
&& ((csr
& USB_IN_CSR1_FIFO_NOT_EMPTY
)
1297 || !list_empty(&ep
->queue
))) {
1299 * Attempts to halt IN endpoints will fail (returning -EAGAIN)
1300 * if any transfer requests are still queued, or if the controller
1301 * FIFO still holds bytes that the host hasn’t collected.
1303 spin_unlock_irqrestore(&ep
->dev
->lock
, flags
);
1305 ("Attempt to halt IN endpoint failed (returning -EAGAIN) %d %d\n",
1306 (csr
& USB_IN_CSR1_FIFO_NOT_EMPTY
),
1307 !list_empty(&ep
->queue
));
1312 usb_set(USB_IN_CSR1_SEND_STALL
, ep
->csr1
);
1314 usb_clear(USB_IN_CSR1_SEND_STALL
, ep
->csr1
);
1315 usb_set(USB_IN_CSR1_CLR_DATA_TOGGLE
, ep
->csr1
);
1322 usb_set(USB_OUT_CSR1_SEND_STALL
, ep
->csr1
);
1324 usb_clear(USB_OUT_CSR1_SEND_STALL
, ep
->csr1
);
1325 usb_set(USB_OUT_CSR1_CLR_DATA_REG
, ep
->csr1
);
1335 spin_unlock_irqrestore(&ep
->dev
->lock
, flags
);
1337 DEBUG("%s %s halted\n", _ep
->name
, value
== 0 ? "NOT" : "IS");
1342 /** Return bytes in EP FIFO
1343 * NOTE: Sets INDEX register to EP
1345 static int lh7a40x_fifo_status(struct usb_ep
*_ep
)
1349 struct lh7a40x_ep
*ep
;
1351 ep
= container_of(_ep
, struct lh7a40x_ep
, ep
);
1353 DEBUG("%s, bad ep\n", __FUNCTION__
);
1357 DEBUG("%s, %d\n", __FUNCTION__
, ep_index(ep
));
1359 /* LPD can't report unclaimed bytes from IN fifos */
1363 usb_set_index(ep_index(ep
));
1365 csr
= usb_read(ep
->csr1
);
1366 if (ep
->dev
->gadget
.speed
!= USB_SPEED_UNKNOWN
||
1367 csr
& USB_OUT_CSR1_OUT_PKT_RDY
) {
1368 count
= usb_read(USB_OUT_FIFO_WC1
);
1375 * NOTE: Sets INDEX register to EP
1377 static void lh7a40x_fifo_flush(struct usb_ep
*_ep
)
1379 struct lh7a40x_ep
*ep
;
1381 ep
= container_of(_ep
, struct lh7a40x_ep
, ep
);
1382 if (unlikely(!_ep
|| (!ep
->desc
&& ep
->ep
.name
!= ep0name
))) {
1383 DEBUG("%s, bad ep\n", __FUNCTION__
);
1387 usb_set_index(ep_index(ep
));
1391 /****************************************************************/
1392 /* End Point 0 related functions */
1393 /****************************************************************/
1395 /* return: 0 = still running, 1 = completed, negative = errno */
1396 static int write_fifo_ep0(struct lh7a40x_ep
*ep
, struct lh7a40x_request
*req
)
1402 max
= ep_maxpacket(ep
);
1404 DEBUG_EP0("%s\n", __FUNCTION__
);
1406 count
= write_packet(ep
, req
, max
);
1408 /* last packet is usually short (or a zlp) */
1409 if (unlikely(count
!= max
))
1412 if (likely(req
->req
.length
!= req
->req
.actual
) || req
->req
.zero
)
1418 DEBUG_EP0("%s: wrote %s %d bytes%s %d left %p\n", __FUNCTION__
,
1420 is_last
? "/L" : "", req
->req
.length
- req
->req
.actual
, req
);
1422 /* requests complete when all IN data is in the FIFO */
1431 static __inline__
int lh7a40x_fifo_read(struct lh7a40x_ep
*ep
,
1432 unsigned char *cp
, int max
)
1435 int count
= usb_read(USB_OUT_FIFO_WC1
);
1436 volatile u32
*fifo
= (volatile u32
*)ep
->fifo
;
1442 *cp
++ = *fifo
& 0xFF;
1446 static __inline__
void lh7a40x_fifo_write(struct lh7a40x_ep
*ep
,
1447 unsigned char *cp
, int count
)
1449 volatile u32
*fifo
= (volatile u32
*)ep
->fifo
;
1450 DEBUG_EP0("fifo_write: %d %d\n", ep_index(ep
), count
);
1455 static int read_fifo_ep0(struct lh7a40x_ep
*ep
, struct lh7a40x_request
*req
)
1459 unsigned bufferspace
, count
, is_short
;
1460 volatile u32
*fifo
= (volatile u32
*)ep
->fifo
;
1462 DEBUG_EP0("%s\n", __FUNCTION__
);
1464 csr
= usb_read(USB_EP0_CSR
);
1465 if (!(csr
& USB_OUT_CSR1_OUT_PKT_RDY
))
1468 buf
= req
->req
.buf
+ req
->req
.actual
;
1470 bufferspace
= req
->req
.length
- req
->req
.actual
;
1472 /* read all bytes from this packet */
1473 if (likely(csr
& EP0_OUT_PKT_RDY
)) {
1474 count
= usb_read(USB_OUT_FIFO_WC1
);
1475 req
->req
.actual
+= min(count
, bufferspace
);
1479 is_short
= (count
< ep
->ep
.maxpacket
);
1480 DEBUG_EP0("read %s %02x, %d bytes%s req %p %d/%d\n",
1481 ep
->ep
.name
, csr
, count
,
1482 is_short
? "/S" : "", req
, req
->req
.actual
, req
->req
.length
);
1484 while (likely(count
-- != 0)) {
1485 u8 byte
= (u8
) (*fifo
& 0xff);
1487 if (unlikely(bufferspace
== 0)) {
1488 /* this happens when the driver's buffer
1489 * is smaller than what the host sent.
1490 * discard the extra data.
1492 if (req
->req
.status
!= -EOVERFLOW
)
1493 DEBUG_EP0("%s overflow %d\n", ep
->ep
.name
,
1495 req
->req
.status
= -EOVERFLOW
;
1503 if (is_short
|| req
->req
.actual
== req
->req
.length
) {
1508 /* finished that packet. the next one may be waiting... */
1513 * udc_set_address - set the USB address for this device
1516 * Called from control endpoint function after it decodes a set address setup packet.
1518 static void udc_set_address(struct lh7a40x_udc
*dev
, unsigned char address
)
1520 DEBUG_EP0("%s: %d\n", __FUNCTION__
, address
);
1521 /* c.f. 15.1.2.2 Table 15-4 address will be used after DATA_END is set */
1522 dev
->usb_address
= address
;
1523 usb_set((address
& USB_FA_FUNCTION_ADDR
), USB_FA
);
1524 usb_set(USB_FA_ADDR_UPDATE
| (address
& USB_FA_FUNCTION_ADDR
), USB_FA
);
1525 /* usb_read(USB_FA); */
1529 * DATA_STATE_RECV (OUT_PKT_RDY)
1531 * set EP0_CLR_OUT | EP0_DATA_END | EP0_SEND_STALL bits
1533 * set EP0_CLR_OUT bit
1534 if last set EP0_DATA_END bit
1536 static void lh7a40x_ep0_out(struct lh7a40x_udc
*dev
, u32 csr
)
1538 struct lh7a40x_request
*req
;
1539 struct lh7a40x_ep
*ep
= &dev
->ep
[0];
1542 DEBUG_EP0("%s: %x\n", __FUNCTION__
, csr
);
1544 if (list_empty(&ep
->queue
))
1547 req
= list_entry(ep
->queue
.next
, struct lh7a40x_request
, queue
);
1551 if (req
->req
.length
== 0) {
1552 DEBUG_EP0("ZERO LENGTH OUT!\n");
1553 usb_set((EP0_CLR_OUT
| EP0_DATA_END
), USB_EP0_CSR
);
1554 dev
->ep0state
= WAIT_FOR_SETUP
;
1557 ret
= read_fifo_ep0(ep
, req
);
1560 DEBUG_EP0("%s: finished, waiting for status\n",
1563 usb_set((EP0_CLR_OUT
| EP0_DATA_END
), USB_EP0_CSR
);
1564 dev
->ep0state
= WAIT_FOR_SETUP
;
1566 /* Not done yet.. */
1567 DEBUG_EP0("%s: not finished\n", __FUNCTION__
);
1568 usb_set(EP0_CLR_OUT
, USB_EP0_CSR
);
1571 DEBUG_EP0("NO REQ??!\n");
1578 static int lh7a40x_ep0_in(struct lh7a40x_udc
*dev
, u32 csr
)
1580 struct lh7a40x_request
*req
;
1581 struct lh7a40x_ep
*ep
= &dev
->ep
[0];
1582 int ret
, need_zlp
= 0;
1584 DEBUG_EP0("%s: %x\n", __FUNCTION__
, csr
);
1586 if (list_empty(&ep
->queue
))
1589 req
= list_entry(ep
->queue
.next
, struct lh7a40x_request
, queue
);
1592 DEBUG_EP0("%s: NULL REQ\n", __FUNCTION__
);
1596 if (req
->req
.length
== 0) {
1598 usb_set((EP0_IN_PKT_RDY
| EP0_DATA_END
), USB_EP0_CSR
);
1599 dev
->ep0state
= WAIT_FOR_SETUP
;
1603 if (req
->req
.length
- req
->req
.actual
== EP0_PACKETSIZE
) {
1604 /* Next write will end with the packet size, */
1605 /* so we need Zero-length-packet */
1609 ret
= write_fifo_ep0(ep
, req
);
1611 if (ret
== 1 && !need_zlp
) {
1613 DEBUG_EP0("%s: finished, waiting for status\n", __FUNCTION__
);
1615 usb_set((EP0_IN_PKT_RDY
| EP0_DATA_END
), USB_EP0_CSR
);
1616 dev
->ep0state
= WAIT_FOR_SETUP
;
1618 DEBUG_EP0("%s: not finished\n", __FUNCTION__
);
1619 usb_set(EP0_IN_PKT_RDY
, USB_EP0_CSR
);
1623 DEBUG_EP0("%s: Need ZLP!\n", __FUNCTION__
);
1624 usb_set(EP0_IN_PKT_RDY
, USB_EP0_CSR
);
1625 dev
->ep0state
= DATA_STATE_NEED_ZLP
;
1631 static int lh7a40x_handle_get_status(struct lh7a40x_udc
*dev
,
1632 struct usb_ctrlrequest
*ctrl
)
1634 struct lh7a40x_ep
*ep0
= &dev
->ep
[0];
1635 struct lh7a40x_ep
*qep
;
1636 int reqtype
= (ctrl
->bRequestType
& USB_RECIP_MASK
);
1639 if (reqtype
== USB_RECIP_INTERFACE
) {
1640 /* This is not supported.
1641 * And according to the USB spec, this one does nothing..
1644 DEBUG_SETUP("GET_STATUS: USB_RECIP_INTERFACE\n");
1645 } else if (reqtype
== USB_RECIP_DEVICE
) {
1646 DEBUG_SETUP("GET_STATUS: USB_RECIP_DEVICE\n");
1647 val
|= (1 << 0); /* Self powered */
1648 /*val |= (1<<1); *//* Remote wakeup */
1649 } else if (reqtype
== USB_RECIP_ENDPOINT
) {
1650 int ep_num
= (ctrl
->wIndex
& ~USB_DIR_IN
);
1653 ("GET_STATUS: USB_RECIP_ENDPOINT (%d), ctrl->wLength = %d\n",
1654 ep_num
, ctrl
->wLength
);
1656 if (ctrl
->wLength
> 2 || ep_num
> 3)
1659 qep
= &dev
->ep
[ep_num
];
1660 if (ep_is_in(qep
) != ((ctrl
->wIndex
& USB_DIR_IN
) ? 1 : 0)
1661 && ep_index(qep
) != 0) {
1665 usb_set_index(ep_index(qep
));
1667 /* Return status on next IN token */
1668 switch (qep
->ep_type
) {
1671 (usb_read(qep
->csr1
) & EP0_SEND_STALL
) ==
1677 (usb_read(qep
->csr1
) & USB_IN_CSR1_SEND_STALL
) ==
1678 USB_IN_CSR1_SEND_STALL
;
1682 (usb_read(qep
->csr1
) & USB_OUT_CSR1_SEND_STALL
) ==
1683 USB_OUT_CSR1_SEND_STALL
;
1687 /* Back to EP0 index */
1690 DEBUG_SETUP("GET_STATUS, ep: %d (%x), val = %d\n", ep_num
,
1693 DEBUG_SETUP("Unknown REQ TYPE: %d\n", reqtype
);
1697 /* Clear "out packet ready" */
1698 usb_set((EP0_CLR_OUT
), USB_EP0_CSR
);
1699 /* Put status to FIFO */
1700 lh7a40x_fifo_write(ep0
, (u8
*) & val
, sizeof(val
));
1701 /* Issue "In packet ready" */
1702 usb_set((EP0_IN_PKT_RDY
| EP0_DATA_END
), USB_EP0_CSR
);
1708 * WAIT_FOR_SETUP (OUT_PKT_RDY)
1709 * - read data packet from EP0 FIFO
1712 * set EP0_CLR_OUT | EP0_DATA_END | EP0_SEND_STALL bits
1714 * set EP0_CLR_OUT | EP0_DATA_END bits
1716 static void lh7a40x_ep0_setup(struct lh7a40x_udc
*dev
, u32 csr
)
1718 struct lh7a40x_ep
*ep
= &dev
->ep
[0];
1719 struct usb_ctrlrequest ctrl
;
1720 int i
, bytes
, is_in
;
1722 DEBUG_SETUP("%s: %x\n", __FUNCTION__
, csr
);
1724 /* Nuke all previous transfers */
1727 /* read control req from fifo (8 bytes) */
1728 bytes
= lh7a40x_fifo_read(ep
, (unsigned char *)&ctrl
, 8);
1730 DEBUG_SETUP("Read CTRL REQ %d bytes\n", bytes
);
1731 DEBUG_SETUP("CTRL.bRequestType = %d (is_in %d)\n", ctrl
.bRequestType
,
1732 ctrl
.bRequestType
== USB_DIR_IN
);
1733 DEBUG_SETUP("CTRL.bRequest = %d\n", ctrl
.bRequest
);
1734 DEBUG_SETUP("CTRL.wLength = %d\n", ctrl
.wLength
);
1735 DEBUG_SETUP("CTRL.wValue = %d (%d)\n", ctrl
.wValue
, ctrl
.wValue
>> 8);
1736 DEBUG_SETUP("CTRL.wIndex = %d\n", ctrl
.wIndex
);
1738 /* Set direction of EP0 */
1739 if (likely(ctrl
.bRequestType
& USB_DIR_IN
)) {
1740 ep
->bEndpointAddress
|= USB_DIR_IN
;
1743 ep
->bEndpointAddress
&= ~USB_DIR_IN
;
1747 dev
->req_pending
= 1;
1749 /* Handle some SETUP packets ourselves */
1750 switch (ctrl
.bRequest
) {
1751 case USB_REQ_SET_ADDRESS
:
1752 if (ctrl
.bRequestType
!= (USB_TYPE_STANDARD
| USB_RECIP_DEVICE
))
1755 DEBUG_SETUP("USB_REQ_SET_ADDRESS (%d)\n", ctrl
.wValue
);
1756 udc_set_address(dev
, ctrl
.wValue
);
1757 usb_set((EP0_CLR_OUT
| EP0_DATA_END
), USB_EP0_CSR
);
1760 case USB_REQ_GET_STATUS
:{
1761 if (lh7a40x_handle_get_status(dev
, &ctrl
) == 0)
1764 case USB_REQ_CLEAR_FEATURE
:
1765 case USB_REQ_SET_FEATURE
:
1766 if (ctrl
.bRequestType
== USB_RECIP_ENDPOINT
) {
1767 struct lh7a40x_ep
*qep
;
1768 int ep_num
= (ctrl
.wIndex
& 0x0f);
1770 /* Support only HALT feature */
1771 if (ctrl
.wValue
!= 0 || ctrl
.wLength
!= 0
1772 || ep_num
> 3 || ep_num
< 1)
1775 qep
= &dev
->ep
[ep_num
];
1776 spin_unlock(&dev
->lock
);
1777 if (ctrl
.bRequest
== USB_REQ_SET_FEATURE
) {
1778 DEBUG_SETUP("SET_FEATURE (%d)\n",
1780 lh7a40x_set_halt(&qep
->ep
, 1);
1782 DEBUG_SETUP("CLR_FEATURE (%d)\n",
1784 lh7a40x_set_halt(&qep
->ep
, 0);
1786 spin_lock(&dev
->lock
);
1789 /* Reply with a ZLP on next IN token */
1790 usb_set((EP0_CLR_OUT
| EP0_DATA_END
),
1801 if (likely(dev
->driver
)) {
1802 /* device-2-host (IN) or no data setup command, process immediately */
1803 spin_unlock(&dev
->lock
);
1804 i
= dev
->driver
->setup(&dev
->gadget
, &ctrl
);
1805 spin_lock(&dev
->lock
);
1808 /* setup processing failed, force stall */
1810 (" --> ERROR: gadget setup FAILED (stalling), setup returned %d\n",
1813 usb_set((EP0_CLR_OUT
| EP0_DATA_END
| EP0_SEND_STALL
),
1816 /* ep->stopped = 1; */
1817 dev
->ep0state
= WAIT_FOR_SETUP
;
1823 * DATA_STATE_NEED_ZLP
1825 static void lh7a40x_ep0_in_zlp(struct lh7a40x_udc
*dev
, u32 csr
)
1827 DEBUG_EP0("%s: %x\n", __FUNCTION__
, csr
);
1829 /* c.f. Table 15-14 */
1830 usb_set((EP0_IN_PKT_RDY
| EP0_DATA_END
), USB_EP0_CSR
);
1831 dev
->ep0state
= WAIT_FOR_SETUP
;
1835 * handle ep0 interrupt
1837 static void lh7a40x_handle_ep0(struct lh7a40x_udc
*dev
, u32 intr
)
1839 struct lh7a40x_ep
*ep
= &dev
->ep
[0];
1844 csr
= usb_read(USB_EP0_CSR
);
1846 DEBUG_EP0("%s: csr = %x\n", __FUNCTION__
, csr
);
1849 * For overview of what we should be doing see c.f. Chapter 18.1.2.4
1850 * We will follow that outline here modified by our own global state
1851 * indication which provides hints as to what we think should be
1856 * if SENT_STALL is set
1857 * - clear the SENT_STALL bit
1859 if (csr
& EP0_SENT_STALL
) {
1860 DEBUG_EP0("%s: EP0_SENT_STALL is set: %x\n", __FUNCTION__
, csr
);
1861 usb_clear((EP0_SENT_STALL
| EP0_SEND_STALL
), USB_EP0_CSR
);
1862 nuke(ep
, -ECONNABORTED
);
1863 dev
->ep0state
= WAIT_FOR_SETUP
;
1868 * if a transfer is in progress && IN_PKT_RDY and OUT_PKT_RDY are clear
1871 * - set IN_PKT_RDY | DATA_END
1875 if (!(csr
& (EP0_IN_PKT_RDY
| EP0_OUT_PKT_RDY
))) {
1876 DEBUG_EP0("%s: IN_PKT_RDY and OUT_PKT_RDY are clear\n",
1879 switch (dev
->ep0state
) {
1880 case DATA_STATE_XMIT
:
1881 DEBUG_EP0("continue with DATA_STATE_XMIT\n");
1882 lh7a40x_ep0_in(dev
, csr
);
1884 case DATA_STATE_NEED_ZLP
:
1885 DEBUG_EP0("continue with DATA_STATE_NEED_ZLP\n");
1886 lh7a40x_ep0_in_zlp(dev
, csr
);
1890 DEBUG_EP0("Odd state!! state = %s\n",
1891 state_names
[dev
->ep0state
]);
1892 dev
->ep0state
= WAIT_FOR_SETUP
;
1894 /* usb_set(EP0_SEND_STALL, ep->csr1); */
1900 * if SETUP_END is set
1901 * - abort the last transfer
1902 * - set SERVICED_SETUP_END_BIT
1904 if (csr
& EP0_SETUP_END
) {
1905 DEBUG_EP0("%s: EP0_SETUP_END is set: %x\n", __FUNCTION__
, csr
);
1907 usb_set(EP0_CLR_SETUP_END
, USB_EP0_CSR
);
1910 dev
->ep0state
= WAIT_FOR_SETUP
;
1914 * if EP0_OUT_PKT_RDY is set
1915 * - read data packet from EP0 FIFO
1918 * set SERVICED_OUT_PKT_RDY | DATA_END bits | SEND_STALL
1920 * set SERVICED_OUT_PKT_RDY | DATA_END bits
1922 if (csr
& EP0_OUT_PKT_RDY
) {
1924 DEBUG_EP0("%s: EP0_OUT_PKT_RDY is set: %x\n", __FUNCTION__
,
1927 switch (dev
->ep0state
) {
1928 case WAIT_FOR_SETUP
:
1929 DEBUG_EP0("WAIT_FOR_SETUP\n");
1930 lh7a40x_ep0_setup(dev
, csr
);
1933 case DATA_STATE_RECV
:
1934 DEBUG_EP0("DATA_STATE_RECV\n");
1935 lh7a40x_ep0_out(dev
, csr
);
1940 DEBUG_EP0("strange state!! 2. send stall? state = %d\n",
1947 static void lh7a40x_ep0_kick(struct lh7a40x_udc
*dev
, struct lh7a40x_ep
*ep
)
1952 csr
= usb_read(USB_EP0_CSR
);
1954 DEBUG_EP0("%s: %x\n", __FUNCTION__
, csr
);
1956 /* Clear "out packet ready" */
1957 usb_set(EP0_CLR_OUT
, USB_EP0_CSR
);
1960 dev
->ep0state
= DATA_STATE_XMIT
;
1961 lh7a40x_ep0_in(dev
, csr
);
1963 dev
->ep0state
= DATA_STATE_RECV
;
1964 lh7a40x_ep0_out(dev
, csr
);
1968 /* ---------------------------------------------------------------------------
1969 * device-scoped parts of the api to the usb controller hardware
1970 * ---------------------------------------------------------------------------
1973 static int lh7a40x_udc_get_frame(struct usb_gadget
*_gadget
)
1975 u32 frame1
= usb_read(USB_FRM_NUM1
); /* Least significant 8 bits */
1976 u32 frame2
= usb_read(USB_FRM_NUM2
); /* Most significant 3 bits */
1977 DEBUG("%s, %p\n", __FUNCTION__
, _gadget
);
1978 return ((frame2
& 0x07) << 8) | (frame1
& 0xff);
1981 static int lh7a40x_udc_wakeup(struct usb_gadget
*_gadget
)
1983 /* host may not have enabled remote wakeup */
1984 /*if ((UDCCS0 & UDCCS0_DRWF) == 0)
1985 return -EHOSTUNREACH;
1986 udc_set_mask_UDCCR(UDCCR_RSM); */
1990 static const struct usb_gadget_ops lh7a40x_udc_ops
= {
1991 .get_frame
= lh7a40x_udc_get_frame
,
1992 .wakeup
= lh7a40x_udc_wakeup
,
1993 /* current versions must always be self-powered */
1996 static void nop_release(struct device
*dev
)
1998 DEBUG("%s %s\n", __FUNCTION__
, dev
->bus_id
);
2001 static struct lh7a40x_udc memory
= {
2005 .ops
= &lh7a40x_udc_ops
,
2006 .ep0
= &memory
.ep
[0].ep
,
2007 .name
= driver_name
,
2010 .release
= nop_release
,
2014 /* control endpoint */
2018 .ops
= &lh7a40x_ep_ops
,
2019 .maxpacket
= EP0_PACKETSIZE
,
2023 .bEndpointAddress
= 0,
2026 .ep_type
= ep_control
,
2027 .fifo
= io_p2v(USB_EP0_FIFO
),
2028 .csr1
= USB_EP0_CSR
,
2029 .csr2
= USB_EP0_CSR
,
2032 /* first group of endpoints */
2035 .name
= "ep1in-bulk",
2036 .ops
= &lh7a40x_ep_ops
,
2041 .bEndpointAddress
= USB_DIR_IN
| 1,
2042 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
2044 .ep_type
= ep_bulk_in
,
2045 .fifo
= io_p2v(USB_EP1_FIFO
),
2046 .csr1
= USB_IN_CSR1
,
2047 .csr2
= USB_IN_CSR2
,
2052 .name
= "ep2out-bulk",
2053 .ops
= &lh7a40x_ep_ops
,
2058 .bEndpointAddress
= 2,
2059 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
2061 .ep_type
= ep_bulk_out
,
2062 .fifo
= io_p2v(USB_EP2_FIFO
),
2063 .csr1
= USB_OUT_CSR1
,
2064 .csr2
= USB_OUT_CSR2
,
2069 .name
= "ep3in-int",
2070 .ops
= &lh7a40x_ep_ops
,
2075 .bEndpointAddress
= USB_DIR_IN
| 3,
2076 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
2078 .ep_type
= ep_interrupt
,
2079 .fifo
= io_p2v(USB_EP3_FIFO
),
2080 .csr1
= USB_IN_CSR1
,
2081 .csr2
= USB_IN_CSR2
,
2086 * probe - binds to the platform device
2088 static int lh7a40x_udc_probe(struct platform_device
*pdev
)
2090 struct lh7a40x_udc
*dev
= &memory
;
2093 DEBUG("%s: %p\n", __FUNCTION__
, pdev
);
2095 spin_lock_init(&dev
->lock
);
2096 dev
->dev
= &pdev
->dev
;
2098 device_initialize(&dev
->gadget
.dev
);
2099 dev
->gadget
.dev
.parent
= &pdev
->dev
;
2101 the_controller
= dev
;
2102 platform_set_drvdata(pdev
, dev
);
2107 /* irq setup after old hardware state is cleaned up */
2109 request_irq(IRQ_USBINTR
, lh7a40x_udc_irq
, IRQF_DISABLED
, driver_name
,
2112 DEBUG(KERN_ERR
"%s: can't get irq %i, err %d\n", driver_name
,
2113 IRQ_USBINTR
, retval
);
2117 create_proc_files();
2122 static int lh7a40x_udc_remove(struct platform_device
*pdev
)
2124 struct lh7a40x_udc
*dev
= platform_get_drvdata(pdev
);
2126 DEBUG("%s: %p\n", __FUNCTION__
, pdev
);
2129 remove_proc_files();
2130 usb_gadget_unregister_driver(dev
->driver
);
2132 free_irq(IRQ_USBINTR
, dev
);
2134 platform_set_drvdata(pdev
, 0);
2141 /*-------------------------------------------------------------------------*/
2143 static struct platform_driver udc_driver
= {
2144 .probe
= lh7a40x_udc_probe
,
2145 .remove
= lh7a40x_udc_remove
,
2146 /* FIXME power management support */
2147 /* .suspend = ... disable UDC */
2148 /* .resume = ... re-enable UDC */
2150 .name
= (char *)driver_name
,
2151 .owner
= THIS_MODULE
,
2155 static int __init
udc_init(void)
2157 DEBUG("%s: %s version %s\n", __FUNCTION__
, driver_name
, DRIVER_VERSION
);
2158 return platform_driver_register(&udc_driver
);
2161 static void __exit
udc_exit(void)
2163 platform_driver_unregister(&udc_driver
);
2166 module_init(udc_init
);
2167 module_exit(udc_exit
);
2169 MODULE_DESCRIPTION(DRIVER_DESC
);
2170 MODULE_AUTHOR("Mikko Lahteenmaki, Bo Henriksen");
2171 MODULE_LICENSE("GPL");