Exemple #1
0
//            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;
//            Mass_Memory_Size[0] = Mass_Block_Count[0] * Mass_Block_Size[0];
//            LED1 = 0;
//            if (dis_mem == 0)   //显示TF卡的容量  由于是周期性更新状态,所以,加了条件,只显示一次容量值
//            {
//                printf("\r\n Micro SD卡的容量是 %d MBytes\n" ,SDCardInfo.CardCapacity);
//                dis_mem = 1;
//            }
//            return MAL_OK;
//        }
//    }
//    LED1 = 0;
//    return MAL_FAIL;
//}
u16 MAL_GetStatus (u8 lun)
{
    uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;
    switch (lun)
    {
    case 0:
        if (dis_mem == 0)   //显示TF卡的容量  由于是周期性更新状态,所以,加了条件,只显示一次容量值
        {
            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;
                Mass_Memory_Size[0] = Mass_Block_Count[0] * Mass_Block_Size[0];
                LED1 = 0;
                //                    if (dis_mem == 0)   //显示TF卡的容量  由于是周期性更新状态,所以,加了条件,只显示一次容量值
                //                    {
                printf("\r\n Micro SD卡的容量是 %lld MBytes\n" , SDCardInfo.CardCapacity >> 20);
                dis_mem = 1;
                //                    }
                return MAL_OK;
            }
            dis_mem = 1;
        }
        return MAL_OK;
    case 1:
        return MAL_OK;
    case 2:
        return MAL_FAIL;
    default:
        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;
	uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;


  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)
      {
        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;
      }	      

      Mass_Memory_Size[0] = Mass_Block_Count[0] * Mass_Block_Size[0];
      return MAL_OK;

    }
  }
//  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;
}
Exemple #3
0
/*******************************************************************************
* Function Name  : MAL_GetStatus
* Description    : Get status
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
uint16_t MAL_GetStatus (uint8_t lun)
{
  ;
  uint32_t DeviceSizeMul = 0, NumberOfBlocks = 0;


  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)
      {
        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;
      Mass_Memory_Size[0] = Mass_Block_Count[0] * Mass_Block_Size[0];
      GPIO_SetBits(USB_LED_PORT, GPIO_Pin_7);
      
      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;
      }      
      return MAL_OK;  
    }    
  }
  else
  {
    return MAL_OK;
  }
  GPIO_ResetBits(USB_LED_PORT, GPIO_Pin_7);
  return MAL_FAIL;
}
Exemple #4
0
/*******************************************************************************
* 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:
#ifdef USE_STM3210E_EVAL
      Status = SD_Init();
      Status = SD_GetCardInfo(&SDCardInfo);
      Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
      Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
      Status = SD_SetDeviceMode(SD_DMA_MODE);
#else
      MSD_Init();
#endif
      break;
#ifdef USE_FSMC_NAND
      case 1:
      status = NAND_Init();
      break;
#endif
    default:
      return MAL_FAIL;
  }
  return status;
}
Exemple #5
0
void SDCard_Configuration(void)
{
	int i;
	for( i=0;i<109500;i++);//延时等待电容充电5760,21900//为保证多一点的板子同时脸上的时候有效就设定的大一点21900*5
	/*-------------------------- SD Init ----------------------------- */
	Status = SD_Init();
	//disk_initialize(0);//选择磁盘,这句包括上面的SD_Init();所以只需要这一次
	if (Status == SD_OK)
	{
		/*----------------- Read CSD/CID MSD registers ------------------*/
		Status = SD_GetCardInfo(&SDCardInfo); 
		/*----------------- Select Card --------------------------------*/
		Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
		/* Set Device Transfer Mode to 4b */
		Status = SD_EnableWideBusOperation(SDIO_BusWide_1b);
		/* Set Device Transfer Mode to DMA */
		Status = SD_SetDeviceMode(SD_DMA_MODE);
		//Status = SD_SetDeviceMode(SD_POLLING_MODE);
		//Status = SD_SetDeviceMode(SD_INTERRUPT_MODE);
	}
	res = f_mount(0,&fs);
	if(res==FR_OK)
		printf("\n\rFile system mounted.\n\r");
	else printf("Error mounting file system.\n\r");
}
Exemple #6
0
/*******************************************************************************
* 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((uint32_t) (SDCardInfo.RCA << 16));
        Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
        Status = SD_SetDeviceMode(SD_DMA_MODE);
        if (Status == SD_OK)
        {
            // 从地址0开始读取512字节
            Status = SD_ReadBlock(Buffer_Block_Rx, 0x00,  BlockSize);
        }
        if (Status == SD_OK)
        {
            // 返回成功的话,串口输出SD卡测试成功信息
						DbgPrintf(" \n SD SDIO-4bit模式 TF OK");
        }
        break;
    default:
        return MAL_FAIL;
    }
    return status;
}
Exemple #7
0
/* 注意:從函數的代碼上來看,所謂的drv這個參數,是用一個數字來代表文件硬件的類型,從其switch語句看
   drv = ATA = 0:表示是IDE硬盤的一種接口
   drv = MMC = 1: 表示的是MMC卡的接口,也就是SD卡
   drv = USB = 2: 表示的是USB存儲設備的接口
   從這裡看來,我們應該要選擇的是MMC接口,輸入參數必須為1*/
DSTATUS disk_initialize (
	BYTE drv				/* Physical drive nmuber (0..) */
)
{	
  SD_Error Status;
  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((u32) (SDCardInfo.RCA << 16));
  }

  if (Status == SD_OK)
  {
    Status = SD_EnableWideBusOperation(SDIO_BusWide_1b);
  }

  /* Set Device Transfer Mode to DMA [設置傳輸模式為DMA方式]*/
  if (Status == SD_OK)
  {  
    Status = SD_SetDeviceMode(SD_INTERRUPT_MODE);
  }
  if(Status == SD_OK)return 0;
  else return STA_NOINIT;
}
Exemple #8
0
/*******************************************************************************
* 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:
#ifdef USE_STM3210E_EVAL
      Status = SD_Init();
      Status = SD_GetCardInfo(&SDCardInfo);
      Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
      Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
      Status = SD_SetDeviceMode(SD_DMA_MODE);
	  if (Status == SD_OK)
  {	 
     
	  
      //Status = SD_ReadMultiBlocks(0x00, Buffer_MultiBlock_Rx, BlockSize, NumberOfBlocks1);	
	 // printf("\r\nSD SDIO-4bit模式 测试TF卡读写成功! \n ");
	 
  }
  
 
  if (Status == SD_OK)
  {	
    // Read block of 512 bytes from address 0 
    Status = SD_ReadBlock(0x00, Buffer_Block_Rx, BlockSize);   

  }

 
  
  

  if (Status == SD_OK)
  {	 
    // Check the corectness of written dada 
    

	printf("\r\nSD SDIO-4bit模式 测试TF卡读写成功! \n ");
  }  
  
  

#else
      MSD_Init();
#endif
      break;
#ifdef USE_STM3210E_EVAL
    case 1:
	
      status = NAND_Init();
      break;
#endif
    default:
      return MAL_FAIL;
  }
  return status;
}
Exemple #9
0
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;
}
Exemple #11
0
/*******************************************************************************
* 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;
}
Exemple #12
0
//初始化SD卡
//返回值:错误代码;(0,无错误)
SD_Error SD_Init(void)
{
	SD_Error errorstatus=SD_OK;	  
	u8 clkdiv=0;
	//SDIO IO口初始化   	 
	RCC->AHB1ENR|=1<<2;    		//使能PORTC时钟
	RCC->AHB1ENR|=1<<3;    		//使能PORTD时钟 
	RCC->AHB1ENR|=1<<22;		//DMA2时钟使能
	RCC->APB2ENR|=1<<11;		//SDIO时钟使能
	RCC->APB2RSTR|=1<<11;		//SDIO复位
	GPIO_Set(GPIOC,0X1F<<8,GPIO_MODE_AF,GPIO_OTYPE_PP,GPIO_SPEED_50M,GPIO_PUPD_PU);	//PC8,9,10,11,12复用功能输出	
 	GPIO_Set(GPIOD,1<<2,GPIO_MODE_AF,GPIO_OTYPE_PP,GPIO_SPEED_50M,GPIO_PUPD_PU);	//PD2复用功能输出	
  	GPIO_AF_Set(GPIOC,8,12);	//PC8,AF12
 	GPIO_AF_Set(GPIOC,9,12);	//PC9,AF12
 	GPIO_AF_Set(GPIOC,10,12);	//PC10,AF12 
 	GPIO_AF_Set(GPIOC,11,12);	//PC11,AF12 
 	GPIO_AF_Set(GPIOC,12,12);	//PC12,AF12 
 	GPIO_AF_Set(GPIOD,2,12);	//PD2,AF12    
	RCC->APB2RSTR&=~(1<<11);	//SDIO结束复位
 	//SDIO外设寄存器设置为默认值 			   
	SDIO->POWER=0x00000000;
	SDIO->CLKCR=0x00000000;
	SDIO->ARG=0x00000000;
	SDIO->CMD=0x00000000;
	SDIO->DTIMER=0x00000000;
	SDIO->DLEN=0x00000000;
	SDIO->DCTRL=0x00000000;
	SDIO->ICR=0x00C007FF;
	SDIO->MASK=0x00000000;	  
 	MY_NVIC_Init(0,0,SDIO_IRQn,2);		//SDIO中断配置
   	errorstatus=SD_PowerON();			//SD卡上电
 	if(errorstatus==SD_OK)errorstatus=SD_InitializeCards();			//初始化SD卡														  
  	if(errorstatus==SD_OK)errorstatus=SD_GetCardInfo(&SDCardInfo);	//获取卡信息
 	if(errorstatus==SD_OK)errorstatus=SD_SelectDeselect((u32)(SDCardInfo.RCA<<16));//选中SD卡   
   	if(errorstatus==SD_OK)errorstatus=SD_EnableWideBusOperation(1);	//4位宽度,如果是MMC卡,则不能用4位模式 
  	if((errorstatus==SD_OK)||(SDIO_MULTIMEDIA_CARD==CardType))
	{  		    
		if(SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1||SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)
		{
			clkdiv=SDIO_TRANSFER_CLK_DIV+2;	//V1.1/V2.0卡,设置最高48/4=12Mhz
		}else clkdiv=SDIO_TRANSFER_CLK_DIV;	//SDHC等其他卡,设置最高48/2=24Mhz
		SDIO_Clock_Set(clkdiv);	//设置时钟频率,SDIO时钟计算公式:SDIO_CK时钟=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定为48Mhz 
		//errorstatus=SD_SetDeviceMode(SD_DMA_MODE);	//设置为DMA模式
		errorstatus=SD_SetDeviceMode(SD_POLLING_MODE);//设置为查询模式
 	}
	return errorstatus;		 
}
Exemple #13
0
/****************************************************************************
* 名    称:void SD_TEST(void)
* 功    能:SD卡测试函数
* 入口参数:无
* 出口参数:无
* 说    明:
* 调用方法:无 
****************************************************************************/ 
void SD_TEST(void){
	Status = SD_Init();
    Status = SD_GetCardInfo(&SDCardInfo);
    Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
    Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
    Status = SD_SetDeviceMode(SD_DMA_MODE);  
 	if (Status == SD_OK)
  	{
        // 从地址0开始读取512字节  
    	Status = SD_ReadBlock(Buffer_Block_Rx, 0x00,  512); 
  	}
  	if (Status == SD_OK)
    {	 
       // 返回成功的话,串口输出SD卡测试成功信息 
	    USART_OUT(USART1,"\r\nSD SDIO-4bit模式 测试TF卡成功! \n ");
    } 
}
Exemple #14
0
/*******************************************************************************
* 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;
}
Exemple #15
0
/*******************************************************************************
* Function Name  : main
* Description    : Main program.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
int main(void)
{
#ifdef DEBUG
  debug();
#endif
  
  /*
  static uint8_t sector[SECTOR_SIZE];
  static uint8_t transferbuffer[SECTOR_SIZE];
  uint32_t pstart, psize, i;
  uint8_t pactive, ptype;
  VOLINFO vi;
  DIRINFO di;
  FILEINFO fi;
  DIRENT de;
  uint32_t cache;
  */
  
  
  // Clock Config: HSE 72 MHz
  RCC_Configuration();
  
  // Interrupt Config
  NVIC_Configuration();
  
  // USART Config : 115200,8,n,1
  Serial_Init();
  
  /////////////////////////////////////////////////////////////////////
  //////// SDCARD Initialisation //////////////////////////////////////
  /////////////////Section adapted from ST example/////////////////////
  
  /*-------------------------- SD Init ----------------------------- */
  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((u32) (SDCardInfo.RCA << 16));
  }
  
  if (Status == SD_OK)
  {
    //Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
  }
  
  /* Set Device Transfer Mode to DMA */
  if (Status == SD_OK)
  {  
//    Status = SD_SetDeviceMode(SD_DMA_MODE);//oet
 //   Status = SD_SetDeviceMode(SD_POLLING_MODE);
    Status = SD_SetDeviceMode(SD_INTERRUPT_MODE);
  }
  
  
  OutPutFile();
  /////////////////////////////////////////////////////////////////////
  //////// DOSFS Volume Acess /////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////
/*
  if (DFS_ReadSector(0,sector,0,1))
  {
    printf("Cannot read media!\n");
    while(1);
    return -1;
  }

  if ((sector[0x1FE] == 0x55) & (sector[0x1FF] == 0xAA))
  {
    printf("The end of the last read sector contains a FAT or MBR end delimiter\n");
    if ((sector[0x36] == 'F') & (sector[0x37] == 'A') & (sector[0x38] == 'T'))
    {
      printf("Well, this is not a MBR, but a FAT12/16 header!\n");
      pstart = 0;
      pactive = 0x80;
      ptype = 0x06;
      psize = 0xFFFFFFFF;
    }
    else if ((sector[0x52] == 'F') & (sector[0x53] == 'A') & (sector[0x54] == 'T'))
    {
      printf("Well, this is not a MBR, but a FAT32 header!\n");
      pstart = 0;
      pactive = 0x80;
      ptype = 0x06;
      psize = 0xFFFFFFFF;
    }
    else
    {
      pstart = DFS_GetPtnStart(0, sector, 0, &pactive, &ptype, &psize);
      if (pstart == 0xffffffff)
      {
        printf("Cannot find first partition\n");
        return -1;
      }
    }
  }
  
  printf("Partition 0 start sector 0x%-08.8lX active %-02.2hX type %-02.2hX size %-08.8lX\n", pstart, pactive, ptype, psize);
  
  if (DFS_GetVolInfo(0, sector, pstart, &vi))
  {
    printf("Error getting volume information\n");
    return -1;
  }
  
  printf("Volume label '%-11.11s'\n", vi.label);
  printf("%d sector/s per cluster, %d reserved sector/s, volume total %d sectors.\n", vi.secperclus, vi.reservedsecs, vi.numsecs);
  printf("%d sectors per FAT, first FAT at sector #%d, root dir at #%d.\n",vi.secperfat,vi.fat1,vi.rootdir);
  printf("(For FAT32, the root dir is a CLUSTER number, FAT12/16 it is a SECTOR number)\n");
  printf("%d root dir entries, data area commences at sector #%d.\n",vi.rootentries,vi.dataarea);
  printf("%d clusters (%d bytes) in data area, filesystem IDd as ", vi.numclusters, vi.numclusters * vi.secperclus * SECTOR_SIZE);
  if (vi.filesystem == FAT12)
    printf("FAT12.\n");
  else if (vi.filesystem == FAT16)
    printf("FAT16.\n");
  else if (vi.filesystem == FAT32)
    printf("FAT32.\n");
  else
    printf("[unknown]\n");
  
  /////////////////////////////////////////////////////////////////////
  //////// DOSFS File list Acess //////////////////////////////////////
  /////////////////////////////////////////////////////////////////////
  
  // Directory enumeration test
  di.scratch = sector;
  if (DFS_OpenDir(&vi, "", &di)) {
    printf("Error opening root directory\n");
    return -1;
  }
  ////This section is to list a directory "/MYDIR1"
  if (DFS_OpenDir(&vi, "MYDIR1", &di))
    {
    printf("error opening subdirectory\n");
    return -1;
    }
  //
  while (!DFS_GetNext(&vi, &di, &de)) {
    if (de.name[0])
      printf("file: '%-11.11s'\n", de.name);
  }

//------------------------------------------------------------
// File read test

  printf("\n=====Read test\n");
	if (DFS_OpenFile(&vi, "WVO.TXT", DFS_READ, sector, &fi)) {
		printf("error opening file\n");
		return -1;
	}

	DFS_ReadFile(&fi, sector, transferbuffer, &i, 512);
        printf("read complete %d bytes (expected %d) pointer %d\n", i, fi.filelen, fi.pointer);

        printf("%s",transferbuffer);    
             
//------------------------------------------------------------
// File write test
  printf("\n=====Write test\n");

	if (DFS_OpenFile(&vi, "WRTEST.TXT", DFS_WRITE, sector, &fi))
        {
	  printf("error opening file\n");
	  return -1;
        }
	DFS_WriteFile(&fi, sector, transferbuffer, &cache, SECTOR_SIZE/2);


*/
        
  printf("\nLet's loop for infinity, and beyond!\n");
  while (1)
  {}
}
Exemple #16
0
/*******************************************************************************
* 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;
}
Exemple #17
0
/*******************************************************************************
* 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;
}
Exemple #18
0
/*******************************************************************************
* 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;
}
Exemple #19
0
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;  
    }
}
Exemple #20
0
/*******************************************************************************
* 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;
}
Exemple #21
0
/*******************************************************************************
* Function Name  : main.
* Description    : main routine.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
int main(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
#ifdef DEBUG
  debug();
#endif

  Set_System();
  
  
  Serial_Init();
  
  /////////////////////////////////////////////////////////////////////
  //////// SDCARD Initialisation //////////////////////////////////////
  /////////////////Section adapted from ST example/////////////////////
  
  /*-------------------------- SD Init ----------------------------- */
  Status = SD_Init();

  
  if (Status == SD_OK)
  {	
     
	 Status = SD_GetCardInfo(&SDCardInfo);	   
  }
 
  if (Status == SD_OK)
  {	
    /*----------------- Select Card --------------------------------*/
    Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));  
  }

 
  if (Status == SD_OK)
  {  
    Status = SD_SetDeviceMode(SD_DMA_MODE);	 
	//Status = SD_SetDeviceMode(SD_INTERRUPT_MODE);	
	//Status = SD_SetDeviceMode(SD_POLLING_MODE);  
  }
  
  if (Status == SD_OK)
  {	 
     
	  //Status = SD_ReadBlock(0x00, Buffer_Block_Rx, BlockSize);  
	  //Status = SD_WriteBlock(0x00, Buffer_Block_Tx, BlockSize);   
      Status = SD_ReadMultiBlocks(0x00, Buffer_MultiBlock_Rx, BlockSize, NumberOfBlocks);	
	 
  }
  
 
  if (Status == SD_OK)
  {	
    /* Read block of 512 bytes from address 0 */
    Status = SD_ReadBlock(0x00, Buffer_Block_Rx, BlockSize);  
  }

 
  
  if (Status == SD_OK)
  {
    /* Read block of many bytes from address 0 */
    Status = SD_ReadMultiBlocks(0x00, Buffer_MultiBlock_Rx, BlockSize, NumberOfBlocks);	 
  }

  if (Status == SD_OK)
  {	 
    /* Check the corectness of written dada */
    

	printf("\r\nSD SDIO-1bit模式 测试TF卡读写成功! \n ");
  }  


   
  Get_Medium_Characteristics();
  Set_USBClock();
  USB_Interrupts_Config(); 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
  GPIO_Init(GPIOC, &GPIO_InitStructure);
  USB_Init();

  
  
  while (1)
  {	
    //printf("\nTEST OK!\n");
    //if (JoyState() != 0)
    //{
    //  Joystick_Send(JoyState());
    //}
  }
}
Exemple #22
0
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;
}
Exemple #23
0
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;
}