drvotgmain.c

MSTAR03的数码相框的代码

#include "DrvOTGMain.h"
//#include "uart.h"
//#include "common.h"
//#include "command.h"
#include "Board.h"
#include "drvisr.h"
#include "drvtimer.h"
#include "msAPI_MSDCtrl.h"
static code const char drvdisp_dummy_constant=0;

#if 0
void MDrv_OTG_Init(void)
{
   OTGUSBInitial(0x130000,Device_PictureBridge);

}

void MDrv_OTG_Connect(PBSTATUS *PBC)
{
   __u32 i;
   for(i=0;i<=0x20000;i++)
   {
     if(pbIsUSBDetect())
	   break;
   }

   //printf("\r\n i=%x",(__u16)(i>>16));
   //printf(",%x",(__u16)(i));

   if(i<0x20000)
   {
     while(!(pbDPSSevSts&0x08)&& usbConnectFlag)
     {
       pbInitPictureBridge();
	   PBC->DeviceStatus=pbDPSSevSts;
	   PBC->ErrReasonStatus= pbDPSJobErrReason;
	   PBC->BUSSatus=usbConnectFlag;
     }
   }
   else
     PBC->BUSSatus=usbConnectFlag;

}

void MDrv_OTG_Disconnect(void)
{
   //printf("\r\n discnt",0);
   pbUSBDisconnect();
}

BYTE MDrv_OTG_Routine(PBSTATUS *PBC)
{
   if (usbIsUSBConfiged())
   {
     pbIsSndNewJobPnt();
     if (pbIsUSBDetect())
     {
       pbInitPictureBridge();
	   PBC->DeviceStatus=pbDPSSevSts;
	   PBC->ErrReasonStatus= pbDPSJobErrReason;
	   //if((pbDPSSevSts&0x08))
	   PBC->BUSSatus=usbConnectFlag;
     }
   }
   return 0;
}

BYTE MDrv_PBStartPrint(PICTUREINFO PictureInfo)
{
   //pbSendOptionComFlag=1;
   printf("\r\n Start print",0);
   if (pbGetImageFlag==1)
   {
     pbStartJob(PictureInfo.IMG_WIDTH, PictureInfo.IMG_HEIGHT,PictureInfo.IMG_COMSIZE,PictureInfo.IMG_ADR,PictureInfo.THU_COMSIZE);
     return 0;
   }
   else
     return 1;
}

void MDrv_PBAbortJob(void)
{
   pbAbortJob();
}

void MDrv_PBContinueJob(void)
{
   pbContinueJob();
}
#endif

#if 1
void MDrv_OTG_Init(void)
{
   XBYTE[0x2680]|=0x40; //register usb otg
      
   //#if (CERAMAL_STEPPING>=2)
   //XBYTE[0x1E14]|=0x80;   //drive vbus_enable set enable
   //#else
   XBYTE[0x1E14]&=0x7F; //drive vbus_enable set disable 
   XBYTE[0x1E80]&=0xFE; //GPIOA0 output enable and output 0
   //#endif
   
   XBYTE[0x1F27]|=0x08;      // RX bias current => 60uA (default 40uA)
   XBYTE[0x1F2a]=0x00;       // Squelch voltage => 100mV (default 150mV) .18 process
   XBYTE[0x1F2d]|=0x00;      // HS_RTERM bias current .18 process

   //after Neptune project must to set this for eye pattern
   XBYTE[0x1F2c]|=0x01;   // TX slew rate control
   
   XBYTE[0x1F13]|=0x02;   //ISI improvement
   if (CHIP_VERSION >= CHIP_VER_U03)
   {
   XBYTE[0x1F2C]|=0xc1;   //Slew rate control,Common mode voltage,Pre-emphasis select
   XBYTE[0x1F2D]|=0x07;   //HS RTerm current: 5/6,Enable common mode adjust,Enable common mode voltage,Pre-emphasis select
   XBYTE[0x1F2F]|=0x0e;   //Enable pre-emphasis at data enable edge,Enable pre-emphasis at data transition edge,Enable pre-emphasis
   }
   else
   {
     XBYTE[0x1F2C]|=0x01;   //Slew rate control,
   }
   XBYTE[0x1F09]|=0x20;   //patch low tempture
   XBYTE[0x1F29]|=0x08;   //Disable FS retiming

   
   //XBYTE[0x268C]|=0x01; //miu_mode
      
   MDrv_Enable_IRQ(IRQ_INTERRUPT_OTG_INT);
   OTGUSBInitial(BASEADR_SDRAM_MCU_XDATA,Device_MassStorage);

   //printf("\r\n start_init_SD\n");
   //msAPI_MSD_Initial(NULL);
}

void MDrv_OTG_Routine(void)
{
  //if (usbIsPeripheral())
  //{
    if (usbIsUSBConfiged())
    {
      MSDFNCMDloop();
    }
  //}
}

#endif

#if 0
void MDrv_OTG_Init2(void)
{
   //OTGUSBInitial(0x70000,Device_MassStorage);
   OTGUSBInitial(BASEADR_SDRAM_MCU_XDATA,Device_MassStorage);
   MDrv_Enable_IRQ(IRQ_INTERRUPT_OTG_INT);
}

#ifdef OTG_READ_WRITE_TEST
__u8 TestMemory[512*4] _at_ 0xB000;
#endif

void MDrv_OTG_Routine2(void)
{
   //MDrv_Timer_Delayms(100);


   //XBYTE[0x1E14]|=0x80; // GPIO AO enable, reg_drvbus_en=1, eable drive vbus pad
   //printf("1.[0x2680]=%bx",XBYTE[0x2680]);
   //XBYTE[0x2680]=0x01; //USB IP rest disable
   //printf("2.[0x2680]=%bx",XBYTE[0x2680]);
   XBYTE[0x2502]|=0x10; //id pull up
   XBYTE[0x1F06]|=0x80; //dual otg mode
   XBYTE[0x2502]|=0x02; //swicth to OTG
   XBYTE[0x2680]|=0x40; //register usb otg

   printf("[0x2684]=%bx\n",XBYTE[0x2684]);
   printf("[0x2686]=%bx\n",XBYTE[0x2686]);
   printf("[0x2687]=%bx\n",XBYTE[0x2687]);



   MDrv_OTG_Init2();

   //XBYTE[0x268B]=0x20;
   //XBYTE[0x268A]=0x40;
   //printf("XBYTE[0x268B]=%bx\n",XBYTE[0x268B]);
   //printf("XBYTE[0x268A]=%bx\n",XBYTE[0x268A]);

   while(1)
   {

    //printf("%bx\n",XBYTE[0x2508]);

    //MDrv_Timer_Delayms(10);

    #if 1
    if(!(XBYTE[0x2508]& 0x08))
       XBYTE[0x1E14]|=0x80; // GPIO AO enable, reg_drvbus_en=1, eable drive vbus pad
    else
    {
       XBYTE[0x1E14]&=0x7F;
       XBYTE[0x1E80]&=0xFE;
    }
    //   printf("\r\n test0!!");

    //if(!(XBYTE[0x2684]& 0x01)&&!(usbREG_READ8(REG_DEVCTL)&0x04))
    //if(!(XBYTE[0x2508]& 0x08))
    //  XBYTE[0x2502]|=0x02; //swicth to OTG
    if(!(XBYTE[0x2508]& 0x08)&&!(usbREG_READ8(REG_DEVCTL)&0x04))
   	{
   	  //printf("\r\n test1!!");
   	  usbREG_WRITE8(REG_DEVCTL, usbREG_READ8(REG_DEVCTL)|0x01);// enable session
   	}

    if (usbResetComplete==1)
    {
      USB_EP0_Manager();
      usbResetComplete=0;
    }

    if (usbIsPeripheral())
    {
      if (usbIsUSBConfiged())
      {
        MSDFNCMDloop();
      }
    }
    #endif

    #ifdef OTG_READ_WRITE_TEST
    if (!usbIsPeripheral()&&usbIsUSBConfiged()&&ProcessCount==1)
    {
      __u32 blknum,blksize;
      __u8 LunIndex=0,RMB,DeviceType;
      __u32 i,j,k=0;

      printf("\r\n Start Burn Test!!!",0);

      if(TestRdy_Command(LunIndex)==USB_FAILURE)
      {
        printf("\r\n SCSI Device not Ready", 0);
      }

      Inquiry_Command(LunIndex, &RMB, &DeviceType);
      printf("\r\n RMB=%bx", RMB);

      RdCap_Command(LunIndex,&blknum,&blksize);
      printf("\r\n blknum=%x", (__u16)(blknum>>16));
      printf(",%x", (__u16)blknum);
      printf("\r\n blksize=%x", (__u16)(blksize>>16));
      printf(",%x", (__u16)blksize);
      //TestMemory=usbMalloc(512*4*sizeof(__u8)); // allocate 512 byte memory for test read /write


      //prepare pattern
      for(i=0;i<512;i++) //fill 4*512 memory pattern 0~FF
      {
        *(TestMemory+i)=i%256;
        *(TestMemory+512+i)=i%256;
	    *(TestMemory+1024+i)=i%256;
	    *(TestMemory+1536+i)=i%256;
      }

      *(TestMemory)=0;
      *(TestMemory+512)=1;
      *(TestMemory+1024)=2;
      *(TestMemory+1536)=3;
      //end pattern prepare

      while(1)
      {
        for(i=0;i<blknum-4;i++)
        {
          for(j=0;j<4;j++)
	      {
            usbMemcpy((void *)usbMass_Data_Buffer_Addr, TestMemory, 512*(j+1));

 	        GetPartHeaderTransfer=0;
            Wt10_Command(LunIndex,1+j,i);

		    usbMem_Set((void *)usbMass_Data_Buffer_Addr,0,512*(j+1));

	        GetPartHeaderTransfer=0;
            Rd10_Command(LunIndex,1+j,i);
            //printf("\r\n len=%lx",512*(j+1));
            if(usbCompareData(TestMemory, (__u8 *)usbMass_Data_Buffer_Addr, 512*(j+1)) )
	        {
	          while(1)
		      {
		        printf("\r\n compare fail, LBA=%lx", i);
		        printf("\r\n run times=%d",k);
		      }
	        }
	      }
	      printf("\r\n R/W LBA=%x",(__u16)( i>>16));
	      printf(",%x",(__u16)i);
	    }

	    k++;
	    printf("\r\n run times=%lx", k);
	    if(k>20)
	    {
	   	  while(1){ printf("\r\n Burn Test Done",0); }
	    }
      }
      ProcessCount=0;
    }
    #endif

   }
}
#endif

#if 0
BYTE PictureBridgeStarPrint(__u16 ImageWidth,__u16 ImageHeight,__u32 ImageSize,__u32 ImageAddr,__u32 ThumbSize)
{
   BYTE Status=0;
   //if (!usbIsUSBConfiged())
   //	return USB_DISCONNECT;
   //while(1)
   {
     if (usbIsUSBConfiged())
     {
       //printf("\r\n !configed", 0);
       pbSendOptionComFlag=1;
       pbIsSndNewJobPnt();
       pbServiceJob(ImageWidth,ImageHeight, ImageSize,ImageAddr,ThumbSize);

     }
   }
   return Status;
}


void PBStartPrint(PICINFO PictureInfo)
{

   if (pbGetImageFlag==1)
   {
     pbStartJob(PictureInfo.IMG_WIDTH, PictureInfo.IMG_HEIGHT,PictureInfo.IMG_COMSIZE,PictureInfo.IMG_ADR,PictureInfo.THU_COMSIZE);
   }
}

BYTE PBRoutine(void)
{
   BYTE Status=0;
   if (usbIsUSBConfiged())
   {
     pbIsSndNewJobPnt();
     if (pbIsUSBDetect())
     {
       pbInitPictureBridge();

     }

   }
   else
   {
     Status=1;
   }

   return Status;
}
#endif