static int check_sdcard(void)
{
unsigned int DeviceSizeMul = 0, NumberOfBlocks = 0;
SD_Error Status;
if (SD_Init() == SD_OK)
{
SD_GetCardInfo(&SDIO_Info);
SD_SelectDeselect((unsigned int) (SDIO_Info.RCA << 16));
DeviceSizeMul = (SDIO_Info.SD_csd.DeviceSizeMul + 2);
if(SDIO_Info.CardType == SDIO_HIGH_CAPACITY_SD_CARD)
{
SDIO_Block_Count = (SDIO_Info.SD_csd.DeviceSize + 1) * 1024;
SDIO_Block_Size = 1;
}
else
{
NumberOfBlocks = ((1 << (SDIO_Info.SD_csd.RdBlockLen)) / 512);
SDIO_Block_Count = ((SDIO_Info.SD_csd.DeviceSize + 1) * (1 << DeviceSizeMul) << (NumberOfBlocks/2));
SDIO_Block_Size = 512;
}
Status = SD_SelectDeselect((unsigned int) (SDIO_Info.RCA << 16));
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
if ( Status != SD_OK )
{
return -1;
}
Status = SD_SetDeviceMode(SD_DMA_MODE);
if ( Status != SD_OK )
{
return -1;
}
SDIO_Memory_Size = SDIO_Block_Count * SDIO_Block_Size;
if( SDIO_Memory_Size >= (2*1024 * 1024 * 1024)) // * 512))
{
return 0; // 卡大于2G
}
else
return -1;
}
return -1;
}
uint16_t MAL_GetStatus (uint8_t lun)
{
uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;
uint64_t dwDevSize; /* nemui */
if (lun == 0)
{
if (SD_Init() == SD_OK)
{
SD_GetCardInfo(&SDCardInfo);
SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
DeviceSizeMul = (SDCardInfo.SD_csd.DeviceSizeMul + 2);
if(SDCardInfo.CardType == SDIO_HIGH_CAPACITY_SD_CARD)
{
/* nemui */
dwDevSize = (uint64_t)(SDCardInfo.SD_csd.DeviceSize + 1) * 512 * 1024;
/* nemui calculate highest LBA */
Mass_Block_Count[0] = (dwDevSize - 1) / 512;
}
else
{
NumberOfBlocks = ((1 << (SDCardInfo.SD_csd.RdBlockLen)) / 512);
Mass_Block_Count[0] = ((SDCardInfo.SD_csd.DeviceSize + 1) * (1 << DeviceSizeMul) << (NumberOfBlocks/2));
}
Mass_Block_Size[0] = 512;
Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
if ( Status != SD_OK )
{
return MAL_FAIL;
}
Mass_Memory_Size[0] = Mass_Block_Count[0] * Mass_Block_Size[0];
return MAL_OK;
}
}
return MAL_FAIL;
}
/* Inidialize a Drive */
DSTATUS disk_initialize (
BYTE drv /* Physical drive nmuber (0..) */
)
{
//printf("Disk init: %x\r\n", drv);
SD_Error Status;
if(drv==0)
{
//FIXME: DMA stuff - fix later...
// NVIC_InitTypeDef NVIC_InitStructure;
// NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
// NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
// NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
// NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
// NVIC_Init(&NVIC_InitStructure);
// NVIC_InitStructure.NVIC_IRQChannel = SD_SDIO_DMA_IRQn;
// NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
// NVIC_Init(&NVIC_InitStructure);
Status = SD_Init();
if(Status != SD_OK)
return STA_NODISK; //assume no disk if initialization failed
else
{
Status = SD_GetCardInfo(&SDCardInfo);
if(Status != SD_OK)
return STA_NOINIT;
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
if(Status != SD_OK)
return STA_NOINIT;
return 0;
}
}
else
return STA_NOINIT;
}
/*******************************************************************************
* Function Name : MAL_Init
* Description : Initializes the Media on the STM32
* Input : None
* Output : None
* Return : None
*******************************************************************************/
uint16_t MAL_Init(uint8_t lun) {
uint16_t status = MAL_OK;
switch (lun) {
case 0:
Status = SD_Init();
Status = SD_GetCardInfo(&SDCardInfo);
Status = SD_SelectDeselect((u32) (SDCardInfo.RCA << 16));
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
Status = SD_SetDeviceMode(SD_DMA_MODE);
break;
case 1:
status = NAND_Init();
break;
default:
return MAL_FAIL;
}
return status;
}
/*******************************************************************************
* Function Name : MAL_GetStatus
* Description : Get status
* Input : None
* Output : None
* Return : None
*******************************************************************************/
uint16_t MAL_GetStatus (uint8_t lun) {
NAND_IDTypeDef NAND_ID;
u32 DeviceSizeMul = 0, NumberOfBlocks = 0;
if (lun == 0) {
if (SD_Init() == SD_OK) {
SD_GetCardInfo(&SDCardInfo);
SD_SelectDeselect((u32) (SDCardInfo.RCA << 16));
DeviceSizeMul = (SDCardInfo.SD_csd.DeviceSizeMul + 2);
if(SDCardInfo.CardType == SDIO_HIGH_CAPACITY_SD_CARD) {
Mass_Block_Count[0] = (SDCardInfo.SD_csd.DeviceSize + 1) * 1024;
} else {
NumberOfBlocks = ((1 << (SDCardInfo.SD_csd.RdBlockLen)) / 512);
Mass_Block_Count[0] = ((SDCardInfo.SD_csd.DeviceSize + 1) * (1 << DeviceSizeMul) << (NumberOfBlocks/2));
}
Mass_Block_Size[0] = 512;
Status = SD_SelectDeselect((u32) (SDCardInfo.RCA << 16));
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
if ( Status != SD_OK ) return MAL_FAIL;
Status = SD_SetDeviceMode(SD_DMA_MODE);
if ( Status != SD_OK ) return MAL_FAIL;
}
} else {
FSMC_NAND_ReadID(&NAND_ID);
if (NAND_ID.Device_ID != 0 ) {
//printf("\r\n Device ID : %02X %02X" ,NAND_ID.Maker_ID,NAND_ID.Device_ID );
/* only one zone is used */
Mass_Block_Count[1] = NAND_ZONE_SIZE * NAND_BLOCK_SIZE * NAND_MAX_ZONE ;
Mass_Block_Size[1] = NAND_PAGE_SIZE;
Mass_Memory_Size[1] = (Mass_Block_Count[1] * Mass_Block_Size[1]);
return MAL_OK;
}
}
return MAL_FAIL;
}
uint8_t BSP_TEST_SDIO(void)
{
uint8_t t_status = 0;
/*-------------------------- SD Init ----------------------------- */
BSP_SDCARD_ENABLE();
Status = SD_Init();
if (Status == SD_OK)
{
/*----------------- Read CSD/CID MSD registers ------------------*/
Status = SD_GetCardInfo(&SDCardInfo);
}
if (Status == SD_OK)
{
/*----------------- Select Card --------------------------------*/
Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
}
if (Status == SD_OK)
{
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
}
/*------------------- Block Erase -------------------------------*/
if (Status == SD_OK)
{
/* Erase NumberOfBlocks Blocks of WRITE_BL_LEN(512 Bytes) */
Status = SD_Erase(0x00, (SDIO_BLOCK_SIZE * SDIO_NB_BLOCK));
}
/* Set Device Transfer Mode to DMA */
if (Status == SD_OK)
{
Status = SD_SetDeviceMode(SD_DMA_MODE);
}
if (Status == SD_OK)
{
Status = SD_ReadMultiBlocks(0x00, Buffer_MultiBlock_Rx, SDIO_BLOCK_SIZE, SDIO_NB_BLOCK);
}
if (Status == SD_OK)
{
t_status = eBuffercmp(Buffer_MultiBlock_Rx, SDIO_MULTIWSIZE);
}
/*------------------- Block Read/Write --------------------------*/
/* Fill the buffer to send */
Fill_Buffer(Buffer_Block_Tx, SDIO_BUFFERW_SIZE, 0xFFFF);
if (Status == SD_OK)
{
/* Write block of 512 bytes on address 0 */
Status = SD_WriteBlock(0x00, Buffer_Block_Tx, SDIO_BLOCK_SIZE);
}
if (Status == SD_OK)
{
/* Read block of 512 bytes from address 0 */
Status = SD_ReadBlock(0x00, Buffer_Block_Rx, SDIO_BLOCK_SIZE);
}
if (Status == SD_OK)
{
/* Check the corectness of written dada */
t_status &= Buffercmp(Buffer_Block_Tx, Buffer_Block_Rx, SDIO_BUFFERW_SIZE);
}
BSP_SDCARD_DISABLE();
return t_status;
}
/*******************************************************************************
* Function Name : MAL_GetStatus
* Description : Get status
* Input : None
* Output : None
* Return : None
*******************************************************************************/
uint16_t MAL_GetStatus (uint8_t lun)
{
#ifdef USE_STM3210E_EVAL
NAND_IDTypeDef NAND_ID;
uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;
#else
SD_CSD SD_csd;
uint32_t DeviceSizeMul = 0;
#endif /* USE_STM3210E_EVAL */
#ifdef USE_STM32L152D_EVAL
uint32_t NumberOfBlocks = 0;
#endif
if (lun == 0)
{
#if defined (USE_STM3210E_EVAL) || defined(USE_STM32L152D_EVAL)
if (SD_Init() == SD_OK)
{
SD_GetCardInfo(&mSDCardInfo);
SD_SelectDeselect((uint32_t) (mSDCardInfo.RCA << 16));
DeviceSizeMul = (mSDCardInfo.SD_csd.DeviceSizeMul + 2);
if(mSDCardInfo.CardType == SDIO_HIGH_CAPACITY_SD_CARD)
{
Mass_Block_Count[0] = (mSDCardInfo.SD_csd.DeviceSize + 1) * 1024;
}
else
{
NumberOfBlocks = ((1 << (mSDCardInfo.SD_csd.RdBlockLen)) / 512);
Mass_Block_Count[0] = ((mSDCardInfo.SD_csd.DeviceSize + 1) * (1 << DeviceSizeMul) << (NumberOfBlocks/2));
}
Mass_Block_Size[0] = 512;
Status = SD_SelectDeselect((uint32_t) (mSDCardInfo.RCA << 16));
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
if ( Status != SD_OK )
{
return MAL_FAIL;
}
#else
uint32_t temp_block_mul = 0;
SD_GetCSDRegister(&SD_csd);
DeviceSizeMul = SD_csd.DeviceSizeMul + 2;
temp_block_mul = (1 << SD_csd.RdBlockLen)/ 512;
Mass_Block_Count[0] = ((SD_csd.DeviceSize + 1) * (1 << (DeviceSizeMul))) * temp_block_mul;
Mass_Block_Size[0] = 512;
Mass_Memory_Size[0] = (Mass_Block_Count[0] * Mass_Block_Size[0]);
#endif /* USE_STM3210E_EVAL */
Mass_Memory_Size[0] = Mass_Block_Count[0] * Mass_Block_Size[0];
LED_On1();
return MAL_OK;
#if defined (USE_STM3210E_EVAL) || defined(USE_STM32L152D_EVAL)
}
#endif /* USE_STM3210E_EVAL */
}
#ifdef USE_STM3210E_EVAL
else
{
FSMC_NAND_ReadID(&NAND_ID);
if (NAND_ID.Device_ID != 0 )
{
/* only one zone is used */
Mass_Block_Count[1] = NAND_ZONE_SIZE * NAND_BLOCK_SIZE * NAND_MAX_ZONE ;
Mass_Block_Size[1] = NAND_PAGE_SIZE;
Mass_Memory_Size[1] = (Mass_Block_Count[1] * Mass_Block_Size[1]);
return MAL_OK;
}
}
#endif /* USE_STM3210E_EVAL */
LED_On1();
return MAL_FAIL;
}
/*******************************************************************************
* Function Name : MAL_GetStatus
* Description : Get status
* Input : None
* Output : None
* Return : None
*******************************************************************************/
uint16_t MAL_GetStatus (uint8_t lun)
{
#ifdef USE_STM3210E_EVAL
uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;
#else
uint32_t temp_block_mul = 0;
sMSD_CSD MSD_csd;
uint32_t DeviceSizeMul = 0;
#endif
#ifdef USE_FSMC_NAND
NAND_IDTypeDef NAND_ID;
#endif
if (lun == 0)
{
#ifdef USE_STM3210E_EVAL
if (SD_Init() == SD_OK)
{
SD_GetCardInfo(&SDCardInfo);
SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
DeviceSizeMul = (SDCardInfo.SD_csd.DeviceSizeMul + 2);
if(SDCardInfo.CardType == SDIO_HIGH_CAPACITY_SD_CARD)
{
Mass_Block_Count[0] = (SDCardInfo.SD_csd.DeviceSize + 1) * 1024;
}
else
{
NumberOfBlocks = ((1 << (SDCardInfo.SD_csd.RdBlockLen)) / 512);
Mass_Block_Count[0] = ((SDCardInfo.SD_csd.DeviceSize + 1) * (1 << DeviceSizeMul) << (NumberOfBlocks/2));
}
Mass_Block_Size[0] = 512;
Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
if ( Status != SD_OK )
{
return MAL_FAIL;
}
Status = SD_SetDeviceMode(SD_DMA_MODE);
if ( Status != SD_OK )
{
return MAL_FAIL;
}
#else
MSD_GetCSDRegister(&MSD_csd);
DeviceSizeMul = MSD_csd.DeviceSizeMul + 2;
temp_block_mul = (1 << MSD_csd.RdBlockLen)/ 512;
Mass_Block_Count[0] = ((MSD_csd.DeviceSize + 1) * (1 << (DeviceSizeMul))) * temp_block_mul;
Mass_Block_Size[0] = 512;
Mass_Memory_Size[0] = (Mass_Block_Count[0] * Mass_Block_Size[0]);
#endif
Mass_Memory_Size[0] = Mass_Block_Count[0] * Mass_Block_Size[0];
GPIO_SetBits(USB_LED_PORT, GPIO_Pin_7);
return MAL_OK;
#ifdef USE_STM3210E_EVAL
}
#endif
}
#ifdef USE_FSMC_NAND
else
{
FSMC_NAND_ReadID(&NAND_ID);
if (NAND_ID.Device_ID != 0 )
{
//only one zone is used
Mass_Block_Count[1] = NAND_ZONE_SIZE * NAND_BLOCK_SIZE * NAND_MAX_ZONE ;
Mass_Block_Size[1] = NAND_PAGE_SIZE;
Mass_Memory_Size[1] = (Mass_Block_Count[1] * Mass_Block_Size[1]);
return MAL_OK;
}
}
#endif
GPIO_ResetBits(USB_LED_PORT, GPIO_Pin_7);
return MAL_FAIL;
}
/*******************************************************************************
* Function Name : MAL_GetStatus
* Description : Get status
* Input : None
* Output : None
* Return : None
*******************************************************************************/
uint16_t MAL_GetStatus (uint8_t lun)
{
#ifdef USE_STM3210E_EVAL
NAND_IDTypeDef NAND_ID;
uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;
#else
uint32_t temp_block_mul = 0;
sMSD_CSD MSD_csd;
uint32_t DeviceSizeMul = 0;
#endif
if (lun == 0)
{
#ifdef USE_STM3210E_EVAL
if (SD_Init() == SD_OK)
{
SD_GetCardInfo(&SDCardInfo);
SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
DeviceSizeMul = (SDCardInfo.SD_csd.DeviceSizeMul + 2);
if(SDCardInfo.CardType == SDIO_HIGH_CAPACITY_SD_CARD)
{
Mass_Block_Count[0] = (SDCardInfo.SD_csd.DeviceSize + 1) * 1024;
}
else
{
NumberOfBlocks = ((1 << (SDCardInfo.SD_csd.RdBlockLen)) / 512);
Mass_Block_Count[0] = ((SDCardInfo.SD_csd.DeviceSize + 1) * (1 << DeviceSizeMul) << (NumberOfBlocks/2));
}
Mass_Block_Size[0] = 512;
Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
if ( Status != SD_OK )
{
return MAL_FAIL;
}
Status = SD_SetDeviceMode(SD_DMA_MODE);
if ( Status != SD_OK )
{
return MAL_FAIL;
}
#else
MSD_GetCSDRegister(&MSD_csd);
DeviceSizeMul = MSD_csd.DeviceSizeMul + 2;
temp_block_mul = (1 << MSD_csd.RdBlockLen)/ 512;
Mass_Block_Count[0] = ((MSD_csd.DeviceSize + 1) * (1 << (DeviceSizeMul))) * temp_block_mul;
Mass_Block_Size[0] = 512;
Mass_Memory_Size[0] = (Mass_Block_Count[0] * Mass_Block_Size[0]);
#endif
Mass_Memory_Size[0] = Mass_Block_Count[0] * Mass_Block_Size[0];
//STM_EVAL_LEDOn(LED2);
if(dis_mem==0){ //显示TF卡的容量 由于是周期性更新状态，所以，加了条件，只显示一次容量值
//printf("\r\n Micro SD卡的容量是 %d MBytes\n" ,Mass_Memory_Size[0]/1024/1024);
dis_mem=1;
}
return MAL_OK;
#ifdef USE_STM3210E_EVAL
}
#endif
}
#ifdef USE_STM3210E_EVAL
else
{
FSMC_NAND_ReadID(&NAND_ID);
if (NAND_ID.Device_ID != 0 )
{
// printf("\r\n Device ID : %02X %02X" ,NAND_ID.Maker_ID,NAND_ID.Device_ID );
/* only one zone is used */
Mass_Block_Count[1] = NAND_ZONE_SIZE * NAND_BLOCK_SIZE * NAND_MAX_ZONE ;
Mass_Block_Size[1] = NAND_PAGE_SIZE;
Mass_Memory_Size[1] = (Mass_Block_Count[1] * Mass_Block_Size[1]);
return MAL_OK;
}
}
#endif
//STM_EVAL_LEDOn(LED2);
return MAL_FAIL;
}
/*******************************************************************************
* Function Name : MAL_GetStatus
* Description : Get status
* Input : None
* Output : None
* Return : None
*******************************************************************************/
uint16_t MAL_GetStatus (uint8_t lun)
{
#ifdef USE_STM3210E_EVAL
NAND_IDTypeDef NAND_ID;
uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;
#else
//uint32_t temp_block_mul = 0;
//SD_CSD SD_csd;
//uint32_t DeviceSizeMul = 0;
#endif /* USE_STM3210E_EVAL */
if (lun == 0)
{
#ifdef USE_STM3210E_EVAL
if (SD_Init() == SD_OK)
{
SD_GetCardInfo(&mSDCardInfo);
SD_SelectDeselect((uint32_t) (mSDCardInfo.RCA << 16));
DeviceSizeMul = (mSDCardInfo.SD_csd.DeviceSizeMul + 2);
if(mSDCardInfo.CardType == SDIO_HIGH_CAPACITY_SD_CARD)
{
Mass_Block_Count[0] = (mSDCardInfo.SD_csd.DeviceSize + 1) * 1024;
}
else
{
NumberOfBlocks = ((1 << (mSDCardInfo.SD_csd.RdBlockLen)) / 512);
Mass_Block_Count[0] = ((mSDCardInfo.SD_csd.DeviceSize + 1) * (1 << DeviceSizeMul) << (NumberOfBlocks/2));
}
Mass_Block_Size[0] = 512;
Status = SD_SelectDeselect((uint32_t) (mSDCardInfo.RCA << 16));
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
if ( Status != SD_OK )
{
return MAL_FAIL;
}
Status = SD_SetDeviceMode(SD_DMA_MODE);
if ( Status != SD_OK )
{
return MAL_FAIL;
}
#else
//SD_GetCSDRegister(&SD_csd);
//DeviceSizeMul = SD_csd.DeviceSizeMul + 2;
//temp_block_mul = (1 << SD_csd.RdBlockLen)/ 512;/* Physical drive number (0) */
while(Sd_Spi_Called_From_USB_MSC){;}
if(disk_ioctl (0, GET_SECTOR_COUNT, &Mass_Block_Count[0]))//Sectors are the same as blocks and 512 bytes long?
return MAL_FAIL;
//Mass_Block_Count[0] = ((SD_csd.DeviceSize + 1) * (1 << (DeviceSizeMul))) * temp_block_mul;
Mass_Block_Size[0] = 512;
#endif /* USE_STM3210E_EVAL */
Mass_Memory_Size[0] = Mass_Block_Count[0] * Mass_Block_Size[0];
#ifdef CRT
GREEN_LED_ON;
#else
STM_EVAL_LEDOn(LED2);
#endif
return MAL_OK;
#ifdef USE_STM3210E_EVAL
}
#endif /* USE_STM3210E_EVAL */
}
#ifdef USE_STM3210E_EVAL
else
{
FSMC_NAND_ReadID(&NAND_ID);
if (NAND_ID.Device_ID != 0 )
{
/* only one zone is used */
Mass_Block_Count[1] = NAND_ZONE_SIZE * NAND_BLOCK_SIZE * NAND_MAX_ZONE ;
Mass_Block_Size[1] = NAND_PAGE_SIZE;
Mass_Memory_Size[1] = (Mass_Block_Count[1] * Mass_Block_Size[1]);
return MAL_OK;
}
}
#endif /* USE_STM3210E_EVAL */
#ifdef CRT
GREEN_LED_OFF;
#else
STM_EVAL_LEDOff(LED2);
#endif
return MAL_FAIL;
}
DSTATUS disk_initialize (
BYTE drv /* Physical drive nmuber (0..) */
)
{
SD_Error Status;
if(drv==0)
{
Status = SD_Init();
// printf("SD Init : %d\r\n",Status);
if(Status != SD_OK)
{
return STA_NOINIT; //其他错误：初始化失败
}
else
{
Status = SD_GetCardInfo(&SDCardInfo); //读sd卡信息
// printf("SD_GetCardInfo : %d\r\n",Status);
if (Status != SD_OK)
{
return STA_NOINIT;//RES_NOTRDY; //报NOT READY错误
}
// Select Card
Status = SD_SelectDeselect((u32) (SDCardInfo.RCA << 16));
if (Status != SD_OK)
{
return STA_NOINIT;//RES_NOTRDY; //报NOT READY错误
}
switch(SD_Mode)
{
case 0: //dma方式
Status = SD_EnableWideBusOperation(SDIO_BusWide_1b);
if (Status != SD_OK)
{
return RES_NOTRDY; //报NOT READY错误
}
Status = SD_SetDeviceMode(SD_DMA_MODE);
if (Status != SD_OK)
{
return RES_NOTRDY; //报NOT READY错误
}
break;
case 1: //中断方式
Status = SD_EnableWideBusOperation(SDIO_BusWide_1b);
if (Status != SD_OK)
{
return RES_NOTRDY; //报NOT READY错误
}
Status = SD_SetDeviceMode(SD_INTERRUPT_MODE);
if (Status != SD_OK)
{
return RES_NOTRDY; //报NOT READY错误
}
break;
default :
return RES_NOTRDY;
}
return 0; //初始化成功
}
}
else//仅支持磁盘0的操作
{
return STA_NOINIT;
}
}
DSTATUS disk_initialize (
BYTE drv /* Physical drive nmuber (0..) */
)
{
SD_CardInfo mSDCardInfo; /* 定义SD卡状态信息结构体 */
uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;
uint16_t Status;
switch(drv)
{
case SD_CARD://SD卡
//SD卡初始化--------------------------------------------------------------------------
Status = SD_Init();
if (Status != SD_OK)
{
fs_printf("SD_Init() fail (%d) : file %s on line %d\r\n", Status, __FILE__, __LINE__);
goto retfail;
}
SD_GetCardInfo(&mSDCardInfo); /* 读取SD卡的信息 */
SD_SelectDeselect((uint32_t) (mSDCardInfo.RCA << 16));
DeviceSizeMul = (mSDCardInfo.SD_csd.DeviceSizeMul + 2);
if (mSDCardInfo.CardType == SDIO_HIGH_CAPACITY_SD_CARD) /* 高容量SD卡 SDHC */
{
Mass_Block_Count = (mSDCardInfo.SD_csd.DeviceSize + 1) * 1024;
}
else /* 普通SD卡, 最大4G */
{
NumberOfBlocks = ((1 << (mSDCardInfo.SD_csd.RdBlockLen)) / 512);
Mass_Block_Count = ((mSDCardInfo.SD_csd.DeviceSize + 1) * (1 << DeviceSizeMul) << (NumberOfBlocks/2));
}
Status = SD_SelectDeselect((uint32_t) (mSDCardInfo.RCA << 16));
Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
if (Status != SD_OK)
{
fs_printf("SD_EnableWideBusOperation(SDIO_BusWide_4b) Fail (%d)\r\n", Status);
goto retfail;
}
Status = SD_SetDeviceMode(SD_DMA_MODE); /* 设置SD卡工作模式为DMA, 其它模式由中断、轮询 */
if (Status != SD_OK)
{
fs_printf("SD_SetDeviceMode(SD_DMA_MODE) Fail (%d)\r\n", Status);
goto retfail;
}
/* 显示容量 */
Mass_Block_Size = 512;
if (mSDCardInfo.CardType == SDIO_HIGH_CAPACITY_SD_CARD) /* 高容量SD卡 SDHC */
{
fs_printf("SDHC Card, Memory Size = %uMB\r\n", Mass_Block_Count / (1024 * 4));
}
else
{
fs_printf("Normal Card, Memory Size = %uMB\r\n", (Mass_Block_Count * Mass_Block_Size) /(1024*1024));
}
//SD卡初始化结束--------------------------------------------------------------------------
break;
case EX_FLASH://外部flash
SPI_Flash_Init();
if(SPI_FLASH_TYPE==W25Q64)FLASH_SECTOR_COUNT=2048*6;//W25Q64
else FLASH_SECTOR_COUNT=2048*2; //其他
break;
default:
goto retfail;
}
return RES_OK;
retfail:
return RES_ERROR;
}
