예제 #1
0
DRESULT disk_ioctl (
    BYTE drv,        /* Physical drive number (0..) */
    BYTE ctrl,        /* Control code */
    void *buff        /* Buffer to send/receive control data */
)
{ 
    DRESULT res=RES_PARERR;
   
    switch (drv) {
        case DRV_SDRAM :
        switch (ctrl) { 

            case GET_BLOCK_SIZE:
                *(WORD*)buff = 1;
                res = RES_OK;
                break;
            
            case GET_SECTOR_COUNT :   /* Get number of sectors on the disk (DWORD) */
                //*(DWORD*)buff = (DWORD)(medias[DRV_SDRAM].size);
                if (medias[DRV_SDRAM].blockSize < SECTOR_SIZE_DEFAULT)
                    *(DWORD*)buff = (DWORD)(medias[DRV_SDRAM].size /
                                            (SECTOR_SIZE_DEFAULT /
                                            medias[DRV_SDRAM].blockSize));
                else
                    *(DWORD*)buff = (DWORD)(medias[DRV_SDRAM].size);

                res = RES_OK;
                break; 

            case GET_SECTOR_SIZE :   /* Get sectors on the disk (WORD) */
                //*(WORD*)buff = medias[DRV_SDRAM].blockSize;
                if (medias[DRV_SDRAM].blockSize < SECTOR_SIZE_DEFAULT)
                    *(WORD*)buff = SECTOR_SIZE_DEFAULT;
                else
                    *(WORD*)buff = medias[DRV_SDRAM].blockSize;
                res = RES_OK;
                break; 

            case CTRL_SYNC :   /* Make sure that data has been written */ 
                res = RES_OK; 
                break; 

            default: 
                res = RES_PARERR; 
        }
        break;

        case DRV_MMC :
        switch (ctrl) { 

            case GET_BLOCK_SIZE:
                *(WORD*)buff = 1; 
                res = RES_OK; 
                break; 
            
            case GET_SECTOR_COUNT :   /* Get number of sectors on the disk (DWORD) */ 
                //*(DWORD*)buff = (DWORD)(medias[DRV_MMC].size);
                if (medias[DRV_MMC].blockSize < SECTOR_SIZE_DEFAULT)
                        *(DWORD*)buff = (DWORD)(medias[DRV_MMC].size /
                                                (SECTOR_SIZE_DEFAULT /
                                                medias[DRV_MMC].blockSize));
                else
                    *(DWORD*)buff = (DWORD)(medias[DRV_MMC].size);
                res = RES_OK; 
                break; 

            case GET_SECTOR_SIZE :   /* Get sectors on the disk (WORD) */ 
                //*(WORD*)buff = medias[DRV_MMC].blockSize;
                if (medias[DRV_MMC].blockSize < SECTOR_SIZE_DEFAULT)
                    *(WORD*)buff = SECTOR_SIZE_DEFAULT;
                else
                    *(WORD*)buff = medias[DRV_MMC].blockSize;
                res = RES_OK;
                break;

            case CTRL_SYNC :   /* Make sure that data has been written */ 
                res = RES_OK; 
                break; 

            default: 
                res = RES_PARERR; 
        }
        break;

        case DRV_NAND :
            switch (ctrl) { 

                case GET_BLOCK_SIZE:
                    *(WORD*)buff = 1; 
                    res = RES_OK; 
                    break; 

                case GET_SECTOR_COUNT :   /* Get number of sectors on the disk (DWORD) */ 
                    if (medias[DRV_NAND].blockSize < SECTOR_SIZE_DEFAULT)
                        *(DWORD*)buff = (DWORD)(medias[DRV_NAND].size /
                                                (SECTOR_SIZE_DEFAULT /
                                                medias[DRV_NAND].blockSize));
                    else
                        *(DWORD*)buff = (DWORD)(medias[DRV_NAND].size);
                    res = RES_OK;
                    break; 

                case GET_SECTOR_SIZE :	 /* Get sectors on the disk (WORD) */ 
                    //*(WORD*)buff = medias[DRV_MMC].blockSize;
                    if (medias[DRV_NAND].blockSize < SECTOR_SIZE_DEFAULT)
                        *(WORD*)buff = SECTOR_SIZE_DEFAULT;
                    else
                        *(WORD*)buff = medias[DRV_NAND].blockSize;
                    res = RES_OK;
                    break;

                case CTRL_SYNC :   /* Make sure that data has been written */ 
                    MED_Flush(&medias[DRV_NAND]);
                    res = RES_OK; 
                    break; 

                default: 
                    res = RES_PARERR; 
        }

    } 

   return res; 
}
예제 #2
0
//------------------------------------------------------------------------------
//! \brief  Processes a SBC command by dispatching it to a subfunction.
//! \param  lun          Pointer to the affected LUN
//! \param  commandState Pointer to the current command state
//! \return Operation result code
//------------------------------------------------------------------------------
unsigned char SBC_ProcessCommand(MSDLun               *lun,
                                 MSDCommandState *commandState)
{
    unsigned char result = MSDD_STATUS_INCOMPLETE;
    SBCCommand *command = (SBCCommand *) commandState->cbw.pCommand;

    // Identify command
    switch (command->bOperationCode) {
    //---------------
    case SBC_READ_10:
    //---------------
        TRACE_INFO_WP("Read(10) ");

        // Perform the Read10 command
        result = SBC_Read10(lun, commandState);
        break;

    //----------------
    case SBC_WRITE_10:
    //----------------
        TRACE_INFO_WP("Write(10) ");

        // Perform the Write10 command
        result = SBC_Write10(lun, commandState);
        break;

    //---------------------
    case SBC_READ_CAPACITY_10:
    //---------------------
        TRACE_INFO_WP("RdCapacity(10) ");

        // Perform the ReadCapacity command
        result = SBC_ReadCapacity10(lun, commandState);
        break;

    //---------------------
    case SBC_VERIFY_10:
    //---------------------
        TRACE_INFO_WP("Verify(10) ");

        // Flush media
        MED_Flush(lun->media);
        result = MSDD_STATUS_SUCCESS;
        break;

    //---------------
    case SBC_INQUIRY:
    //---------------
        TRACE_INFO_WP("Inquiry ");

        // Process Inquiry command
        result = SBC_Inquiry(lun, commandState);
        break;

    //--------------------
    case SBC_MODE_SENSE_6:
    //--------------------
        TRACE_INFO_WP("ModeSense(6) ");

        // Process ModeSense6 command
        result = SBC_ModeSense6(commandState);
        break;

    //-----------------------
    case SBC_TEST_UNIT_READY:
    //-----------------------
        TRACE_INFO_WP("TstUnitRdy ");

        // Process TestUnitReady command
        //MED_Flush(lun->media);
        result = SBC_TestUnitReady(lun);
        break;

    //---------------------
    case SBC_REQUEST_SENSE:
    //---------------------
        TRACE_INFO_WP("ReqSense ");

        // Perform the RequestSense command
        result = SBC_RequestSense(lun, commandState);
        break;

    //------------------------------------
    case SBC_PREVENT_ALLOW_MEDIUM_REMOVAL:
    //------------------------------------
        TRACE_INFO_WP("PrevAllowRem ");

        // Nothing to do
        result = MSDD_STATUS_SUCCESS;
        break;

    //------
    default:
    //------
        result = MSDD_STATUS_PARAMETER;
    }

    return result;
}