2 * Copyright (C) 2006 by Bryan O'Donoghue, CodeHermit
3 * bodonoghue@CodeHermit.ie
6 * DasUBoot/drivers/usb/usbdcore_omap1510.c, for design and implementation
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the
21 * Free Software Foundation, Inc.,
22 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
28 * 1. #define __SIMULATE_ERROR__ to inject a CRC error into every 2nd TX
29 * packet to force the USB re-transmit protocol.
31 * 2. #define __DEBUG_UDC__ to switch on debug tracing to serial console
32 * be careful that tracing doesn't create Hiesen-bugs with respect to
33 * response timeouts to control requests.
35 * 3. This driver should be able to support any higher level driver that
36 * that wants to do either of the two standard UDC implementations
37 * Control-Bulk-Interrupt or Bulk-IN/Bulk-Out standards. Hence
38 * gserial and cdc_acm should work with this code.
40 * 4. NAK events never actually get raised at all, the documentation
43 * 5. For some reason, cbd_datlen is *always* +2 the value it should be.
44 * this means that having an RX cbd of 16 bytes is not possible, since
45 * the same size is reported for 14 bytes received as 16 bytes received
46 * until we can find out why this happens, RX cbds must be limited to 8
47 * bytes. TODO: check errata for this behaviour.
49 * 6. Right now this code doesn't support properly powering up with the USB
50 * cable attached to the USB host my development board the Adder87x doesn't
51 * have a pull-up fitted to allow this, so it is necessary to power the
52 * board and *then* attached the USB cable to the host. However somebody
53 * with a different design in their board may be able to keep the cable
54 * constantly connected and simply enable/disable a pull-up re
55 * figure 31.1 in MPC885RM.pdf instead of having to power up the board and
56 * then attach the cable !
62 #if defined(CONFIG_MPC885_FAMILY) && defined(CONFIG_USB_DEVICE)
65 #include "usbdcore_mpc8xx.h"
66 #include "usbdcore_ep0.h"
68 DECLARE_GLOBAL_DATA_PTR
;
70 #define ERR(fmt, args...)\
71 serial_printf("ERROR : [%s] %s:%d: "fmt,\
72 __FILE__,__FUNCTION__,__LINE__, ##args)
74 #define DBG(fmt,args...)\
75 serial_printf("[%s] %s:%d: "fmt,\
76 __FILE__,__FUNCTION__,__LINE__, ##args)
78 #define DBG(fmt,args...)
82 #ifdef __SIMULATE_ERROR__
83 static char err_poison_test
= 0;
85 static struct mpc8xx_ep ep_ref
[MAX_ENDPOINTS
];
86 static u32 address_base
= STATE_NOT_READY
;
87 static mpc8xx_udc_state_t udc_state
= 0;
88 static struct usb_device_instance
*udc_device
= 0;
89 static volatile usb_epb_t
*endpoints
[MAX_ENDPOINTS
];
90 static volatile cbd_t
*tx_cbd
[TX_RING_SIZE
];
91 static volatile cbd_t
*rx_cbd
[RX_RING_SIZE
];
92 static volatile immap_t
*immr
= 0;
93 static volatile cpm8xx_t
*cp
= 0;
94 static volatile usb_pram_t
*usb_paramp
= 0;
95 static volatile usb_t
*usbp
= 0;
99 /* Static Function Declarations */
100 static void mpc8xx_udc_state_transition_up (usb_device_state_t initial
,
101 usb_device_state_t final
);
102 static void mpc8xx_udc_state_transition_down (usb_device_state_t initial
,
103 usb_device_state_t final
);
104 static void mpc8xx_udc_stall (unsigned int ep
);
105 static void mpc8xx_udc_flush_tx_fifo (int epid
);
106 static void mpc8xx_udc_flush_rx_fifo (void);
107 static void mpc8xx_udc_clear_rxbd (volatile cbd_t
* rx_cbdp
);
108 static void mpc8xx_udc_init_tx (struct usb_endpoint_instance
*epi
,
110 static void mpc8xx_udc_dump_request (struct usb_device_request
*request
);
111 static void mpc8xx_udc_clock_init (volatile immap_t
* immr
,
112 volatile cpm8xx_t
* cp
);
113 static int mpc8xx_udc_ep_tx (struct usb_endpoint_instance
*epi
);
114 static int mpc8xx_udc_epn_rx (unsigned int epid
, volatile cbd_t
* rx_cbdp
);
115 static void mpc8xx_udc_ep0_rx (volatile cbd_t
* rx_cbdp
);
116 static void mpc8xx_udc_cbd_init (void);
117 static void mpc8xx_udc_endpoint_init (void);
118 static void mpc8xx_udc_cbd_attach (int ep
, uchar tx_size
, uchar rx_size
);
119 static u32
mpc8xx_udc_alloc (u32 data_size
, u32 alignment
);
120 static int mpc8xx_udc_ep0_rx_setup (volatile cbd_t
* rx_cbdp
);
121 static void mpc8xx_udc_set_nak (unsigned int ep
);
122 static short mpc8xx_udc_handle_txerr (void);
123 static void mpc8xx_udc_advance_rx (volatile cbd_t
** rx_cbdp
, int epid
);
125 /******************************************************************************
127 *****************************************************************************/
131 * Do initial bus gluing
135 /* Init various pointers */
136 immr
= (immap_t
*) CONFIG_SYS_IMMR
;
137 cp
= (cpm8xx_t
*) & (immr
->im_cpm
);
138 usb_paramp
= (usb_pram_t
*) & (cp
->cp_dparam
[PROFF_USB
]);
139 usbp
= (usb_t
*) & (cp
->cp_scc
[0]);
141 memset (ep_ref
, 0x00, (sizeof (struct mpc8xx_ep
) * MAX_ENDPOINTS
));
144 udc_state
= STATE_NOT_READY
;
149 /* Set USB Frame #0, Respond at Address & Get a clock source */
151 mpc8xx_udc_clock_init (immr
, cp
);
153 /* PA15, PA14 as perhiperal USBRXD and USBOE */
154 immr
->im_ioport
.iop_padir
&= ~0x0003;
155 immr
->im_ioport
.iop_papar
|= 0x0003;
157 /* PC11/PC10 as peripheral USBRXP USBRXN */
158 immr
->im_ioport
.iop_pcso
|= 0x0030;
160 /* PC7/PC6 as perhiperal USBTXP and USBTXN */
161 immr
->im_ioport
.iop_pcdir
|= 0x0300;
162 immr
->im_ioport
.iop_pcpar
|= 0x0300;
164 /* Set the base address */
165 address_base
= (u32
) (cp
->cp_dpmem
+ CPM_USB_BASE
);
167 /* Initialise endpoints and circular buffers */
168 mpc8xx_udc_endpoint_init ();
169 mpc8xx_udc_cbd_init ();
171 /* Assign allocated Dual Port Endpoint descriptors */
172 usb_paramp
->ep0ptr
= (u32
) endpoints
[0];
173 usb_paramp
->ep1ptr
= (u32
) endpoints
[1];
174 usb_paramp
->ep2ptr
= (u32
) endpoints
[2];
175 usb_paramp
->ep3ptr
= (u32
) endpoints
[3];
176 usb_paramp
->frame_n
= 0;
178 DBG ("ep0ptr=0x%08x ep1ptr=0x%08x ep2ptr=0x%08x ep3ptr=0x%08x\n",
179 usb_paramp
->ep0ptr
, usb_paramp
->ep1ptr
, usb_paramp
->ep2ptr
,
187 * Poll for whatever events may have occured
192 volatile cbd_t
*rx_cbdp
= 0;
193 volatile cbd_t
*rx_cbdp_base
= 0;
195 if (udc_state
!= STATE_READY
) {
199 if (usbp
->usber
& USB_E_BSY
) {
200 /* This shouldn't happen. If it does then it's a bug ! */
201 usbp
->usber
|= USB_E_BSY
;
202 mpc8xx_udc_flush_rx_fifo ();
205 /* Scan all RX/Bidirectional Endpoints for RX data. */
206 for (epid
= 0; epid
< MAX_ENDPOINTS
; epid
++) {
207 if (!ep_ref
[epid
].prx
) {
210 rx_cbdp
= rx_cbdp_base
= ep_ref
[epid
].prx
;
213 if (!(rx_cbdp
->cbd_sc
& RX_BD_E
)) {
215 if (rx_cbdp
->cbd_sc
& 0x1F) {
216 /* Corrupt data discard it.
217 * Controller has NAK'd this packet.
219 mpc8xx_udc_clear_rxbd (rx_cbdp
);
223 mpc8xx_udc_ep0_rx (rx_cbdp
);
227 mpc8xx_udc_set_nak (epid
);
228 mpc8xx_udc_epn_rx (epid
, rx_cbdp
);
229 mpc8xx_udc_clear_rxbd (rx_cbdp
);
233 /* Advance RX CBD pointer */
234 mpc8xx_udc_advance_rx (&rx_cbdp
, epid
);
235 ep_ref
[epid
].prx
= rx_cbdp
;
237 /* Advance RX CBD pointer */
238 mpc8xx_udc_advance_rx (&rx_cbdp
, epid
);
241 } while (rx_cbdp
!= rx_cbdp_base
);
244 /* Handle TX events as appropiate, the correct place to do this is
245 * in a tx routine. Perhaps TX on epn was pre-empted by ep0
248 if (usbp
->usber
& USB_E_TXB
) {
249 usbp
->usber
|= USB_E_TXB
;
252 if (usbp
->usber
& (USB_TX_ERRMASK
)) {
253 mpc8xx_udc_handle_txerr ();
256 /* Switch to the default state, respond at the default address */
257 if (usbp
->usber
& USB_E_RESET
) {
258 usbp
->usber
|= USB_E_RESET
;
260 udc_device
->device_state
= STATE_DEFAULT
;
263 /* if(usbp->usber&USB_E_IDLE){
264 We could suspend here !
265 usbp->usber|=USB_E_IDLE;
266 DBG("idle state change\n");
269 We could resume here when IDLE is deasserted !
270 Not worth doing, so long as we are self powered though.
277 /* udc_endpoint_write
279 * Write some data to an endpoint
281 int udc_endpoint_write (struct usb_endpoint_instance
*epi
)
284 short epid
= 1, unnak
= 0, ret
= 0;
286 if (udc_state
!= STATE_READY
) {
287 ERR ("invalid udc_state != STATE_READY!\n");
291 if (!udc_device
|| !epi
) {
295 if (udc_device
->device_state
!= STATE_CONFIGURED
) {
299 ep
= epi
->endpoint_address
& 0x03;
300 if (ep
>= MAX_ENDPOINTS
) {
304 /* Set NAK for all RX endpoints during TX */
305 for (epid
= 1; epid
< MAX_ENDPOINTS
; epid
++) {
307 /* Don't set NAK on DATA IN/CONTROL endpoints */
308 if (ep_ref
[epid
].sc
& USB_DIR_IN
) {
312 if (!(usbp
->usep
[epid
] & (USEP_THS_NAK
| USEP_RHS_NAK
))) {
316 mpc8xx_udc_set_nak (epid
);
319 mpc8xx_udc_init_tx (&udc_device
->bus
->endpoint_array
[ep
],
321 ret
= mpc8xx_udc_ep_tx (&udc_device
->bus
->endpoint_array
[ep
]);
323 /* Remove temporary NAK */
324 for (epid
= 1; epid
< MAX_ENDPOINTS
; epid
++) {
325 if (unnak
& (1 << epid
)) {
326 udc_unset_nak (epid
);
333 /* mpc8xx_udc_assign_urb
335 * Associate a given urb to an endpoint TX or RX transmit/receive buffers
337 static int mpc8xx_udc_assign_urb (int ep
, char direction
)
339 struct usb_endpoint_instance
*epi
= 0;
341 if (ep
>= MAX_ENDPOINTS
) {
344 epi
= &udc_device
->bus
->endpoint_array
[ep
];
349 if (!ep_ref
[ep
].urb
) {
350 ep_ref
[ep
].urb
= usbd_alloc_urb (udc_device
, udc_device
->bus
->endpoint_array
);
351 if (!ep_ref
[ep
].urb
) {
355 ep_ref
[ep
].urb
->actual_length
= 0;
360 epi
->tx_urb
= ep_ref
[ep
].urb
;
363 epi
->rcv_urb
= ep_ref
[ep
].urb
;
371 udc_state
= STATE_ERROR
;
377 * Associate U-Boot software endpoints to mpc8xx endpoint parameter ram
378 * Isochronous endpoints aren't yet supported!
380 void udc_setup_ep (struct usb_device_instance
*device
, unsigned int ep
,
381 struct usb_endpoint_instance
*epi
)
386 if (epi
&& (ep
< MAX_ENDPOINTS
)) {
389 if (epi
->rcv_attributes
!= USB_ENDPOINT_XFER_CONTROL
390 || epi
->tx_attributes
!=
391 USB_ENDPOINT_XFER_CONTROL
) {
393 /* ep0 must be a control endpoint */
394 udc_state
= STATE_ERROR
;
398 if (!(ep_ref
[ep
].sc
& EP_ATTACHED
)) {
399 mpc8xx_udc_cbd_attach (ep
, epi
->tx_packetSize
,
400 epi
->rcv_packetSize
);
402 usbp
->usep
[ep
] = 0x0000;
406 if ((epi
->endpoint_address
& USB_ENDPOINT_DIR_MASK
)
410 ep_attrib
= epi
->tx_attributes
;
411 epi
->rcv_packetSize
= 0;
412 ep_ref
[ep
].sc
|= USB_DIR_IN
;
416 ep_attrib
= epi
->rcv_attributes
;
417 epi
->tx_packetSize
= 0;
418 ep_ref
[ep
].sc
&= ~USB_DIR_IN
;
421 if (mpc8xx_udc_assign_urb (ep
, epi
->endpoint_address
422 & USB_ENDPOINT_DIR_MASK
)) {
427 case USB_ENDPOINT_XFER_CONTROL
:
428 if (!(ep_ref
[ep
].sc
& EP_ATTACHED
)) {
429 mpc8xx_udc_cbd_attach (ep
,
431 epi
->rcv_packetSize
);
433 usbp
->usep
[ep
] = ep
<< 12;
434 epi
->rcv_urb
= epi
->tx_urb
= ep_ref
[ep
].urb
;
437 case USB_ENDPOINT_XFER_BULK
:
438 case USB_ENDPOINT_XFER_INT
:
439 if (!(ep_ref
[ep
].sc
& EP_ATTACHED
)) {
441 mpc8xx_udc_cbd_attach (ep
,
445 mpc8xx_udc_cbd_attach (ep
,
447 epi
->rcv_packetSize
);
450 usbp
->usep
[ep
] = (ep
<< 12) | ((ep_attrib
) << 8);
453 case USB_ENDPOINT_XFER_ISOC
:
455 serial_printf ("Error endpoint attrib %d>3\n", ep_attrib
);
456 udc_state
= STATE_ERROR
;
465 * Move state, switch on the USB
467 void udc_connect (void)
469 /* Enable pull-up resistor on D+
470 * TODO: fit a pull-up resistor to drive SE0 for > 2.5us
473 if (udc_state
!= STATE_ERROR
) {
474 udc_state
= STATE_READY
;
475 usbp
->usmod
|= USMOD_EN
;
481 * Disconnect is not used but, is included for completeness
483 void udc_disconnect (void)
485 /* Disable pull-up resistor on D-
486 * TODO: fix a pullup resistor to control this
489 if (udc_state
!= STATE_ERROR
) {
490 udc_state
= STATE_NOT_READY
;
492 usbp
->usmod
&= ~USMOD_EN
;
497 * Grab an EP0 URB, register interest in a subset of USB events
499 void udc_enable (struct usb_device_instance
*device
)
501 if (udc_state
== STATE_ERROR
) {
507 if (!ep_ref
[0].urb
) {
508 ep_ref
[0].urb
= usbd_alloc_urb (device
, device
->bus
->endpoint_array
);
511 /* Register interest in all events except SOF, enable transceiver */
512 usbp
->usber
= 0x03FF;
513 usbp
->usbmr
= 0x02F7;
520 * disable the currently hooked device
522 void udc_disable (void)
526 if (udc_state
== STATE_ERROR
) {
527 DBG ("Won't disable UDC. udc_state==STATE_ERROR !\n");
533 for (; i
< MAX_ENDPOINTS
; i
++) {
535 usbd_dealloc_urb (ep_ref
[i
].urb
);
541 usbp
->usmod
= ~USMOD_EN
;
542 udc_state
= STATE_NOT_READY
;
545 /* udc_startup_events
547 * Enable the specified device
549 void udc_startup_events (struct usb_device_instance
*device
)
552 if (udc_state
== STATE_READY
) {
553 usbd_device_event_irq (device
, DEVICE_CREATE
, 0);
559 * Allow upper layers to signal lower layers should not accept more RX data
562 void udc_set_nak (int epid
)
565 mpc8xx_udc_set_nak (epid
);
571 * Suspend sending of NAK tokens for DATA OUT tokens on a given endpoint.
572 * Switch off NAKing on this endpoint to accept more data output from host.
575 void udc_unset_nak (int epid
)
577 if (epid
> MAX_ENDPOINTS
) {
581 if (usbp
->usep
[epid
] & (USEP_THS_NAK
| USEP_RHS_NAK
)) {
582 usbp
->usep
[epid
] &= ~(USEP_THS_NAK
| USEP_RHS_NAK
);
587 /******************************************************************************
589 ******************************************************************************/
591 /* udc_state_transition_up
592 * udc_state_transition_down
594 * Helper functions to implement device state changes. The device states and
595 * the events that transition between them are:
600 * DEVICE_HUB_CONFIGURED DEVICE_HUB_RESET
606 * DEVICE_RESET DEVICE_POWER_INTERRUPTION
612 * DEVICE_ADDRESS_ASSIGNED DEVICE_RESET
618 * DEVICE_CONFIGURED DEVICE_DE_CONFIGURED
623 * udc_state_transition_up transitions up (in the direction from STATE_ATTACHED
624 * to STATE_CONFIGURED) from the specified initial state to the specified final
625 * state, passing through each intermediate state on the way. If the initial
626 * state is at or above (i.e. nearer to STATE_CONFIGURED) the final state, then
627 * no state transitions will take place.
629 * udc_state_transition_down transitions down (in the direction from
630 * STATE_CONFIGURED to STATE_ATTACHED) from the specified initial state to the
631 * specified final state, passing through each intermediate state on the way.
632 * If the initial state is at or below (i.e. nearer to STATE_ATTACHED) the final
633 * state, then no state transitions will take place.
637 static void mpc8xx_udc_state_transition_up (usb_device_state_t initial
,
638 usb_device_state_t final
)
640 if (initial
< final
) {
643 usbd_device_event_irq (udc_device
,
644 DEVICE_HUB_CONFIGURED
, 0);
645 if (final
== STATE_POWERED
)
648 usbd_device_event_irq (udc_device
, DEVICE_RESET
, 0);
649 if (final
== STATE_DEFAULT
)
652 usbd_device_event_irq (udc_device
,
653 DEVICE_ADDRESS_ASSIGNED
, 0);
654 if (final
== STATE_ADDRESSED
)
656 case STATE_ADDRESSED
:
657 usbd_device_event_irq (udc_device
, DEVICE_CONFIGURED
,
659 case STATE_CONFIGURED
:
667 static void mpc8xx_udc_state_transition_down (usb_device_state_t initial
,
668 usb_device_state_t final
)
670 if (initial
> final
) {
672 case STATE_CONFIGURED
:
673 usbd_device_event_irq (udc_device
,
674 DEVICE_DE_CONFIGURED
, 0);
675 if (final
== STATE_ADDRESSED
)
677 case STATE_ADDRESSED
:
678 usbd_device_event_irq (udc_device
, DEVICE_RESET
, 0);
679 if (final
== STATE_DEFAULT
)
682 usbd_device_event_irq (udc_device
,
683 DEVICE_POWER_INTERRUPTION
, 0);
684 if (final
== STATE_POWERED
)
687 usbd_device_event_irq (udc_device
, DEVICE_HUB_RESET
,
699 * Force returning of STALL tokens on the given endpoint. Protocol or function
700 * STALL conditions are permissable here
702 static void mpc8xx_udc_stall (unsigned int ep
)
704 usbp
->usep
[ep
] |= STALL_BITMASK
;
707 /* mpc8xx_udc_set_nak
709 * Force returning of NAK responses for the given endpoint as a kind of very
710 * simple flow control
712 static void mpc8xx_udc_set_nak (unsigned int ep
)
714 usbp
->usep
[ep
] |= NAK_BITMASK
;
718 /* mpc8xx_udc_handle_txerr
720 * Handle errors relevant to TX. Return a status code to allow calling
721 * indicative of what if anything happened
723 static short mpc8xx_udc_handle_txerr ()
725 short ep
= 0, ret
= 0;
727 for (; ep
< TX_RING_SIZE
; ep
++) {
728 if (usbp
->usber
& (0x10 << ep
)) {
730 /* Timeout or underrun */
731 if (tx_cbd
[ep
]->cbd_sc
& 0x06) {
733 mpc8xx_udc_flush_tx_fifo (ep
);
736 if (usbp
->usep
[ep
] & STALL_BITMASK
) {
738 usbp
->usep
[ep
] &= ~STALL_BITMASK
;
742 usbp
->usber
|= (0x10 << ep
);
748 /* mpc8xx_udc_advance_rx
752 static void mpc8xx_udc_advance_rx (volatile cbd_t
** rx_cbdp
, int epid
)
754 if ((*rx_cbdp
)->cbd_sc
& RX_BD_W
) {
755 *rx_cbdp
= (volatile cbd_t
*) (endpoints
[epid
]->rbase
+ CONFIG_SYS_IMMR
);
763 /* mpc8xx_udc_flush_tx_fifo
765 * Flush a given TX fifo. Assumes one tx cbd per endpoint
767 static void mpc8xx_udc_flush_tx_fifo (int epid
)
769 volatile cbd_t
*tx_cbdp
= 0;
771 if (epid
> MAX_ENDPOINTS
) {
776 immr
->im_cpm
.cp_cpcr
= ((epid
<< 2) | 0x1D01);
778 while (immr
->im_cpm
.cp_cpcr
& 0x01);
780 usbp
->uscom
= 0x40 | 0;
783 tx_cbdp
= (cbd_t
*) (endpoints
[epid
]->tbptr
+ CONFIG_SYS_IMMR
);
784 tx_cbdp
->cbd_sc
= (TX_BD_I
| TX_BD_W
);
787 endpoints
[epid
]->tptr
= endpoints
[epid
]->tbase
;
788 endpoints
[epid
]->tstate
= 0x00;
789 endpoints
[epid
]->tbcnt
= 0x00;
792 immr
->im_cpm
.cp_cpcr
= ((epid
<< 2) | 0x2D01);
794 while (immr
->im_cpm
.cp_cpcr
& 0x01);
799 /* mpc8xx_udc_flush_rx_fifo
801 * For the sake of completeness of the namespace, it seems like
802 * a good-design-decision (tm) to include mpc8xx_udc_flush_rx_fifo();
803 * If RX_BD_E is true => a driver bug either here or in an upper layer
804 * not polling frequently enough. If RX_BD_E is true we have told the host
805 * we have accepted data but, the CPM found it had no-where to put that data
806 * which needless to say would be a bad thing.
808 static void mpc8xx_udc_flush_rx_fifo ()
812 for (i
= 0; i
< RX_RING_SIZE
; i
++) {
813 if (!(rx_cbd
[i
]->cbd_sc
& RX_BD_E
)) {
814 ERR ("buf %p used rx data len = 0x%x sc=0x%x!\n",
815 rx_cbd
[i
], rx_cbd
[i
]->cbd_datlen
,
820 ERR ("BUG : Input over-run\n");
823 /* mpc8xx_udc_clear_rxbd
825 * Release control of RX CBD to CP.
827 static void mpc8xx_udc_clear_rxbd (volatile cbd_t
* rx_cbdp
)
829 rx_cbdp
->cbd_datlen
= 0x0000;
830 rx_cbdp
->cbd_sc
= ((rx_cbdp
->cbd_sc
& RX_BD_W
) | (RX_BD_E
| RX_BD_I
));
836 * Parse for tx timeout, control RX or USB reset/busy conditions
837 * Return -1 on timeout, -2 on fatal error, else return zero
839 static int mpc8xx_udc_tx_irq (int ep
)
843 if (usbp
->usber
& (USB_TX_ERRMASK
)) {
844 if (mpc8xx_udc_handle_txerr ()) {
845 /* Timeout, controlling function must retry send */
850 if (usbp
->usber
& (USB_E_RESET
| USB_E_BSY
)) {
851 /* Fatal, abandon TX transaction */
855 if (usbp
->usber
& USB_E_RXB
) {
856 for (i
= 0; i
< RX_RING_SIZE
; i
++) {
857 if (!(rx_cbd
[i
]->cbd_sc
& RX_BD_E
)) {
858 if ((rx_cbd
[i
] == ep_ref
[0].prx
) || ep
) {
870 * Transmit in a re-entrant fashion outbound USB packets.
871 * Implement retry/timeout mechanism described in USB specification
872 * Toggle DATA0/DATA1 pids as necessary
873 * Introduces non-standard tx_retry. The USB standard has no scope for slave
874 * devices to give up TX, however tx_retry stops us getting stuck in an endless
877 static int mpc8xx_udc_ep_tx (struct usb_endpoint_instance
*epi
)
879 struct urb
*urb
= epi
->tx_urb
;
880 volatile cbd_t
*tx_cbdp
= 0;
881 unsigned int ep
= 0, pkt_len
= 0, x
= 0, tx_retry
= 0;
884 if (!epi
|| (epi
->endpoint_address
& 0x03) >= MAX_ENDPOINTS
|| !urb
) {
888 ep
= epi
->endpoint_address
& 0x03;
889 tx_cbdp
= (cbd_t
*) (endpoints
[ep
]->tbptr
+ CONFIG_SYS_IMMR
);
891 if (tx_cbdp
->cbd_sc
& TX_BD_R
|| usbp
->usber
& USB_E_TXB
) {
892 mpc8xx_udc_flush_tx_fifo (ep
);
893 usbp
->usber
|= USB_E_TXB
;
896 while (tx_retry
++ < 100) {
897 ret
= mpc8xx_udc_tx_irq (ep
);
899 /* ignore timeout here */
900 } else if (ret
== -2) {
902 mpc8xx_udc_flush_tx_fifo (ep
);
906 tx_cbdp
= (cbd_t
*) (endpoints
[ep
]->tbptr
+ CONFIG_SYS_IMMR
);
907 while (tx_cbdp
->cbd_sc
& TX_BD_R
) {
909 tx_cbdp
->cbd_sc
= (tx_cbdp
->cbd_sc
& TX_BD_W
);
911 pkt_len
= urb
->actual_length
- epi
->sent
;
913 if (pkt_len
> epi
->tx_packetSize
|| pkt_len
> EP_MAX_PKT
) {
914 pkt_len
= MIN (epi
->tx_packetSize
, EP_MAX_PKT
);
917 for (x
= 0; x
< pkt_len
; x
++) {
918 *((unsigned char *) (tx_cbdp
->cbd_bufaddr
+ x
)) =
919 urb
->buffer
[epi
->sent
+ x
];
921 tx_cbdp
->cbd_datlen
= pkt_len
;
922 tx_cbdp
->cbd_sc
|= (CBD_TX_BITMASK
| ep_ref
[ep
].pid
);
925 #ifdef __SIMULATE_ERROR__
926 if (++err_poison_test
== 2) {
928 tx_cbdp
->cbd_sc
&= ~TX_BD_TC
;
932 usbp
->uscom
= (USCOM_STR
| ep
);
934 while (!(usbp
->usber
& USB_E_TXB
)) {
935 ret
= mpc8xx_udc_tx_irq (ep
);
939 } else if (ret
== -2) {
940 if (usbp
->usber
& USB_E_TXB
) {
941 usbp
->usber
|= USB_E_TXB
;
943 mpc8xx_udc_flush_tx_fifo (ep
);
948 if (usbp
->usber
& USB_E_TXB
) {
949 usbp
->usber
|= USB_E_TXB
;
952 /* ACK must be present <= 18bit times from TX */
957 /* TX ACK : USB 2.0 8.7.2, Toggle PID, Advance TX */
958 epi
->sent
+= pkt_len
;
959 epi
->last
= MIN (urb
->actual_length
- epi
->sent
, epi
->tx_packetSize
);
960 TOGGLE_TX_PID (ep_ref
[ep
].pid
);
962 if (epi
->sent
>= epi
->tx_urb
->actual_length
) {
964 epi
->tx_urb
->actual_length
= 0;
967 if (ep_ref
[ep
].sc
& EP_SEND_ZLP
) {
968 ep_ref
[ep
].sc
&= ~EP_SEND_ZLP
;
975 ERR ("TX fail, endpoint 0x%x tx bytes 0x%x/0x%x\n", ep
, epi
->sent
,
976 epi
->tx_urb
->actual_length
);
981 /* mpc8xx_udc_dump_request
983 * Dump a control request to console
985 static void mpc8xx_udc_dump_request (struct usb_device_request
*request
)
987 DBG ("bmRequestType:%02x bRequest:%02x wValue:%04x "
988 "wIndex:%04x wLength:%04x ?\n",
989 request
->bmRequestType
,
991 request
->wValue
, request
->wIndex
, request
->wLength
);
996 /* mpc8xx_udc_ep0_rx_setup
998 * Decode received ep0 SETUP packet. return non-zero on error
1000 static int mpc8xx_udc_ep0_rx_setup (volatile cbd_t
* rx_cbdp
)
1003 struct urb
*purb
= ep_ref
[0].urb
;
1004 struct usb_endpoint_instance
*epi
=
1005 &udc_device
->bus
->endpoint_array
[0];
1007 for (; x
< rx_cbdp
->cbd_datlen
; x
++) {
1008 *(((unsigned char *) &ep_ref
[0].urb
->device_request
) + x
) =
1009 *((unsigned char *) (rx_cbdp
->cbd_bufaddr
+ x
));
1012 mpc8xx_udc_clear_rxbd (rx_cbdp
);
1014 if (ep0_recv_setup (purb
)) {
1015 mpc8xx_udc_dump_request (&purb
->device_request
);
1019 if ((purb
->device_request
.bmRequestType
& USB_REQ_DIRECTION_MASK
)
1020 == USB_REQ_HOST2DEVICE
) {
1022 switch (purb
->device_request
.bRequest
) {
1023 case USB_REQ_SET_ADDRESS
:
1024 /* Send the Status OUT ZLP */
1025 ep_ref
[0].pid
= TX_BD_PID_DATA1
;
1026 purb
->actual_length
= 0;
1027 mpc8xx_udc_init_tx (epi
, purb
);
1028 mpc8xx_udc_ep_tx (epi
);
1030 /* Move to the addressed state */
1031 usbp
->usaddr
= udc_device
->address
;
1032 mpc8xx_udc_state_transition_up (udc_device
->device_state
,
1036 case USB_REQ_SET_CONFIGURATION
:
1037 if (!purb
->device_request
.wValue
) {
1038 /* Respond at default address */
1039 usbp
->usaddr
= 0x00;
1040 mpc8xx_udc_state_transition_down (udc_device
->device_state
,
1043 /* TODO: Support multiple configurations */
1044 mpc8xx_udc_state_transition_up (udc_device
->device_state
,
1046 for (x
= 1; x
< MAX_ENDPOINTS
; x
++) {
1047 if ((udc_device
->bus
->endpoint_array
[x
].endpoint_address
& USB_ENDPOINT_DIR_MASK
)
1049 ep_ref
[x
].pid
= TX_BD_PID_DATA0
;
1051 ep_ref
[x
].pid
= RX_BD_PID_DATA0
;
1053 /* Set configuration must unstall endpoints */
1054 usbp
->usep
[x
] &= ~STALL_BITMASK
;
1059 /* CDC/Vendor specific */
1063 /* Send ZLP as ACK in Status OUT phase */
1064 ep_ref
[0].pid
= TX_BD_PID_DATA1
;
1065 purb
->actual_length
= 0;
1066 mpc8xx_udc_init_tx (epi
, purb
);
1067 mpc8xx_udc_ep_tx (epi
);
1071 if (purb
->actual_length
) {
1072 ep_ref
[0].pid
= TX_BD_PID_DATA1
;
1073 mpc8xx_udc_init_tx (epi
, purb
);
1075 if (!(purb
->actual_length
% EP0_MAX_PACKET_SIZE
)) {
1076 ep_ref
[0].sc
|= EP_SEND_ZLP
;
1079 if (purb
->device_request
.wValue
==
1080 USB_DESCRIPTOR_TYPE_DEVICE
) {
1081 if (le16_to_cpu (purb
->device_request
.wLength
)
1082 > purb
->actual_length
) {
1083 /* Send EP0_MAX_PACKET_SIZE bytes
1084 * unless correct size requested.
1086 if (purb
->actual_length
> epi
->tx_packetSize
) {
1087 purb
->actual_length
= epi
->tx_packetSize
;
1091 mpc8xx_udc_ep_tx (epi
);
1094 /* Corrupt SETUP packet? */
1095 ERR ("Zero length data or SETUP with DATA-IN phase ?\n");
1102 /* mpc8xx_udc_init_tx
1104 * Setup some basic parameters for a TX transaction
1106 static void mpc8xx_udc_init_tx (struct usb_endpoint_instance
*epi
,
1111 epi
->tx_urb
= tx_urb
;
1114 /* mpc8xx_udc_ep0_rx
1116 * Receive ep0/control USB data. Parse and possibly send a response.
1118 static void mpc8xx_udc_ep0_rx (volatile cbd_t
* rx_cbdp
)
1120 if (rx_cbdp
->cbd_sc
& RX_BD_PID_SETUP
) {
1122 /* Unconditionally accept SETUP packets */
1123 if (mpc8xx_udc_ep0_rx_setup (rx_cbdp
)) {
1124 mpc8xx_udc_stall (0);
1129 mpc8xx_udc_clear_rxbd (rx_cbdp
);
1131 if ((rx_cbdp
->cbd_datlen
- 2)) {
1132 /* SETUP with a DATA phase
1133 * outside of SETUP packet.
1136 mpc8xx_udc_stall (0);
1141 /* mpc8xx_udc_epn_rx
1143 * Receive some data from cbd into USB system urb data abstraction
1144 * Upper layers should NAK if there is insufficient RX data space
1146 static int mpc8xx_udc_epn_rx (unsigned int epid
, volatile cbd_t
* rx_cbdp
)
1148 struct usb_endpoint_instance
*epi
= 0;
1149 struct urb
*urb
= 0;
1152 if (epid
>= MAX_ENDPOINTS
|| !rx_cbdp
->cbd_datlen
) {
1156 /* USB 2.0 PDF section 8.6.4
1157 * Discard data with invalid PID it is a resend.
1159 if (ep_ref
[epid
].pid
!= (rx_cbdp
->cbd_sc
& 0xC0)) {
1162 TOGGLE_RX_PID (ep_ref
[epid
].pid
);
1164 epi
= &udc_device
->bus
->endpoint_array
[epid
];
1167 for (; x
< (rx_cbdp
->cbd_datlen
- 2); x
++) {
1168 *((unsigned char *) (urb
->buffer
+ urb
->actual_length
+ x
)) =
1169 *((unsigned char *) (rx_cbdp
->cbd_bufaddr
+ x
));
1173 usbd_rcv_complete (epi
, x
, 0);
1174 if (ep_ref
[epid
].urb
->status
== RECV_ERROR
) {
1175 DBG ("RX error unset NAK\n");
1176 udc_unset_nak (epid
);
1182 /* mpc8xx_udc_clock_init
1184 * Obtain a clock reference for Full Speed Signaling
1186 static void mpc8xx_udc_clock_init (volatile immap_t
* immr
,
1187 volatile cpm8xx_t
* cp
)
1190 #if defined(CONFIG_SYS_USB_EXTC_CLK)
1192 /* This has been tested with a 48MHz crystal on CLK6 */
1193 switch (CONFIG_SYS_USB_EXTC_CLK
) {
1195 immr
->im_ioport
.iop_papar
|= 0x0100;
1196 immr
->im_ioport
.iop_padir
&= ~0x0100;
1197 cp
->cp_sicr
|= 0x24;
1200 immr
->im_ioport
.iop_papar
|= 0x0200;
1201 immr
->im_ioport
.iop_padir
&= ~0x0200;
1202 cp
->cp_sicr
|= 0x2D;
1205 immr
->im_ioport
.iop_papar
|= 0x0400;
1206 immr
->im_ioport
.iop_padir
&= ~0x0400;
1207 cp
->cp_sicr
|= 0x36;
1210 immr
->im_ioport
.iop_papar
|= 0x0800;
1211 immr
->im_ioport
.iop_padir
&= ~0x0800;
1212 cp
->cp_sicr
|= 0x3F;
1215 udc_state
= STATE_ERROR
;
1219 #elif defined(CONFIG_SYS_USB_BRGCLK)
1221 /* This has been tested with brgclk == 50MHz */
1224 if (gd
->cpu_clk
< 48000000L) {
1225 ERR ("brgclk is too slow for full-speed USB!\n");
1226 udc_state
= STATE_ERROR
;
1230 /* Assume the brgclk is 'good enough', we want !(gd->cpu_clk%48Mhz)
1231 * but, can /probably/ live with close-ish alternative rates.
1233 divisor
= (gd
->cpu_clk
/ 48000000L) - 1;
1234 cp
->cp_sicr
&= ~0x0000003F;
1236 switch (CONFIG_SYS_USB_BRGCLK
) {
1238 cp
->cp_brgc1
|= (divisor
| CPM_BRG_EN
);
1239 cp
->cp_sicr
&= ~0x2F;
1242 cp
->cp_brgc2
|= (divisor
| CPM_BRG_EN
);
1243 cp
->cp_sicr
|= 0x00000009;
1246 cp
->cp_brgc3
|= (divisor
| CPM_BRG_EN
);
1247 cp
->cp_sicr
|= 0x00000012;
1250 cp
->cp_brgc4
= (divisor
| CPM_BRG_EN
);
1251 cp
->cp_sicr
|= 0x0000001B;
1254 udc_state
= STATE_ERROR
;
1259 #error "CONFIG_SYS_USB_EXTC_CLK or CONFIG_SYS_USB_BRGCLK must be defined"
1264 /* mpc8xx_udc_cbd_attach
1266 * attach a cbd to and endpoint
1268 static void mpc8xx_udc_cbd_attach (int ep
, uchar tx_size
, uchar rx_size
)
1271 if (!tx_cbd
[ep
] || !rx_cbd
[ep
] || ep
>= MAX_ENDPOINTS
) {
1272 udc_state
= STATE_ERROR
;
1276 if (tx_size
> USB_MAX_PKT
|| rx_size
> USB_MAX_PKT
||
1277 (!tx_size
&& !rx_size
)) {
1278 udc_state
= STATE_ERROR
;
1282 /* Attach CBD to appropiate Parameter RAM Endpoint data structure */
1284 endpoints
[ep
]->rbase
= (u32
) rx_cbd
[rx_ct
];
1285 endpoints
[ep
]->rbptr
= (u32
) rx_cbd
[rx_ct
];
1290 endpoints
[ep
]->rbptr
= (u32
) rx_cbd
[rx_ct
];
1291 rx_cbd
[rx_ct
]->cbd_sc
|= RX_BD_W
;
1296 endpoints
[ep
]->rbptr
= (u32
) rx_cbd
[rx_ct
];
1297 rx_cbd
[rx_ct
]->cbd_sc
|= RX_BD_W
;
1301 /* Where we expect to RX data on this endpoint */
1302 ep_ref
[ep
].prx
= rx_cbd
[rx_ct
- 1];
1306 endpoints
[ep
]->rbase
= 0;
1307 endpoints
[ep
]->rbptr
= 0;
1311 endpoints
[ep
]->tbase
= (u32
) tx_cbd
[tx_ct
];
1312 endpoints
[ep
]->tbptr
= (u32
) tx_cbd
[tx_ct
];
1315 endpoints
[ep
]->tbase
= 0;
1316 endpoints
[ep
]->tbptr
= 0;
1319 endpoints
[ep
]->tstate
= 0;
1320 endpoints
[ep
]->tbcnt
= 0;
1321 endpoints
[ep
]->mrblr
= EP_MAX_PKT
;
1322 endpoints
[ep
]->rfcr
= 0x18;
1323 endpoints
[ep
]->tfcr
= 0x18;
1324 ep_ref
[ep
].sc
|= EP_ATTACHED
;
1326 DBG ("ep %d rbase 0x%08x rbptr 0x%08x tbase 0x%08x tbptr 0x%08x prx = %p\n",
1327 ep
, endpoints
[ep
]->rbase
, endpoints
[ep
]->rbptr
,
1328 endpoints
[ep
]->tbase
, endpoints
[ep
]->tbptr
,
1334 /* mpc8xx_udc_cbd_init
1336 * Allocate space for a cbd and allocate TX/RX data space
1338 static void mpc8xx_udc_cbd_init (void)
1342 for (; i
< TX_RING_SIZE
; i
++) {
1343 tx_cbd
[i
] = (cbd_t
*)
1344 mpc8xx_udc_alloc (sizeof (cbd_t
), sizeof (int));
1347 for (i
= 0; i
< RX_RING_SIZE
; i
++) {
1348 rx_cbd
[i
] = (cbd_t
*)
1349 mpc8xx_udc_alloc (sizeof (cbd_t
), sizeof (int));
1352 for (i
= 0; i
< TX_RING_SIZE
; i
++) {
1353 tx_cbd
[i
]->cbd_bufaddr
=
1354 mpc8xx_udc_alloc (EP_MAX_PKT
, sizeof (int));
1356 tx_cbd
[i
]->cbd_sc
= (TX_BD_I
| TX_BD_W
);
1357 tx_cbd
[i
]->cbd_datlen
= 0x0000;
1361 for (i
= 0; i
< RX_RING_SIZE
; i
++) {
1362 rx_cbd
[i
]->cbd_bufaddr
=
1363 mpc8xx_udc_alloc (EP_MAX_PKT
, sizeof (int));
1364 rx_cbd
[i
]->cbd_sc
= (RX_BD_I
| RX_BD_E
);
1365 rx_cbd
[i
]->cbd_datlen
= 0x0000;
1372 /* mpc8xx_udc_endpoint_init
1374 * Attach an endpoint to some dpram
1376 static void mpc8xx_udc_endpoint_init (void)
1380 for (; i
< MAX_ENDPOINTS
; i
++) {
1381 endpoints
[i
] = (usb_epb_t
*)
1382 mpc8xx_udc_alloc (sizeof (usb_epb_t
), 32);
1388 * Grab the address of some dpram
1390 static u32
mpc8xx_udc_alloc (u32 data_size
, u32 alignment
)
1392 u32 retaddr
= address_base
;
1394 while (retaddr
% alignment
) {
1397 address_base
+= data_size
;
1402 #endif /* CONFIG_MPC885_FAMILY && CONFIG_USB_DEVICE) */