/*******************************************************************************
* Function Name : MAL_GetStatus
* Description : Get status
* Input : None
* Output : None
* Return : None
*******************************************************************************/
uint16_t MAL_GetStatus (uint8_t lun)
{
NAND_IDTypeDef NAND_ID;
if (lun == 0)
{
} 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;
}
}
return MAL_FAIL;
}
/*******************************************************************************
* 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;
}
void rt_init_thread_entry(void* parameter)
{
#ifdef RT_USING_LWIP
/* initialize eth interface */
rt_hw_stm32_eth_init();
#endif
#ifdef RT_USING_COMPONENTS_INIT
/* initialization RT-Thread Components */
rt_components_init();
#endif
rt_platform_init();
/* do some thing here. */
#if defined(RT_USING_DFS) && defined(RT_USING_LWIP) && defined(RT_USING_DFS_NFS)
{
/* NFSv3 Initialization */
rt_kprintf("begin init NFSv3 File System ...\n");
if (dfs_mount(RT_NULL, "/", "nfs", 0, RT_NFS_HOST_EXPORT) == 0)
rt_kprintf("NFSv3 File System initialized!\n");
else
rt_kprintf("NFSv3 File System initialzation failed!\n");
}
#endif
k9f2g08_nand_init();
FSMC_NAND_Init();
FSMC_NAND_ReadID(&NAND_ID);
rt_kprintf("\tMaker = %02x\n", NAND_ID.Maker_ID);
rt_kprintf("\tdevice = %02x\n", NAND_ID.Device_ID);
rt_kprintf("\tThird = %02x\n", NAND_ID.Third_ID);
rt_kprintf("\tFourth = %02x\n", NAND_ID.Fourth_ID);
nand_test();
}
/*******************************************************************************
* 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;
}
/**
* @brief Main program.
* @param None
* @retval : None
*/
int main(void)
{
/* System Clocks Configuration */
RCC_Configuration();
/* PF.06, PF.07 and PF.08 config to drive LD1, LD2 and LD3 *****************/
/* Enable GPIOF clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF, ENABLE);
/* Configure PF.06, PF.07 and PF.08 as Output push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOF, &GPIO_InitStructure);
/* Enable the FSMC Clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* FSMC Initialization */
FSMC_NAND_Init();
/* NAND read ID command */
FSMC_NAND_ReadID(&NAND_ID);
/* Verify the NAND ID */
if((NAND_ID.Maker_ID == NAND_ST_MakerID) && (NAND_ID.Device_ID == NAND_ST_DeviceID))
{
/* NAND memory address to write to */
WriteReadAddr.Zone = 0x00;
WriteReadAddr.Block = 0x00;
WriteReadAddr.Page = 0x00;
/* Erase the NAND first Block */
status = FSMC_NAND_EraseBlock(WriteReadAddr);
/* Write data to FSMC NAND memory */
/* Fill the buffer to send */
Fill_Buffer(TxBuffer, BUFFER_SIZE , 0x66);
status = FSMC_NAND_WriteSmallPage(TxBuffer, WriteReadAddr, PageNumber);
/* Read back the written data */
status = FSMC_NAND_ReadSmallPage (RxBuffer, WriteReadAddr, PageNumber);
/* Verify the written data */
for(j = 0; j < BUFFER_SIZE; j++)
{
if(TxBuffer[j] != RxBuffer[j])
{
WriteReadStatus++;
}
}
if (WriteReadStatus == 0)
{ /* OK */
/* Turn on LD1 */
GPIO_SetBits(GPIOF, GPIO_Pin_6);
}
else
{ /* KO */
/* Turn on LD2 */
GPIO_SetBits(GPIOF, GPIO_Pin_7);
}
}
else
{
/* Turn on LD3 */
GPIO_SetBits(GPIOF, GPIO_Pin_8);
}
while(1)
{
}
}
/*******************************************************************************
* 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;
}
void Task1 (void *pdata)
{
NAND_IDTypeDef NAND_ID;
NAND_ADDRESS WriteReadAddr;
char pStr[64];
u8 nFlag;
__IO uint32_t PageNumber = 2;
pdata = pdata; /* Prevent compiler warning */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
FSMC_NAND_Init();
/* NAND memory address to write to */
WriteReadAddr.Zone = 0x00;
WriteReadAddr.Block = 0x00;
WriteReadAddr.Page = 0x00;
/* Erase the NAND first Block */
status = FSMC_NAND_EraseBlock(WriteReadAddr);
Fill_Buffer(TxBuffer, BUFFER_SIZE , 0x66);
status = FSMC_NAND_WriteSmallPage(TxBuffer, WriteReadAddr, PageNumber);
status = FSMC_NAND_ReadSmallPage (RxBuffer, WriteReadAddr, PageNumber);
for(;;)
{
FSMC_NAND_ReadID(&NAND_ID);
sprintf(pStr, "Nand Flash ID = %02X,%02X,%02X,%02X ",
NAND_ID.Maker_ID, NAND_ID.Device_ID,
NAND_ID.Third_ID, NAND_ID.Fourth_ID);
// UART_Print(pStr);
nFlag = 1;
if ((NAND_ID.Maker_ID == 0xEC) && (NAND_ID.Device_ID == 0xF1)
&& (NAND_ID.Third_ID == 0x80) && (NAND_ID.Fourth_ID == 0x15))
{
// UART_Print("Type = K9F1G08U0A\n\r");
nFlag = 2;
}
else if ((NAND_ID.Maker_ID == 0xEC) && (NAND_ID.Device_ID == 0xF1)
&& (NAND_ID.Third_ID == 0x00) && (NAND_ID.Fourth_ID == 0x95))
{
// UART_Print("Type = K9F1G08U0B\n\r");
nFlag = 3;
}
else if ((NAND_ID.Maker_ID == 0xEC) && (NAND_ID.Device_ID == 0xF1)
&& (NAND_ID.Fourth_ID == 0x15))
{
// UART_Print("Type = K9F1G08U0M\n\r");
nFlag = 6;
}
else if ((NAND_ID.Maker_ID == 0xAD) && (NAND_ID.Device_ID == 0xF1)
&& (NAND_ID.Third_ID == 0x80) && (NAND_ID.Fourth_ID == 0x1D))
{
// UART_Print("Type = HY27UF081G2A\n\r");
nFlag = 4;
}
else
{
// UART_Print("Type = Unknow\n\r");
nFlag = 5;
}
OSTimeDly(500);
}
}
/*******************************************************************************
* 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;
}
