msdrc.c

MSTAR03的数码相框的代码

#include "sysinfo.h"
#include "DrvOTGMain.h"
#include "mcu.h"
#include <stdlib.h>
#include <string.h>
//#include "uart.h"
//#include "MsMcu.h"

struct devrequest volatile usbEP0Setup;
endpoint_t volatile usbEP[usbNumEPDefs];
extern U8 u8varOTG_FORCE_FS;
__s8 volatile usbResetting;
__s8 volatile usbRegPower;
__u8 volatile usbIntStatus;
__u8 volatile usbDataPhaseDir;
__u8 volatile usbIntInStatus;
__u8 volatile usbBulkInStatus;
__u8 volatile usbBulkOutStatus;
__u8 volatile GetPartHeaderTransfer;

__u8 volatile usbBulkInStatus2;

//__u8 volatile usbPictCmdRevFlag;
__u8 volatile usbPictRxDataReceived;

__u32 volatile USB_TTX_FIX_XDATA_ADDR;
__u8 gu8LunMapping[TOTAL_LUN];
void InitUSBVar(__u8 Device_Mode_Type)
{
   //usbPictCmdRevFlag=0;
   usbPictRxDataReceived=0;
   usbStillImageSts=0;
   usbSetFaddr=0;
   usbClearedEP=0;
   usbMyDeviceHNPSupport=1;

   usbReqOTGState=0;
   usbCurOTGState=AB_IDLE;

   usbSessRequest=0;
   usbResuming=0;
   usbSuspended=0;
   usbRemoteWakeup=0;
   usbHNPEnabled=0;
   usbHNPSupport=0;
   usbSRPSupport=0;
   usbSelfPower=1;
   usbEP0State=0;
   usbConfig=0;
   usbInterface=0;
   usbUSBState=0;
   usbcid=0;
   usbFaddr=0;
   usbRegDevCtl=0;
   usbSpeed=0;
   usbDescFoundOTG=0;
   usbConnectFlag=0;
   NotifyusbConnect=0;

   pbGetImageFlag=0;

   usbResetComplete=0;
   ProcessCount=1;
   DetCount=0;
   NotifyusbConnect2=0;
   HostMassmax_Lun=0;
   HostMassValid_Lun=0;
   EPConfig=0;

   IntCheck=0; // for test

    DviceMassmax_Lun=0;
#ifndef Only_NAND_Exist
    #if ENABLE_SD_MS_XD_MULTISLOT
    gu8LunMapping[DviceMassmax_Lun] = eSD_MS_XD;
    DviceMassmax_Lun++;
    #else
        #if (ENABLE_SD_MMC)
        gu8LunMapping[DviceMassmax_Lun] = eSDMMC;
        DviceMassmax_Lun++;
        #endif
        #if (ENABLE_MS||ENABLE_MSPRO)
        gu8LunMapping[DviceMassmax_Lun] = eMSMSP;
        DviceMassmax_Lun++;
        #endif
        #if (ENABLE_SM||ENABLE_XD)
        gu8LunMapping[DviceMassmax_Lun] = eSMXD;
        DviceMassmax_Lun++;
        #endif
    #endif

    #if ENABLE_CF
    gu8LunMapping[DviceMassmax_Lun] = eCF;
    DviceMassmax_Lun++;
    #endif

    #ifdef SUPPORT_NAND_DISK    // NAND use one LUN
    gu8LunMapping[DviceMassmax_Lun] = eNAND;
    DviceMassmax_Lun++;
    #endif

    #if ENABLE_NOR_DEBUG     // NOR use one LUN
    gu8LunMapping[DviceMassmax_Lun] = eNOR;
    DviceMassmax_Lun++;
    #endif

#else   // Only_NAND_Exist
    gu8LunMapping[DviceMassmax_Lun] = eNAND;
    DviceMassmax_Lun++;  // Only NAND LUN
#endif
    DviceMassmax_Lun -= 1;  // MaxLUN = TotalLUN - 1;
    /*
   #ifdef SUPPORT_NAND_DISK
     #ifdef Only_NAND_Exist
     DviceMassmax_Lun=0;
     #else // card reader and NAND exist at same time
     DviceMassmax_Lun=1;
     #endif
   #else
   DviceMassmax_Lun=0;
   #endif
    */
   usbMassRxDataReceived=0;
   usbMassCmdRevFlag=0;

   OtgDeviceType=Device_Mode_Type;

}

void LopezUSBInit(void)
{
   usbREG_WRITE8(0x80,0x00); // setting Srst_n
   usbREG_WRITE8(0x80,0x01); // close Srst_n
   usbREG_WRITE8(0x83,0x00); // setting reg_usbotg, clear VBUSDET_PDN
   usbREG_WRITE8(0x84,0x04); // clear reg_suspend, set otg_clk_en = 1

   XBYTE[0x1EA1]=0x06; //switch pad_GPIOT0  to otg_drvvbus

}

void usbDRCInit(void)
{
   usbResetting=0;

   usbRegPower=0;
   usbIntStatus=0;
   usbIntInStatus=0;
   usbBulkInStatus=0;
   usbBulkOutStatus=0;
   usbDataPhaseDir=0;

   usbBulkInStatus2=0;

}

void usbEnable_EP_DRC(__u8 ep);
void usbEnable_EP_DRC2(__u8 ep);
void usbParse_DRC_Int(drcintitem_t *dP);

void usbRead_DRC_Power(void)
{
   usbRegPower = usbREG_READ8(USB_REG_POWER);/* and refresh */
}

void usbRead_DRC_Devctl(void)
{
   usbRegDevCtl = usbREG_READ8(REG_DEVCTL);/* and refresh */
}

void usbRefresh_DRC_Registers(void)
{
   usbRead_DRC_Power();
   usbRead_DRC_Devctl();
}

#ifdef Enable_OTG_Host
void usbReset_DRC_Core(void)
{
   __u8   i;
   __s8 SRPEnabled=0;

   printf("\r\n Reset_DRC",0);
   usbResetting = 1;
   usbCurOTGState = 0;
   //////////////    USB_Disable_USB_Ints();
   //MsOS_DisableInterrupt (E_INT_USB);
   usbREG_WRITE8(USB_REG_FADDR, 0);
   //usbREG_WRITE8(USB_REG_POWER, M_POWER_SOFTCONN | M_POWER_HSENAB);
   usbREG_WRITE8(USB_REG_POWER, M_POWER_SOFTCONN | M_POWER_ENSUSPEND);
   usbREG_WRITE8(REG_DEVCTL,0);
   for ( i=0; i < usbNumEPDefs; i++)
     usbReset_EP_DRC_Regs(i);
   usbReset_All_EP_IO_Vars();
   usbREG_WRITE8(USB_REG_INTRUSBE, ((__u8)(~0) ^ M_INTR_SOF));/* no sof int*/
   usbSet_DRC_Interrupts();
   usbClear_DRC_Interrupts();
   ///////////////////////    USB_Enable_USB_Ints();
   //MsOS_EnableInterrupt(E_INT_USB);
   usbResetting = 0;
   usbRefresh_DRC_Registers();
   usbEP0State = 0;
   usbUSBState = 0;
   SRPEnabled = NO;
   if(!usbFaddr)
     usbFaddr = 2;          /* use 2 for all ADDRESS function */
   usbChange_OTG_State(AB_IDLE);
}
#endif

void usbSet_DRC_Power(__u8  regupdate)
{
   usbRegPower |= regupdate;
   usbREG_WRITE8(USB_REG_POWER,usbRegPower);
   usbRegPower = usbREG_READ8(USB_REG_POWER);
}


void usbClear_DRC_Power( __u8 regupdate)
{
   if  (!regupdate)
   {
     if (u8varOTG_FORCE_FS||(CHIP_VERSION<=CHIP_VER_U02))
     usbRegPower = M_POWER_SOFTCONN;
   else
       usbRegPower = M_POWER_SOFTCONN | M_POWER_HSENAB;

   }
   else
     usbRegPower &= ~regupdate;

   usbREG_WRITE8(USB_REG_POWER,usbRegPower);
   usbRegPower = usbREG_READ8(USB_REG_POWER);
}

void usbSet_DRC_Devctl(__u8 regupdate)
{
   usbRegDevCtl |= regupdate;
   usbREG_WRITE8(REG_DEVCTL,usbRegDevCtl);
   usbRegDevCtl = usbREG_READ8(REG_DEVCTL);
}

void usbClear_DRC_Devctl(__u8 regupdate)
{
   if(!regupdate)
     usbRegDevCtl = 0;
   else
     usbRegDevCtl &= ~regupdate;
   usbREG_WRITE8(REG_DEVCTL,usbRegDevCtl);
   usbRegDevCtl = usbREG_READ8(REG_DEVCTL);
}

///////////////////
void USB_Setup_Endpoint(__s8 epnum,__s8 epdir,__s8 eptype,__s8 epinf ,__s16 epmaxps)
{
   usbEP[epnum].MaxEPSize = epmaxps;
   usbEP[epnum].DRCDir = epdir;
   usbEP[epnum].FifoRemain = 0;
   usbEP[epnum].BytesRequested = 0;
   usbEP[epnum].BytesProcessed = 0;
   usbEP[epnum].pipe = eptype;
   usbEP[epnum].BltEP = epnum;
   usbEP[epnum].LastPacket = 0;
   usbEP[epnum].transfer_buffer = 0;
   usbEP[epnum].transfer_buffer_length = 0;
   usbEP[epnum].IOState = EP_IDLE;
   usbEP[epnum].Halted = 0;
   usbEP[epnum].Infnum = epinf;
   if (epnum!=0)
     usbEnable_EP_DRC(epnum);
}

void usbDRC_Index_Select_INT(__u8 epnum)
{
   __u8    reg;

   reg = usbREG_READ8(USB_REG_INDEX);
   if  (reg != epnum)
     usbREG_WRITE8(USB_REG_INDEX, epnum);
}


void usbEnable_EP_DRC(__u8 ep)
{
   __u8 reg;
   __u16 csr;


   usbDRC_Index_Select_INT(usbEP[ep].BltEP);
   reg = (usbEP[ep].BltEP2 & 0x0f) | ((usbEP[ep].pipe & 0x03) << 4);

   #ifdef  BIG_ENDIAN
   csr = usbREG_READ8(USB_REG_RXCSR);
   #else
   csr = usbREG_READ16(USB_REG_RXCSR);
   #endif
   if(usbEP[ep].DRCDir == FIFO_RX)
   {
     usbREG_WRITE8(USB_REG_RXTYPE, reg);
     #ifdef  BIG_ENDIAN
     usbREG_WRITE16(USB_REG_RXMAXP, Swap16(usbEP[ep].MaxEPSize));
     #else
     usbREG_WRITE16(USB_REG_RXMAXP, usbEP[ep].MaxEPSize);
     #endif
	 if (csr & M_RXCSR_RXPKTRDY)
	 {
	   usbEP[ep].FifoRemain = usbRead_RxCount();
	 }
	 else
	 {
	   csr = M_RXCSR_CLRDATATOG;
	 }

	 if (usbEP[ep].pipe == USB_ENDPOINT_XFER_INT)
	   csr |= M_RXCSR_DISNYET;
     #ifdef  BIG_ENDIAN
     usbREG_WRITE16(USB_REG_RXCSR, Swap16(csr));
     #else
     usbREG_WRITE16(USB_REG_RXCSR, csr);
     #endif
     usbREG_WRITE16(USB_REG_TXCSR, 0);

     if(usbIsHOST())
	 {
       //printf("\r\n ar1=%x",usbREG_READ8(USB_REG_RXINTERVAL));
	   usbREG_WRITE8(USB_REG_RXINTERVAL,0x0);
	   //printf("\r\n ar2=%x",usbREG_READ8(USB_REG_RXINTERVAL));
	 }

   }
   else
   {
     usbREG_WRITE8(USB_REG_TXTYPE, reg);
     #ifdef  BIG_ENDIAN
     usbREG_WRITE16(USB_REG_TXMAXP, Swap16(usbEP[ep].MaxEPSize));
     usbREG_WRITE16(USB_REG_TXCSR, Swap16(M_TXCSR_FLUSHFIFO));
     #else
     usbREG_WRITE16(USB_REG_TXMAXP, usbEP[ep].MaxEPSize);
     usbREG_WRITE16(USB_REG_TXCSR, M_TXCSR_FLUSHFIFO);
     #endif
     csr = M_TXCSR_MODE | M_TXCSR_CLRDATATOG;
     #ifdef  BIG_ENDIAN
     usbREG_WRITE16(USB_REG_TXCSR, Swap16(csr));
     #else
     usbREG_WRITE16(USB_REG_TXCSR, csr);
     #endif
     if(usbIsHOST())
	 {
       //printf("\r\n at1=%x",usbREG_READ8(USB_REG_TXINTERVAL));
	   usbREG_WRITE8(USB_REG_TXINTERVAL,0x0);
	   //printf("\r\n at2=%x",usbREG_READ8(USB_REG_TXINTERVAL));
	 }
   }
}

#ifdef Enable_OTG_Host
void usbEnable_EP_DRC2(__u8 ep)
{
   __u8 reg;
   __u16 csr;


   usbDRC_Index_Select_INT(usbEP[ep].BltEP2);
   reg = (usbEP[ep].BltEP2 & 0x0f) | ((usbEP[ep].pipe & 0x03) << 4);

   #ifdef  BIG_ENDIAN
   csr = usbREG_READ8(USB_REG_RXCSR);
   #else
   csr = usbREG_READ16(USB_REG_RXCSR);
   #endif
   if(usbEP[ep].DRCDir == FIFO_RX)
   {
     usbREG_WRITE8(USB_REG_RXTYPE, reg);
     #ifdef  BIG_ENDIAN
     usbREG_WRITE16(USB_REG_RXMAXP, Swap16(usbEP[ep].MaxEPSize));
     #else
     usbREG_WRITE16(REG_RXMAXP, usbEP[ep].MaxEPSize);
     #endif
	 if (csr & M_RXCSR_RXPKTRDY)
	 {
	   usbEP[ep].FifoRemain = usbRead_RxCount();
	 }
	 else
	 {
	   //csr = M_RXCSR_CLRDATATOG;
	 }

	 if (usbEP[ep].pipe == USB_ENDPOINT_XFER_INT)
	   csr |= M_RXCSR_DISNYET;
     #ifdef  BIG_ENDIAN
     usbREG_WRITE16(USB_REG_RXCSR, Swap16(csr));
     #else
     usbREG_WRITE16(USB_REG_RXCSR, csr);
     #endif
     usbREG_WRITE16(USB_REG_TXCSR, 0);
   }
   else
   {
     usbREG_WRITE8(USB_REG_TXTYPE, reg);
     #ifdef  BIG_ENDIAN
     usbREG_WRITE16(USB_REG_TXMAXP, Swap16(usbEP[ep].MaxEPSize));
     usbREG_WRITE16(USB_REG_TXCSR, Swap16(M_TXCSR_FLUSHFIFO));
     #else
     usbREG_WRITE16(USB_REG_TXMAXP, usbEP[ep].MaxEPSize);
     usbREG_WRITE16(USB_REG_TXCSR, M_TXCSR_FLUSHFIFO);
     #endif
     csr = M_TXCSR_MODE;// | M_TXCSR_CLRDATATOG;
     #ifdef  BIG_ENDIAN
     usbREG_WRITE16(USB_REG_TXCSR, Swap16(csr));
     #else
     usbREG_WRITE16(USB_REG_TXCSR, csr);
     #endif
   }
}
#endif
#if 1
void usbDRC_Fifo_Read_INT(__u8 *dstP,__u8 ep)
{
   __s32 readcount;
   __u32 volatile fifo;
   #ifdef _Indirect
   __u8 volatile tmp;
   #endif

   readcount = MIN((usbEP[ep].BytesRequested - usbEP[ep].BytesProcessed),usbEP[ep].FifoRemain);
   if  (readcount <= 0)
     return;
   dstP += usbEP[ep].BytesProcessed;
   usbEP[ep].BytesProcessed += readcount;
   usbEP[ep].FifoRemain -= readcount;
   if (ep==0)
     usbEP[ep].BltEP=0;
   fifo = FIFO_ADDRESS(usbEP[ep].BltEP);
   #ifdef USB_DEBUG
   //printf("\r\nrfifo = %x ",fifo);
   //if (ep!=0)
   //{
       //printf("\r\ndstP = %x ",(__u16)dstP);
       //printf("\r\n",0);
   //}
   //*((__u8 volatile xdata *)dstP)=*((__u8 volatile xdata *)fifo);
   #endif
   #ifndef _Indirect
   if (readcount > 0)
   {
     while (readcount > 0)/*While Looping_Free:<Exit counter added>*/
	 {
       *((__u8 volatile xdata *)dstP)=*((__u8 volatile xdata *)fifo);
	   //if (ep!=0)
	       //printf("%x ",*((__u8 volatile xdata *)dstP));
	   dstP++;
	   readcount--;
	 }
   }
   #else
   if (readcount > 0)
   {
     while (readcount > 0)/*While Looping_Free:<Unused codes>*/
	 {
	   tmp=*((__u8 volatile xdata *)fifo);
       while (!(usbEXTREG_READ8(0x02)&0x01));/*While Looping_Free:<Unused codes>*/
       #ifdef USB_DEBUG
       //printf("\r\n1502 = %x ",usbEXTREG_READ8(0x02));
       #endif
       usbEXTREG_WRITE8(0x02,0);
       *((__u8 volatile xdata *)dstP)=usbEXTREG_READ8(0x98);
       #ifdef USB_DEBUG
       //if (ep!=0)
           //printf("%x ",*((__u8 volatile xdata *)dstP));
       #endif
	   dstP++;
	   readcount--;
	 }
   }
   #endif
}

void usbDRC_Fifo_Write_INT(__u8 *srcP,__u8 ep)
{
   __s32 writecount;
   __u32 volatile fifo;

   if (usbEP[ep].MaxEPSize!=0)
     writecount = MIN(usbEP[ep].MaxEPSize, (usbEP[ep].BytesRequested - usbEP[ep].BytesProcessed));
   else
     writecount = usbEP[ep].BytesRequested - usbEP[ep].BytesProcessed;
   if  (!writecount)
   {
     usbEP[ep].LastPacket = 1;
     return;
   }
   srcP += usbEP[ep].BytesProcessed;
   usbEP[ep].BytesProcessed += writecount;

   if(usbEP[ep].BytesProcessed == usbEP[ep].BytesRequested)
     usbEP[ep].LastPacket = 1;
   if (ep==0)
     usbEP[ep].BltEP=0;
   fifo=FIFO_ADDRESS(usbEP[ep].BltEP);
   #ifdef USB_DEBUG
   //printf("\r\nwfifo = %x ",fifo);
   //printf("\r\nwritecount = %x ",nwritecount);
   //printf("\r\nsrcP = %x ",(__u16)srcP);
   #endif
   /* byte access for unaligned */
   if (writecount > 0)
   {
     while(writecount)/*While Looping_Free:<Exit counter added>*/
	 {
       //#ifdef USB_DEBUG
       //printf("   srcP = %x ",(__u8 )*((__u8 volatile xdata *)srcP));
       //#endif
	   *((__u8 volatile xdata *)fifo) = *((__u8 volatile xdata *)srcP);
	   srcP++;
	   writecount--;
	 }
   }
}
#else
void usbDRC_Fifo_Read_INT(__u8 *dstP,__u8 ep)
{
   __s32 readcount;
   __u32 fifo;

   readcount = MIN((usbEP[ep].BytesRequested - usbEP[ep].BytesProcessed),usbEP[ep].FifoRemain);
   if  (readcount <= 0)
     return;
   dstP += usbEP[ep].BytesProcessed;
   usbEP[ep].BytesProcessed += readcount;
   usbEP[ep].FifoRemain -= readcount;
   fifo = FIFO_ADDRESS(usbEP[ep].BltEP);
   *dstP = *((__u8 *)fifo);
   if ((readcount > 0)&& ((__u32) dstP & 3))
   {
     while (readcount > 0)
	 {