msdrc.c

MSTAR03的数码相框的代码

     #else
     usbDRC_Fifo_Write((__u8 *)usbEP[1].transfer_buffer, 1);
     outreg |= M_TXCSR1_TXPKTRDY;
     #endif
   }
   if  (outreg)
     usbREG_WRITE8(USB_REG_TXCSR1, outreg);
   //putchar('2');
   u32Cnt = 0;
   while(true)/*While Looping_Free:<Exit counter added>*/
   {
    if(usbBulkInStatus2!=0xff)
        break;
    if(!usbConnectFlag)
        break;
    if(++u32Cnt>0x3FFFF)
        break;
   }
   //putchar('3');
   //if(txsize!=0x40)
   u32Cnt = 0;
   while(true)/*While Looping_Free:<Exit counter added>*/
   {
    if(usbBulkInStatus!=0xff)
        break;
    if(!usbConnectFlag)
        break;
    if(++u32Cnt>0x3FFFF)
        break;
   }
   //while((usbBulkInStatus==0xff)&&(usbConnectFlag));
   //putchar('4');
   u32Cnt = 0;
   while(true)/*While Looping_Free:<Exit counter added>*/
   {
    if(usbEP[1].LastPacket)
        break;
    if(!usbConnectFlag)
        break;
    if(++u32Cnt>0x3FFFF)
        break;
   }
   //while((!usbEP[1].LastPacket)&&(usbConnectFlag));
   //putchar('5');
   u32Cnt = 0;
   while(true)/*While Looping_Free:<Exit counter added>*/
   {
    if(usbEP[1].BytesRequested==usbEP[1].BytesProcessed)
        break;
    if(!usbConnectFlag)
        break;
    if(++u32Cnt>0xFFFF)
        break;
   }
   //while((usbEP[1].BytesRequested!=usbEP[1].BytesProcessed)&&(usbConnectFlag));
   //putchar('6');
   usbEP[1].BytesRequested=0;
   usbDRC_Index_Select(usbEP[2].BltEP);

   if(!usbConnectFlag)
   {
     printf("\r\n ck1=%bx", ck);
	 printf("\r\n ck2=%bx", GetPartHeaderTransfer);
	 printf("\r\n ck3=%bx", inreg);
	 printf("\r\n txend=%lx",txsize);
	 printf("\r\n sts=%bx",usbBulkInStatus);
	 printf("\r\n sts2=%bx",usbBulkInStatus2);
	 printf("\r\n LP=%bx",usbEP[1].LastPacket);
   }
   //printf("\r\n tdr=%x",(__u16)(txaddr>>16));
   //printf(" %x",(__u16)(txaddr));
   if(IntCheck!=0)
   {
     //printf("\r\n tsz=%x",txsize);
	 //printf("\r\n IntCheck=%x",IntCheck);
   }
   return (usbBulkInStatus);
}

__u8 USB2SDRAM_Bulk(__u32 rxaddr,__u32 rxsize)
{
   __u32 u32Cnt=0;
   usbBulkOutStatus=0xff;
   usbEP[2].BytesProcessed=0;
   usbEP[2].BytesRequested=rxsize;
   usbEP[2].transfer_buffer=rxaddr;
   usbEP[2].transfer_buffer_length=0;
   usbDRC_Index_Select(usbEP[2].BltEP);
   /*
   if(NotifyusbConnect==1)
   {
     printf("\r\n AAA3=%x",usbEP[2].BytesRequested);
     printf("\r\n AAA4=%x",usbEP[2].BytesProcessed);
     printf("\r\n AAA5=%x",usbConnectFlag);
	 printf("\r\n AAA6=%x",usbEP[2].FifoRemain);
     printf("\r\n AAA7=%x",usbPictRxDataReceived);
   }*/
   while (rxsize>0)/*While Looping_Free:<Exit counter added>*/
   {
     if (usbPictRxDataReceived==1||usbMassRxDataReceived==1)
     {
       usbPictRxDataReceived=0;
       usbMassRxDataReceived=0;
       rxsize=rxsize-usbEP[2].FifoRemain;
       usbDataPhaseDir=usb_rcvbulkpipe(usbEP[2].BltEP);   //PIPE_In
       if (usbEP[2].FifoRemain < usbEP[2].MaxEPSize)
         usbEP[2].LastPacket = 1;
       else
       {
         if ((usbEP[2].BytesProcessed + usbEP[2].FifoRemain) >= usbEP[2].BytesRequested)
           usbEP[2].LastPacket = 1;
         else
           usbEP[2].LastPacket = 0;
       }
       #ifdef DMA
	   //if (usbSet_DMA(2, DMA_RX_ONE_IRQ) < 0)
	   {
       #endif
	     usbDRC_Fifo_Read((__u8 *)usbEP[2].transfer_buffer, 2);
         //usbEP[2].transfer_buffer=usbEP[2].transfer_buffer+usbEP[2].BytesProcessed;
		 usbEP[2].FifoRemain = usbRead_RxCount();
		 if (!usbEP[2].FifoRemain)
		   usbREG_WRITE8(USB_REG_RXCSR1, 0);
       #ifdef DMA
	   }
       #endif
     }
   }
   //while(usbBulkOutStatus==0xff);

   while((usbEP[2].BytesRequested!=usbEP[2].BytesProcessed)&&(usbConnectFlag))/*While Looping_Free:<Exit counter added>*/
   {
     if(++u32Cnt==0x3FFFF)
        break;
   }
   usbEP[2].BytesRequested=0;
   return (usbBulkOutStatus);
}

#ifdef Enable_Device_MassStorage
__u8 USB2SDRAM_Bulk_MassStorage(__u32 rxaddr,__u32 rxsize)
{
   __u32 u32Cnt=0;
   usbBulkOutStatus=0xff;
   usbEP[2].BytesRequested=rxsize;
   usbEP[2].BytesProcessed=0;
   usbEP[2].transfer_buffer=rxaddr;
   usbEP[2].transfer_buffer_length=0;
   usbDataPhaseDir=usb_rcvbulkpipe(usbEP[2].BltEP);   //PIPE_In
   usbSet_DMA(2, DMA_RX_ONE_IRQ);
   while(usbBulkOutStatus==0xff)/*While Looping_Free:<Exit counter added>*/
   {
        if( (++u32Cnt==0x3FFFF) || (!usbConnectFlag))
        {
            /*
            u32Tmp = dwEndianXCH(usbREG_READ32((U16)DMA_COUNT_REGISTER(1)));
            printf("DMA_CNT = 0x%lx\r\n",u32Tmp);
            u32Tmp = dwEndianXCH(usbREG_READ32((U16)DMA_CNTL_REGISTER(1)));
            printf("DMA_CTL = 0x%lx\r\n",u32Tmp);
            u32Tmp = dwEndianXCH(usbREG_READ32((U16)DMA_ADDR_REGISTER(1)));
            printf("DMA_ADR = 0x%lx\r\n",u32Tmp);
            u8DMAIntr = usbREG_READ8(REG_DMA_INTR);
            printf("rxPktCnt = 0x%x\r\n",pbReadUSB16Reg(USB_REG_DMA_MODE_CTL));
            */
            break;
        }
   }
   return (usbBulkOutStatus);
}
#endif

__u8 SDRAM2USB_Int(__u32 txaddr,__u32 txsize)
{
   __u8 inreg,outreg=0;

   usbIntInStatus=0xff;

   usbEP[3].IOState = EP_TX;
   usbEP[3].BytesRequested = txsize;
   usbEP[3].BytesProcessed = 0;
   usbEP[3].LastPacket     = 0;
   usbEP[3].transfer_buffer=txaddr;
   usbDataPhaseDir=usb_sndbulkpipe(usbEP[3].BltEP);   //PIPE_OUT

   usbDRC_Index_Select(usbEP[3].BltEP);
   inreg = usbREG_READ8(USB_REG_TXCSR1);
   if  (inreg & M_TXCSR1_P_SENTSTALL)
     outreg |= M_TXCSR1_CLRDATATOG;
   if  (!(inreg & M_TXCSR1_FIFONOTEMPTY)||(outreg & M_TXCSR1_CLRDATATOG))
   {
     #ifdef DMA
     if(usbSet_DMA(3, DMA_TX_ONE_IRQ) < 0)
     {
       usbDRC_Fifo_Write((__u8 *)usbEP[3].transfer_buffer, 3);
       outreg |= M_TXCSR1_TXPKTRDY;
     }
     else
     outreg = 0;
     #else
     usbDRC_Fifo_Write((__u8 *)usbEP[3].transfer_buffer, 3);
     outreg |= M_TXCSR1_TXPKTRDY;
     #endif
   }
   if  (outreg)
     usbREG_WRITE8(USB_REG_TXCSR1, outreg);
   while((usbIntInStatus==0xff)&&(usbConnectFlag));/*While Looping_Free:<Unused codes>*/
   while((!usbEP[3].LastPacket)&&(usbConnectFlag));/*While Looping_Free:<Unused codes>*/
   //while((usbEP[3].BytesRequested!=usbEP[3].BytesProcessed)&&(usbConnectFlag));
   usbDRC_Index_Select(usbEP[2].BltEP);
   usbEP[3].BytesRequested=0;
   return (usbIntInStatus);
}

void usbSet_DRC_Interrupts(void)
{
   __u16 reg;

   #ifdef BIG_ENDIAN
   reg = Swap16(0xff);
   #else
   reg = 0xff;
   #endif
   usbREG_WRITE8(USB_REG_INTRUSBE, 0xf7);
   usbREG_WRITE16(USB_REG_INTRTXE, reg);
   usbREG_WRITE16(USB_REG_INTRRXE, reg);
}

#ifdef Enable_OTG_Host
#if 1
void usbClear_DRC_Interrupts(void)
{
   __u16 temp;

   temp = usbREG_READ8(USB_REG_INTRUSB);
   #ifdef  BIG_ENDIAN
   temp = Swap16(usbREG_READ16(USB_REG_INTRTX));
   temp = Swap16(usbREG_READ16(USB_REG_INTRRX));
   #else
   temp = usbREG_READ16(USB_REG_INTRTX);
   temp = usbREG_READ16(USB_REG_INTRRX);
   #endif
}
#endif
#endif
#ifdef _Indirect
__u8 usbREG_READ8(__u16 addr)
{
   #if 1
   #ifdef USB_DEBUG
   //printf("\r\naddr = %x ",usbRegAddress + (addr));
   //printf("\r\ndata = %x ",DRC_IN8(usbRegAddress + addr));
   #endif
   DRC_IN8(usbRegAddress + addr);
   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);
   //usbEXTREG_WRITE8(0x02,DRC_IN8(0x1502)&0xFE);
   #ifndef VERSION_C
   return usbEXTREG_READ8(0x98);
   #else
   return usbEXTREG_READ8(0x01); //for lola Ver C
   #endif
   #else
   DRC_IN8(usbRegAddress + addr);
   while (!(DRC_IN8(0x1502)&0x01));
   DRC_OUT8(0x1502,0);
   return DRC_IN8(0x1590);
   #endif
}

void pbWriteUSB32Reg(__u16 addr, __u32 x)
{
   #ifdef USB_DEBUG
   //printf("\r\n32addr = %x ",addr);
   //printf("\r\n32x4 = %x ",*((__u8 volatile *)&x+3));
   //printf("\r\n32x5 = %x ",*((__u8 volatile *)&x+2));
   //printf("\r\n32x6 = %x ",*((__u8 volatile *)&x+1));
   //printf("\r\n32x7 = %x ",*((__u8 volatile *)&x+0));
   #endif
   usbEXTREG_WRITE8(0x00,0x02);
   usbEXTREG_WRITE8(0x04,*((__u8 volatile *)&x+3));
   usbEXTREG_WRITE8(0x05,*((__u8 volatile *)&x+2));
   usbEXTREG_WRITE8(0x06,*((__u8 volatile *)&x+1));
   usbEXTREG_WRITE8(0x07,*((__u8 volatile *)&x+0));
   usbREG_WRITE8(addr,0x55);
   usbEXTREG_WRITE8(0x00,0x00);
}
#ifdef VERSION_C
__u32 pbReadUSB32Reg(__u16 addr)
{
   __u32 tmp=0;

   #ifdef USB_DEBUG
   //printf("\r\nADDR = %x ",addr);
   #endif
   usbEXTREG_WRITE8(0x00,0x02);

   usbEXTREG_WRITE8(0x01,0x40);
   usbREG_READ8(addr);
   *((__u8 volatile *)&tmp+0)=usbEXTREG_READ8(1);
   #ifdef USB_DEBUG
   //printf("\r\n1501_0 = %x ",usbEXTREG_READ8(1));
   #endif

   usbEXTREG_WRITE8(0x01,0x20);
   usbREG_READ8(addr);
   *((__u8 volatile *)&tmp+1)=usbEXTREG_READ8(1);
   #ifdef USB_DEBUG
   //printf("\r\n1501_1 = %x ",usbEXTREG_READ8(1));
   #endif

   usbEXTREG_WRITE8(0x01,0x10);
   usbREG_READ8(addr);
   *((__u8 volatile *)&tmp+2)=usbEXTREG_READ8(1);
   #ifdef USB_DEBUG
   //printf("\r\n1501_2 = %x ",usbEXTREG_READ8(1));
   #endif

   usbEXTREG_WRITE8(0x01,0x00);
   usbREG_READ8(addr);
   *((__u8 volatile *)&tmp+3)=usbEXTREG_READ8(1);
   #ifdef USB_DEBUG
   //printf("\r\n1501_3 = %x ",usbEXTREG_READ8(1));
   #endif

   usbEXTREG_WRITE8(0x00,0x00);
   return tmp;
}
#endif
void pbWriteUSB16Reg(__u16 addr, __u16 x)
{
   #ifdef USB_DEBUG
   //printf("\r\n16addr = %x ",addr);
   //printf("\r\n16xL = %x ",x);
   #endif
   usbEXTREG_WRITE8(0x00,0x02);
   usbEXTREG_WRITE8(0x04,*((__u8 volatile *)&x+1));
   usbEXTREG_WRITE8(0x05,*((__u8 volatile *)&x+0));
   usbREG_WRITE8(addr,0x55);
   usbEXTREG_WRITE8(0x00,0x00);
}
#endif

//artemis modify at 06/11/2007
#ifndef _Indirect
void pbWriteUSB32Reg(__u16 addr, __u32 x)
{
   usbREG_WRITE8(addr,*((__u8 volatile *)&x+3));
   usbREG_WRITE8(addr+1,*((__u8 volatile *)&x+2));
   usbREG_WRITE8(addr+2,*((__u8 volatile *)&x+1));
   usbREG_WRITE8(addr+3,*((__u8 volatile *)&x+0));
}

void pbWriteUSB16Reg(__u16 addr, __u16 x)
{
   usbREG_WRITE8(addr,*((__u8 volatile *)&x+1));
   usbREG_WRITE8(addr+1,*((__u8 volatile *)&x+0));
}

__u16 pbReadUSB16Reg(__u16 addr)
{
   __u16 temp;

   temp=usbREG_READ8(addr+1)&0xFF;
   temp=(temp<<8)|(usbREG_READ8(addr)&0xFF);
   return temp;
}
void pbWriteUSB32RegINT(__u16 addr, __u32 x)
{
   usbREG_WRITE8(addr,*((__u8 volatile *)&x+3));
   usbREG_WRITE8(addr+1,*((__u8 volatile *)&x+2));
   usbREG_WRITE8(addr+2,*((__u8 volatile *)&x+1));
   usbREG_WRITE8(addr+3,*((__u8 volatile *)&x+0));
}

void pbWriteUSB16RegINT(__u16 addr, __u16 x)
{
   usbREG_WRITE8(addr,*((__u8 volatile *)&x+1));
   usbREG_WRITE8(addr+1,*((__u8 volatile *)&x+0));
}
#endif
//end modify
void  usbInitmemPool(int StarPoolAddr, int PoolSize)
{
   init_mempool (&XBYTE [StarPoolAddr], PoolSize); //artemis add
}

void *usbMalloc(int size)
{
   void *m;

   m = malloc(size);
   return (m);
}

void usbFree (void * ptr)
{
   free(ptr);
 }

#ifdef Enable_OTG_Host
void *usbMemcpy(void *s1, const void *s2, int n)
{
   void *m;

   m=(memcpy(s1,s2,n));
   return (m);
}

void *usbMem_Set(void *s, __s32 c, int n)
{
   void *m;

   m=(memset(s,c,n));
   return (m);
}


__u8 usbCompareData(__u8 *ptr1, __u8 *ptr2, int n)
{
   int i;
   //printf("\r\n clen=%x",n);
   for(i=0;i<n;i++)
   {
     //printf("\r\n %bx",*(ptr1+i));
     //printf(", %bx",*(ptr2+i));

     if(*(ptr1+i)!=*(ptr2+i))
	   break;
   }

   if(( i+1)<n)
     return 1; // compare fail
   else
   	 return 0; //compare sucess

}
#endif

#ifdef Enable_Device_MassStorage
void usbSet_ClrRXMode1(void)
{
	pbWriteUSB16Reg(USB_REG_DMA_MODE_CTL, (pbReadUSB16Reg(USB_REG_DMA_MODE_CTL)&(~M_Mode1_P_OK2Rcv))); //disable set_ok2rcv[15]&ECO4NAK_en[14],wayne added
	//pbWriteUSB16Reg(USB_REG_DMA_MODE_CTL, (pbReadUSB16Reg(USB_REG_DMA_MODE_CTL)&(0x3FFF))); //disable set_ok2rcv[15]&ECO4NAK_en[14],wayne added
	//printf("scl=%x\n",pbReadUSB16Reg(USB_REG_DMA_MODE_CTL));
    //printf("scl2=%bx\n",XBYTE[0x268B]);
	pbWriteUSB16Reg(USB_REG_DMA_MODE_CTL, (pbReadUSB16Reg(USB_REG_DMA_MODE_CTL)|M_Mode1_P_AllowAck)); //enable Allow ok,wayne added
	pbWriteUSB16Reg(USB_REG_DMA_MODE_CTL, (pbReadUSB16Reg(USB_REG_DMA_MODE_CTL)&(~M_Mode1_P_AllowAck))); //enable Allow ok,wayne added
	//printf("escl=%x\n",pbReadUSB16Reg(USB_REG_DMA_MODE_CTL));
}

void usbReSet_ClrRXMode1(void)
{
	pbWriteUSB16RegINT(USB_REG_DMA_MODE_CTL, 0); //disable set_ok2rcv[15]&ECO4NAK_en[14],wayne added
}
#endif


#if 0
void CommC2X(__u8 xdata *Xdest,__u8 code *Csrc,__u16 size)
{
   while(size-->0)
     *Xdest++=*Csrc++;
}
#endif

void XDATA4KMapToDRAM(__u16 w4k)
{
   XBYTE[0x2BCC]=(__u8)(w4k);
   XBYTE[0x2BCD]= (__u8)(w4k>>8);
}

void usbSDRAM2SDRAM(__u32 u32src, __u32 u32dst, __u32 u32len)
{
   __u16 srcBlkAdr,srcOffset;
   __u16 i,lenTemp;

   __u8 old_w1_start, old_w1_end;
   __u32 old_w1_phys;

   MDrv_GetXdataWindow1Map( &old_w1_start, &old_w1_end, &old_w1_phys );

   #if 0
   printf("\r\nu32src=%x", (__u16)(u32src>>16));
   printf(",%x",(__u16)(u32src));

   printf("\r\nu32dst=%x", (__u16)(u32dst>>16));
   printf(",%x",(__u16)(u32dst));

   printf("\r\nu32len=%x", (__u16)(u32len>>16));
   printf(",%x",(__u16)(u32len));
   #endif

   srcBlkAdr=(__u16)(u32src/0x1000);
   srcOffset =(__u16)(u32src%0x1000);
   if(u32len>4096)
     lenTemp=4096-srcOffset;
   else
   {
     if((u32len+srcOffset)>0x1000)
       lenTemp=(0x1000-srcOffset);
     else
       lenTemp=u32len;
   }
   while(u32len>0)/*While Looping_Free:<Exit counter added>*/
   {
     XDATA4KMapToDRAM(srcBlkAdr);

     for(i=0;i<lenTemp;i++)
     {
       XBYTE[(u32dst-USB_TTX_FIX_XDATA_ADDR)+i]=XBYTE[0xF000+srcOffset+i];
     }
	 u32dst+=lenTemp;

     u32len=u32len-lenTemp;

     if(u32len>4096)
	   lenTemp=4096;
     else
       lenTemp=u32len;

     srcOffset=0;
     srcBlkAdr++;

   }

   //MDrv_MapXdataWindow1(old_w1_start, old_w1_end, old_w1_phys);
}
#if 0
void usbSDRAM2SDRAM(__u32 u32src, __u32 u32dst, __u32 u32len)
{
   __u32 i,j;
   __u32 dCount=0;