mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-05 19:10:13 +00:00
eae4b2b67b
Signed-off-by: Vagrant Cascadian <vagrant@debian.org> Reviewed-by: Simon Glass <sjg@chromium.org>
1386 lines
32 KiB
C
1386 lines
32 KiB
C
/*
|
|
* Copyright (C) 2006 by Bryan O'Donoghue, CodeHermit
|
|
* bodonoghue@CodeHermit.ie
|
|
*
|
|
* References
|
|
* DasUBoot/drivers/usb/gadget/omap1510_udc.c, for design and implementation
|
|
* ideas.
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
*/
|
|
|
|
/*
|
|
* Notes :
|
|
* 1. #define __SIMULATE_ERROR__ to inject a CRC error into every 2nd TX
|
|
* packet to force the USB re-transmit protocol.
|
|
*
|
|
* 2. #define __DEBUG_UDC__ to switch on debug tracing to serial console
|
|
* be careful that tracing doesn't create Hiesen-bugs with respect to
|
|
* response timeouts to control requests.
|
|
*
|
|
* 3. This driver should be able to support any higher level driver that
|
|
* that wants to do either of the two standard UDC implementations
|
|
* Control-Bulk-Interrupt or Bulk-IN/Bulk-Out standards. Hence
|
|
* gserial and cdc_acm should work with this code.
|
|
*
|
|
* 4. NAK events never actually get raised at all, the documentation
|
|
* is just wrong !
|
|
*
|
|
* 5. For some reason, cbd_datlen is *always* +2 the value it should be.
|
|
* this means that having an RX cbd of 16 bytes is not possible, since
|
|
* the same size is reported for 14 bytes received as 16 bytes received
|
|
* until we can find out why this happens, RX cbds must be limited to 8
|
|
* bytes. TODO: check errata for this behaviour.
|
|
*
|
|
* 6. Right now this code doesn't support properly powering up with the USB
|
|
* cable attached to the USB host my development board the Adder87x doesn't
|
|
* have a pull-up fitted to allow this, so it is necessary to power the
|
|
* board and *then* attached the USB cable to the host. However somebody
|
|
* with a different design in their board may be able to keep the cable
|
|
* constantly connected and simply enable/disable a pull-up re
|
|
* figure 31.1 in MPC885RM.pdf instead of having to power up the board and
|
|
* then attach the cable !
|
|
*
|
|
*/
|
|
#include <common.h>
|
|
#include <config.h>
|
|
#include <commproc.h>
|
|
#include <usbdevice.h>
|
|
#include <usb/mpc8xx_udc.h>
|
|
#include <usb/udc.h>
|
|
|
|
#include "ep0.h"
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
#define ERR(fmt, args...)\
|
|
serial_printf("ERROR : [%s] %s:%d: "fmt,\
|
|
__FILE__,__FUNCTION__,__LINE__, ##args)
|
|
#ifdef __DEBUG_UDC__
|
|
#define DBG(fmt,args...)\
|
|
serial_printf("[%s] %s:%d: "fmt,\
|
|
__FILE__,__FUNCTION__,__LINE__, ##args)
|
|
#else
|
|
#define DBG(fmt,args...)
|
|
#endif
|
|
|
|
/* Static Data */
|
|
#ifdef __SIMULATE_ERROR__
|
|
static char err_poison_test = 0;
|
|
#endif
|
|
static struct mpc8xx_ep ep_ref[MAX_ENDPOINTS];
|
|
static u32 address_base = STATE_NOT_READY;
|
|
static mpc8xx_udc_state_t udc_state = 0;
|
|
static struct usb_device_instance *udc_device = 0;
|
|
static volatile usb_epb_t *endpoints[MAX_ENDPOINTS];
|
|
static volatile cbd_t *tx_cbd[TX_RING_SIZE];
|
|
static volatile cbd_t *rx_cbd[RX_RING_SIZE];
|
|
static volatile immap_t *immr = 0;
|
|
static volatile cpm8xx_t *cp = 0;
|
|
static volatile usb_pram_t *usb_paramp = 0;
|
|
static volatile usb_t *usbp = 0;
|
|
static int rx_ct = 0;
|
|
static int tx_ct = 0;
|
|
|
|
/* Static Function Declarations */
|
|
static void mpc8xx_udc_state_transition_up (usb_device_state_t initial,
|
|
usb_device_state_t final);
|
|
static void mpc8xx_udc_state_transition_down (usb_device_state_t initial,
|
|
usb_device_state_t final);
|
|
static void mpc8xx_udc_stall (unsigned int ep);
|
|
static void mpc8xx_udc_flush_tx_fifo (int epid);
|
|
static void mpc8xx_udc_flush_rx_fifo (void);
|
|
static void mpc8xx_udc_clear_rxbd (volatile cbd_t * rx_cbdp);
|
|
static void mpc8xx_udc_init_tx (struct usb_endpoint_instance *epi,
|
|
struct urb *tx_urb);
|
|
static void mpc8xx_udc_dump_request (struct usb_device_request *request);
|
|
static void mpc8xx_udc_clock_init (volatile immap_t * immr,
|
|
volatile cpm8xx_t * cp);
|
|
static int mpc8xx_udc_ep_tx (struct usb_endpoint_instance *epi);
|
|
static int mpc8xx_udc_epn_rx (unsigned int epid, volatile cbd_t * rx_cbdp);
|
|
static void mpc8xx_udc_ep0_rx (volatile cbd_t * rx_cbdp);
|
|
static void mpc8xx_udc_cbd_init (void);
|
|
static void mpc8xx_udc_endpoint_init (void);
|
|
static void mpc8xx_udc_cbd_attach (int ep, uchar tx_size, uchar rx_size);
|
|
static u32 mpc8xx_udc_alloc (u32 data_size, u32 alignment);
|
|
static int mpc8xx_udc_ep0_rx_setup (volatile cbd_t * rx_cbdp);
|
|
static void mpc8xx_udc_set_nak (unsigned int ep);
|
|
static short mpc8xx_udc_handle_txerr (void);
|
|
static void mpc8xx_udc_advance_rx (volatile cbd_t ** rx_cbdp, int epid);
|
|
|
|
/******************************************************************************
|
|
Global Linkage
|
|
*****************************************************************************/
|
|
|
|
/* udc_init
|
|
*
|
|
* Do initial bus gluing
|
|
*/
|
|
int udc_init (void)
|
|
{
|
|
/* Init various pointers */
|
|
immr = (immap_t *) CONFIG_SYS_IMMR;
|
|
cp = (cpm8xx_t *) & (immr->im_cpm);
|
|
usb_paramp = (usb_pram_t *) & (cp->cp_dparam[PROFF_USB]);
|
|
usbp = (usb_t *) & (cp->cp_scc[0]);
|
|
|
|
memset (ep_ref, 0x00, (sizeof (struct mpc8xx_ep) * MAX_ENDPOINTS));
|
|
|
|
udc_device = 0;
|
|
udc_state = STATE_NOT_READY;
|
|
|
|
usbp->usmod = 0x00;
|
|
usbp->uscom = 0;
|
|
|
|
/* Set USB Frame #0, Respond at Address & Get a clock source */
|
|
usbp->usaddr = 0x00;
|
|
mpc8xx_udc_clock_init (immr, cp);
|
|
|
|
/* PA15, PA14 as perhiperal USBRXD and USBOE */
|
|
immr->im_ioport.iop_padir &= ~0x0003;
|
|
immr->im_ioport.iop_papar |= 0x0003;
|
|
|
|
/* PC11/PC10 as peripheral USBRXP USBRXN */
|
|
immr->im_ioport.iop_pcso |= 0x0030;
|
|
|
|
/* PC7/PC6 as perhiperal USBTXP and USBTXN */
|
|
immr->im_ioport.iop_pcdir |= 0x0300;
|
|
immr->im_ioport.iop_pcpar |= 0x0300;
|
|
|
|
/* Set the base address */
|
|
address_base = (u32) (cp->cp_dpmem + CPM_USB_BASE);
|
|
|
|
/* Initialise endpoints and circular buffers */
|
|
mpc8xx_udc_endpoint_init ();
|
|
mpc8xx_udc_cbd_init ();
|
|
|
|
/* Assign allocated Dual Port Endpoint descriptors */
|
|
usb_paramp->ep0ptr = (u32) endpoints[0];
|
|
usb_paramp->ep1ptr = (u32) endpoints[1];
|
|
usb_paramp->ep2ptr = (u32) endpoints[2];
|
|
usb_paramp->ep3ptr = (u32) endpoints[3];
|
|
usb_paramp->frame_n = 0;
|
|
|
|
DBG ("ep0ptr=0x%08x ep1ptr=0x%08x ep2ptr=0x%08x ep3ptr=0x%08x\n",
|
|
usb_paramp->ep0ptr, usb_paramp->ep1ptr, usb_paramp->ep2ptr,
|
|
usb_paramp->ep3ptr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* udc_irq
|
|
*
|
|
* Poll for whatever events may have occurred
|
|
*/
|
|
void udc_irq (void)
|
|
{
|
|
int epid = 0;
|
|
volatile cbd_t *rx_cbdp = 0;
|
|
volatile cbd_t *rx_cbdp_base = 0;
|
|
|
|
if (udc_state != STATE_READY) {
|
|
return;
|
|
}
|
|
|
|
if (usbp->usber & USB_E_BSY) {
|
|
/* This shouldn't happen. If it does then it's a bug ! */
|
|
usbp->usber |= USB_E_BSY;
|
|
mpc8xx_udc_flush_rx_fifo ();
|
|
}
|
|
|
|
/* Scan all RX/Bidirectional Endpoints for RX data. */
|
|
for (epid = 0; epid < MAX_ENDPOINTS; epid++) {
|
|
if (!ep_ref[epid].prx) {
|
|
continue;
|
|
}
|
|
rx_cbdp = rx_cbdp_base = ep_ref[epid].prx;
|
|
|
|
do {
|
|
if (!(rx_cbdp->cbd_sc & RX_BD_E)) {
|
|
|
|
if (rx_cbdp->cbd_sc & 0x1F) {
|
|
/* Corrupt data discard it.
|
|
* Controller has NAK'd this packet.
|
|
*/
|
|
mpc8xx_udc_clear_rxbd (rx_cbdp);
|
|
|
|
} else {
|
|
if (!epid) {
|
|
mpc8xx_udc_ep0_rx (rx_cbdp);
|
|
|
|
} else {
|
|
/* Process data */
|
|
mpc8xx_udc_set_nak (epid);
|
|
mpc8xx_udc_epn_rx (epid, rx_cbdp);
|
|
mpc8xx_udc_clear_rxbd (rx_cbdp);
|
|
}
|
|
}
|
|
|
|
/* Advance RX CBD pointer */
|
|
mpc8xx_udc_advance_rx (&rx_cbdp, epid);
|
|
ep_ref[epid].prx = rx_cbdp;
|
|
} else {
|
|
/* Advance RX CBD pointer */
|
|
mpc8xx_udc_advance_rx (&rx_cbdp, epid);
|
|
}
|
|
|
|
} while (rx_cbdp != rx_cbdp_base);
|
|
}
|
|
|
|
/* Handle TX events as appropiate, the correct place to do this is
|
|
* in a tx routine. Perhaps TX on epn was pre-empted by ep0
|
|
*/
|
|
|
|
if (usbp->usber & USB_E_TXB) {
|
|
usbp->usber |= USB_E_TXB;
|
|
}
|
|
|
|
if (usbp->usber & (USB_TX_ERRMASK)) {
|
|
mpc8xx_udc_handle_txerr ();
|
|
}
|
|
|
|
/* Switch to the default state, respond at the default address */
|
|
if (usbp->usber & USB_E_RESET) {
|
|
usbp->usber |= USB_E_RESET;
|
|
usbp->usaddr = 0x00;
|
|
udc_device->device_state = STATE_DEFAULT;
|
|
}
|
|
|
|
/* if(usbp->usber&USB_E_IDLE){
|
|
We could suspend here !
|
|
usbp->usber|=USB_E_IDLE;
|
|
DBG("idle state change\n");
|
|
}
|
|
if(usbp->usbs){
|
|
We could resume here when IDLE is deasserted !
|
|
Not worth doing, so long as we are self powered though.
|
|
}
|
|
*/
|
|
|
|
return;
|
|
}
|
|
|
|
/* udc_endpoint_write
|
|
*
|
|
* Write some data to an endpoint
|
|
*/
|
|
int udc_endpoint_write (struct usb_endpoint_instance *epi)
|
|
{
|
|
int ep = 0;
|
|
short epid = 1, unnak = 0, ret = 0;
|
|
|
|
if (udc_state != STATE_READY) {
|
|
ERR ("invalid udc_state != STATE_READY!\n");
|
|
return -1;
|
|
}
|
|
|
|
if (!udc_device || !epi) {
|
|
return -1;
|
|
}
|
|
|
|
if (udc_device->device_state != STATE_CONFIGURED) {
|
|
return -1;
|
|
}
|
|
|
|
ep = epi->endpoint_address & 0x03;
|
|
if (ep >= MAX_ENDPOINTS) {
|
|
return -1;
|
|
}
|
|
|
|
/* Set NAK for all RX endpoints during TX */
|
|
for (epid = 1; epid < MAX_ENDPOINTS; epid++) {
|
|
|
|
/* Don't set NAK on DATA IN/CONTROL endpoints */
|
|
if (ep_ref[epid].sc & USB_DIR_IN) {
|
|
continue;
|
|
}
|
|
|
|
if (!(usbp->usep[epid] & (USEP_THS_NAK | USEP_RHS_NAK))) {
|
|
unnak |= 1 << epid;
|
|
}
|
|
|
|
mpc8xx_udc_set_nak (epid);
|
|
}
|
|
|
|
mpc8xx_udc_init_tx (&udc_device->bus->endpoint_array[ep],
|
|
epi->tx_urb);
|
|
ret = mpc8xx_udc_ep_tx (&udc_device->bus->endpoint_array[ep]);
|
|
|
|
/* Remove temporary NAK */
|
|
for (epid = 1; epid < MAX_ENDPOINTS; epid++) {
|
|
if (unnak & (1 << epid)) {
|
|
udc_unset_nak (epid);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* mpc8xx_udc_assign_urb
|
|
*
|
|
* Associate a given urb to an endpoint TX or RX transmit/receive buffers
|
|
*/
|
|
static int mpc8xx_udc_assign_urb (int ep, char direction)
|
|
{
|
|
struct usb_endpoint_instance *epi = 0;
|
|
|
|
if (ep >= MAX_ENDPOINTS) {
|
|
goto err;
|
|
}
|
|
epi = &udc_device->bus->endpoint_array[ep];
|
|
if (!epi) {
|
|
goto err;
|
|
}
|
|
|
|
if (!ep_ref[ep].urb) {
|
|
ep_ref[ep].urb = usbd_alloc_urb (udc_device, udc_device->bus->endpoint_array);
|
|
if (!ep_ref[ep].urb) {
|
|
goto err;
|
|
}
|
|
} else {
|
|
ep_ref[ep].urb->actual_length = 0;
|
|
}
|
|
|
|
switch (direction) {
|
|
case USB_DIR_IN:
|
|
epi->tx_urb = ep_ref[ep].urb;
|
|
break;
|
|
case USB_DIR_OUT:
|
|
epi->rcv_urb = ep_ref[ep].urb;
|
|
break;
|
|
default:
|
|
goto err;
|
|
}
|
|
return 0;
|
|
|
|
err:
|
|
udc_state = STATE_ERROR;
|
|
return -1;
|
|
}
|
|
|
|
/* udc_setup_ep
|
|
*
|
|
* Associate U-Boot software endpoints to mpc8xx endpoint parameter ram
|
|
* Isochronous endpoints aren't yet supported!
|
|
*/
|
|
void udc_setup_ep (struct usb_device_instance *device, unsigned int ep,
|
|
struct usb_endpoint_instance *epi)
|
|
{
|
|
uchar direction = 0;
|
|
int ep_attrib = 0;
|
|
|
|
if (epi && (ep < MAX_ENDPOINTS)) {
|
|
|
|
if (ep == 0) {
|
|
if (epi->rcv_attributes != USB_ENDPOINT_XFER_CONTROL
|
|
|| epi->tx_attributes !=
|
|
USB_ENDPOINT_XFER_CONTROL) {
|
|
|
|
/* ep0 must be a control endpoint */
|
|
udc_state = STATE_ERROR;
|
|
return;
|
|
|
|
}
|
|
if (!(ep_ref[ep].sc & EP_ATTACHED)) {
|
|
mpc8xx_udc_cbd_attach (ep, epi->tx_packetSize,
|
|
epi->rcv_packetSize);
|
|
}
|
|
usbp->usep[ep] = 0x0000;
|
|
return;
|
|
}
|
|
|
|
if ((epi->endpoint_address & USB_ENDPOINT_DIR_MASK)
|
|
== USB_DIR_IN) {
|
|
|
|
direction = 1;
|
|
ep_attrib = epi->tx_attributes;
|
|
epi->rcv_packetSize = 0;
|
|
ep_ref[ep].sc |= USB_DIR_IN;
|
|
} else {
|
|
|
|
direction = 0;
|
|
ep_attrib = epi->rcv_attributes;
|
|
epi->tx_packetSize = 0;
|
|
ep_ref[ep].sc &= ~USB_DIR_IN;
|
|
}
|
|
|
|
if (mpc8xx_udc_assign_urb (ep, epi->endpoint_address
|
|
& USB_ENDPOINT_DIR_MASK)) {
|
|
return;
|
|
}
|
|
|
|
switch (ep_attrib) {
|
|
case USB_ENDPOINT_XFER_CONTROL:
|
|
if (!(ep_ref[ep].sc & EP_ATTACHED)) {
|
|
mpc8xx_udc_cbd_attach (ep,
|
|
epi->tx_packetSize,
|
|
epi->rcv_packetSize);
|
|
}
|
|
usbp->usep[ep] = ep << 12;
|
|
epi->rcv_urb = epi->tx_urb = ep_ref[ep].urb;
|
|
|
|
break;
|
|
case USB_ENDPOINT_XFER_BULK:
|
|
case USB_ENDPOINT_XFER_INT:
|
|
if (!(ep_ref[ep].sc & EP_ATTACHED)) {
|
|
if (direction) {
|
|
mpc8xx_udc_cbd_attach (ep,
|
|
epi->tx_packetSize,
|
|
0);
|
|
} else {
|
|
mpc8xx_udc_cbd_attach (ep,
|
|
0,
|
|
epi->rcv_packetSize);
|
|
}
|
|
}
|
|
usbp->usep[ep] = (ep << 12) | ((ep_attrib) << 8);
|
|
|
|
break;
|
|
case USB_ENDPOINT_XFER_ISOC:
|
|
default:
|
|
serial_printf ("Error endpoint attrib %d>3\n", ep_attrib);
|
|
udc_state = STATE_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/* udc_connect
|
|
*
|
|
* Move state, switch on the USB
|
|
*/
|
|
void udc_connect (void)
|
|
{
|
|
/* Enable pull-up resistor on D+
|
|
* TODO: fit a pull-up resistor to drive SE0 for > 2.5us
|
|
*/
|
|
|
|
if (udc_state != STATE_ERROR) {
|
|
udc_state = STATE_READY;
|
|
usbp->usmod |= USMOD_EN;
|
|
}
|
|
}
|
|
|
|
/* udc_disconnect
|
|
*
|
|
* Disconnect is not used but, is included for completeness
|
|
*/
|
|
void udc_disconnect (void)
|
|
{
|
|
/* Disable pull-up resistor on D-
|
|
* TODO: fix a pullup resistor to control this
|
|
*/
|
|
|
|
if (udc_state != STATE_ERROR) {
|
|
udc_state = STATE_NOT_READY;
|
|
}
|
|
usbp->usmod &= ~USMOD_EN;
|
|
}
|
|
|
|
/* udc_enable
|
|
*
|
|
* Grab an EP0 URB, register interest in a subset of USB events
|
|
*/
|
|
void udc_enable (struct usb_device_instance *device)
|
|
{
|
|
if (udc_state == STATE_ERROR) {
|
|
return;
|
|
}
|
|
|
|
udc_device = device;
|
|
|
|
if (!ep_ref[0].urb) {
|
|
ep_ref[0].urb = usbd_alloc_urb (device, device->bus->endpoint_array);
|
|
}
|
|
|
|
/* Register interest in all events except SOF, enable transceiver */
|
|
usbp->usber = 0x03FF;
|
|
usbp->usbmr = 0x02F7;
|
|
|
|
return;
|
|
}
|
|
|
|
/* udc_disable
|
|
*
|
|
* disable the currently hooked device
|
|
*/
|
|
void udc_disable (void)
|
|
{
|
|
int i = 0;
|
|
|
|
if (udc_state == STATE_ERROR) {
|
|
DBG ("Won't disable UDC. udc_state==STATE_ERROR !\n");
|
|
return;
|
|
}
|
|
|
|
udc_device = 0;
|
|
|
|
for (; i < MAX_ENDPOINTS; i++) {
|
|
if (ep_ref[i].urb) {
|
|
usbd_dealloc_urb (ep_ref[i].urb);
|
|
ep_ref[i].urb = 0;
|
|
}
|
|
}
|
|
|
|
usbp->usbmr = 0x00;
|
|
usbp->usmod = ~USMOD_EN;
|
|
udc_state = STATE_NOT_READY;
|
|
}
|
|
|
|
/* udc_startup_events
|
|
*
|
|
* Enable the specified device
|
|
*/
|
|
void udc_startup_events (struct usb_device_instance *device)
|
|
{
|
|
udc_enable (device);
|
|
if (udc_state == STATE_READY) {
|
|
usbd_device_event_irq (device, DEVICE_CREATE, 0);
|
|
}
|
|
}
|
|
|
|
/* udc_set_nak
|
|
*
|
|
* Allow upper layers to signal lower layers should not accept more RX data
|
|
*
|
|
*/
|
|
void udc_set_nak (int epid)
|
|
{
|
|
if (epid) {
|
|
mpc8xx_udc_set_nak (epid);
|
|
}
|
|
}
|
|
|
|
/* udc_unset_nak
|
|
*
|
|
* Suspend sending of NAK tokens for DATA OUT tokens on a given endpoint.
|
|
* Switch off NAKing on this endpoint to accept more data output from host.
|
|
*
|
|
*/
|
|
void udc_unset_nak (int epid)
|
|
{
|
|
if (epid > MAX_ENDPOINTS) {
|
|
return;
|
|
}
|
|
|
|
if (usbp->usep[epid] & (USEP_THS_NAK | USEP_RHS_NAK)) {
|
|
usbp->usep[epid] &= ~(USEP_THS_NAK | USEP_RHS_NAK);
|
|
__asm__ ("eieio");
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
Static Linkage
|
|
******************************************************************************/
|
|
|
|
/* udc_state_transition_up
|
|
* udc_state_transition_down
|
|
*
|
|
* Helper functions to implement device state changes. The device states and
|
|
* the events that transition between them are:
|
|
*
|
|
* STATE_ATTACHED
|
|
* || /\
|
|
* \/ ||
|
|
* DEVICE_HUB_CONFIGURED DEVICE_HUB_RESET
|
|
* || /\
|
|
* \/ ||
|
|
* STATE_POWERED
|
|
* || /\
|
|
* \/ ||
|
|
* DEVICE_RESET DEVICE_POWER_INTERRUPTION
|
|
* || /\
|
|
* \/ ||
|
|
* STATE_DEFAULT
|
|
* || /\
|
|
* \/ ||
|
|
* DEVICE_ADDRESS_ASSIGNED DEVICE_RESET
|
|
* || /\
|
|
* \/ ||
|
|
* STATE_ADDRESSED
|
|
* || /\
|
|
* \/ ||
|
|
* DEVICE_CONFIGURED DEVICE_DE_CONFIGURED
|
|
* || /\
|
|
* \/ ||
|
|
* STATE_CONFIGURED
|
|
*
|
|
* udc_state_transition_up transitions up (in the direction from STATE_ATTACHED
|
|
* to STATE_CONFIGURED) from the specified initial state to the specified final
|
|
* state, passing through each intermediate state on the way. If the initial
|
|
* state is at or above (i.e. nearer to STATE_CONFIGURED) the final state, then
|
|
* no state transitions will take place.
|
|
*
|
|
* udc_state_transition_down transitions down (in the direction from
|
|
* STATE_CONFIGURED to STATE_ATTACHED) from the specified initial state to the
|
|
* specified final state, passing through each intermediate state on the way.
|
|
* If the initial state is at or below (i.e. nearer to STATE_ATTACHED) the final
|
|
* state, then no state transitions will take place.
|
|
*
|
|
*/
|
|
|
|
static void mpc8xx_udc_state_transition_up (usb_device_state_t initial,
|
|
usb_device_state_t final)
|
|
{
|
|
if (initial < final) {
|
|
switch (initial) {
|
|
case STATE_ATTACHED:
|
|
usbd_device_event_irq (udc_device,
|
|
DEVICE_HUB_CONFIGURED, 0);
|
|
if (final == STATE_POWERED)
|
|
break;
|
|
case STATE_POWERED:
|
|
usbd_device_event_irq (udc_device, DEVICE_RESET, 0);
|
|
if (final == STATE_DEFAULT)
|
|
break;
|
|
case STATE_DEFAULT:
|
|
usbd_device_event_irq (udc_device,
|
|
DEVICE_ADDRESS_ASSIGNED, 0);
|
|
if (final == STATE_ADDRESSED)
|
|
break;
|
|
case STATE_ADDRESSED:
|
|
usbd_device_event_irq (udc_device, DEVICE_CONFIGURED,
|
|
0);
|
|
case STATE_CONFIGURED:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void mpc8xx_udc_state_transition_down (usb_device_state_t initial,
|
|
usb_device_state_t final)
|
|
{
|
|
if (initial > final) {
|
|
switch (initial) {
|
|
case STATE_CONFIGURED:
|
|
usbd_device_event_irq (udc_device,
|
|
DEVICE_DE_CONFIGURED, 0);
|
|
if (final == STATE_ADDRESSED)
|
|
break;
|
|
case STATE_ADDRESSED:
|
|
usbd_device_event_irq (udc_device, DEVICE_RESET, 0);
|
|
if (final == STATE_DEFAULT)
|
|
break;
|
|
case STATE_DEFAULT:
|
|
usbd_device_event_irq (udc_device,
|
|
DEVICE_POWER_INTERRUPTION, 0);
|
|
if (final == STATE_POWERED)
|
|
break;
|
|
case STATE_POWERED:
|
|
usbd_device_event_irq (udc_device, DEVICE_HUB_RESET,
|
|
0);
|
|
case STATE_ATTACHED:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* mpc8xx_udc_stall
|
|
*
|
|
* Force returning of STALL tokens on the given endpoint. Protocol or function
|
|
* STALL conditions are permissable here
|
|
*/
|
|
static void mpc8xx_udc_stall (unsigned int ep)
|
|
{
|
|
usbp->usep[ep] |= STALL_BITMASK;
|
|
}
|
|
|
|
/* mpc8xx_udc_set_nak
|
|
*
|
|
* Force returning of NAK responses for the given endpoint as a kind of very
|
|
* simple flow control
|
|
*/
|
|
static void mpc8xx_udc_set_nak (unsigned int ep)
|
|
{
|
|
usbp->usep[ep] |= NAK_BITMASK;
|
|
__asm__ ("eieio");
|
|
}
|
|
|
|
/* mpc8xx_udc_handle_txerr
|
|
*
|
|
* Handle errors relevant to TX. Return a status code to allow calling
|
|
* indicative of what if anything happened
|
|
*/
|
|
static short mpc8xx_udc_handle_txerr ()
|
|
{
|
|
short ep = 0, ret = 0;
|
|
|
|
for (; ep < TX_RING_SIZE; ep++) {
|
|
if (usbp->usber & (0x10 << ep)) {
|
|
|
|
/* Timeout or underrun */
|
|
if (tx_cbd[ep]->cbd_sc & 0x06) {
|
|
ret = 1;
|
|
mpc8xx_udc_flush_tx_fifo (ep);
|
|
|
|
} else {
|
|
if (usbp->usep[ep] & STALL_BITMASK) {
|
|
if (!ep) {
|
|
usbp->usep[ep] &= ~STALL_BITMASK;
|
|
}
|
|
} /* else NAK */
|
|
}
|
|
usbp->usber |= (0x10 << ep);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* mpc8xx_udc_advance_rx
|
|
*
|
|
* Advance cbd rx
|
|
*/
|
|
static void mpc8xx_udc_advance_rx (volatile cbd_t ** rx_cbdp, int epid)
|
|
{
|
|
if ((*rx_cbdp)->cbd_sc & RX_BD_W) {
|
|
*rx_cbdp = (volatile cbd_t *) (endpoints[epid]->rbase + CONFIG_SYS_IMMR);
|
|
|
|
} else {
|
|
(*rx_cbdp)++;
|
|
}
|
|
}
|
|
|
|
|
|
/* mpc8xx_udc_flush_tx_fifo
|
|
*
|
|
* Flush a given TX fifo. Assumes one tx cbd per endpoint
|
|
*/
|
|
static void mpc8xx_udc_flush_tx_fifo (int epid)
|
|
{
|
|
volatile cbd_t *tx_cbdp = 0;
|
|
|
|
if (epid > MAX_ENDPOINTS) {
|
|
return;
|
|
}
|
|
|
|
/* TX stop */
|
|
immr->im_cpm.cp_cpcr = ((epid << 2) | 0x1D01);
|
|
__asm__ ("eieio");
|
|
while (immr->im_cpm.cp_cpcr & 0x01);
|
|
|
|
usbp->uscom = 0x40 | 0;
|
|
|
|
/* reset ring */
|
|
tx_cbdp = (cbd_t *) (endpoints[epid]->tbptr + CONFIG_SYS_IMMR);
|
|
tx_cbdp->cbd_sc = (TX_BD_I | TX_BD_W);
|
|
|
|
|
|
endpoints[epid]->tptr = endpoints[epid]->tbase;
|
|
endpoints[epid]->tstate = 0x00;
|
|
endpoints[epid]->tbcnt = 0x00;
|
|
|
|
/* TX start */
|
|
immr->im_cpm.cp_cpcr = ((epid << 2) | 0x2D01);
|
|
__asm__ ("eieio");
|
|
while (immr->im_cpm.cp_cpcr & 0x01);
|
|
|
|
return;
|
|
}
|
|
|
|
/* mpc8xx_udc_flush_rx_fifo
|
|
*
|
|
* For the sake of completeness of the namespace, it seems like
|
|
* a good-design-decision (tm) to include mpc8xx_udc_flush_rx_fifo();
|
|
* If RX_BD_E is true => a driver bug either here or in an upper layer
|
|
* not polling frequently enough. If RX_BD_E is true we have told the host
|
|
* we have accepted data but, the CPM found it had no-where to put that data
|
|
* which needless to say would be a bad thing.
|
|
*/
|
|
static void mpc8xx_udc_flush_rx_fifo ()
|
|
{
|
|
int i = 0;
|
|
|
|
for (i = 0; i < RX_RING_SIZE; i++) {
|
|
if (!(rx_cbd[i]->cbd_sc & RX_BD_E)) {
|
|
ERR ("buf %p used rx data len = 0x%x sc=0x%x!\n",
|
|
rx_cbd[i], rx_cbd[i]->cbd_datlen,
|
|
rx_cbd[i]->cbd_sc);
|
|
|
|
}
|
|
}
|
|
ERR ("BUG : Input over-run\n");
|
|
}
|
|
|
|
/* mpc8xx_udc_clear_rxbd
|
|
*
|
|
* Release control of RX CBD to CP.
|
|
*/
|
|
static void mpc8xx_udc_clear_rxbd (volatile cbd_t * rx_cbdp)
|
|
{
|
|
rx_cbdp->cbd_datlen = 0x0000;
|
|
rx_cbdp->cbd_sc = ((rx_cbdp->cbd_sc & RX_BD_W) | (RX_BD_E | RX_BD_I));
|
|
__asm__ ("eieio");
|
|
}
|
|
|
|
/* mpc8xx_udc_tx_irq
|
|
*
|
|
* Parse for tx timeout, control RX or USB reset/busy conditions
|
|
* Return -1 on timeout, -2 on fatal error, else return zero
|
|
*/
|
|
static int mpc8xx_udc_tx_irq (int ep)
|
|
{
|
|
int i = 0;
|
|
|
|
if (usbp->usber & (USB_TX_ERRMASK)) {
|
|
if (mpc8xx_udc_handle_txerr ()) {
|
|
/* Timeout, controlling function must retry send */
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (usbp->usber & (USB_E_RESET | USB_E_BSY)) {
|
|
/* Fatal, abandon TX transaction */
|
|
return -2;
|
|
}
|
|
|
|
if (usbp->usber & USB_E_RXB) {
|
|
for (i = 0; i < RX_RING_SIZE; i++) {
|
|
if (!(rx_cbd[i]->cbd_sc & RX_BD_E)) {
|
|
if ((rx_cbd[i] == ep_ref[0].prx) || ep) {
|
|
return -2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* mpc8xx_udc_ep_tx
|
|
*
|
|
* Transmit in a re-entrant fashion outbound USB packets.
|
|
* Implement retry/timeout mechanism described in USB specification
|
|
* Toggle DATA0/DATA1 pids as necessary
|
|
* Introduces non-standard tx_retry. The USB standard has no scope for slave
|
|
* devices to give up TX, however tx_retry stops us getting stuck in an endless
|
|
* TX loop.
|
|
*/
|
|
static int mpc8xx_udc_ep_tx (struct usb_endpoint_instance *epi)
|
|
{
|
|
struct urb *urb = epi->tx_urb;
|
|
volatile cbd_t *tx_cbdp = 0;
|
|
unsigned int ep = 0, pkt_len = 0, x = 0, tx_retry = 0;
|
|
int ret = 0;
|
|
|
|
if (!epi || (epi->endpoint_address & 0x03) >= MAX_ENDPOINTS || !urb) {
|
|
return -1;
|
|
}
|
|
|
|
ep = epi->endpoint_address & 0x03;
|
|
tx_cbdp = (cbd_t *) (endpoints[ep]->tbptr + CONFIG_SYS_IMMR);
|
|
|
|
if (tx_cbdp->cbd_sc & TX_BD_R || usbp->usber & USB_E_TXB) {
|
|
mpc8xx_udc_flush_tx_fifo (ep);
|
|
usbp->usber |= USB_E_TXB;
|
|
};
|
|
|
|
while (tx_retry++ < 100) {
|
|
ret = mpc8xx_udc_tx_irq (ep);
|
|
if (ret == -1) {
|
|
/* ignore timeout here */
|
|
} else if (ret == -2) {
|
|
/* Abandon TX */
|
|
mpc8xx_udc_flush_tx_fifo (ep);
|
|
return -1;
|
|
}
|
|
|
|
tx_cbdp = (cbd_t *) (endpoints[ep]->tbptr + CONFIG_SYS_IMMR);
|
|
while (tx_cbdp->cbd_sc & TX_BD_R) {
|
|
};
|
|
tx_cbdp->cbd_sc = (tx_cbdp->cbd_sc & TX_BD_W);
|
|
|
|
pkt_len = urb->actual_length - epi->sent;
|
|
|
|
if (pkt_len > epi->tx_packetSize || pkt_len > EP_MAX_PKT) {
|
|
pkt_len = min(epi->tx_packetSize, EP_MAX_PKT);
|
|
}
|
|
|
|
for (x = 0; x < pkt_len; x++) {
|
|
*((unsigned char *) (tx_cbdp->cbd_bufaddr + x)) =
|
|
urb->buffer[epi->sent + x];
|
|
}
|
|
tx_cbdp->cbd_datlen = pkt_len;
|
|
tx_cbdp->cbd_sc |= (CBD_TX_BITMASK | ep_ref[ep].pid);
|
|
__asm__ ("eieio");
|
|
|
|
#ifdef __SIMULATE_ERROR__
|
|
if (++err_poison_test == 2) {
|
|
err_poison_test = 0;
|
|
tx_cbdp->cbd_sc &= ~TX_BD_TC;
|
|
}
|
|
#endif
|
|
|
|
usbp->uscom = (USCOM_STR | ep);
|
|
|
|
while (!(usbp->usber & USB_E_TXB)) {
|
|
ret = mpc8xx_udc_tx_irq (ep);
|
|
if (ret == -1) {
|
|
/* TX timeout */
|
|
break;
|
|
} else if (ret == -2) {
|
|
if (usbp->usber & USB_E_TXB) {
|
|
usbp->usber |= USB_E_TXB;
|
|
}
|
|
mpc8xx_udc_flush_tx_fifo (ep);
|
|
return -1;
|
|
}
|
|
};
|
|
|
|
if (usbp->usber & USB_E_TXB) {
|
|
usbp->usber |= USB_E_TXB;
|
|
}
|
|
|
|
/* ACK must be present <= 18bit times from TX */
|
|
if (ret == -1) {
|
|
continue;
|
|
}
|
|
|
|
/* TX ACK : USB 2.0 8.7.2, Toggle PID, Advance TX */
|
|
epi->sent += pkt_len;
|
|
epi->last = min(urb->actual_length - epi->sent, epi->tx_packetSize);
|
|
TOGGLE_TX_PID (ep_ref[ep].pid);
|
|
|
|
if (epi->sent >= epi->tx_urb->actual_length) {
|
|
|
|
epi->tx_urb->actual_length = 0;
|
|
epi->sent = 0;
|
|
|
|
if (ep_ref[ep].sc & EP_SEND_ZLP) {
|
|
ep_ref[ep].sc &= ~EP_SEND_ZLP;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
ERR ("TX fail, endpoint 0x%x tx bytes 0x%x/0x%x\n", ep, epi->sent,
|
|
epi->tx_urb->actual_length);
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* mpc8xx_udc_dump_request
|
|
*
|
|
* Dump a control request to console
|
|
*/
|
|
static void mpc8xx_udc_dump_request (struct usb_device_request *request)
|
|
{
|
|
DBG ("bmRequestType:%02x bRequest:%02x wValue:%04x "
|
|
"wIndex:%04x wLength:%04x ?\n",
|
|
request->bmRequestType,
|
|
request->bRequest,
|
|
request->wValue, request->wIndex, request->wLength);
|
|
|
|
return;
|
|
}
|
|
|
|
/* mpc8xx_udc_ep0_rx_setup
|
|
*
|
|
* Decode received ep0 SETUP packet. return non-zero on error
|
|
*/
|
|
static int mpc8xx_udc_ep0_rx_setup (volatile cbd_t * rx_cbdp)
|
|
{
|
|
unsigned int x = 0;
|
|
struct urb *purb = ep_ref[0].urb;
|
|
struct usb_endpoint_instance *epi =
|
|
&udc_device->bus->endpoint_array[0];
|
|
|
|
for (; x < rx_cbdp->cbd_datlen; x++) {
|
|
*(((unsigned char *) &ep_ref[0].urb->device_request) + x) =
|
|
*((unsigned char *) (rx_cbdp->cbd_bufaddr + x));
|
|
}
|
|
|
|
mpc8xx_udc_clear_rxbd (rx_cbdp);
|
|
|
|
if (ep0_recv_setup (purb)) {
|
|
mpc8xx_udc_dump_request (&purb->device_request);
|
|
return -1;
|
|
}
|
|
|
|
if ((purb->device_request.bmRequestType & USB_REQ_DIRECTION_MASK)
|
|
== USB_REQ_HOST2DEVICE) {
|
|
|
|
switch (purb->device_request.bRequest) {
|
|
case USB_REQ_SET_ADDRESS:
|
|
/* Send the Status OUT ZLP */
|
|
ep_ref[0].pid = TX_BD_PID_DATA1;
|
|
purb->actual_length = 0;
|
|
mpc8xx_udc_init_tx (epi, purb);
|
|
mpc8xx_udc_ep_tx (epi);
|
|
|
|
/* Move to the addressed state */
|
|
usbp->usaddr = udc_device->address;
|
|
mpc8xx_udc_state_transition_up (udc_device->device_state,
|
|
STATE_ADDRESSED);
|
|
return 0;
|
|
|
|
case USB_REQ_SET_CONFIGURATION:
|
|
if (!purb->device_request.wValue) {
|
|
/* Respond at default address */
|
|
usbp->usaddr = 0x00;
|
|
mpc8xx_udc_state_transition_down (udc_device->device_state,
|
|
STATE_ADDRESSED);
|
|
} else {
|
|
/* TODO: Support multiple configurations */
|
|
mpc8xx_udc_state_transition_up (udc_device->device_state,
|
|
STATE_CONFIGURED);
|
|
for (x = 1; x < MAX_ENDPOINTS; x++) {
|
|
if ((udc_device->bus->endpoint_array[x].endpoint_address & USB_ENDPOINT_DIR_MASK)
|
|
== USB_DIR_IN) {
|
|
ep_ref[x].pid = TX_BD_PID_DATA0;
|
|
} else {
|
|
ep_ref[x].pid = RX_BD_PID_DATA0;
|
|
}
|
|
/* Set configuration must unstall endpoints */
|
|
usbp->usep[x] &= ~STALL_BITMASK;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
/* CDC/Vendor specific */
|
|
break;
|
|
}
|
|
|
|
/* Send ZLP as ACK in Status OUT phase */
|
|
ep_ref[0].pid = TX_BD_PID_DATA1;
|
|
purb->actual_length = 0;
|
|
mpc8xx_udc_init_tx (epi, purb);
|
|
mpc8xx_udc_ep_tx (epi);
|
|
|
|
} else {
|
|
|
|
if (purb->actual_length) {
|
|
ep_ref[0].pid = TX_BD_PID_DATA1;
|
|
mpc8xx_udc_init_tx (epi, purb);
|
|
|
|
if (!(purb->actual_length % EP0_MAX_PACKET_SIZE)) {
|
|
ep_ref[0].sc |= EP_SEND_ZLP;
|
|
}
|
|
|
|
if (purb->device_request.wValue ==
|
|
USB_DESCRIPTOR_TYPE_DEVICE) {
|
|
if (le16_to_cpu (purb->device_request.wLength)
|
|
> purb->actual_length) {
|
|
/* Send EP0_MAX_PACKET_SIZE bytes
|
|
* unless correct size requested.
|
|
*/
|
|
if (purb->actual_length > epi->tx_packetSize) {
|
|
purb->actual_length = epi->tx_packetSize;
|
|
}
|
|
}
|
|
}
|
|
mpc8xx_udc_ep_tx (epi);
|
|
|
|
} else {
|
|
/* Corrupt SETUP packet? */
|
|
ERR ("Zero length data or SETUP with DATA-IN phase ?\n");
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* mpc8xx_udc_init_tx
|
|
*
|
|
* Setup some basic parameters for a TX transaction
|
|
*/
|
|
static void mpc8xx_udc_init_tx (struct usb_endpoint_instance *epi,
|
|
struct urb *tx_urb)
|
|
{
|
|
epi->sent = 0;
|
|
epi->last = 0;
|
|
epi->tx_urb = tx_urb;
|
|
}
|
|
|
|
/* mpc8xx_udc_ep0_rx
|
|
*
|
|
* Receive ep0/control USB data. Parse and possibly send a response.
|
|
*/
|
|
static void mpc8xx_udc_ep0_rx (volatile cbd_t * rx_cbdp)
|
|
{
|
|
if (rx_cbdp->cbd_sc & RX_BD_PID_SETUP) {
|
|
|
|
/* Unconditionally accept SETUP packets */
|
|
if (mpc8xx_udc_ep0_rx_setup (rx_cbdp)) {
|
|
mpc8xx_udc_stall (0);
|
|
}
|
|
|
|
} else {
|
|
|
|
mpc8xx_udc_clear_rxbd (rx_cbdp);
|
|
|
|
if ((rx_cbdp->cbd_datlen - 2)) {
|
|
/* SETUP with a DATA phase
|
|
* outside of SETUP packet.
|
|
* Reply with STALL.
|
|
*/
|
|
mpc8xx_udc_stall (0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* mpc8xx_udc_epn_rx
|
|
*
|
|
* Receive some data from cbd into USB system urb data abstraction
|
|
* Upper layers should NAK if there is insufficient RX data space
|
|
*/
|
|
static int mpc8xx_udc_epn_rx (unsigned int epid, volatile cbd_t * rx_cbdp)
|
|
{
|
|
struct usb_endpoint_instance *epi = 0;
|
|
struct urb *urb = 0;
|
|
unsigned int x = 0;
|
|
|
|
if (epid >= MAX_ENDPOINTS || !rx_cbdp->cbd_datlen) {
|
|
return 0;
|
|
}
|
|
|
|
/* USB 2.0 PDF section 8.6.4
|
|
* Discard data with invalid PID it is a resend.
|
|
*/
|
|
if (ep_ref[epid].pid != (rx_cbdp->cbd_sc & 0xC0)) {
|
|
return 1;
|
|
}
|
|
TOGGLE_RX_PID (ep_ref[epid].pid);
|
|
|
|
epi = &udc_device->bus->endpoint_array[epid];
|
|
urb = epi->rcv_urb;
|
|
|
|
for (; x < (rx_cbdp->cbd_datlen - 2); x++) {
|
|
*((unsigned char *) (urb->buffer + urb->actual_length + x)) =
|
|
*((unsigned char *) (rx_cbdp->cbd_bufaddr + x));
|
|
}
|
|
|
|
if (x) {
|
|
usbd_rcv_complete (epi, x, 0);
|
|
if (ep_ref[epid].urb->status == RECV_ERROR) {
|
|
DBG ("RX error unset NAK\n");
|
|
udc_unset_nak (epid);
|
|
}
|
|
}
|
|
return x;
|
|
}
|
|
|
|
/* mpc8xx_udc_clock_init
|
|
*
|
|
* Obtain a clock reference for Full Speed Signaling
|
|
*/
|
|
static void mpc8xx_udc_clock_init (volatile immap_t * immr,
|
|
volatile cpm8xx_t * cp)
|
|
{
|
|
|
|
#if defined(CONFIG_SYS_USB_EXTC_CLK)
|
|
|
|
/* This has been tested with a 48MHz crystal on CLK6 */
|
|
switch (CONFIG_SYS_USB_EXTC_CLK) {
|
|
case 1:
|
|
immr->im_ioport.iop_papar |= 0x0100;
|
|
immr->im_ioport.iop_padir &= ~0x0100;
|
|
cp->cp_sicr |= 0x24;
|
|
break;
|
|
case 2:
|
|
immr->im_ioport.iop_papar |= 0x0200;
|
|
immr->im_ioport.iop_padir &= ~0x0200;
|
|
cp->cp_sicr |= 0x2D;
|
|
break;
|
|
case 3:
|
|
immr->im_ioport.iop_papar |= 0x0400;
|
|
immr->im_ioport.iop_padir &= ~0x0400;
|
|
cp->cp_sicr |= 0x36;
|
|
break;
|
|
case 4:
|
|
immr->im_ioport.iop_papar |= 0x0800;
|
|
immr->im_ioport.iop_padir &= ~0x0800;
|
|
cp->cp_sicr |= 0x3F;
|
|
break;
|
|
default:
|
|
udc_state = STATE_ERROR;
|
|
break;
|
|
}
|
|
|
|
#elif defined(CONFIG_SYS_USB_BRGCLK)
|
|
|
|
/* This has been tested with brgclk == 50MHz */
|
|
int divisor = 0;
|
|
|
|
if (gd->cpu_clk < 48000000L) {
|
|
ERR ("brgclk is too slow for full-speed USB!\n");
|
|
udc_state = STATE_ERROR;
|
|
return;
|
|
}
|
|
|
|
/* Assume the brgclk is 'good enough', we want !(gd->cpu_clk%48MHz)
|
|
* but, can /probably/ live with close-ish alternative rates.
|
|
*/
|
|
divisor = (gd->cpu_clk / 48000000L) - 1;
|
|
cp->cp_sicr &= ~0x0000003F;
|
|
|
|
switch (CONFIG_SYS_USB_BRGCLK) {
|
|
case 1:
|
|
cp->cp_brgc1 |= (divisor | CPM_BRG_EN);
|
|
cp->cp_sicr &= ~0x2F;
|
|
break;
|
|
case 2:
|
|
cp->cp_brgc2 |= (divisor | CPM_BRG_EN);
|
|
cp->cp_sicr |= 0x00000009;
|
|
break;
|
|
case 3:
|
|
cp->cp_brgc3 |= (divisor | CPM_BRG_EN);
|
|
cp->cp_sicr |= 0x00000012;
|
|
break;
|
|
case 4:
|
|
cp->cp_brgc4 = (divisor | CPM_BRG_EN);
|
|
cp->cp_sicr |= 0x0000001B;
|
|
break;
|
|
default:
|
|
udc_state = STATE_ERROR;
|
|
break;
|
|
}
|
|
|
|
#else
|
|
#error "CONFIG_SYS_USB_EXTC_CLK or CONFIG_SYS_USB_BRGCLK must be defined"
|
|
#endif
|
|
|
|
}
|
|
|
|
/* mpc8xx_udc_cbd_attach
|
|
*
|
|
* attach a cbd to and endpoint
|
|
*/
|
|
static void mpc8xx_udc_cbd_attach (int ep, uchar tx_size, uchar rx_size)
|
|
{
|
|
|
|
if (!tx_cbd[ep] || !rx_cbd[ep] || ep >= MAX_ENDPOINTS) {
|
|
udc_state = STATE_ERROR;
|
|
return;
|
|
}
|
|
|
|
if (tx_size > USB_MAX_PKT || rx_size > USB_MAX_PKT ||
|
|
(!tx_size && !rx_size)) {
|
|
udc_state = STATE_ERROR;
|
|
return;
|
|
}
|
|
|
|
/* Attach CBD to appropiate Parameter RAM Endpoint data structure */
|
|
if (rx_size) {
|
|
endpoints[ep]->rbase = (u32) rx_cbd[rx_ct];
|
|
endpoints[ep]->rbptr = (u32) rx_cbd[rx_ct];
|
|
rx_ct++;
|
|
|
|
if (!ep) {
|
|
|
|
endpoints[ep]->rbptr = (u32) rx_cbd[rx_ct];
|
|
rx_cbd[rx_ct]->cbd_sc |= RX_BD_W;
|
|
rx_ct++;
|
|
|
|
} else {
|
|
rx_ct += 2;
|
|
endpoints[ep]->rbptr = (u32) rx_cbd[rx_ct];
|
|
rx_cbd[rx_ct]->cbd_sc |= RX_BD_W;
|
|
rx_ct++;
|
|
}
|
|
|
|
/* Where we expect to RX data on this endpoint */
|
|
ep_ref[ep].prx = rx_cbd[rx_ct - 1];
|
|
} else {
|
|
|
|
ep_ref[ep].prx = 0;
|
|
endpoints[ep]->rbase = 0;
|
|
endpoints[ep]->rbptr = 0;
|
|
}
|
|
|
|
if (tx_size) {
|
|
endpoints[ep]->tbase = (u32) tx_cbd[tx_ct];
|
|
endpoints[ep]->tbptr = (u32) tx_cbd[tx_ct];
|
|
tx_ct++;
|
|
} else {
|
|
endpoints[ep]->tbase = 0;
|
|
endpoints[ep]->tbptr = 0;
|
|
}
|
|
|
|
endpoints[ep]->tstate = 0;
|
|
endpoints[ep]->tbcnt = 0;
|
|
endpoints[ep]->mrblr = EP_MAX_PKT;
|
|
endpoints[ep]->rfcr = 0x18;
|
|
endpoints[ep]->tfcr = 0x18;
|
|
ep_ref[ep].sc |= EP_ATTACHED;
|
|
|
|
DBG ("ep %d rbase 0x%08x rbptr 0x%08x tbase 0x%08x tbptr 0x%08x prx = %p\n",
|
|
ep, endpoints[ep]->rbase, endpoints[ep]->rbptr,
|
|
endpoints[ep]->tbase, endpoints[ep]->tbptr,
|
|
ep_ref[ep].prx);
|
|
|
|
return;
|
|
}
|
|
|
|
/* mpc8xx_udc_cbd_init
|
|
*
|
|
* Allocate space for a cbd and allocate TX/RX data space
|
|
*/
|
|
static void mpc8xx_udc_cbd_init (void)
|
|
{
|
|
int i = 0;
|
|
|
|
for (; i < TX_RING_SIZE; i++) {
|
|
tx_cbd[i] = (cbd_t *)
|
|
mpc8xx_udc_alloc (sizeof (cbd_t), sizeof (int));
|
|
}
|
|
|
|
for (i = 0; i < RX_RING_SIZE; i++) {
|
|
rx_cbd[i] = (cbd_t *)
|
|
mpc8xx_udc_alloc (sizeof (cbd_t), sizeof (int));
|
|
}
|
|
|
|
for (i = 0; i < TX_RING_SIZE; i++) {
|
|
tx_cbd[i]->cbd_bufaddr =
|
|
mpc8xx_udc_alloc (EP_MAX_PKT, sizeof (int));
|
|
|
|
tx_cbd[i]->cbd_sc = (TX_BD_I | TX_BD_W);
|
|
tx_cbd[i]->cbd_datlen = 0x0000;
|
|
}
|
|
|
|
|
|
for (i = 0; i < RX_RING_SIZE; i++) {
|
|
rx_cbd[i]->cbd_bufaddr =
|
|
mpc8xx_udc_alloc (EP_MAX_PKT, sizeof (int));
|
|
rx_cbd[i]->cbd_sc = (RX_BD_I | RX_BD_E);
|
|
rx_cbd[i]->cbd_datlen = 0x0000;
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/* mpc8xx_udc_endpoint_init
|
|
*
|
|
* Attach an endpoint to some dpram
|
|
*/
|
|
static void mpc8xx_udc_endpoint_init (void)
|
|
{
|
|
int i = 0;
|
|
|
|
for (; i < MAX_ENDPOINTS; i++) {
|
|
endpoints[i] = (usb_epb_t *)
|
|
mpc8xx_udc_alloc (sizeof (usb_epb_t), 32);
|
|
}
|
|
}
|
|
|
|
/* mpc8xx_udc_alloc
|
|
*
|
|
* Grab the address of some dpram
|
|
*/
|
|
static u32 mpc8xx_udc_alloc (u32 data_size, u32 alignment)
|
|
{
|
|
u32 retaddr = address_base;
|
|
|
|
while (retaddr % alignment) {
|
|
retaddr++;
|
|
}
|
|
address_base += data_size;
|
|
|
|
return retaddr;
|
|
}
|