bulkonly.c

瑞星微公司RK27XX系列芯片的SDK开发包

    UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_CHECK_STATUS, &MediaStatus);

    if ((pCBW->Reseved0) & 0x01) //EVPD
    {
        t = (UINT8)((pCBW->LBA) >> 24);
        if (t == SUPPORTED_PAGES)
        {
            CSWHandler(CASE6, sizeof(InquirySupportedData));
            UsbWriteDataEP(sizeof(InquirySupportedData), (UINT8*)(&InquirySupportedData));
            SendCSW();
        }
        else if (t == SERIAL_NUMBER_PAGE)
        {
            CSWHandler(CASE6, sizeof(InquirySnData));
            Modify_DRM9ID();
            UsbWriteDataEP(sizeof(InquirySnData), (UINT8*)(&InquirySnData));
            SendCSW();
        }
        else if (t == DEVICE_INDENIFICATION_PAGE)
        {
            CSWHandler(CASE6, sizeof(InquiryDeviceData));
            UsbWriteDataEP(sizeof(InquiryDeviceData), (UINT8*)(&InquiryDeviceData));
            SendCSW();
        }
        else
        {
            BuildSenseData(SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ADSENSE_INVALID_CDB, 0);
            CSWHandler(CASECBW, 0);
        }
    }
    else
    {
        BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);
        CSWHandler(CASE6, pCBW->LBA >> 8);

        UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_GET_PROPERTIES , &p);
        UsbWriteDataEP(pCBW->LBA >> 8, (UINT8*)p.SCSI_Inquiry);

        SendCSW();
    }
}

/***************************************************************************
命令:读可格式化容量0x23
***************************************************************************/
void SCSICMD_ReadFormatCapacities(void)
{
    UINT8 capacity[12];
    UINT32 TotalSecs;
    UINT16 BytsPerSec;
    MSC_GEOMETRY    geo;

    MSC_STATUS     MediaStatus;
    UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_CHECK_STATUS, &MediaStatus);

    if (SCSI_MediaReady == 0 || MediaStatus == MSC_STATUS_NO_MEDIA)
    {
        BuildSenseData(SCSI_SENSE_NOT_READY, SCSI_ADSENSE_NO_MEDIA_IN_DEVICE, 0); //modify by lxs @2008.02.20
//     BuildSenseData(SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ADSENSE_INVALID_CDB, 0);
        CSWHandler(CASECBW, 0);
        SendCSW();
        MediaChange[pCBW->bCBWLUN] = 0;
        return;
    }
    else
    {
        if (MediaChange[pCBW->bCBWLUN] == 0)
        {
            BuildSenseData(SCSI_SENSE_UNIT_ATTENTION, SCSI_ADSENSE_MEDIUM_CHANGED, 0);
            CSWHandler(CASECBW, 0);
            SendCSW();
            MediaChange[pCBW->bCBWLUN] = 1;
            return;
        }
        UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_GET_GEOMETRY , &geo);
        TotalSecs = geo.LbaMax;
        BytsPerSec = geo.LbaSize;
    }

    CSWHandler(CASE6, 12);
    BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);
    capacity[0] = 0;
    capacity[1] = 0;
    capacity[2] = 0;
    capacity[3] = 8;
    capacity[4] = (TotalSecs >> 24) & 0x00ff;
    capacity[5] = (TotalSecs >> 16) & 0x00ff;
    capacity[6] = (TotalSecs >> 8) & 0x00ff;
    capacity[7] = TotalSecs & 0x00ff;
    capacity[8] = 0x03;
    capacity[9] = 0x00;
    capacity[10] = (UINT8)(BytsPerSec >> 8);  //bytes/block
    capacity[11] = (UINT8)(BytsPerSec & 0x00ff);
    UsbWriteDataEP(12, capacity);

    SendCSW();
}

/***************************************************************************
命令:读容量0x25
***************************************************************************/
void SCSICMD_ReadCapacity(void)
{
    UINT8 capacity[8];
    UINT32 TotalSecs;
    UINT16 BytsPerSec;
    MSC_GEOMETRY    geo;

    MSC_STATUS     MediaStatus;
    UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_CHECK_STATUS, &MediaStatus);

    if (SCSI_MediaReady == 0 || MediaStatus == MSC_STATUS_NO_MEDIA)
    {
        BuildSenseData(SCSI_SENSE_NOT_READY, SCSI_ADSENSE_NO_MEDIA_IN_DEVICE, 0); //modify by lxs @2008.02.20
//     BuildSenseData(SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ADSENSE_INVALID_CDB, 0);
        CSWHandler(CASECBW, 0);
        SendCSW();
        MediaChange[pCBW->bCBWLUN] = 0;
        return;
    }
    else
    {
        if (MediaChange[pCBW->bCBWLUN] == 0)
        {
            BuildSenseData(SCSI_SENSE_UNIT_ATTENTION, SCSI_ADSENSE_MEDIUM_CHANGED, 0);
            CSWHandler(CASECBW, 0);
            SendCSW();
            MediaChange[pCBW->bCBWLUN] = 1;
            return;
        }
        UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_GET_GEOMETRY , &geo);
        TotalSecs = geo.LbaMax - 1;
        BytsPerSec = geo.LbaSize;
    }

    CSWHandler(CASE6, 8);
    BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);


    capacity[0] = (TotalSecs >> 24) & 0x00ff;
    capacity[1] = (TotalSecs >> 16) & 0x00ff;
    capacity[2] = (TotalSecs >> 8) & 0x00ff;
    capacity[3] = TotalSecs & 0x00ff;
    capacity[4] = 0x00;
    capacity[5] = 0x00;
    capacity[6] = (UINT8)(BytsPerSec >> 8);
    capacity[7] = (UINT8)(BytsPerSec & 0x00ff);
    UsbWriteDataEP(8, capacity);
    SendCSW();
}

/***************************************************************************
命令:读缓冲0x28
***************************************************************************/
void SCSICMD_Read10(void)
{
    //UINT8 *pBuf;
    UINT16 len;

    MSC_STATUS     MediaStatus;
    UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_CHECK_STATUS, &MediaStatus);

    if (SCSI_MediaReady == 0 || MediaStatus == MSC_STATUS_NO_MEDIA)
    {
        BuildSenseData(SCSI_SENSE_NOT_READY, SCSI_ADSENSE_NO_MEDIA_IN_DEVICE, 0);
        CSWHandler(CASECBW, 0);
        SendCSW();
        return;
    }

    //pBulkInDataBuff = UsbBlkBulkIn( pCBW->bCBWLUN , pCBW->LBA , pCBW->Len );
    CSWHandler(CASE6, (UINT16)(pCBW->dCBWDataTransferLength));
    RockOSSendMsg(MBAUDIO , AS_USB_BulkInInd, NULL);

#if 0
    pBulkInDataBuff = UsbBlkBulkInDataPack(BulkEndpSize);
    UsbWriteDataEP(BulkEndpSize, pBulkInDataBuff);
    G_ucBulkStausPhase = K_InDataPhase;
    //#else
    do
    {
        pBulkInDataBuff = UsbBlkBulkInDataPack(BulkEndpSize);
        if (pBulkInDataBuff)
        {
            UsbWriteDataEP(BulkEndpSize, pBulkInDataBuff);
        }
    }
    while (pBulkInDataBuff);
#endif
}

/***************************************************************************
命令:读模式0x1a
***************************************************************************/
void SCSICMD_ModeSense06(void)
{
    MSC_STATUS     MediaStatus;
    UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_CHECK_STATUS, &MediaStatus);
    if (SCSI_MediaReady == 0 || MediaStatus == MSC_STATUS_NO_MEDIA)//(FlashValid)
    {
        BuildSenseData(SCSI_SENSE_NOT_READY, SCSI_ADSENSE_NO_MEDIA_IN_DEVICE, 0);
        CSWHandler(CASECBW, 0);
        SendCSW();
        return;
    }

    CSWHandler(CASEOK, 0x04);
    UsbWriteDataEP(4, (UINT8*)(&SCSIDATA_Sense));
    SendCSW();//2007-10-12 16:58
}

/***************************************************************************
命令:测试准备0x00
***************************************************************************/
void SCSICMD_TestUnitReady(void)//csw是否准备好
{
    MSC_STATUS     MediaStatus;

    UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_CHECK_STATUS, &MediaStatus);

    if (SCSI_MediaReady == 0 || MediaStatus == MSC_STATUS_NO_MEDIA)
    {
        BuildSenseData(SCSI_SENSE_NOT_READY, SCSI_ADSENSE_NO_MEDIA_IN_DEVICE, 0);
        CSWHandler(CASE1, 0);
        gCSW.bCSWStatus = CSW_FAIL;
        MediaChange[pCBW->bCBWLUN] = 0;
    }
    else
    {
        if (MediaChange[pCBW->bCBWLUN] == 0 || MediaStatus == MSC_STATUS_MEDIA_CHANGE)
        {
            UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_RESET, NULL);
            BuildSenseData(SCSI_SENSE_UNIT_ATTENTION, SCSI_ADSENSE_MEDIUM_CHANGED, 0);
            CSWHandler(CASE1, 0);
            gCSW.bCSWStatus = CSW_FAIL;
            MediaChange[pCBW->bCBWLUN] = 1;
        }
        else
        {
            CSWHandler(CASE1, 0);
            BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);
        }
    }



    SendCSW();
}

/***************************************************************************
命令:请求0x03
***************************************************************************/
void SCSICMD_RequestSense(void)
{
    UINT16 residue = sizeof(SCSIDATA_RequestSense);

    CSWHandler(CASE6, residue);
    UsbWriteDataEP(residue, (UINT8*)(&SCSIDATA_RequestSense)) ;
    SendCSW();//2007-10-12 16:59
}

/***************************************************************************
命令:阻止器件移除0x1e
***************************************************************************/
#if 0
void SCSICMD_PreventAllowMediumRemoval(void)
{
#if 1
    if (0)//(EpBuf[19] & 0x01) == 0x01)
    {
        BuildSenseData(SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ADSENSE_INVALID_PARAMETER, SCSI_SENSEQ_INIT_COMMAND_REQUIRED);
        CSWHandler(CASE11, (UINT16)(pCBW->dCBWDataTransferLength));//CSWHandler(CASE11,(UINT16)dCBWDaTrLen);   //允许移除设备
        gCSW.bCSWStatus = CSW_FAIL;
    }
    else
    {
        BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);
        CSWHandler(CASE1, (UINT16)(pCBW->dCBWDataTransferLength));  //允许移除设备
    }
#endif

    SendCSW();
}
#endif
void SCSICMD_PreventAllowMediumRemoval(void)
{
#if 1
    if (((pCBW->LBA >> 8)& 0x01) == 0x01)
    {
        BuildSenseData(SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ADSENSE_INVALID_CDB, 0);
        CSWHandler(CASE11, pCBW->dCBWDataTransferLength);  //允许移除设备
        gCSW.bCSWStatus = CSW_FAIL;
    }
    else
    {
        BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);
        CSWHandler(CASE1, pCBW->dCBWDataTransferLength);  //允许移除设备
    }
#endif
    SendCSW();
}
/***************************************************************************
命令:启停命令0x1b
***************************************************************************/
void SCSICMD_StartStopUnit(void)
{
#if 1
    if (0)//(EpBuf[19] & 0x01) == 0x01)
    {
        BuildSenseData(SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ADSENSE_ILLEGAL_COMMAND, 0);
        CSWHandler(CASE11, (UINT16)pCBW->dCBWDataTransferLength);  //允许移除设备
    }
    else
    {
        BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);
        CSWHandler(CASE1, (UINT16)pCBW->dCBWDataTransferLength);  //允许移除设备
    }
#endif
    SendCSW();
}

/***************************************************************************
命令:写缓冲0x2a
***************************************************************************/
void SCSICMD_Write10(void)
{
    MSC_STATUS     MediaStatus;
    UsbBlkIoCtrl(pCBW->bCBWLUN , MSC_IOCTL_CHECK_STATUS, &MediaStatus);

    if (SCSI_MediaReady == 0 || MediaStatus == MSC_STATUS_NO_MEDIA)
    {
        BuildSenseData(SCSI_SENSE_NOT_READY, SCSI_ADSENSE_NO_MEDIA_IN_DEVICE, 0);
        CSWHandler(CASECBW, 0);
        SendCSW();
        return;
    }

    CSWHandler(CASE12, (UINT16)(pCBW->dCBWDataTransferLength));
    BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);

#if (USB_WRITE_BUF_EN)
    pBulkOutDataBuff = UsbBlkBulkOut(pCBW->bCBWLUN, pCBW->LBA, pCBW->Len);
    UsbReadyToReadDataEP(pBulkOutDataBuff);
    dCSWDataResidueVal  = (pCBW->Len) * 512;
    SCSI_BulkOutDataLen = 0;
    //printf("write ep1 \n");
#else
    SCSI_BulkOutDataLen = 0;
    dCSWDataResidueVal  = (pCBW->Len) * 512;
    pBulkOutDataBuff    = Out_buf;
    UsbReadyToReadDataEP(pBulkOutDataBuff);
#endif
}
/***************************************************************************
命令:校对0x2f
***************************************************************************/
void SCSICMD_Verify10(void)
{
    if ((pCBW->dCBWDataTransferLength) == 0)
    {
        CSWHandler(CASE1, 0);
        BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);
        SendCSW();
        G_ucBulkStausPhase = K_CommandPhase;
    }
    else
    {
        CSWHandler(CASE12, (UINT16)pCBW->dCBWDataTransferLength);
        BuildSenseData(SCSI_SENSE_NO_SENSE, 0, 0);
        G_ucBulkPhase = K_OutDataPhase;
    }
}

/***************************************************************************
命令:0x5a
***************************************************************************/
void SCSICMD_ModeSense10(void)
{
    UINT16 len;

    len = pCBW->dCBWDataTransferLength;
    CSWHandler(CASEOK, len);
    UsbWriteDataEP(len, (UINT8*)(&SCSIDATA_Sense));
    SendCSW();//2007-10-12 16:59
}



/****************************************************************/
//PHILIP DM 相关部分.
/****************************************************************/
extern void ISystemRockUsb(void);

/***************************************************************************
命令:读缓冲0x28 ,
080512,huangsl,用于扩展的 MSC命令.
***************************************************************************/

typedef PACKED struct _CBWCB
{

    uint32 Signature;
    uint32 Tag;
    uint32 XferLen;
    uint8 Flags;
    uint8 LUN;
    uint8 CBWLen;

    //CBWCB
    uint8 cbCode;
    uint8 cbLun;
    uint32 LBA;
    uint32 cbLen;
    uint8 Reseved0[2+4];
} CBWCB, *PCBWCB;

void SCSICMD_Read12(void)
{
    UINT16  len;
    INT32U  version[3];
    PCBWCB  pCbwCb = (PCBWCB)pCBW;

    if (pCbwCb->cbLun == 0XE0)
    {
        if (pCbwCb->LBA == 0XFFFFFFFF)   //GET VERSION.
        {
            if (pCbwCb->cbLen == 12)
            {
                version[0] = RkLdGetVersion();
                version[0] = ((version[0] << 8) & 0x00ff0000)
                             | (version[0] & 0x000000ff);

                version[1] = (gpSwVersion->RkKnlMajor << 16) | gpSwVersion->RkKnlMinor;
                version[2] = (gpDvlpVersion->VerMajor << 16) | gpDvlpVersion->VerMinor;


                CSWHandler(CASEOK, 12);
                UsbWriteDataEP(12, (UINT8*)version);
                SendCSW();
                return ;
            }
        }
        else if (pCbwCb->LBA == 0XFFFFFFFE)    //SWITCH ROCK USB
        {
            if (pCbwCb->cbLen == 0)
            {
                CSWHandler(CASEOK, 0);
                SendCSW();
                DelayMs_nops(10);
                ISystemRockUsb();
                return;
            }
        }
        else if (pCbwCb->LBA == 0XFFFFFFFD)    //CHECK os USB,RO LOADER USB. OS:RETURN 0, LOADER:RETURN 1.
        {
            if (pCbwCb->cbLen == 1)
            {
                INT8U       systemUSb = 0;
                CSWHandler(CASEOK, 1);
                UsbWriteDataEP(1, (UINT8*)&systemUSb);
                SendCSW();
                return ;
            }
        }
        else if (pCbwCb->LBA == 0XFFFFFFFC)    //080524,huangsl , SWITCH TO OPEN SYSTEMDISK
        {
            if (pCbwCb->cbLen == 0)
            {
                CSWHandler(CASEOK, 0);
                SendCSW();//2007-10-12 16:58
                DelayMs_nops(20);
                ISystemReboot(3);
            }
        }
    }

    CSWHandler(CASEOK, 0);
    SendCSW();//2007-10-12 16:58
    return;

}