2 * drivers/usb/gadget/emxx_udc.c
3 * EMXX FCD (Function Controller Driver) for USB.
5 * Copyright (C) 2010 Renesas Electronics Corporation
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2
9 * as published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/platform_device.h>
24 #include <linux/delay.h>
25 #include <linux/ioport.h>
26 #include <linux/slab.h>
27 #include <linux/errno.h>
28 #include <linux/init.h>
29 #include <linux/list.h>
30 #include <linux/interrupt.h>
31 #include <linux/proc_fs.h>
32 #include <linux/clk.h>
33 #include <linux/ctype.h>
34 #include <linux/string.h>
35 #include <linux/dma-mapping.h>
36 #include <linux/workqueue.h>
37 #include <linux/device.h>
39 #include <linux/usb/ch9.h>
40 #include <linux/usb/gadget.h>
42 #include <linux/irq.h>
43 #include <linux/gpio.h>
47 #define DRIVER_DESC "EMXX UDC driver"
48 #define DMA_ADDR_INVALID (~(dma_addr_t)0)
50 static const char driver_name
[] = "emxx_udc";
51 static const char driver_desc
[] = DRIVER_DESC
;
53 /*===========================================================================*/
55 static void _nbu2ss_ep_dma_abort(struct nbu2ss_udc
*, struct nbu2ss_ep
*);
56 static void _nbu2ss_ep0_enable(struct nbu2ss_udc
*);
57 /*static void _nbu2ss_ep0_disable(struct nbu2ss_udc *);*/
58 static void _nbu2ss_ep_done(struct nbu2ss_ep
*, struct nbu2ss_req
*, int);
59 static void _nbu2ss_set_test_mode(struct nbu2ss_udc
*, u32 mode
);
60 static void _nbu2ss_endpoint_toggle_reset(struct nbu2ss_udc
*udc
, u8 ep_adrs
);
62 static int _nbu2ss_pullup(struct nbu2ss_udc
*, int);
63 static void _nbu2ss_fifo_flush(struct nbu2ss_udc
*, struct nbu2ss_ep
*);
65 /*===========================================================================*/
67 #define _nbu2ss_zero_len_pkt(udc, epnum) \
68 _nbu2ss_ep_in_end(udc, epnum, 0, 0)
71 /*===========================================================================*/
73 struct nbu2ss_udc udc_controller
;
76 /*-------------------------------------------------------------------------*/
78 static inline u32
_nbu2ss_readl(void *address
)
80 return __raw_readl(address
);
83 /*-------------------------------------------------------------------------*/
85 static inline void _nbu2ss_writel(void *address
, u32 udata
)
87 __raw_writel(udata
, address
);
90 /*-------------------------------------------------------------------------*/
92 static inline void _nbu2ss_bitset(void *address
, u32 udata
)
94 u32 reg_dt
= __raw_readl(address
) | (udata
);
96 __raw_writel(reg_dt
, address
);
99 /*-------------------------------------------------------------------------*/
101 static inline void _nbu2ss_bitclr(void *address
, u32 udata
)
103 u32 reg_dt
= __raw_readl(address
) & ~(udata
);
105 __raw_writel(reg_dt
, address
);
108 #ifdef UDC_DEBUG_DUMP
109 /*-------------------------------------------------------------------------*/
110 static void _nbu2ss_dump_register(struct nbu2ss_udc
*udc
)
115 pr_info("=== %s()\n", __func__
);
118 ERR("%s udc == NULL\n", __func__
);
122 spin_unlock(&udc
->lock
);
124 printk(KERN_DEBUG
"\n-USB REG-\n");
125 for (i
= 0x0 ; i
< USB_BASE_SIZE
; i
+= 16) {
126 reg_data
= _nbu2ss_readl(
127 (u32
*)IO_ADDRESS(USB_BASE_ADDRESS
+ i
));
128 printk(KERN_DEBUG
"USB%04x =%08x", i
, (int)reg_data
);
130 reg_data
= _nbu2ss_readl(
131 (u32
*)IO_ADDRESS(USB_BASE_ADDRESS
+ i
+ 4));
132 printk(KERN_DEBUG
" %08x", (int)reg_data
);
134 reg_data
= _nbu2ss_readl(
135 (u32
*)IO_ADDRESS(USB_BASE_ADDRESS
+ i
+ 8));
136 printk(KERN_DEBUG
" %08x", (int)reg_data
);
138 reg_data
= _nbu2ss_readl(
139 (u32
*)IO_ADDRESS(USB_BASE_ADDRESS
+ i
+ 12));
140 printk(KERN_DEBUG
" %08x\n", (int)reg_data
);
144 spin_lock(&udc
->lock
);
146 #endif /* UDC_DEBUG_DUMP */
148 /*-------------------------------------------------------------------------*/
149 /* Endpoint 0 Callback (Complete) */
150 static void _nbu2ss_ep0_complete(struct usb_ep
*_ep
, struct usb_request
*_req
)
155 struct usb_ctrlrequest
*p_ctrl
;
156 struct nbu2ss_udc
*udc
;
158 if ((_ep
== NULL
) || (_req
== NULL
))
161 udc
= (struct nbu2ss_udc
*)_req
->context
;
163 if ((p_ctrl
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
165 if (p_ctrl
->bRequest
== USB_REQ_SET_FEATURE
) {
166 /*-------------------------------------------------*/
168 recipient
= (u8
)(p_ctrl
->bRequestType
& USB_RECIP_MASK
);
169 selector
= p_ctrl
->wValue
;
170 if ((recipient
== USB_RECIP_DEVICE
) &&
171 (selector
== USB_DEVICE_TEST_MODE
)) {
172 test_mode
= (u32
)(p_ctrl
->wIndex
>> 8);
173 _nbu2ss_set_test_mode(udc
, test_mode
);
179 /*-------------------------------------------------------------------------*/
180 /* Initialization usb_request */
181 static void _nbu2ss_create_ep0_packet(
182 struct nbu2ss_udc
*udc
,
187 udc
->ep0_req
.req
.buf
= p_buf
;
188 udc
->ep0_req
.req
.length
= length
;
189 udc
->ep0_req
.req
.dma
= 0;
190 udc
->ep0_req
.req
.zero
= TRUE
;
191 udc
->ep0_req
.req
.complete
= _nbu2ss_ep0_complete
;
192 udc
->ep0_req
.req
.status
= -EINPROGRESS
;
193 udc
->ep0_req
.req
.context
= udc
;
194 udc
->ep0_req
.req
.actual
= 0;
197 /*-------------------------------------------------------------------------*/
198 /* Acquisition of the first address of RAM(FIFO) */
199 static u32
_nbu2ss_get_begin_ram_address(struct nbu2ss_udc
*udc
)
202 u32 data
, last_ram_adr
, use_ram_size
;
204 PT_EP_REGS p_ep_regs
;
206 last_ram_adr
= (D_RAM_SIZE_CTRL
/ sizeof(u32
)) * 2;
209 for (num
= 0; num
< NUM_ENDPOINTS
- 1; num
++) {
210 p_ep_regs
= &udc
->p_regs
->EP_REGS
[num
];
211 data
= _nbu2ss_readl(&p_ep_regs
->EP_PCKT_ADRS
);
212 buf_type
= _nbu2ss_readl(&p_ep_regs
->EP_CONTROL
) & EPn_BUF_TYPE
;
215 use_ram_size
+= (data
& EPn_MPKT
) / sizeof(u32
);
218 use_ram_size
+= ((data
& EPn_MPKT
) / sizeof(u32
)) * 2;
221 if ((data
>> 16) > last_ram_adr
)
222 last_ram_adr
= data
>>16;
225 return last_ram_adr
+ use_ram_size
;
228 /*-------------------------------------------------------------------------*/
229 /* Construction of Endpoint */
230 static int _nbu2ss_ep_init(struct nbu2ss_udc
*udc
, struct nbu2ss_ep
*ep
)
241 /*-------------------------------------------------------------*/
242 /* RAM Transfer Address */
243 begin_adrs
= _nbu2ss_get_begin_ram_address(udc
);
244 data
= (begin_adrs
<< 16) | ep
->ep
.maxpacket
;
245 _nbu2ss_writel(&udc
->p_regs
->EP_REGS
[num
].EP_PCKT_ADRS
, data
);
247 /*-------------------------------------------------------------*/
248 /* Interrupt Enable */
249 data
= 1 << (ep
->epnum
+ 8);
250 _nbu2ss_bitset(&udc
->p_regs
->USB_INT_ENA
, data
);
252 /*-------------------------------------------------------------*/
253 /* Endpoint Type(Mode) */
254 /* Bulk, Interrupt, ISO */
255 switch (ep
->ep_type
) {
256 case USB_ENDPOINT_XFER_BULK
:
260 case USB_ENDPOINT_XFER_INT
:
261 data
= EPn_BUF_SINGLE
| EPn_INTERRUPT
;
264 case USB_ENDPOINT_XFER_ISOC
:
273 _nbu2ss_bitset(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
274 _nbu2ss_endpoint_toggle_reset(udc
, (ep
->epnum
|ep
->direct
));
276 if (ep
->direct
== USB_DIR_OUT
) {
277 /*---------------------------------------------------------*/
279 data
= EPn_EN
| EPn_BCLR
| EPn_DIR0
;
280 _nbu2ss_bitset(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
282 data
= (EPn_ONAK
| EPn_OSTL_EN
| EPn_OSTL
);
283 _nbu2ss_bitclr(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
285 data
= (EPn_OUT_EN
| EPn_OUT_END_EN
);
286 _nbu2ss_bitset(&udc
->p_regs
->EP_REGS
[num
].EP_INT_ENA
, data
);
288 /*---------------------------------------------------------*/
290 data
= (EPn_EN
| EPn_BCLR
| EPn_AUTO
);
291 _nbu2ss_bitset(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
294 _nbu2ss_bitclr(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
296 data
= (EPn_IN_EN
| EPn_IN_END_EN
);
297 _nbu2ss_bitset(&udc
->p_regs
->EP_REGS
[num
].EP_INT_ENA
, data
);
303 /*-------------------------------------------------------------------------*/
304 /* Release of Endpoint */
305 static int _nbu2ss_epn_exit(struct nbu2ss_udc
*udc
, struct nbu2ss_ep
*ep
)
310 if ((ep
->epnum
== 0) || (udc
->vbus_active
== 0))
315 /*-------------------------------------------------------------*/
316 /* RAM Transfer Address */
317 _nbu2ss_writel(&udc
->p_regs
->EP_REGS
[num
].EP_PCKT_ADRS
, 0);
319 /*-------------------------------------------------------------*/
320 /* Interrupt Disable */
321 data
= 1 << (ep
->epnum
+ 8);
322 _nbu2ss_bitclr(&udc
->p_regs
->USB_INT_ENA
, data
);
324 if (ep
->direct
== USB_DIR_OUT
) {
325 /*---------------------------------------------------------*/
327 data
= EPn_ONAK
| EPn_BCLR
;
328 _nbu2ss_bitset(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
330 data
= EPn_EN
| EPn_DIR0
;
331 _nbu2ss_bitclr(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
333 data
= EPn_OUT_EN
| EPn_OUT_END_EN
;
334 _nbu2ss_bitclr(&udc
->p_regs
->EP_REGS
[num
].EP_INT_ENA
, data
);
336 /*---------------------------------------------------------*/
339 _nbu2ss_bitset(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
341 data
= EPn_EN
| EPn_AUTO
;
342 _nbu2ss_bitclr(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
344 data
= EPn_IN_EN
| EPn_IN_END_EN
;
345 _nbu2ss_bitclr(&udc
->p_regs
->EP_REGS
[num
].EP_INT_ENA
, data
);
351 /*-------------------------------------------------------------------------*/
352 /* DMA setting (without Endpoint 0) */
353 static void _nbu2ss_ep_dma_init(struct nbu2ss_udc
*udc
, struct nbu2ss_ep
*ep
)
358 data
= _nbu2ss_readl(&udc
->p_regs
->USBSSCONF
);
359 if (((ep
->epnum
== 0) || (data
& (1 << ep
->epnum
)) == 0))
360 return; /* Not Support DMA */
364 if (ep
->direct
== USB_DIR_OUT
) {
365 /*---------------------------------------------------------*/
367 data
= ep
->ep
.maxpacket
;
368 _nbu2ss_writel(&udc
->p_regs
->EP_DCR
[num
].EP_DCR2
, data
);
370 /*---------------------------------------------------------*/
371 /* Transfer Direct */
372 data
= DCR1_EPn_DIR0
;
373 _nbu2ss_bitset(&udc
->p_regs
->EP_DCR
[num
].EP_DCR1
, data
);
375 /*---------------------------------------------------------*/
377 data
= EPn_STOP_MODE
| EPn_STOP_SET
| EPn_DMAMODE0
;
378 _nbu2ss_writel(&udc
->p_regs
->EP_REGS
[num
].EP_DMA_CTRL
, data
);
380 /*---------------------------------------------------------*/
382 _nbu2ss_bitset(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, EPn_AUTO
);
384 /*---------------------------------------------------------*/
386 data
= EPn_BURST_SET
| EPn_DMAMODE0
;
387 _nbu2ss_writel(&udc
->p_regs
->EP_REGS
[num
].EP_DMA_CTRL
, data
);
391 /*-------------------------------------------------------------------------*/
392 /* DMA setting release */
393 static void _nbu2ss_ep_dma_exit(struct nbu2ss_udc
*udc
, struct nbu2ss_ep
*ep
)
397 PT_FC_REGS preg
= udc
->p_regs
;
399 if (udc
->vbus_active
== 0)
400 return; /* VBUS OFF */
402 data
= _nbu2ss_readl(&preg
->USBSSCONF
);
403 if ((ep
->epnum
== 0) || ((data
& (1 << ep
->epnum
)) == 0))
404 return; /* Not Support DMA */
408 _nbu2ss_ep_dma_abort(udc
, ep
);
410 if (ep
->direct
== USB_DIR_OUT
) {
411 /*---------------------------------------------------------*/
413 _nbu2ss_writel(&preg
->EP_DCR
[num
].EP_DCR2
, 0);
414 _nbu2ss_bitclr(&preg
->EP_DCR
[num
].EP_DCR1
, DCR1_EPn_DIR0
);
415 _nbu2ss_writel(&preg
->EP_REGS
[num
].EP_DMA_CTRL
, 0);
417 /*---------------------------------------------------------*/
419 _nbu2ss_bitclr(&preg
->EP_REGS
[num
].EP_CONTROL
, EPn_AUTO
);
420 _nbu2ss_writel(&preg
->EP_REGS
[num
].EP_DMA_CTRL
, 0);
424 /*-------------------------------------------------------------------------*/
426 static void _nbu2ss_ep_dma_abort(struct nbu2ss_udc
*udc
, struct nbu2ss_ep
*ep
)
428 PT_FC_REGS preg
= udc
->p_regs
;
430 _nbu2ss_bitclr(&preg
->EP_DCR
[ep
->epnum
-1].EP_DCR1
, DCR1_EPn_REQEN
);
431 mdelay(DMA_DISABLE_TIME
); /* DCR1_EPn_REQEN Clear */
432 _nbu2ss_bitclr(&preg
->EP_REGS
[ep
->epnum
-1].EP_DMA_CTRL
, EPn_DMA_EN
);
435 /*-------------------------------------------------------------------------*/
436 /* Start IN Transfer */
437 static void _nbu2ss_ep_in_end(
438 struct nbu2ss_udc
*udc
,
446 PT_FC_REGS preg
= udc
->p_regs
;
448 if (length
>= sizeof(u32
))
452 _nbu2ss_bitclr(&preg
->EP0_CONTROL
, EP0_AUTO
);
454 /* Writing of 1-4 bytes */
456 _nbu2ss_writel(&preg
->EP0_WRITE
, data32
);
458 data
= ((length
<< 5) & EP0_DW
) | EP0_DEND
;
459 _nbu2ss_writel(&preg
->EP0_CONTROL
, data
);
461 _nbu2ss_bitset(&preg
->EP0_CONTROL
, EP0_AUTO
);
465 _nbu2ss_bitclr(&preg
->EP_REGS
[num
].EP_CONTROL
, EPn_AUTO
);
467 /* Writing of 1-4 bytes */
469 _nbu2ss_writel(&preg
->EP_REGS
[num
].EP_WRITE
, data32
);
471 data
= (((((u32
)length
) << 5) & EPn_DW
) | EPn_DEND
);
472 _nbu2ss_bitset(&preg
->EP_REGS
[num
].EP_CONTROL
, data
);
474 _nbu2ss_bitset(&preg
->EP_REGS
[num
].EP_CONTROL
, EPn_AUTO
);
479 /*-------------------------------------------------------------------------*/
480 static void _nbu2ss_dma_map_single(
481 struct nbu2ss_udc
*udc
,
482 struct nbu2ss_ep
*ep
,
483 struct nbu2ss_req
*req
,
487 if (req
->req
.dma
== DMA_ADDR_INVALID
) {
489 req
->req
.dma
= ep
->phys_buf
;
491 req
->req
.dma
= dma_map_single(
492 udc
->gadget
.dev
.parent
,
495 (direct
== USB_DIR_IN
)
496 ? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
501 dma_sync_single_for_device(
502 udc
->gadget
.dev
.parent
,
505 (direct
== USB_DIR_IN
)
506 ? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
512 /*-------------------------------------------------------------------------*/
513 static void _nbu2ss_dma_unmap_single(
514 struct nbu2ss_udc
*udc
,
515 struct nbu2ss_ep
*ep
,
516 struct nbu2ss_req
*req
,
524 if (direct
== USB_DIR_OUT
) {
525 count
= req
->req
.actual
% 4;
528 p
+= (req
->req
.actual
- count
);
529 memcpy(data
, p
, count
);
534 if (req
->unaligned
) {
535 if (direct
== USB_DIR_OUT
)
536 memcpy(req
->req
.buf
, ep
->virt_buf
,
537 req
->req
.actual
& 0xfffffffc);
539 dma_unmap_single(udc
->gadget
.dev
.parent
,
540 req
->req
.dma
, req
->req
.length
,
541 (direct
== USB_DIR_IN
)
544 req
->req
.dma
= DMA_ADDR_INVALID
;
548 dma_sync_single_for_cpu(udc
->gadget
.dev
.parent
,
549 req
->req
.dma
, req
->req
.length
,
550 (direct
== USB_DIR_IN
)
557 p
+= (req
->req
.actual
- count
);
558 memcpy(p
, data
, count
);
563 /*-------------------------------------------------------------------------*/
564 /* Endpoint 0 OUT Transfer (PIO) */
565 static int EP0_out_PIO(struct nbu2ss_udc
*udc
, u8
*pBuf
, u32 length
)
570 USB_REG_ACCESS
*pBuf32
= (USB_REG_ACCESS
*)pBuf
;
572 /*------------------------------------------------------------*/
574 iWordLength
= length
/ sizeof(u32
);
576 /*------------------------------------------------------------*/
579 for (i
= 0; i
< iWordLength
; i
++) {
580 pBuf32
->dw
= _nbu2ss_readl(&udc
->p_regs
->EP0_READ
);
583 nret
= iWordLength
* sizeof(u32
);
589 /*-------------------------------------------------------------------------*/
590 /* Endpoint 0 OUT Transfer (PIO, OverBytes) */
591 static int EP0_out_OverBytes(struct nbu2ss_udc
*udc
, u8
*pBuf
, u32 length
)
595 USB_REG_ACCESS Temp32
;
596 USB_REG_ACCESS
*pBuf32
= (USB_REG_ACCESS
*)pBuf
;
598 if ((0 < length
) && (length
< sizeof(u32
))) {
599 Temp32
.dw
= _nbu2ss_readl(&udc
->p_regs
->EP0_READ
);
600 for (i
= 0 ; i
< length
; i
++)
601 pBuf32
->byte
.DATA
[i
] = Temp32
.byte
.DATA
[i
];
608 /*-------------------------------------------------------------------------*/
609 /* Endpoint 0 IN Transfer (PIO) */
610 static int EP0_in_PIO(struct nbu2ss_udc
*udc
, u8
*pBuf
, u32 length
)
613 u32 iMaxLength
= EP0_PACKETSIZE
;
615 u32 iWriteLength
= 0;
616 USB_REG_ACCESS
*pBuf32
= (USB_REG_ACCESS
*)pBuf
;
618 /*------------------------------------------------------------*/
619 /* Transfer Length */
620 if (iMaxLength
< length
)
621 iWordLength
= iMaxLength
/ sizeof(u32
);
623 iWordLength
= length
/ sizeof(u32
);
625 /*------------------------------------------------------------*/
627 for (i
= 0; i
< iWordLength
; i
++) {
628 _nbu2ss_writel(&udc
->p_regs
->EP0_WRITE
, pBuf32
->dw
);
630 iWriteLength
+= sizeof(u32
);
636 /*-------------------------------------------------------------------------*/
637 /* Endpoint 0 IN Transfer (PIO, OverBytes) */
638 static int EP0_in_OverBytes(struct nbu2ss_udc
*udc
, u8
*pBuf
, u32 iRemainSize
)
641 USB_REG_ACCESS Temp32
;
642 USB_REG_ACCESS
*pBuf32
= (USB_REG_ACCESS
*)pBuf
;
644 if ((0 < iRemainSize
) && (iRemainSize
< sizeof(u32
))) {
645 for (i
= 0 ; i
< iRemainSize
; i
++)
646 Temp32
.byte
.DATA
[i
] = pBuf32
->byte
.DATA
[i
];
647 _nbu2ss_ep_in_end(udc
, 0, Temp32
.dw
, iRemainSize
);
655 /*-------------------------------------------------------------------------*/
656 /* Transfer NULL Packet (Epndoint 0) */
657 static int EP0_send_NULL(struct nbu2ss_udc
*udc
, bool pid_flag
)
661 data
= _nbu2ss_readl(&udc
->p_regs
->EP0_CONTROL
);
662 data
&= ~(u32
)EP0_INAK
;
665 data
|= (EP0_INAK_EN
| EP0_PIDCLR
| EP0_DEND
);
667 data
|= (EP0_INAK_EN
| EP0_DEND
);
669 _nbu2ss_writel(&udc
->p_regs
->EP0_CONTROL
, data
);
674 /*-------------------------------------------------------------------------*/
675 /* Receive NULL Packet (Endpoint 0) */
676 static int EP0_receive_NULL(struct nbu2ss_udc
*udc
, bool pid_flag
)
680 data
= _nbu2ss_readl(&udc
->p_regs
->EP0_CONTROL
);
681 data
&= ~(u32
)EP0_ONAK
;
686 _nbu2ss_writel(&udc
->p_regs
->EP0_CONTROL
, data
);
691 /*-------------------------------------------------------------------------*/
692 static int _nbu2ss_ep0_in_transfer(
693 struct nbu2ss_udc
*udc
,
694 struct nbu2ss_ep
*ep
,
695 struct nbu2ss_req
*req
698 u8
*pBuffer
; /* IN Data Buffer */
703 /*-------------------------------------------------------------*/
704 /* End confirmation */
705 if (req
->req
.actual
== req
->req
.length
) {
706 if ((req
->req
.actual
% EP0_PACKETSIZE
) == 0) {
709 EP0_send_NULL(udc
, FALSE
);
714 return 0; /* Transfer End */
717 /*-------------------------------------------------------------*/
719 data
= _nbu2ss_readl(&udc
->p_regs
->EP0_CONTROL
);
721 data
&= ~(u32
)EP0_INAK
;
722 _nbu2ss_writel(&udc
->p_regs
->EP0_CONTROL
, data
);
724 iRemainSize
= req
->req
.length
- req
->req
.actual
;
725 pBuffer
= (u8
*)req
->req
.buf
;
726 pBuffer
+= req
->req
.actual
;
728 /*-------------------------------------------------------------*/
730 result
= EP0_in_PIO(udc
, pBuffer
, iRemainSize
);
732 req
->div_len
= result
;
733 iRemainSize
-= result
;
735 if (iRemainSize
== 0) {
736 EP0_send_NULL(udc
, FALSE
);
740 if ((iRemainSize
< sizeof(u32
)) && (result
!= EP0_PACKETSIZE
)) {
742 result
+= EP0_in_OverBytes(udc
, pBuffer
, iRemainSize
);
743 req
->div_len
= result
;
749 /*-------------------------------------------------------------------------*/
750 static int _nbu2ss_ep0_out_transfer(
751 struct nbu2ss_udc
*udc
,
752 struct nbu2ss_ep
*ep
,
753 struct nbu2ss_req
*req
762 /*-------------------------------------------------------------*/
763 /* Receive data confirmation */
764 iRecvLength
= _nbu2ss_readl(&udc
->p_regs
->EP0_LENGTH
) & EP0_LDATA
;
765 if (iRecvLength
!= 0) {
769 iRemainSize
= req
->req
.length
- req
->req
.actual
;
770 pBuffer
= (u8
*)req
->req
.buf
;
771 pBuffer
+= req
->req
.actual
;
773 result
= EP0_out_PIO(udc
, pBuffer
774 , min(iRemainSize
, iRecvLength
));
778 req
->req
.actual
+= result
;
779 iRecvLength
-= result
;
781 if ((0 < iRecvLength
) && (iRecvLength
< sizeof(u32
))) {
783 iRemainSize
-= result
;
785 result
= EP0_out_OverBytes(udc
, pBuffer
786 , min(iRemainSize
, iRecvLength
));
787 req
->req
.actual
+= result
;
793 /*-------------------------------------------------------------*/
794 /* End confirmation */
795 if (req
->req
.actual
== req
->req
.length
) {
796 if ((req
->req
.actual
% EP0_PACKETSIZE
) == 0) {
799 EP0_receive_NULL(udc
, FALSE
);
804 return 0; /* Transfer End */
807 if ((req
->req
.actual
% EP0_PACKETSIZE
) != 0)
808 return 0; /* Short Packet Transfer End */
810 if (req
->req
.actual
> req
->req
.length
) {
811 ERR(" *** Overrun Error\n");
816 iRemainSize
= _nbu2ss_readl(&udc
->p_regs
->EP0_CONTROL
);
817 if (iRemainSize
& EP0_ONAK
) {
818 /*---------------------------------------------------*/
820 _nbu2ss_bitclr(&udc
->p_regs
->EP0_CONTROL
, EP0_ONAK
);
828 /*-------------------------------------------------------------------------*/
829 static int _nbu2ss_out_dma(
830 struct nbu2ss_udc
*udc
,
831 struct nbu2ss_req
*req
,
842 int result
= -EINVAL
;
843 PT_FC_REGS preg
= udc
->p_regs
;
846 return 1; /* DMA is forwarded */
848 req
->dma_flag
= TRUE
;
849 pBuffer
= (u8
*)req
->req
.dma
;
850 pBuffer
+= req
->req
.actual
;
853 _nbu2ss_writel(&preg
->EP_DCR
[num
].EP_TADR
, (u32
)pBuffer
);
855 /* Number of transfer packets */
856 mpkt
= _nbu2ss_readl(&preg
->EP_REGS
[num
].EP_PCKT_ADRS
) & EPn_MPKT
;
857 dmacnt
= (length
/ mpkt
);
858 lmpkt
= (length
% mpkt
) & ~(u32
)0x03;
860 if (DMA_MAX_COUNT
< dmacnt
) {
861 dmacnt
= DMA_MAX_COUNT
;
863 } else if (0 != lmpkt
) {
865 burst
= 0; /* Burst OFF */
869 data
= mpkt
| (lmpkt
<< 16);
870 _nbu2ss_writel(&preg
->EP_DCR
[num
].EP_DCR2
, data
);
872 data
= ((dmacnt
& 0xff) << 16) | DCR1_EPn_DIR0
| DCR1_EPn_REQEN
;
873 _nbu2ss_writel(&preg
->EP_DCR
[num
].EP_DCR1
, data
);
876 _nbu2ss_writel(&preg
->EP_REGS
[num
].EP_LEN_DCNT
, 0);
877 _nbu2ss_bitclr(&preg
->EP_REGS
[num
].EP_DMA_CTRL
, EPn_BURST_SET
);
879 _nbu2ss_writel(&preg
->EP_REGS
[num
].EP_LEN_DCNT
881 _nbu2ss_bitset(&preg
->EP_REGS
[num
].EP_DMA_CTRL
, EPn_BURST_SET
);
883 _nbu2ss_bitset(&preg
->EP_REGS
[num
].EP_DMA_CTRL
, EPn_DMA_EN
);
885 result
= length
& ~(u32
)0x03;
886 req
->div_len
= result
;
891 /*-------------------------------------------------------------------------*/
892 static int _nbu2ss_epn_out_pio(
893 struct nbu2ss_udc
*udc
,
894 struct nbu2ss_ep
*ep
,
895 struct nbu2ss_req
*req
,
903 USB_REG_ACCESS Temp32
;
904 USB_REG_ACCESS
*pBuf32
;
906 PT_FC_REGS preg
= udc
->p_regs
;
909 return 1; /* DMA is forwarded */
914 pBuffer
= (u8
*)req
->req
.buf
;
915 pBuf32
= (USB_REG_ACCESS
*)(pBuffer
+ req
->req
.actual
);
917 iWordLength
= length
/ sizeof(u32
);
918 if (iWordLength
> 0) {
919 /*---------------------------------------------------------*/
920 /* Copy of every four bytes */
921 for (i
= 0; i
< iWordLength
; i
++) {
923 _nbu2ss_readl(&preg
->EP_REGS
[ep
->epnum
-1].EP_READ
);
926 result
= iWordLength
* sizeof(u32
);
929 data
= length
- result
;
931 /*---------------------------------------------------------*/
932 /* Copy of fraction byte */
933 Temp32
.dw
= _nbu2ss_readl(&preg
->EP_REGS
[ep
->epnum
-1].EP_READ
);
934 for (i
= 0 ; i
< data
; i
++)
935 pBuf32
->byte
.DATA
[i
] = Temp32
.byte
.DATA
[i
];
939 req
->req
.actual
+= result
;
941 if ((req
->req
.actual
== req
->req
.length
)
942 || ((req
->req
.actual
% ep
->ep
.maxpacket
) != 0)) {
950 /*-------------------------------------------------------------------------*/
951 static int _nbu2ss_epn_out_data(
952 struct nbu2ss_udc
*udc
,
953 struct nbu2ss_ep
*ep
,
954 struct nbu2ss_req
*req
,
967 iBufSize
= min((req
->req
.length
- req
->req
.actual
), data_size
);
969 if ((ep
->ep_type
!= USB_ENDPOINT_XFER_INT
)
970 && (req
->req
.dma
!= 0)
971 && (iBufSize
>= sizeof(u32
))) {
972 nret
= _nbu2ss_out_dma(udc
, req
, num
, iBufSize
);
974 iBufSize
= min(iBufSize
, (u32
)ep
->ep
.maxpacket
);
975 nret
= _nbu2ss_epn_out_pio(udc
, ep
, req
, iBufSize
);
981 /*-------------------------------------------------------------------------*/
982 static int _nbu2ss_epn_out_transfer(
983 struct nbu2ss_udc
*udc
,
984 struct nbu2ss_ep
*ep
,
985 struct nbu2ss_req
*req
991 PT_FC_REGS preg
= udc
->p_regs
;
998 /*-------------------------------------------------------------*/
1001 = _nbu2ss_readl(&preg
->EP_REGS
[num
].EP_LEN_DCNT
) & EPn_LDATA
;
1003 if (iRecvLength
!= 0) {
1004 result
= _nbu2ss_epn_out_data(udc
, ep
, req
, iRecvLength
);
1005 if (iRecvLength
< ep
->ep
.maxpacket
) {
1006 if (iRecvLength
== result
) {
1007 req
->req
.actual
+= result
;
1012 if ((req
->req
.actual
== req
->req
.length
)
1013 || ((req
->req
.actual
% ep
->ep
.maxpacket
) != 0)) {
1020 if ((req
->req
.actual
% ep
->ep
.maxpacket
) == 0) {
1028 if (req
->req
.actual
> req
->req
.length
) {
1029 ERR(" *** Overrun Error\n");
1030 ERR(" *** actual = %d, length = %d\n",
1031 req
->req
.actual
, req
->req
.length
);
1032 result
= -EOVERFLOW
;
1038 /*-------------------------------------------------------------------------*/
1039 static int _nbu2ss_in_dma(
1040 struct nbu2ss_udc
*udc
,
1041 struct nbu2ss_ep
*ep
,
1042 struct nbu2ss_req
*req
,
1048 u32 mpkt
; /* MaxPacketSize */
1049 u32 lmpkt
; /* Last Packet Data Size */
1050 u32 dmacnt
; /* IN Data Size */
1053 int result
= -EINVAL
;
1054 PT_FC_REGS preg
= udc
->p_regs
;
1057 return 1; /* DMA is forwarded */
1060 if (req
->req
.actual
== 0)
1061 _nbu2ss_dma_map_single(udc
, ep
, req
, USB_DIR_IN
);
1063 req
->dma_flag
= TRUE
;
1065 /* MAX Packet Size */
1066 mpkt
= _nbu2ss_readl(&preg
->EP_REGS
[num
].EP_PCKT_ADRS
) & EPn_MPKT
;
1068 if ((DMA_MAX_COUNT
* mpkt
) < length
)
1069 iWriteLength
= DMA_MAX_COUNT
* mpkt
;
1071 iWriteLength
= length
;
1073 /*------------------------------------------------------------*/
1074 /* Number of transmission packets */
1075 if (mpkt
< iWriteLength
) {
1076 dmacnt
= iWriteLength
/ mpkt
;
1077 lmpkt
= (iWriteLength
% mpkt
) & ~(u32
)0x3;
1081 lmpkt
= mpkt
& ~(u32
)0x3;
1085 lmpkt
= iWriteLength
& ~(u32
)0x3;
1088 /* Packet setting */
1089 data
= mpkt
| (lmpkt
<< 16);
1090 _nbu2ss_writel(&preg
->EP_DCR
[num
].EP_DCR2
, data
);
1092 /* Address setting */
1093 pBuffer
= (u8
*)req
->req
.dma
;
1094 pBuffer
+= req
->req
.actual
;
1095 _nbu2ss_writel(&preg
->EP_DCR
[num
].EP_TADR
, (u32
)pBuffer
);
1097 /* Packet and DMA setting */
1098 data
= ((dmacnt
& 0xff) << 16) | DCR1_EPn_REQEN
;
1099 _nbu2ss_writel(&preg
->EP_DCR
[num
].EP_DCR1
, data
);
1101 /* Packet setting of EPC */
1102 data
= dmacnt
<< 16;
1103 _nbu2ss_writel(&preg
->EP_REGS
[num
].EP_LEN_DCNT
, data
);
1105 /*DMA setting of EPC */
1106 _nbu2ss_bitset(&preg
->EP_REGS
[num
].EP_DMA_CTRL
, EPn_DMA_EN
);
1108 result
= iWriteLength
& ~(u32
)0x3;
1109 req
->div_len
= result
;
1114 /*-------------------------------------------------------------------------*/
1115 static int _nbu2ss_epn_in_pio(
1116 struct nbu2ss_udc
*udc
,
1117 struct nbu2ss_ep
*ep
,
1118 struct nbu2ss_req
*req
,
1126 USB_REG_ACCESS Temp32
;
1127 USB_REG_ACCESS
*pBuf32
= NULL
;
1129 PT_FC_REGS preg
= udc
->p_regs
;
1132 return 1; /* DMA is forwarded */
1135 pBuffer
= (u8
*)req
->req
.buf
;
1136 pBuf32
= (USB_REG_ACCESS
*)(pBuffer
+ req
->req
.actual
);
1138 iWordLength
= length
/ sizeof(u32
);
1139 if (iWordLength
> 0) {
1140 for (i
= 0; i
< iWordLength
; i
++) {
1142 &preg
->EP_REGS
[ep
->epnum
-1].EP_WRITE
1148 result
= iWordLength
* sizeof(u32
);
1152 if (result
!= ep
->ep
.maxpacket
) {
1153 data
= length
- result
;
1155 for (i
= 0 ; i
< data
; i
++)
1156 Temp32
.byte
.DATA
[i
] = pBuf32
->byte
.DATA
[i
];
1158 _nbu2ss_ep_in_end(udc
, ep
->epnum
, Temp32
.dw
, data
);
1162 req
->div_len
= result
;
1167 /*-------------------------------------------------------------------------*/
1168 static int _nbu2ss_epn_in_data(
1169 struct nbu2ss_udc
*udc
,
1170 struct nbu2ss_ep
*ep
,
1171 struct nbu2ss_req
*req
,
1181 num
= ep
->epnum
- 1;
1183 if ((ep
->ep_type
!= USB_ENDPOINT_XFER_INT
)
1184 && (req
->req
.dma
!= 0)
1185 && (data_size
>= sizeof(u32
))) {
1186 nret
= _nbu2ss_in_dma(udc
, ep
, req
, num
, data_size
);
1188 data_size
= min(data_size
, (u32
)ep
->ep
.maxpacket
);
1189 nret
= _nbu2ss_epn_in_pio(udc
, ep
, req
, data_size
);
1195 /*-------------------------------------------------------------------------*/
1196 static int _nbu2ss_epn_in_transfer(
1197 struct nbu2ss_udc
*udc
,
1198 struct nbu2ss_ep
*ep
,
1199 struct nbu2ss_req
*req
1210 num
= ep
->epnum
- 1;
1212 status
= _nbu2ss_readl(&udc
->p_regs
->EP_REGS
[num
].EP_STATUS
);
1214 /*-------------------------------------------------------------*/
1215 /* State confirmation of FIFO */
1216 if (req
->req
.actual
== 0) {
1217 if ((status
& EPn_IN_EMPTY
) == 0)
1218 return 1; /* Not Empty */
1221 if ((status
& EPn_IN_FULL
) != 0)
1222 return 1; /* Not Empty */
1225 /*-------------------------------------------------------------*/
1227 iBufSize
= req
->req
.length
- req
->req
.actual
;
1229 result
= _nbu2ss_epn_in_data(udc
, ep
, req
, iBufSize
);
1230 else if (req
->req
.length
== 0)
1231 _nbu2ss_zero_len_pkt(udc
, ep
->epnum
);
1236 /*-------------------------------------------------------------------------*/
1237 static int _nbu2ss_start_transfer(
1238 struct nbu2ss_udc
*udc
,
1239 struct nbu2ss_ep
*ep
,
1240 struct nbu2ss_req
*req
,
1245 req
->dma_flag
= FALSE
;
1248 if (req
->req
.length
== 0)
1251 if ((req
->req
.length
% ep
->ep
.maxpacket
) == 0)
1252 req
->zero
= req
->req
.zero
;
1257 if (ep
->epnum
== 0) {
1259 switch (udc
->ep0state
) {
1260 case EP0_IN_DATA_PHASE
:
1261 nret
= _nbu2ss_ep0_in_transfer(udc
, ep
, req
);
1264 case EP0_OUT_DATA_PHASE
:
1265 nret
= _nbu2ss_ep0_out_transfer(udc
, ep
, req
);
1268 case EP0_IN_STATUS_PHASE
:
1269 nret
= EP0_send_NULL(udc
, TRUE
);
1278 if (ep
->direct
== USB_DIR_OUT
) {
1281 nret
= _nbu2ss_epn_out_transfer(udc
, ep
, req
);
1284 nret
= _nbu2ss_epn_in_transfer(udc
, ep
, req
);
1291 /*-------------------------------------------------------------------------*/
1292 static void _nbu2ss_restert_transfer(struct nbu2ss_ep
*ep
)
1296 struct nbu2ss_req
*req
;
1298 if (list_empty(&ep
->queue
))
1301 req
= list_entry(ep
->queue
.next
, struct nbu2ss_req
, queue
);
1306 if (ep
->epnum
> 0) {
1307 length
= _nbu2ss_readl(
1308 &ep
->udc
->p_regs
->EP_REGS
[ep
->epnum
-1].EP_LEN_DCNT
);
1310 length
&= EPn_LDATA
;
1311 if (length
< ep
->ep
.maxpacket
)
1315 _nbu2ss_start_transfer(ep
->udc
, ep
, req
, bflag
);
1318 /*-------------------------------------------------------------------------*/
1319 /* Endpoint Toggle Reset */
1320 static void _nbu2ss_endpoint_toggle_reset(
1321 struct nbu2ss_udc
*udc
,
1327 if ((ep_adrs
== 0) || (ep_adrs
== 0x80))
1330 num
= (ep_adrs
& 0x7F) - 1;
1332 if (ep_adrs
& USB_DIR_IN
)
1335 data
= EPn_BCLR
| EPn_OPIDCLR
;
1337 _nbu2ss_bitset(&udc
->p_regs
->EP_REGS
[num
].EP_CONTROL
, data
);
1340 /*-------------------------------------------------------------------------*/
1341 /* Endpoint STALL set */
1342 static void _nbu2ss_set_endpoint_stall(
1343 struct nbu2ss_udc
*udc
,
1349 struct nbu2ss_ep
*ep
;
1350 PT_FC_REGS preg
= udc
->p_regs
;
1352 if ((ep_adrs
== 0) || (ep_adrs
== 0x80)) {
1355 _nbu2ss_bitset(&preg
->EP0_CONTROL
, EP0_STL
);
1358 _nbu2ss_bitclr(&preg
->EP0_CONTROL
, EP0_STL
);
1361 epnum
= ep_adrs
& USB_ENDPOINT_NUMBER_MASK
;
1363 ep
= &udc
->ep
[epnum
];
1369 if (ep_adrs
& USB_DIR_IN
)
1370 data
= EPn_BCLR
| EPn_ISTL
;
1372 data
= EPn_OSTL_EN
| EPn_OSTL
;
1374 _nbu2ss_bitset(&preg
->EP_REGS
[num
].EP_CONTROL
, data
);
1377 ep
->stalled
= FALSE
;
1378 if (ep_adrs
& USB_DIR_IN
) {
1379 _nbu2ss_bitclr(&preg
->EP_REGS
[num
].EP_CONTROL
1383 _nbu2ss_readl(&preg
->EP_REGS
[num
].EP_CONTROL
);
1386 data
|= EPn_OSTL_EN
;
1388 _nbu2ss_writel(&preg
->EP_REGS
[num
].EP_CONTROL
1392 ep
->stalled
= FALSE
;
1395 _nbu2ss_restert_transfer(ep
);
1402 /*-------------------------------------------------------------------------*/
1403 /* Device Descriptor */
1404 static struct usb_device_descriptor device_desc
= {
1405 .bLength
= sizeof(device_desc
),
1406 .bDescriptorType
= USB_DT_DEVICE
,
1407 .bcdUSB
= cpu_to_le16(0x0200),
1408 .bDeviceClass
= USB_CLASS_VENDOR_SPEC
,
1409 .bDeviceSubClass
= 0x00,
1410 .bDeviceProtocol
= 0x00,
1411 .bMaxPacketSize0
= 64,
1412 .idVendor
= cpu_to_le16(0x0409),
1413 .idProduct
= cpu_to_le16(0xfff0),
1414 .bcdDevice
= 0xffff,
1415 .iManufacturer
= 0x00,
1417 .iSerialNumber
= 0x00,
1418 .bNumConfigurations
= 0x01,
1421 /*-------------------------------------------------------------------------*/
1422 static void _nbu2ss_set_test_mode(struct nbu2ss_udc
*udc
, u32 mode
)
1426 if (mode
> MAX_TEST_MODE_NUM
)
1429 pr_info("SET FEATURE : test mode = %d\n", mode
);
1431 data
= _nbu2ss_readl(&udc
->p_regs
->USB_CONTROL
);
1432 data
&= ~TEST_FORCE_ENABLE
;
1433 data
|= mode
<< TEST_MODE_SHIFT
;
1435 _nbu2ss_writel(&udc
->p_regs
->USB_CONTROL
, data
);
1436 _nbu2ss_bitset(&udc
->p_regs
->TEST_CONTROL
, CS_TESTMODEEN
);
1439 /*-------------------------------------------------------------------------*/
1440 static int _nbu2ss_set_feature_device(
1441 struct nbu2ss_udc
*udc
,
1446 int result
= -EOPNOTSUPP
;
1449 case USB_DEVICE_REMOTE_WAKEUP
:
1450 if (0x0000 == wIndex
) {
1451 udc
->remote_wakeup
= U2F_ENABLE
;
1456 case USB_DEVICE_TEST_MODE
:
1457 wIndex
= wIndex
>> 8;
1458 if (wIndex
<= MAX_TEST_MODE_NUM
)
1469 /*-------------------------------------------------------------------------*/
1470 static int _nbu2ss_get_ep_stall(struct nbu2ss_udc
*udc
, u8 ep_adrs
)
1473 u32 data
= 0, bit_data
;
1474 PT_FC_REGS preg
= udc
->p_regs
;
1476 epnum
= ep_adrs
& ~USB_ENDPOINT_DIR_MASK
;
1478 data
= _nbu2ss_readl(&preg
->EP0_CONTROL
);
1482 data
= _nbu2ss_readl(&preg
->EP_REGS
[epnum
-1].EP_CONTROL
);
1483 if ((data
& EPn_EN
) == 0)
1486 if (ep_adrs
& USB_ENDPOINT_DIR_MASK
)
1487 bit_data
= EPn_ISTL
;
1489 bit_data
= EPn_OSTL
;
1492 if ((data
& bit_data
) == 0)
1498 /*-------------------------------------------------------------------------*/
1499 static inline int _nbu2ss_req_feature(struct nbu2ss_udc
*udc
, bool bset
)
1501 u8 recipient
= (u8
)(udc
->ctrl
.bRequestType
& USB_RECIP_MASK
);
1502 u8 direction
= (u8
)(udc
->ctrl
.bRequestType
& USB_DIR_IN
);
1503 u16 selector
= udc
->ctrl
.wValue
;
1504 u16 wIndex
= udc
->ctrl
.wIndex
;
1506 int result
= -EOPNOTSUPP
;
1508 if ((0x0000 != udc
->ctrl
.wLength
) ||
1509 (USB_DIR_OUT
!= direction
)) {
1513 switch (recipient
) {
1514 case USB_RECIP_DEVICE
:
1517 _nbu2ss_set_feature_device(udc
, selector
, wIndex
);
1520 case USB_RECIP_ENDPOINT
:
1521 if (0x0000 == (wIndex
& 0xFF70)) {
1522 if (USB_ENDPOINT_HALT
== selector
) {
1523 ep_adrs
= wIndex
& 0xFF;
1524 if (bset
== FALSE
) {
1525 _nbu2ss_endpoint_toggle_reset(
1529 _nbu2ss_set_endpoint_stall(
1530 udc
, ep_adrs
, bset
);
1542 _nbu2ss_create_ep0_packet(udc
, udc
->ep0_buf
, 0);
1547 /*-------------------------------------------------------------------------*/
1548 static inline enum usb_device_speed
_nbu2ss_get_speed(struct nbu2ss_udc
*udc
)
1551 enum usb_device_speed speed
= USB_SPEED_FULL
;
1553 data
= _nbu2ss_readl(&udc
->p_regs
->USB_STATUS
);
1554 if (data
& HIGH_SPEED
)
1555 speed
= USB_SPEED_HIGH
;
1560 /*-------------------------------------------------------------------------*/
1561 static void _nbu2ss_epn_set_stall(
1562 struct nbu2ss_udc
*udc
,
1563 struct nbu2ss_ep
*ep
1570 PT_FC_REGS preg
= udc
->p_regs
;
1572 if (ep
->direct
== USB_DIR_IN
) {
1574 ; limit_cnt
< IN_DATA_EMPTY_COUNT
1577 regdata
= _nbu2ss_readl(
1578 &preg
->EP_REGS
[ep
->epnum
-1].EP_STATUS
);
1580 if ((regdata
& EPn_IN_DATA
) == 0)
1587 ep_adrs
= ep
->epnum
| ep
->direct
;
1588 _nbu2ss_set_endpoint_stall(udc
, ep_adrs
, 1);
1591 /*-------------------------------------------------------------------------*/
1592 static int std_req_get_status(struct nbu2ss_udc
*udc
)
1595 u16 status_data
= 0;
1596 u8 recipient
= (u8
)(udc
->ctrl
.bRequestType
& USB_RECIP_MASK
);
1597 u8 direction
= (u8
)(udc
->ctrl
.bRequestType
& USB_DIR_IN
);
1599 int result
= -EINVAL
;
1601 if ((0x0000 != udc
->ctrl
.wValue
)
1602 || (USB_DIR_IN
!= direction
)) {
1607 length
= min(udc
->ctrl
.wLength
, (u16
)sizeof(status_data
));
1609 switch (recipient
) {
1610 case USB_RECIP_DEVICE
:
1611 if (udc
->ctrl
.wIndex
== 0x0000) {
1612 if (udc
->self_powered
)
1613 status_data
|= (1 << USB_DEVICE_SELF_POWERED
);
1615 if (udc
->remote_wakeup
)
1616 status_data
|= (1 << USB_DEVICE_REMOTE_WAKEUP
);
1622 case USB_RECIP_ENDPOINT
:
1623 if (0x0000 == (udc
->ctrl
.wIndex
& 0xFF70)) {
1624 ep_adrs
= (u8
)(udc
->ctrl
.wIndex
& 0xFF);
1625 result
= _nbu2ss_get_ep_stall(udc
, ep_adrs
);
1628 status_data
|= (1 << USB_ENDPOINT_HALT
);
1637 memcpy(udc
->ep0_buf
, &status_data
, length
);
1638 _nbu2ss_create_ep0_packet(udc
, udc
->ep0_buf
, length
);
1639 _nbu2ss_ep0_in_transfer(udc
, &udc
->ep
[0], &udc
->ep0_req
);
1642 ERR("*** Error GET_STATUS\n");
1648 /*-------------------------------------------------------------------------*/
1649 static int std_req_clear_feature(struct nbu2ss_udc
*udc
)
1651 return _nbu2ss_req_feature(udc
, FALSE
);
1654 /*-------------------------------------------------------------------------*/
1655 static int std_req_set_feature(struct nbu2ss_udc
*udc
)
1657 return _nbu2ss_req_feature(udc
, TRUE
);
1660 /*-------------------------------------------------------------------------*/
1661 static int std_req_set_address(struct nbu2ss_udc
*udc
)
1664 u32 wValue
= udc
->ctrl
.wValue
;
1666 if ((0x00 != udc
->ctrl
.bRequestType
) ||
1667 (0x0000 != udc
->ctrl
.wIndex
) ||
1668 (0x0000 != udc
->ctrl
.wLength
)) {
1672 if (wValue
!= (wValue
& 0x007F))
1675 wValue
= wValue
<< USB_ADRS_SHIFT
;
1677 _nbu2ss_writel(&udc
->p_regs
->USB_ADDRESS
, wValue
);
1678 _nbu2ss_create_ep0_packet(udc
, udc
->ep0_buf
, 0);
1683 /*-------------------------------------------------------------------------*/
1684 static int std_req_set_configuration(struct nbu2ss_udc
*udc
)
1686 u32 ConfigValue
= (u32
)(udc
->ctrl
.wValue
& 0x00ff);
1688 if ((0x0000 != udc
->ctrl
.wIndex
) ||
1689 (0x0000 != udc
->ctrl
.wLength
) ||
1690 (0x00 != udc
->ctrl
.bRequestType
)) {
1694 udc
->curr_config
= ConfigValue
;
1696 if (ConfigValue
> 0) {
1697 _nbu2ss_bitset(&udc
->p_regs
->USB_CONTROL
, CONF
);
1698 udc
->devstate
= USB_STATE_CONFIGURED
;
1701 _nbu2ss_bitclr(&udc
->p_regs
->USB_CONTROL
, CONF
);
1702 udc
->devstate
= USB_STATE_ADDRESS
;
1708 /*-------------------------------------------------------------------------*/
1709 static inline void _nbu2ss_read_request_data(struct nbu2ss_udc
*udc
, u32
*pdata
)
1711 if ((udc
== NULL
) && (pdata
== NULL
))
1714 *pdata
= _nbu2ss_readl(&udc
->p_regs
->SETUP_DATA0
);
1716 *pdata
= _nbu2ss_readl(&udc
->p_regs
->SETUP_DATA1
);
1719 /*-------------------------------------------------------------------------*/
1720 static inline int _nbu2ss_decode_request(struct nbu2ss_udc
*udc
)
1722 bool bcall_back
= TRUE
;
1724 struct usb_ctrlrequest
*p_ctrl
;
1726 p_ctrl
= &udc
->ctrl
;
1727 _nbu2ss_read_request_data(udc
, (u32
*)p_ctrl
);
1729 /* ep0 state control */
1730 if (p_ctrl
->wLength
== 0) {
1731 udc
->ep0state
= EP0_IN_STATUS_PHASE
;
1734 if (p_ctrl
->bRequestType
& USB_DIR_IN
)
1735 udc
->ep0state
= EP0_IN_DATA_PHASE
;
1737 udc
->ep0state
= EP0_OUT_DATA_PHASE
;
1740 if ((p_ctrl
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
1741 switch (p_ctrl
->bRequest
) {
1742 case USB_REQ_GET_STATUS
:
1743 nret
= std_req_get_status(udc
);
1747 case USB_REQ_CLEAR_FEATURE
:
1748 nret
= std_req_clear_feature(udc
);
1752 case USB_REQ_SET_FEATURE
:
1753 nret
= std_req_set_feature(udc
);
1757 case USB_REQ_SET_ADDRESS
:
1758 nret
= std_req_set_address(udc
);
1762 case USB_REQ_SET_CONFIGURATION
:
1763 nret
= std_req_set_configuration(udc
);
1771 if (bcall_back
== FALSE
) {
1772 if (udc
->ep0state
== EP0_IN_STATUS_PHASE
) {
1774 /*--------------------------------------*/
1776 nret
= EP0_send_NULL(udc
, TRUE
);
1781 spin_unlock(&udc
->lock
);
1782 nret
= udc
->driver
->setup(&udc
->gadget
, &udc
->ctrl
);
1783 spin_lock(&udc
->lock
);
1787 udc
->ep0state
= EP0_IDLE
;
1792 /*-------------------------------------------------------------------------*/
1793 static inline int _nbu2ss_ep0_in_data_stage(struct nbu2ss_udc
*udc
)
1796 struct nbu2ss_req
*req
;
1797 struct nbu2ss_ep
*ep
= &udc
->ep
[0];
1799 if (list_empty(&ep
->queue
))
1802 req
= list_entry(ep
->queue
.next
, struct nbu2ss_req
, queue
);
1805 req
= &udc
->ep0_req
;
1807 req
->req
.actual
+= req
->div_len
;
1810 nret
= _nbu2ss_ep0_in_transfer(udc
, ep
, req
);
1812 udc
->ep0state
= EP0_OUT_STATUS_PAHSE
;
1813 EP0_receive_NULL(udc
, TRUE
);
1819 /*-------------------------------------------------------------------------*/
1820 static inline int _nbu2ss_ep0_out_data_stage(struct nbu2ss_udc
*udc
)
1823 struct nbu2ss_req
*req
;
1824 struct nbu2ss_ep
*ep
= &udc
->ep
[0];
1826 if (list_empty(&ep
->queue
))
1829 req
= list_entry(ep
->queue
.next
, struct nbu2ss_req
, queue
);
1832 req
= &udc
->ep0_req
;
1834 nret
= _nbu2ss_ep0_out_transfer(udc
, ep
, req
);
1836 udc
->ep0state
= EP0_IN_STATUS_PHASE
;
1837 EP0_send_NULL(udc
, TRUE
);
1839 } else if (nret
< 0) {
1840 _nbu2ss_bitset(&udc
->p_regs
->EP0_CONTROL
, EP0_BCLR
);
1841 req
->req
.status
= nret
;
1847 /*-------------------------------------------------------------------------*/
1848 static inline int _nbu2ss_ep0_status_stage(struct nbu2ss_udc
*udc
)
1850 struct nbu2ss_req
*req
;
1851 struct nbu2ss_ep
*ep
= &udc
->ep
[0];
1853 if (list_empty(&ep
->queue
))
1856 req
= list_entry(ep
->queue
.next
, struct nbu2ss_req
, queue
);
1859 req
= &udc
->ep0_req
;
1860 if (req
->req
.complete
)
1861 req
->req
.complete(&ep
->ep
, &req
->req
);
1864 if (req
->req
.complete
)
1865 _nbu2ss_ep_done(ep
, req
, 0);
1868 udc
->ep0state
= EP0_IDLE
;
1873 /*-------------------------------------------------------------------------*/
1874 static inline void _nbu2ss_ep0_int(struct nbu2ss_udc
*udc
)
1881 status
= _nbu2ss_readl(&udc
->p_regs
->EP0_STATUS
);
1882 intr
= status
& EP0_STATUS_RW_BIT
;
1883 _nbu2ss_writel(&udc
->p_regs
->EP0_STATUS
, ~(u32
)intr
);
1885 status
&= (SETUP_INT
| EP0_IN_INT
| EP0_OUT_INT
1886 | STG_END_INT
| EP0_OUT_NULL_INT
);
1889 pr_info("--- %s Not Decode Interrupt\n", __func__
);
1890 pr_info("--- EP0_STATUS = 0x%08x\n", intr
);
1894 if (udc
->gadget
.speed
== USB_SPEED_UNKNOWN
)
1895 udc
->gadget
.speed
= _nbu2ss_get_speed(udc
);
1897 for (i
= 0; i
< EP0_END_XFER
; i
++) {
1898 switch (udc
->ep0state
) {
1900 if (status
& SETUP_INT
) {
1902 nret
= _nbu2ss_decode_request(udc
);
1906 case EP0_IN_DATA_PHASE
:
1907 if (status
& EP0_IN_INT
) {
1908 status
&= ~EP0_IN_INT
;
1909 nret
= _nbu2ss_ep0_in_data_stage(udc
);
1913 case EP0_OUT_DATA_PHASE
:
1914 if (status
& EP0_OUT_INT
) {
1915 status
&= ~EP0_OUT_INT
;
1916 nret
= _nbu2ss_ep0_out_data_stage(udc
);
1920 case EP0_IN_STATUS_PHASE
:
1921 if ((status
& STG_END_INT
) || (status
& SETUP_INT
)) {
1922 status
&= ~(STG_END_INT
| EP0_IN_INT
);
1923 nret
= _nbu2ss_ep0_status_stage(udc
);
1927 case EP0_OUT_STATUS_PAHSE
:
1928 if ((status
& STG_END_INT
)
1929 || (status
& SETUP_INT
)
1930 || (status
& EP0_OUT_NULL_INT
)) {
1931 status
&= ~(STG_END_INT
1933 | EP0_OUT_NULL_INT
);
1935 nret
= _nbu2ss_ep0_status_stage(udc
);
1951 _nbu2ss_set_endpoint_stall(udc
, 0, TRUE
);
1955 /*-------------------------------------------------------------------------*/
1956 static void _nbu2ss_ep_done(
1957 struct nbu2ss_ep
*ep
,
1958 struct nbu2ss_req
*req
,
1961 struct nbu2ss_udc
*udc
= ep
->udc
;
1963 list_del_init(&req
->queue
);
1965 if (status
== -ECONNRESET
)
1966 _nbu2ss_fifo_flush(udc
, ep
);
1968 if (likely(req
->req
.status
== -EINPROGRESS
))
1969 req
->req
.status
= status
;
1972 _nbu2ss_epn_set_stall(udc
, ep
);
1974 if (!list_empty(&ep
->queue
))
1975 _nbu2ss_restert_transfer(ep
);
1979 if ((ep
->direct
== USB_DIR_OUT
) && (ep
->epnum
> 0) &&
1980 (req
->req
.dma
!= 0))
1981 _nbu2ss_dma_unmap_single(udc
, ep
, req
, USB_DIR_OUT
);
1984 spin_unlock(&udc
->lock
);
1985 req
->req
.complete(&ep
->ep
, &req
->req
);
1986 spin_lock(&udc
->lock
);
1989 /*-------------------------------------------------------------------------*/
1990 static inline void _nbu2ss_epn_in_int(
1991 struct nbu2ss_udc
*udc
,
1992 struct nbu2ss_ep
*ep
,
1993 struct nbu2ss_req
*req
)
1998 PT_FC_REGS preg
= udc
->p_regs
;
2001 return; /* DMA is forwarded */
2003 req
->req
.actual
+= req
->div_len
;
2006 if (req
->req
.actual
!= req
->req
.length
) {
2007 /*---------------------------------------------------------*/
2008 /* remainder of data */
2009 result
= _nbu2ss_epn_in_transfer(udc
, ep
, req
);
2012 if (req
->zero
&& ((req
->req
.actual
% ep
->ep
.maxpacket
) == 0)) {
2015 _nbu2ss_readl(&preg
->EP_REGS
[ep
->epnum
-1].EP_STATUS
);
2017 if ((status
& EPn_IN_FULL
) == 0) {
2018 /*-----------------------------------------*/
2019 /* 0 Length Packet */
2021 _nbu2ss_zero_len_pkt(udc
, ep
->epnum
);
2028 /*---------------------------------------------------------*/
2030 _nbu2ss_ep_done(ep
, req
, result
);
2034 /*-------------------------------------------------------------------------*/
2035 static inline void _nbu2ss_epn_out_int(
2036 struct nbu2ss_udc
*udc
,
2037 struct nbu2ss_ep
*ep
,
2038 struct nbu2ss_req
*req
)
2042 result
= _nbu2ss_epn_out_transfer(udc
, ep
, req
);
2044 _nbu2ss_ep_done(ep
, req
, result
);
2047 /*-------------------------------------------------------------------------*/
2048 static inline void _nbu2ss_epn_in_dma_int(
2049 struct nbu2ss_udc
*udc
,
2050 struct nbu2ss_ep
*ep
,
2051 struct nbu2ss_req
*req
)
2055 struct usb_request
*preq
;
2059 if (req
->dma_flag
== FALSE
)
2062 preq
->actual
+= req
->div_len
;
2064 req
->dma_flag
= FALSE
;
2067 _nbu2ss_dma_unmap_single(udc
, ep
, req
, USB_DIR_IN
);
2070 if (preq
->actual
!= preq
->length
) {
2071 _nbu2ss_epn_in_transfer(udc
, ep
, req
);
2073 mpkt
= ep
->ep
.maxpacket
;
2074 size
= preq
->actual
% mpkt
;
2076 if (((preq
->actual
& 0x03) == 0) && (size
< mpkt
))
2077 _nbu2ss_ep_in_end(udc
, ep
->epnum
, 0, 0);
2079 _nbu2ss_epn_in_int(udc
, ep
, req
);
2084 /*-------------------------------------------------------------------------*/
2085 static inline void _nbu2ss_epn_out_dma_int(
2086 struct nbu2ss_udc
*udc
,
2087 struct nbu2ss_ep
*ep
,
2088 struct nbu2ss_req
*req
)
2092 u32 dmacnt
, ep_dmacnt
;
2094 PT_FC_REGS preg
= udc
->p_regs
;
2096 num
= ep
->epnum
- 1;
2098 if (req
->req
.actual
== req
->req
.length
) {
2099 if ((req
->req
.length
% ep
->ep
.maxpacket
) && !req
->zero
) {
2101 req
->dma_flag
= FALSE
;
2102 _nbu2ss_ep_done(ep
, req
, 0);
2107 ep_dmacnt
= _nbu2ss_readl(&preg
->EP_REGS
[num
].EP_LEN_DCNT
)
2111 for (i
= 0; i
< EPC_PLL_LOCK_COUNT
; i
++) {
2112 dmacnt
= _nbu2ss_readl(&preg
->EP_DCR
[num
].EP_DCR1
)
2115 if (ep_dmacnt
== dmacnt
)
2119 _nbu2ss_bitclr(&preg
->EP_DCR
[num
].EP_DCR1
, DCR1_EPn_REQEN
);
2122 mpkt
= ep
->ep
.maxpacket
;
2123 if ((req
->div_len
% mpkt
) == 0)
2124 req
->div_len
-= mpkt
* dmacnt
;
2127 if ((req
->req
.actual
% ep
->ep
.maxpacket
) > 0) {
2128 if (req
->req
.actual
== req
->div_len
) {
2130 req
->dma_flag
= FALSE
;
2131 _nbu2ss_ep_done(ep
, req
, 0);
2136 req
->req
.actual
+= req
->div_len
;
2138 req
->dma_flag
= FALSE
;
2140 _nbu2ss_epn_out_int(udc
, ep
, req
);
2143 /*-------------------------------------------------------------------------*/
2144 static inline void _nbu2ss_epn_int(struct nbu2ss_udc
*udc
, u32 epnum
)
2149 struct nbu2ss_req
*req
;
2150 struct nbu2ss_ep
*ep
= &udc
->ep
[epnum
];
2154 /* Interrupt Status */
2155 status
= _nbu2ss_readl(&udc
->p_regs
->EP_REGS
[num
].EP_STATUS
);
2157 /* Interrupt Clear */
2158 _nbu2ss_writel(&udc
->p_regs
->EP_REGS
[num
].EP_STATUS
, ~(u32
)status
);
2160 if (list_empty(&ep
->queue
))
2163 req
= list_entry(ep
->queue
.next
, struct nbu2ss_req
, queue
);
2166 /* pr_warn("=== %s(%d) req == NULL\n", __func__, epnum); */
2170 if (status
& EPn_OUT_END_INT
) {
2171 status
&= ~EPn_OUT_INT
;
2172 _nbu2ss_epn_out_dma_int(udc
, ep
, req
);
2175 if (status
& EPn_OUT_INT
)
2176 _nbu2ss_epn_out_int(udc
, ep
, req
);
2178 if (status
& EPn_IN_END_INT
) {
2179 status
&= ~EPn_IN_INT
;
2180 _nbu2ss_epn_in_dma_int(udc
, ep
, req
);
2183 if (status
& EPn_IN_INT
)
2184 _nbu2ss_epn_in_int(udc
, ep
, req
);
2187 /*-------------------------------------------------------------------------*/
2188 static inline void _nbu2ss_ep_int(struct nbu2ss_udc
*udc
, u32 epnum
)
2191 _nbu2ss_ep0_int(udc
);
2193 _nbu2ss_epn_int(udc
, epnum
);
2196 /*-------------------------------------------------------------------------*/
2197 static void _nbu2ss_ep0_enable(struct nbu2ss_udc
*udc
)
2199 _nbu2ss_bitset(&udc
->p_regs
->EP0_CONTROL
, (EP0_AUTO
| EP0_BCLR
));
2200 _nbu2ss_writel(&udc
->p_regs
->EP0_INT_ENA
, EP0_INT_EN_BIT
);
2204 /*-------------------------------------------------------------------------*/
2205 static void _nbu2ss_ep0_disable(struct nbu2ss_udc
*udc
)
2207 _nbu2ss_bitclr(&udc
->p_regs
->EP0_INT_ENA
, EP0_INT_EN_BIT
);
2209 _nbu2ss_bitset(&udc
->p_regs
->EP0_CONTROL
2210 , (EP0_BCLR
| EP0_INAK
| EP0_ONAK
| EP0_BCLR
));
2212 _nbu2ss_bitclr(&udc
->p_regs
->EP0_CONTROL
, EP0_AUTO
);
2216 /*-------------------------------------------------------------------------*/
2217 static int _nbu2ss_nuke(struct nbu2ss_udc
*udc
,
2218 struct nbu2ss_ep
*ep
,
2221 struct nbu2ss_req
*req
;
2223 /* Endpoint Disable */
2224 _nbu2ss_epn_exit(udc
, ep
);
2227 _nbu2ss_ep_dma_exit(udc
, ep
);
2229 if (list_empty(&ep
->queue
))
2232 /* called with irqs blocked */
2233 while (!list_empty(&ep
->queue
)) {
2234 req
= list_entry(ep
->queue
.next
, struct nbu2ss_req
, queue
);
2235 _nbu2ss_ep_done(ep
, req
, status
);
2241 /*-------------------------------------------------------------------------*/
2242 static void _nbu2ss_quiesce(struct nbu2ss_udc
*udc
)
2244 struct nbu2ss_ep
*ep
;
2246 udc
->gadget
.speed
= USB_SPEED_UNKNOWN
;
2248 _nbu2ss_nuke(udc
, &udc
->ep
[0], -ESHUTDOWN
);
2251 list_for_each_entry(ep
, &udc
->gadget
.ep_list
, ep
.ep_list
) {
2252 _nbu2ss_nuke(udc
, ep
, -ESHUTDOWN
);
2256 /*-------------------------------------------------------------------------*/
2257 static int _nbu2ss_pullup(struct nbu2ss_udc
*udc
, int is_on
)
2262 ERR("%s, bad param\n", __func__
);
2266 if (udc
->vbus_active
== 0)
2271 /* INFO(" --- D+ Pullup\n"); */
2274 reg_dt
= (_nbu2ss_readl(&udc
->p_regs
->USB_CONTROL
)
2275 | PUE2
) & ~(u32
)CONNECTB
;
2277 _nbu2ss_writel(&udc
->p_regs
->USB_CONTROL
, reg_dt
);
2282 /* INFO(" --- D+ Pulldown\n"); */
2284 reg_dt
= (_nbu2ss_readl(&udc
->p_regs
->USB_CONTROL
) | CONNECTB
)
2287 _nbu2ss_writel(&udc
->p_regs
->USB_CONTROL
, reg_dt
);
2288 udc
->gadget
.speed
= USB_SPEED_UNKNOWN
;
2294 /*-------------------------------------------------------------------------*/
2295 static void _nbu2ss_fifo_flush(struct nbu2ss_udc
*udc
, struct nbu2ss_ep
*ep
)
2297 PT_FC_REGS p
= udc
->p_regs
;
2299 if (udc
->vbus_active
== 0)
2302 if (ep
->epnum
== 0) {
2304 _nbu2ss_bitset(&p
->EP0_CONTROL
, EP0_BCLR
);
2308 _nbu2ss_ep_dma_abort(udc
, ep
);
2309 _nbu2ss_bitset(&p
->EP_REGS
[ep
->epnum
- 1].EP_CONTROL
, EPn_BCLR
);
2313 /*-------------------------------------------------------------------------*/
2314 static int _nbu2ss_enable_controller(struct nbu2ss_udc
*udc
)
2318 if (udc
->udc_enabled
)
2322 emxx_open_clockgate(EMXX_CLK_USB1
);
2323 /* emxx_clkctrl_off(EMXX_CLKCTRL_USB1); */
2324 /* emxx_clkctrl_on(EMXX_CLKCTRL_USB1); */
2325 emxx_unreset_device(EMXX_RST_USB1
);
2330 _nbu2ss_bitset(&udc
->p_regs
->EPCTR
, (DIRPD
| EPC_RST
));
2331 udelay(EPC_RST_DISABLE_TIME
); /* 1us wait */
2333 _nbu2ss_bitclr(&udc
->p_regs
->EPCTR
, DIRPD
);
2334 mdelay(EPC_DIRPD_DISABLE_TIME
); /* 1ms wait */
2336 _nbu2ss_bitclr(&udc
->p_regs
->EPCTR
, EPC_RST
);
2338 _nbu2ss_writel(&udc
->p_regs
->AHBSCTR
, WAIT_MODE
);
2341 /* DMA Mode Setting */
2342 if ((system_rev
& EMXX_REV_MASK
) == EMXX_REV_ES1
) {
2343 _nbu2ss_bitset(&udc
->p_regs
->AHBMCTR
, BURST_TYPE
);
2344 _nbu2ss_bitclr(&udc
->p_regs
->AHBMCTR
, HTRANS_MODE
);
2347 _nbu2ss_writel(&udc
->p_regs
->AHBMCTR
,
2348 HBUSREQ_MODE
| HTRANS_MODE
| WBURST_TYPE
);
2350 while (!(_nbu2ss_readl(&udc
->p_regs
->EPCTR
) & PLL_LOCK
)) {
2352 udelay(1); /* 1us wait */
2353 if (waitcnt
== EPC_PLL_LOCK_COUNT
) {
2354 ERR("*** Reset Cancel failed\n");
2360 if ((system_rev
& EMXX_REV_MASK
) < EMXX_REV_ES3
)
2362 _nbu2ss_bitset(&udc
->p_regs
->UTMI_CHARACTER_1
, USB_SQUSET
);
2364 _nbu2ss_bitset(&udc
->p_regs
->USB_CONTROL
, (INT_SEL
| SOF_RCV
));
2367 _nbu2ss_ep0_enable(udc
);
2369 /* USB Interrupt Enable */
2370 _nbu2ss_bitset(&udc
->p_regs
->USB_INT_ENA
, USB_INT_EN_BIT
);
2372 udc
->udc_enabled
= TRUE
;
2378 /*-------------------------------------------------------------------------*/
2379 static void _nbu2ss_reset_controller(struct nbu2ss_udc
*udc
)
2381 _nbu2ss_bitset(&udc
->p_regs
->EPCTR
, EPC_RST
);
2382 _nbu2ss_bitclr(&udc
->p_regs
->EPCTR
, EPC_RST
);
2385 /*-------------------------------------------------------------------------*/
2386 static void _nbu2ss_disable_controller(struct nbu2ss_udc
*udc
)
2388 if (udc
->udc_enabled
) {
2389 udc
->udc_enabled
= FALSE
;
2390 _nbu2ss_reset_controller(udc
);
2391 _nbu2ss_bitset(&udc
->p_regs
->EPCTR
, (DIRPD
| EPC_RST
));
2394 emxx_reset_device(EMXX_RST_USB1
);
2395 /* emxx_clkctrl_on(EMXX_CLKCTRL_USB1); */
2396 emxx_close_clockgate(EMXX_CLK_USB1
);
2400 /*-------------------------------------------------------------------------*/
2401 static inline void _nbu2ss_check_vbus(struct nbu2ss_udc
*udc
)
2407 mdelay(VBUS_CHATTERING_MDELAY
); /* wait (ms) */
2410 reg_dt
= gpio_get_value(VBUS_VALUE
);
2413 udc
->linux_suspended
= 0;
2415 _nbu2ss_reset_controller(udc
);
2416 pr_info(" ----- VBUS OFF\n");
2418 if (udc
->vbus_active
== 1) {
2420 udc
->vbus_active
= 0;
2421 if (udc
->usb_suspended
) {
2422 udc
->usb_suspended
= 0;
2423 /* _nbu2ss_reset_controller(udc); */
2425 udc
->devstate
= USB_STATE_NOTATTACHED
;
2427 _nbu2ss_quiesce(udc
);
2429 spin_unlock(&udc
->lock
);
2430 udc
->driver
->disconnect(&udc
->gadget
);
2431 spin_lock(&udc
->lock
);
2434 _nbu2ss_disable_controller(udc
);
2437 mdelay(5); /* wait (5ms) */
2438 reg_dt
= gpio_get_value(VBUS_VALUE
);
2442 pr_info(" ----- VBUS ON\n");
2444 if (udc
->linux_suspended
)
2447 if (udc
->vbus_active
== 0) {
2449 udc
->vbus_active
= 1;
2450 udc
->devstate
= USB_STATE_POWERED
;
2452 nret
= _nbu2ss_enable_controller(udc
);
2454 _nbu2ss_disable_controller(udc
);
2455 udc
->vbus_active
= 0;
2459 _nbu2ss_pullup(udc
, 1);
2461 #ifdef UDC_DEBUG_DUMP
2462 _nbu2ss_dump_register(udc
);
2463 #endif /* UDC_DEBUG_DUMP */
2466 if (udc
->devstate
== USB_STATE_POWERED
)
2467 _nbu2ss_pullup(udc
, 1);
2472 /*-------------------------------------------------------------------------*/
2473 static inline void _nbu2ss_int_bus_reset(struct nbu2ss_udc
*udc
)
2475 udc
->devstate
= USB_STATE_DEFAULT
;
2476 udc
->remote_wakeup
= 0;
2478 _nbu2ss_quiesce(udc
);
2480 udc
->ep0state
= EP0_IDLE
;
2483 /*-------------------------------------------------------------------------*/
2484 static inline void _nbu2ss_int_usb_resume(struct nbu2ss_udc
*udc
)
2486 if (udc
->usb_suspended
== 1) {
2487 udc
->usb_suspended
= 0;
2488 if (udc
->driver
&& udc
->driver
->resume
) {
2489 spin_unlock(&udc
->lock
);
2490 udc
->driver
->resume(&udc
->gadget
);
2491 spin_lock(&udc
->lock
);
2496 /*-------------------------------------------------------------------------*/
2497 static inline void _nbu2ss_int_usb_suspend(struct nbu2ss_udc
*udc
)
2501 if (udc
->usb_suspended
== 0) {
2502 reg_dt
= gpio_get_value(VBUS_VALUE
);
2507 udc
->usb_suspended
= 1;
2508 if (udc
->driver
&& udc
->driver
->suspend
) {
2509 spin_unlock(&udc
->lock
);
2510 udc
->driver
->suspend(&udc
->gadget
);
2511 spin_lock(&udc
->lock
);
2514 _nbu2ss_bitset(&udc
->p_regs
->USB_CONTROL
, SUSPEND
);
2518 /*-------------------------------------------------------------------------*/
2519 /* VBUS (GPIO153) Interrupt */
2520 static irqreturn_t
_nbu2ss_vbus_irq(int irq
, void *_udc
)
2522 struct nbu2ss_udc
*udc
= (struct nbu2ss_udc
*)_udc
;
2524 spin_lock(&udc
->lock
);
2525 _nbu2ss_check_vbus(udc
);
2526 spin_unlock(&udc
->lock
);
2531 /*-------------------------------------------------------------------------*/
2532 /* Interrupt (udc) */
2533 static irqreturn_t
_nbu2ss_udc_irq(int irq
, void *_udc
)
2535 u8 suspend_flag
= 0;
2539 struct nbu2ss_udc
*udc
= (struct nbu2ss_udc
*)_udc
;
2540 PT_FC_REGS preg
= udc
->p_regs
;
2542 if (gpio_get_value(VBUS_VALUE
) == 0) {
2543 _nbu2ss_writel(&preg
->USB_INT_STA
, ~USB_INT_STA_RW
);
2544 _nbu2ss_writel(&preg
->USB_INT_ENA
, 0);
2548 spin_lock(&udc
->lock
);
2551 if (gpio_get_value(VBUS_VALUE
) == 0) {
2552 _nbu2ss_writel(&preg
->USB_INT_STA
, ~USB_INT_STA_RW
);
2553 _nbu2ss_writel(&preg
->USB_INT_ENA
, 0);
2556 status
= _nbu2ss_readl(&preg
->USB_INT_STA
);
2561 _nbu2ss_writel(&preg
->USB_INT_STA
, ~(status
& USB_INT_STA_RW
));
2563 if (status
& USB_RST_INT
) {
2565 _nbu2ss_int_bus_reset(udc
);
2568 if (status
& RSUM_INT
) {
2570 _nbu2ss_int_usb_resume(udc
);
2573 if (status
& SPND_INT
) {
2578 if (status
& EPn_INT
) {
2580 int_bit
= status
>> 8;
2582 for (epnum
= 0; epnum
< NUM_ENDPOINTS
; epnum
++) {
2585 _nbu2ss_ep_int(udc
, epnum
);
2596 _nbu2ss_int_usb_suspend(udc
);
2598 spin_unlock(&udc
->lock
);
2603 /*-------------------------------------------------------------------------*/
2605 static int nbu2ss_ep_enable(
2607 const struct usb_endpoint_descriptor
*desc
)
2610 unsigned long flags
;
2612 struct nbu2ss_ep
*ep
;
2613 struct nbu2ss_udc
*udc
;
2615 if ((_ep
== NULL
) || (desc
== NULL
)) {
2616 ERR(" *** %s, bad param\n", __func__
);
2620 ep
= container_of(_ep
, struct nbu2ss_ep
, ep
);
2621 if ((ep
== NULL
) || (ep
->udc
== NULL
)) {
2622 ERR(" *** %s, ep == NULL !!\n", __func__
);
2626 ep_type
= desc
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
;
2627 if ((ep_type
== USB_ENDPOINT_XFER_CONTROL
)
2628 || (ep_type
== USB_ENDPOINT_XFER_ISOC
)) {
2630 ERR(" *** %s, bat bmAttributes\n", __func__
);
2635 if (udc
->vbus_active
== 0)
2638 if ((udc
->driver
== NULL
)
2639 || (udc
->gadget
.speed
== USB_SPEED_UNKNOWN
)) {
2641 ERR(" *** %s, udc !!\n", __func__
);
2645 spin_lock_irqsave(&udc
->lock
, flags
);
2648 ep
->epnum
= desc
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
;
2649 ep
->direct
= desc
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
;
2650 ep
->ep_type
= ep_type
;
2653 ep
->stalled
= FALSE
;
2655 ep
->ep
.maxpacket
= le16_to_cpu(desc
->wMaxPacketSize
);
2658 _nbu2ss_ep_dma_init(udc
, ep
);
2660 /* Endpoint setting */
2661 _nbu2ss_ep_init(udc
, ep
);
2663 spin_unlock_irqrestore(&udc
->lock
, flags
);
2668 /*-------------------------------------------------------------------------*/
2669 static int nbu2ss_ep_disable(struct usb_ep
*_ep
)
2671 struct nbu2ss_ep
*ep
;
2672 struct nbu2ss_udc
*udc
;
2673 unsigned long flags
;
2676 ERR(" *** %s, bad param\n", __func__
);
2680 ep
= container_of(_ep
, struct nbu2ss_ep
, ep
);
2681 if ((ep
== NULL
) || (ep
->udc
== NULL
)) {
2682 ERR(" *** %s, ep == NULL !!\n", __func__
);
2687 if (udc
->vbus_active
== 0)
2690 spin_lock_irqsave(&udc
->lock
, flags
);
2691 _nbu2ss_nuke(udc
, ep
, -EINPROGRESS
); /* dequeue request */
2692 spin_unlock_irqrestore(&udc
->lock
, flags
);
2697 /*-------------------------------------------------------------------------*/
2698 static struct usb_request
*nbu2ss_ep_alloc_request(
2702 struct nbu2ss_req
*req
;
2704 req
= kzalloc(sizeof(*req
), gfp_flags
);
2709 req
->req
.dma
= DMA_ADDR_INVALID
;
2711 INIT_LIST_HEAD(&req
->queue
);
2716 /*-------------------------------------------------------------------------*/
2717 static void nbu2ss_ep_free_request(
2719 struct usb_request
*_req
)
2721 struct nbu2ss_req
*req
;
2724 req
= container_of(_req
, struct nbu2ss_req
, req
);
2731 /*-------------------------------------------------------------------------*/
2732 static int nbu2ss_ep_queue(
2734 struct usb_request
*_req
,
2737 struct nbu2ss_req
*req
;
2738 struct nbu2ss_ep
*ep
;
2739 struct nbu2ss_udc
*udc
;
2740 unsigned long flags
;
2742 int result
= -EINVAL
;
2744 /* catch various bogus parameters */
2745 if ((_ep
== NULL
) || (_req
== NULL
)) {
2747 ERR("*** %s --- _ep == NULL\n", __func__
);
2750 ERR("*** %s --- _req == NULL\n", __func__
);
2755 req
= container_of(_req
, struct nbu2ss_req
, req
);
2757 (!_req
->complete
|| !_req
->buf
2758 || !list_empty(&req
->queue
))) {
2760 if (!_req
->complete
)
2761 ERR("*** %s --- !_req->complete\n", __func__
);
2764 ERR("*** %s --- !_req->buf\n", __func__
);
2766 if (!list_empty(&req
->queue
))
2767 ERR("*** %s --- !list_empty(&req->queue)\n", __func__
);
2772 ep
= container_of(_ep
, struct nbu2ss_ep
, ep
);
2775 /* INFO("=== %s(ep%d), zero=%d\n", __func__, ep->epnum, _req->zero); */
2777 if (udc
->vbus_active
== 0) {
2778 pr_info("Can't ep_queue (VBUS OFF)\n");
2782 if (unlikely(!udc
->driver
)) {
2783 ERR("%s, bogus device state %p\n", __func__
, udc
->driver
);
2787 spin_lock_irqsave(&udc
->lock
, flags
);
2790 if ((u32
)req
->req
.buf
& 0x3)
2791 req
->unaligned
= TRUE
;
2793 req
->unaligned
= FALSE
;
2795 if (req
->unaligned
) {
2796 if (ep
->virt_buf
== NULL
)
2797 ep
->virt_buf
= (u8
*)dma_alloc_coherent(
2799 &ep
->phys_buf
, GFP_KERNEL
| GFP_DMA
);
2800 if (ep
->epnum
> 0) {
2801 if (ep
->direct
== USB_DIR_IN
)
2802 memcpy(ep
->virt_buf
, req
->req
.buf
,
2807 if ((ep
->epnum
> 0) && (ep
->direct
== USB_DIR_OUT
) &&
2808 (req
->req
.dma
!= 0))
2809 _nbu2ss_dma_map_single(udc
, ep
, req
, USB_DIR_OUT
);
2812 _req
->status
= -EINPROGRESS
;
2815 bflag
= list_empty(&ep
->queue
);
2816 list_add_tail(&req
->queue
, &ep
->queue
);
2818 if ((bflag
!= FALSE
) && (ep
->stalled
== FALSE
)) {
2820 result
= _nbu2ss_start_transfer(udc
, ep
, req
, FALSE
);
2822 ERR(" *** %s, result = %d\n", __func__
, result
);
2823 list_del(&req
->queue
);
2824 } else if ((ep
->epnum
> 0) && (ep
->direct
== USB_DIR_OUT
)) {
2826 if (req
->req
.length
< 4 &&
2827 req
->req
.length
== req
->req
.actual
)
2829 if (req
->req
.length
== req
->req
.actual
)
2831 _nbu2ss_ep_done(ep
, req
, result
);
2835 spin_unlock_irqrestore(&udc
->lock
, flags
);
2840 /*-------------------------------------------------------------------------*/
2841 static int nbu2ss_ep_dequeue(
2843 struct usb_request
*_req
)
2845 struct nbu2ss_req
*req
;
2846 struct nbu2ss_ep
*ep
;
2847 struct nbu2ss_udc
*udc
;
2848 unsigned long flags
;
2850 /*INFO("=== %s()\n", __func__);*/
2852 /* catch various bogus parameters */
2853 if ((_ep
== NULL
) || (_req
== NULL
)) {
2854 /* ERR("%s, bad param(1)\n", __func__); */
2858 ep
= container_of(_ep
, struct nbu2ss_ep
, ep
);
2860 ERR("%s, ep == NULL !!\n", __func__
);
2868 spin_lock_irqsave(&udc
->lock
, flags
);
2870 /* make sure it's actually queued on this endpoint */
2871 list_for_each_entry(req
, &ep
->queue
, queue
) {
2872 if (&req
->req
== _req
)
2875 if (&req
->req
!= _req
) {
2876 spin_unlock_irqrestore(&udc
->lock
, flags
);
2877 pr_debug("%s no queue(EINVAL)\n", __func__
);
2881 _nbu2ss_ep_done(ep
, req
, -ECONNRESET
);
2883 spin_unlock_irqrestore(&udc
->lock
, flags
);
2888 /*-------------------------------------------------------------------------*/
2889 static int nbu2ss_ep_set_halt(struct usb_ep
*_ep
, int value
)
2892 unsigned long flags
;
2894 struct nbu2ss_ep
*ep
;
2895 struct nbu2ss_udc
*udc
;
2897 /* INFO("=== %s()\n", __func__); */
2900 ERR("%s, bad param\n", __func__
);
2904 ep
= container_of(_ep
, struct nbu2ss_ep
, ep
);
2906 ERR("%s, bad ep\n", __func__
);
2912 ERR(" *** %s, bad udc\n", __func__
);
2916 spin_lock_irqsave(&udc
->lock
, flags
);
2918 ep_adrs
= ep
->epnum
| ep
->direct
;
2920 _nbu2ss_set_endpoint_stall(udc
, ep_adrs
, value
);
2921 ep
->stalled
= FALSE
;
2923 if (list_empty(&ep
->queue
))
2924 _nbu2ss_epn_set_stall(udc
, ep
);
2932 spin_unlock_irqrestore(&udc
->lock
, flags
);
2937 static int nbu2ss_ep_set_wedge(struct usb_ep
*_ep
)
2939 return nbu2ss_ep_set_halt(_ep
, 1);
2942 /*-------------------------------------------------------------------------*/
2943 static int nbu2ss_ep_fifo_status(struct usb_ep
*_ep
)
2946 struct nbu2ss_ep
*ep
;
2947 struct nbu2ss_udc
*udc
;
2948 unsigned long flags
;
2951 /* INFO("=== %s()\n", __func__); */
2954 ERR("%s, bad param\n", __func__
);
2958 ep
= container_of(_ep
, struct nbu2ss_ep
, ep
);
2960 ERR("%s, bad ep\n", __func__
);
2966 ERR("%s, bad udc\n", __func__
);
2972 data
= gpio_get_value(VBUS_VALUE
);
2976 spin_lock_irqsave(&udc
->lock
, flags
);
2978 if (ep
->epnum
== 0) {
2979 data
= _nbu2ss_readl(&preg
->EP0_LENGTH
) & EP0_LDATA
;
2982 data
= _nbu2ss_readl(&preg
->EP_REGS
[ep
->epnum
-1].EP_LEN_DCNT
)
2986 spin_unlock_irqrestore(&udc
->lock
, flags
);
2991 /*-------------------------------------------------------------------------*/
2992 static void nbu2ss_ep_fifo_flush(struct usb_ep
*_ep
)
2995 struct nbu2ss_ep
*ep
;
2996 struct nbu2ss_udc
*udc
;
2997 unsigned long flags
;
2999 /* INFO("=== %s()\n", __func__); */
3002 ERR("%s, bad param\n", __func__
);
3006 ep
= container_of(_ep
, struct nbu2ss_ep
, ep
);
3008 ERR("%s, bad ep\n", __func__
);
3014 ERR("%s, bad udc\n", __func__
);
3018 data
= gpio_get_value(VBUS_VALUE
);
3022 spin_lock_irqsave(&udc
->lock
, flags
);
3023 _nbu2ss_fifo_flush(udc
, ep
);
3024 spin_unlock_irqrestore(&udc
->lock
, flags
);
3027 /*-------------------------------------------------------------------------*/
3028 static struct usb_ep_ops nbu2ss_ep_ops
= {
3029 .enable
= nbu2ss_ep_enable
,
3030 .disable
= nbu2ss_ep_disable
,
3032 .alloc_request
= nbu2ss_ep_alloc_request
,
3033 .free_request
= nbu2ss_ep_free_request
,
3035 .queue
= nbu2ss_ep_queue
,
3036 .dequeue
= nbu2ss_ep_dequeue
,
3038 .set_halt
= nbu2ss_ep_set_halt
,
3039 .set_wedge
= nbu2ss_ep_set_wedge
,
3041 .fifo_status
= nbu2ss_ep_fifo_status
,
3042 .fifo_flush
= nbu2ss_ep_fifo_flush
,
3046 /*-------------------------------------------------------------------------*/
3047 /* usb_gadget_ops */
3049 /*-------------------------------------------------------------------------*/
3050 static int nbu2ss_gad_get_frame(struct usb_gadget
*pgadget
)
3053 struct nbu2ss_udc
*udc
;
3055 /* INFO("=== %s()\n", __func__); */
3057 if (pgadget
== NULL
) {
3058 ERR("%s, bad param\n", __func__
);
3062 udc
= container_of(pgadget
, struct nbu2ss_udc
, gadget
);
3064 ERR("%s, udc == NULL\n", __func__
);
3068 data
= gpio_get_value(VBUS_VALUE
);
3072 data
= _nbu2ss_readl(&udc
->p_regs
->USB_ADDRESS
) & FRAME
;
3077 /*-------------------------------------------------------------------------*/
3078 static int nbu2ss_gad_wakeup(struct usb_gadget
*pgadget
)
3083 struct nbu2ss_udc
*udc
;
3085 /* INFO("=== %s()\n", __func__); */
3087 if (pgadget
== NULL
) {
3088 ERR("%s, bad param\n", __func__
);
3092 udc
= container_of(pgadget
, struct nbu2ss_udc
, gadget
);
3094 ERR("%s, udc == NULL\n", __func__
);
3098 data
= gpio_get_value(VBUS_VALUE
);
3100 pr_warn("VBUS LEVEL = %d\n", data
);
3104 _nbu2ss_bitset(&udc
->p_regs
->EPCTR
, PLL_RESUME
);
3106 for (i
= 0; i
< EPC_PLL_LOCK_COUNT
; i
++) {
3107 data
= _nbu2ss_readl(&udc
->p_regs
->EPCTR
);
3109 if (data
& PLL_LOCK
)
3113 _nbu2ss_bitclr(&udc
->p_regs
->EPCTR
, PLL_RESUME
);
3118 /*-------------------------------------------------------------------------*/
3119 static int nbu2ss_gad_set_selfpowered(struct usb_gadget
*pgadget
,
3122 struct nbu2ss_udc
*udc
;
3123 unsigned long flags
;
3125 /* INFO("=== %s()\n", __func__); */
3127 if (pgadget
== NULL
) {
3128 ERR("%s, bad param\n", __func__
);
3132 udc
= container_of(pgadget
, struct nbu2ss_udc
, gadget
);
3134 spin_lock_irqsave(&udc
->lock
, flags
);
3135 udc
->self_powered
= (is_selfpowered
!= 0);
3136 spin_unlock_irqrestore(&udc
->lock
, flags
);
3141 /*-------------------------------------------------------------------------*/
3142 static int nbu2ss_gad_vbus_session(struct usb_gadget
*pgadget
, int is_active
)
3144 /* INFO("=== %s()\n", __func__); */
3148 /*-------------------------------------------------------------------------*/
3149 static int nbu2ss_gad_vbus_draw(struct usb_gadget
*pgadget
, unsigned mA
)
3151 struct nbu2ss_udc
*udc
;
3152 unsigned long flags
;
3154 /* INFO("=== %s()\n", __func__); */
3156 if (pgadget
== NULL
) {
3157 ERR("%s, bad param\n", __func__
);
3161 udc
= container_of(pgadget
, struct nbu2ss_udc
, gadget
);
3163 spin_lock_irqsave(&udc
->lock
, flags
);
3165 spin_unlock_irqrestore(&udc
->lock
, flags
);
3170 /*-------------------------------------------------------------------------*/
3171 static int nbu2ss_gad_pullup(struct usb_gadget
*pgadget
, int is_on
)
3173 struct nbu2ss_udc
*udc
;
3174 unsigned long flags
;
3176 /* INFO("=== %s()\n", __func__); */
3178 if (pgadget
== NULL
) {
3179 ERR("%s, bad param\n", __func__
);
3183 udc
= container_of(pgadget
, struct nbu2ss_udc
, gadget
);
3185 if (udc
->driver
== NULL
) {
3186 pr_warn("%s, Not Regist Driver\n", __func__
);
3190 if (udc
->vbus_active
== 0)
3193 spin_lock_irqsave(&udc
->lock
, flags
);
3194 _nbu2ss_pullup(udc
, is_on
);
3195 spin_unlock_irqrestore(&udc
->lock
, flags
);
3200 /*-------------------------------------------------------------------------*/
3201 static int nbu2ss_gad_ioctl(
3202 struct usb_gadget
*pgadget
,
3204 unsigned long param
)
3206 /* INFO("=== %s()\n", __func__); */
3211 static const struct usb_gadget_ops nbu2ss_gadget_ops
= {
3212 .get_frame
= nbu2ss_gad_get_frame
,
3213 .wakeup
= nbu2ss_gad_wakeup
,
3214 .set_selfpowered
= nbu2ss_gad_set_selfpowered
,
3215 .vbus_session
= nbu2ss_gad_vbus_session
,
3216 .vbus_draw
= nbu2ss_gad_vbus_draw
,
3217 .pullup
= nbu2ss_gad_pullup
,
3218 .ioctl
= nbu2ss_gad_ioctl
,
3221 static const char g_ep0_name
[] = "ep0";
3222 static const char g_ep1_name
[] = "ep1-bulk";
3223 static const char g_ep2_name
[] = "ep2-bulk";
3224 static const char g_ep3_name
[] = "ep3in-int";
3225 static const char g_ep4_name
[] = "ep4-iso";
3226 static const char g_ep5_name
[] = "ep5-iso";
3227 static const char g_ep6_name
[] = "ep6-bulk";
3228 static const char g_ep7_name
[] = "ep7-bulk";
3229 static const char g_ep8_name
[] = "ep8in-int";
3230 static const char g_ep9_name
[] = "ep9-iso";
3231 static const char g_epa_name
[] = "epa-iso";
3232 static const char g_epb_name
[] = "epb-bulk";
3233 static const char g_epc_name
[] = "epc-nulk";
3234 static const char g_epd_name
[] = "epdin-int";
3236 static const char *gp_ep_name
[NUM_ENDPOINTS
] = {
3253 /*-------------------------------------------------------------------------*/
3254 static void __init
nbu2ss_drv_set_ep_info(
3255 struct nbu2ss_udc
*udc
,
3256 struct nbu2ss_ep
*ep
,
3262 ep
->ep
.driver_data
= NULL
;
3264 ep
->ep
.ops
= &nbu2ss_ep_ops
;
3266 if (isdigit(name
[2])) {
3272 tempbuf
[0] = name
[2];
3274 res
= kstrtol(tempbuf
, 16, &num
);
3277 ep
->ep
.maxpacket
= EP0_PACKETSIZE
;
3279 ep
->ep
.maxpacket
= EP_PACKETSIZE
;
3282 ep
->ep
.maxpacket
= EP_PACKETSIZE
;
3285 list_add_tail(&ep
->ep
.ep_list
, &udc
->gadget
.ep_list
);
3286 INIT_LIST_HEAD(&ep
->queue
);
3289 /*-------------------------------------------------------------------------*/
3290 static void __init
nbu2ss_drv_ep_init(struct nbu2ss_udc
*udc
)
3294 INIT_LIST_HEAD(&udc
->gadget
.ep_list
);
3295 udc
->gadget
.ep0
= &udc
->ep
[0].ep
;
3298 for (i
= 0; i
< NUM_ENDPOINTS
; i
++)
3299 nbu2ss_drv_set_ep_info(udc
, &udc
->ep
[i
], gp_ep_name
[i
]);
3301 list_del_init(&udc
->ep
[0].ep
.ep_list
);
3304 /*-------------------------------------------------------------------------*/
3305 /* platform_driver */
3306 static int __init
nbu2ss_drv_contest_init(
3307 struct platform_device
*pdev
,
3308 struct nbu2ss_udc
*udc
)
3310 spin_lock_init(&udc
->lock
);
3311 udc
->dev
= &pdev
->dev
;
3313 udc
->self_powered
= 1;
3314 udc
->devstate
= USB_STATE_NOTATTACHED
;
3318 udc
->pdev
->dev
.coherent_dma_mask
= DMA_BIT_MASK(32);
3321 nbu2ss_drv_ep_init(udc
);
3324 udc
->gadget
.ops
= &nbu2ss_gadget_ops
;
3325 udc
->gadget
.ep0
= &udc
->ep
[0].ep
;
3326 udc
->gadget
.speed
= USB_SPEED_UNKNOWN
;
3327 udc
->gadget
.name
= driver_name
;
3328 /* udc->gadget.is_dualspeed = 1; */
3330 device_initialize(&udc
->gadget
.dev
);
3332 dev_set_name(&udc
->gadget
.dev
, "gadget");
3333 udc
->gadget
.dev
.parent
= &pdev
->dev
;
3334 udc
->gadget
.dev
.dma_mask
= pdev
->dev
.dma_mask
;
3340 * probe - binds to the platform device
3342 static int nbu2ss_drv_probe(struct platform_device
*pdev
)
3344 int status
= -ENODEV
;
3345 struct nbu2ss_udc
*udc
;
3348 void __iomem
*mmio_base
;
3350 udc
= &udc_controller
;
3351 memset(udc
, 0, sizeof(struct nbu2ss_udc
));
3353 platform_set_drvdata(pdev
, udc
);
3355 /* require I/O memory and IRQ to be provided as resources */
3356 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
3357 mmio_base
= devm_ioremap_resource(&pdev
->dev
, r
);
3358 if (IS_ERR(mmio_base
))
3359 return PTR_ERR(mmio_base
);
3361 irq
= platform_get_irq(pdev
, 0);
3363 dev_err(&pdev
->dev
, "failed to get IRQ\n");
3366 status
= devm_request_irq(&pdev
->dev
, irq
, _nbu2ss_udc_irq
,
3367 0, driver_name
, udc
);
3370 udc
->p_regs
= (PT_FC_REGS
)mmio_base
;
3372 /* USB Function Controller Interrupt */
3374 ERR("request_irq(USB_UDC_IRQ_1) failed\n");
3378 /* Driver Initialization */
3379 status
= nbu2ss_drv_contest_init(pdev
, udc
);
3385 /* VBUS Interrupt */
3386 irq_set_irq_type(INT_VBUS
, IRQ_TYPE_EDGE_BOTH
);
3387 status
= request_irq(INT_VBUS
,
3394 ERR("request_irq(INT_VBUS) failed\n");
3404 /*-------------------------------------------------------------------------*/
3405 static void nbu2ss_drv_shutdown(struct platform_device
*pdev
)
3407 struct nbu2ss_udc
*udc
;
3409 udc
= platform_get_drvdata(pdev
);
3413 _nbu2ss_disable_controller(udc
);
3416 /*-------------------------------------------------------------------------*/
3417 static int __exit
nbu2ss_drv_remove(struct platform_device
*pdev
)
3419 struct nbu2ss_udc
*udc
;
3420 struct nbu2ss_ep
*ep
;
3423 udc
= &udc_controller
;
3425 for (i
= 0; i
< NUM_ENDPOINTS
; i
++) {
3428 dma_free_coherent(NULL
, PAGE_SIZE
,
3429 (void *)ep
->virt_buf
, ep
->phys_buf
);
3432 /* Interrupt Handler - Release */
3433 free_irq(INT_VBUS
, udc
);
3438 /*-------------------------------------------------------------------------*/
3439 static int nbu2ss_drv_suspend(struct platform_device
*pdev
, pm_message_t state
)
3441 struct nbu2ss_udc
*udc
;
3443 udc
= platform_get_drvdata(pdev
);
3447 if (udc
->vbus_active
) {
3448 udc
->vbus_active
= 0;
3449 udc
->devstate
= USB_STATE_NOTATTACHED
;
3450 udc
->linux_suspended
= 1;
3452 if (udc
->usb_suspended
) {
3453 udc
->usb_suspended
= 0;
3454 _nbu2ss_reset_controller(udc
);
3457 _nbu2ss_quiesce(udc
);
3459 _nbu2ss_disable_controller(udc
);
3464 /*-------------------------------------------------------------------------*/
3465 static int nbu2ss_drv_resume(struct platform_device
*pdev
)
3468 struct nbu2ss_udc
*udc
;
3470 udc
= platform_get_drvdata(pdev
);
3474 data
= gpio_get_value(VBUS_VALUE
);
3476 udc
->vbus_active
= 1;
3477 udc
->devstate
= USB_STATE_POWERED
;
3478 _nbu2ss_enable_controller(udc
);
3479 _nbu2ss_pullup(udc
, 1);
3482 udc
->linux_suspended
= 0;
3488 static struct platform_driver udc_driver
= {
3489 .probe
= nbu2ss_drv_probe
,
3490 .shutdown
= nbu2ss_drv_shutdown
,
3491 .remove
= __exit_p(nbu2ss_drv_remove
),
3492 .suspend
= nbu2ss_drv_suspend
,
3493 .resume
= nbu2ss_drv_resume
,
3495 .owner
= THIS_MODULE
,
3496 .name
= driver_name
,
3500 module_platform_driver(udc_driver
);
3502 MODULE_DESCRIPTION(DRIVER_DESC
);
3503 MODULE_AUTHOR("Renesas Electronics Corporation");
3504 MODULE_LICENSE("GPL");