Add support for usbdcore_mpc8xx.
PATCH 10/14 Add support for usbdcore_mpc8xx.
Signed-off-by Bryan O'Donoghue <[email protected]>
new file: drivers/usbdcore_mpc8xx.c
Adds usbdcore functionality for the mpc8xx. Implements low level flow control currently supports and has been tested with usbtty gserial and cdc_acm.
Also tested with an external oscillator for USB clock source and brgclk as clock source
---
drivers/usbdcore_mpc8xx.c | 1412 +++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 1412 insertions(+), 0 deletions(-) create mode 100644 drivers/usbdcore_mpc8xx.c
de3a7ea767c08b48d40fa798ee8814b54b747108
drivers/usbdcore_mpc8xx.c new file +1412 -0
@@ -0,0 +1,1412 @@ +/* +* Copyright (C) 2006 by Bryan O'Donoghue, CodeHermit +* bodonoghue at CodeHermit.ie +* +* References +* DasUBoot/drivers/usbdcore_omap1510.c, for design and implementation ideas. +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the +* Free Software Foundation, Inc., +* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +* +*/ + +/* +* 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> + +#if defined(CONFIG_MPC885_FAMILY ) && defined(CONFIG_USB_DEVICE ) +#include <commproc.h> +#include "usbdcore.h" +#include "usbdcore_mpc8xx.h" +#include "usbdcore_ep0.h" + +#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 *)CFG_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 occured +*/ +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 +0xFF000000 ); + + }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 +0xFF000000 ); + 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 +0xFF000000 ); + +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 +0xFF000000 ); +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(CFG_USB_EXTC_CLK ) + +/* This has been tested with a 48MHz crystal on CLK6 */ +switch (CFG_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(CFG_USB_BRGCLK ) + +/* This has been tested with brgclk == 50MHz */ +DECLARE_GLOBAL_DATA_PTR ; +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 (CFG_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 "CFG_USB_EXTC_CLK or CFG_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; +} + +#endif /* CONFIG_MPC885_FAMILY && CONFIG_USB_DEVICE) */