msmsd.c

MSTAR03的数码相框的代码

#include "DrvOTGMain.h"
//#include "uart.h"

static code const char msMSD_dummy_constant=0;
#if (ENABLE_OTG_HOST == ENABLE)

__u32 usbMSD_Extact_BOT_CSW(__u8 *data_P);
__s8 usbMSD_BOT_CSW_Process(MSD_CB cmd_blk);
__s8 usbMSD_BOT_CSW_Transport(void);
__s8 usbMSD_BOT_Data_Transport(MSD_CB cmd_blk);
__s8 usbMSD_Unstall_Bulkpipe(__u8 endp_number) ;
__s8 usbMSD_BOT_Reset(void) ;
__s8 usbMSD_Reset_Recovery(void);
__s8 usbMSD_BOT_CBW_Transport(MSD_CB cmd_blk);
void usbMSD_Prepare_BOT_CBW(MSD_CB cmd_blk);



__s8 usbMSD_BOT_Get_Max_LUN(void)
{
    HostMassmax_Lun=0;
    HostMassValid_Lun=0;
	Valid_lun_Mask=0;
    FILL_SETUP(usbEP0Setup, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
        MSD_BOT_GET_MAX_LUN_REQUEST, 0, usbEP[0].Infnum, 1);
    usbEP[0].transfer_buffer_length=1;
    usbEP[0].transfer_buffer=(__u32)&HostMassmax_Lun;
    usbDataPhaseDir=usb_rcvctrlpipe(0);
    usbSWOP_Setup(&usbEP0Setup);
    usbHost_Send_EP0Setup((__u8 *)&usbEP0Setup);
    if (usbIntStatus!=USB_ST_NOERROR)
    {
        if(usbIntStatus==USB_ST_STALL)
        {
            HostMassmax_Lun=0;
	     usbEP0_Clear_Feature(0);
        }
	 else
        usbReset_DRC_Core();
    }
    //return usbIntStatus;
	printf("\r\n HostMassmax_Lun=%bx",HostMassmax_Lun);
	return HostMassmax_Lun;
}

__s8 usbMSD_BOT_Transport(MSD_CB cmd_blk)
{
	  __s8 status=0, index;
    //MSD_BOT_CBW msd_cbw;
    index = usbREG_READ8(USB_REG_INDEX);

    status = usbMSD_BOT_CBW_Transport(cmd_blk);
    //printf("\r\n a1=%x", status);
    //printf("\r\n a2=%x", cmd_blk.buf_length);
    if (status)
    {
        if (status == USB_ST_STALL)
            status = usbMSD_Reset_Recovery();
        return(USB_FAILURE);
    }
    //printf("\r\n len0=%x",(__u16)cmd_blk.buf_length);
   	//printf("\r\n len0=%x",(__u16)(cmd_blk.buf_length>>16));
    if (cmd_blk.buf_length > 0)
        status = usbMSD_BOT_Data_Transport(cmd_blk);

    if (status)
    {
        return(USB_FAILURE);
    }

	if( (*((__u8 *)usbCBWCB_Addr+0) == SCSI_CMD_READ_CPC))
	{
	     /*
	     printf("\r\n D0=%x",*((__u8 *)usbMass_Data_Buffer_Addr));
		 printf("\r\n D1=%x",*((__u8 *)usbMass_Data_Buffer_Addr+1));
		 printf("\r\n D2=%x",*((__u8 *)usbMass_Data_Buffer_Addr+2));
		 printf("\r\n D3=%x",*((__u8 *)usbMass_Data_Buffer_Addr+3));
	     printf("\r\n D4=%x",*((__u8 *)usbMass_Data_Buffer_Addr+4));
		 printf("\r\n D5=%x",*((__u8 *)usbMass_Data_Buffer_Addr+5));
		 printf("\r\n D6=%x",*((__u8 *)usbMass_Data_Buffer_Addr+6));
		 printf("\r\n D7=%x",*((__u8 *)usbMass_Data_Buffer_Addr+7));*/

         if(   ((*((__u8 *)usbMass_Data_Buffer_Addr+4))==0xDD) \
  	         &&((*((__u8 *)usbMass_Data_Buffer_Addr+5))==0xCC) \
 			 &&((*((__u8 *)usbMass_Data_Buffer_Addr+6))==0xBB) \
			 &&((*((__u8 *)usbMass_Data_Buffer_Addr+7))==0xAA)   )
         {
	      EPConfig=EPConfig | 0x01;
	      usbDRC_Index_Select(index);
          return(status);
		 }
    }


   ///*  for test use !!//artemis modify 02/15/2007
    if(*((__u8 *)usbCBWCB_Addr+0) == SCSI_CMD_READ10)
    	{
#ifdef Artemis_DEBUG
	  printf("\r\n AB=%x", 0);
#endif
	  status = usbMSD_BOT_CSW_Process(cmd_blk);
         if(status == USB_FAILURE)
        {
          status = USB_FAILURE;
         }
    	  usbDRC_Index_Select(index);
         return(status);
    	}//*/

    status = usbMSD_BOT_CSW_Transport();
    //printf("\r\n archeck1=%x", status);
    if(status)
    {
        //printf("\r\n archeck1", 0);
        if (status == USB_ST_STALL)
        {
            status = usbMSD_BOT_CSW_Transport();
            if(status != USB_SUCCESS)
            {
                if (status == USB_ST_STALL)
                {
                    usbMSD_Reset_Recovery();
                }
                return(USB_FAILURE);
            }
        }
        return(USB_FAILURE);
    }
    status = usbMSD_BOT_CSW_Process(cmd_blk);
    if(status == USB_FAILURE)
    {
        status = USB_FAILURE;
    }
    usbDRC_Index_Select(index);
    return(status);
}

__s8 usbMSD_BOT_CBW_Transport(MSD_CB cmd_blk)
{
    __s8 retstatus;

    usbMSD_Prepare_BOT_CBW(cmd_blk);
    //printf("\r\n addr1=%x", (__u16)((__u32)usbCSW&0xffff));
    //printf("\r\n addr2=%x", (__u16)((__u32)usbCBW_Addr &0xffff));
    //printf("\r\n CBW[0]=%x", *((__u8 *)usbCBW_Addr));
    //printf("\r\n CBW[1]=%x", *((__u8 *)usbCBW_Addr+1));
    //printf("\r\n CBW[2]=%x", *((__u8 *)usbCBW_Addr+2));
    //printf("\r\n CBW[3]=%x", *((__u8 *)usbCBW_Addr+3));
    //printf("\r\n CBW[15]=%x", *((__u8 *)usbCBW_Addr+15));
   //USB_Setup_Endpoint(1,PIPE_OUT,PIPE_BULK,1,64);
    if(!usbConnectFlag)
	 return(0);
    retstatus=usbSend_TXDATA((__u32)usbCBW_Addr,MSD_BOT_CBW_LENGTH);
    return (retstatus);
}

void usbMSD_Prepare_BOT_CBW(MSD_CB cmd_blk)
{
    __u8            i, j, k;


    for(i =0, j=4, k =8; i<4; i++, j++, k++)
    {
        //CBW signature
        *((__u8 *)usbCBW_Addr+i) =  (__s8)( cmd_blk.signature>> (8*i) );
	//CBW tag
        *((__u8 *)usbCBW_Addr+j) =  (__s8)( cmd_blk.tag>> (8*i) );
	//CBW data transfer length
        *((__u8 *)usbCBW_Addr+k) =  (__s8)( cmd_blk.buf_length >> (8*i) );
    }

    *((__u8 *)usbCBW_Addr+12) =  (__u8)((cmd_blk.direction == USB_DATA_DIR_IN) ? MSD_BOT_CBW_DATA_DIR_IN : MSD_BOT_CBW_DATA_DIR_OUT);
    *((__u8 *)usbCBW_Addr+13) = cmd_blk.lun;
    *((__u8 *)usbCBW_Addr+14) = cmd_blk.cmd_length;

    return;
}

__s8 usbMSD_Reset_Recovery(void)
{
    __s8 status;

    status = usbMSD_BOT_Reset();
    if(status)
        return(status);

    status = usbMSD_Unstall_Bulkpipe(usbEP[1].BltEP);
    if(status)
        return(status);

    status = usbMSD_Unstall_Bulkpipe(usbEP[2].BltEP);
    return(status);
}

__s8 usbMSD_BOT_Reset(void)
{
    FILL_SETUP(usbEP0Setup, USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
        MSD_BOT_RESET_REQUEST, 0, usbEP[0].Infnum, 0);
    usbEP[0].transfer_buffer_length=0;
    usbDataPhaseDir=usb_sndctrlpipe(0);
    usbSWOP_Setup(&usbEP0Setup);
    usbHost_Send_EP0Setup((__u8 *)&usbEP0Setup);
    if (usbIntStatus!=USB_ST_NOERROR)
        usbReset_DRC_Core();
    return usbIntStatus;
}

__s8 usbMSD_Unstall_Bulkpipe(__u8 endp_number)
{
    FILL_SETUP(usbEP0Setup, USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_ENDPOINT,
        USB_REQ_CLEAR_FEATURE, ENDPOINT_HALT, endp_number, 0);
    usbEP[0].transfer_buffer_length=0;
    usbDataPhaseDir=usb_sndctrlpipe(0);
    usbSWOP_Setup(&usbEP0Setup);
    usbHost_Send_EP0Setup((__u8 *)&usbEP0Setup);
    if (usbIntStatus!=USB_ST_NOERROR)
        usbReset_DRC_Core();
    return usbIntStatus;
}

__s8 usbMSD_BOT_Data_Transport(MSD_CB cmd_blk)
{
    __u8 ep;
    __s8 retstatus;
    __u32 tmp=0;

	if(!usbConnectFlag)
	 return(0);

    if (cmd_blk.direction== USB_DATA_DIR_IN)
    {
        ep = usb_Ret_Blt_EP_Object(EP_RX); //artemis add at 03/08/2007
        usbEP[ep].IOState = EP_RX;
    }
    else
    {
        ep = usb_Ret_Blt_EP_Object(EP_TX); //artemis add at 03/08/2007
        usbEP[ep].IOState = EP_TX;
    }

    if (cmd_blk.direction== USB_DATA_DIR_IN)
    {
#if 0
        retstatus=usbReceive_RXDATA(otgMass_Data_Buffer_Addr,msd_bot_cbw.data_transfer_length);
#else
        tmp = usbMass_Data_Buffer_Addr;
        while (cmd_blk.buf_length>0)
        {
            if (cmd_blk.buf_length>MASS_BUFFER_SIZE2)
            {
#ifdef Artemis_DEBUG
			    printf("\r\n a0=%x",(__u16)tmp);
		        printf("\r\n a1=%x",(__u16)(tmp>>16));
		        printf("\r\n a2=%x",cmd_blk.buf_length);
#endif
                retstatus=usbReceive_RXDATA(tmp,MASS_BUFFER_SIZE2);
                if (retstatus)
                    break;
                cmd_blk.buf_length=cmd_blk.buf_length-MASS_BUFFER_SIZE2;
                tmp=tmp+MASS_BUFFER_SIZE2;
            }
            else
            {
#ifdef Artemis_DEBUG
                printf("\r\n !a0=%x",(__u16)tmp);
		        printf("\r\n !a1=%x",(__u16)(tmp>>16));
		        printf("\r\n !a2=%x",cmd_blk.buf_length);
#endif
				//if(tmp==0x180400)
				//  tmp=0x880000;
                retstatus=usbReceive_RXDATA(tmp,cmd_blk.buf_length);
                if (retstatus)
                    break;
                cmd_blk.buf_length=0;
                tmp=tmp+cmd_blk.buf_length;
            }

             //while (usbEP[ep].LastPacket==0); //artemis modify 02/15/2007
        }
#endif
    }
    else
    {
#if 0
        retstatus=usbSend_TXDATA(otgMass_Data_Buffer_Addr,msd_bot_cbw.data_transfer_length);
#else
        tmp=usbMass_Data_Buffer_Addr;
        while (cmd_blk.buf_length>0)
        {
            if (cmd_blk.buf_length>MASS_BUFFER_SIZE2)
            {
                retstatus=usbSend_TXDATA(tmp,MASS_BUFFER_SIZE2);
                if (retstatus)
                    break;
                cmd_blk.buf_length=cmd_blk.buf_length-MASS_BUFFER_SIZE2;
                tmp=tmp+MASS_BUFFER_SIZE2;
            }
            else
            {
                retstatus=usbSend_TXDATA(tmp,cmd_blk.buf_length);
                if (retstatus)
                    break;
                cmd_blk.buf_length=0;
                tmp=tmp+cmd_blk.buf_length;
            }
        }
#endif
    }

    if (retstatus)
    {
        if (retstatus == USB_ST_STALL)
        {
            retstatus = USB_FAILURE;
            retstatus = usbMSD_Unstall_Bulkpipe(usbEP[ep].BltEP);
        }
    }
    return(retstatus);
}

__s8 usbMSD_BOT_CSW_Transport(void)
{
    __u8 ep;
    __s8 retstatus;

	if(!usbConnectFlag)
	 return(0);

    ep = usb_Ret_Blt_EP_Object(EP_RX); //artemis add at 03/08/2007

    retstatus=usbReceive_RXDATA((__u32)usbCSW_Addr,MSD_BOT_CSW_LENGTH);

    if(retstatus)
    {
        if (retstatus == USB_ST_STALL)
            retstatus = usbMSD_Unstall_Bulkpipe(usbEP[ep].BltEP);
    }
    //printf("\r\n ep_csw1=%x",ep);
    //while ((usbEP[ep].LastPacket==0)&&(usbConnectFlag));
    //printf("\r\n ep_csw2=%x",ep);
    return(retstatus);
}

__s8 usbMSD_BOT_CSW_Process(MSD_CB cmd_blk)
{
    __u8 *data_P;
    __u32 data_length;

    __u32 signature, tag, data_residue;
    __u8   status;

    data_P=(__u8 *)usbCSW_Addr;

    signature=usbMSD_Extact_BOT_CSW(data_P);
    tag=usbMSD_Extact_BOT_CSW(data_P+4);
    data_residue=usbMSD_Extact_BOT_CSW(data_P+8);
    status=*(data_P+12);
    data_length  =  cmd_blk.buf_length;

    if ((signature != MSD_BOT_CSW_SIGNATURE) || (tag != MSD_BOT_CBW_TAG))
           status= MSD_BOT_CSW_PHASE_ERROR;

    if ((status == MSD_BOT_CSW_CMD_PASSED) || (status == MSD_BOT_CSW_CMD_FAILED))
    {
        if (data_residue > data_length)
            status = MSD_BOT_CSW_PHASE_ERROR;
    }

    switch(status)
    {
        case MSD_BOT_CSW_CMD_PASSED :
        {
            return(USB_SUCCESS);
        }

        case MSD_BOT_CSW_CMD_FAILED :
        {
         //printf("\r\n cswfail=%x", status);
            return(USB_FAILURE);
        }

        case MSD_BOT_CSW_PHASE_ERROR:
        {
	     printf("\r\n cswphaseEr=%x", status);
            //usbMSD_Reset_Recovery();
            return(USB_FAILURE);
        }
        default :
            return(USB_FAILURE);
    }

    return(USB_FAILURE);
}

__u32 usbMSD_Extact_BOT_CSW(__u8 *data_P)
{
  __u32 temp=0;

  temp=*(data_P+3);
  temp=(temp<<8)|*(data_P+2);
  temp=(temp<<8)|*(data_P+1);
  temp=(temp<<8)|*(data_P);

  return temp;
}

#endif //#if (ENABLE_OTG_HOST == ENABLE)