sdcmd.c

NIOS II 的几个源代码

#include <stdio.h>
#include <sys/unistd.h>
#include <io.h>
#include <string.h>

#include "system.h"
#include "alt_types.h"
#include "altera_avalon_pio_regs.h"

#include "sdconfig.h"
#include "sdhal.h"
#include "sdcrc.h"
#include "sdcmd.h"
#include "sddriver.h"

//向卡发送命令,并取得响应
INT8U SD_SendCmd(INT8U cmd, INT8U *param, INT8U resptype, INT8U *resp)
{
	INT32 i,rlen;
	INT8U tmp;
    
	SPI_CS_Assert();
   
  SPI_RW_Byte((cmd & 0x3F) | 0x40);	
    
  for (i = 3; i >= 0; i--)
    SPI_RW_Byte(param[i]);	

#if SD_CRC_EN
	tmp = SD_GetCmdByte6((cmd & 0x3F) | 0x40, param);
	SPI_RW_Byte(tmp);
#else
  SPI_RW_Byte(0x95);	
#endif 
    
  rlen = 0;
  switch (resptype)	
  {	
  	case R1:
   	case R1B: rlen = 1;  break;
       		 
    case R2:  rlen = 2;	 break;
       		 
   	case R3:  rlen = 5;	 break;
       		 
    default:  SPI_RW_Byte(0xFF);	
      		    SPI_CS_Deassert();						 
        	    return SD_ERR_CMD_RESPTYPE;
    		      break;
  }
    
  i = 0;				
  do 	
  {	
    tmp = SPI_RW_Byte(0xff);
    i++;
  }while (((tmp & 0x80) != 0) && (i < SD_CMD_TIMEOUT));
    
  if (i >= SD_CMD_TIMEOUT)
  {												 
    SPI_CS_Deassert();
    return SD_ERR_CMD_TIMEOUT;
  }
    
  for (i = rlen - 1; i >= 0; i--)
  {
    resp[i] = tmp;
    tmp = SPI_RW_Byte(0xff);
  }
      
  SPI_CS_Deassert();
  return SD_NO_ERR;
}

//将32位的参数转为字节形式	
void SD_PackParam(INT8U *parameter, INT32U value)
{
  parameter[3] = (INT8U)(value >> 24);
  parameter[2] = (INT8U)(value >> 16);
  parameter[1] = (INT8U)(value >> 8);
  parameter[0] = (INT8U)(value);
}

//块命令
INT8U SD_BlockCommand(INT8U cmd, INT8U resptype, INT32U parameter)
{
	INT8U param[4],resp,ret;
	
	parameter <<= SD_BLOCKSIZE_NBITS;

	SD_PackParam(param, parameter);

	ret = SD_SendCmd(cmd, param, resptype, &resp);
	if (ret != SD_NO_ERR)
	  return ret;
	
	if (resp != 0)
		return SD_ERR_CMD_RESP;
		 
	return SD_NO_ERR;
}

//复位SD卡
INT8U SD_ResetSD(void)
{
	INT8U param[4] = {0,0,0,0},resp;
	
  return (SD_SendCmd(CMD0, param, CMD0_R, &resp));
}

//读SD卡的CSD寄存器
INT8U SD_ReadCSD(INT8U csdlen, INT8U *recbuf)
{
  INT8U param[4] = {0,0,0,0},resp,ret;
  
  ret = SD_SendCmd(CMD9, param, CMD9_R, &resp);
  if (ret != SD_NO_ERR) 									
    return ret;									
  
  if (resp != 0)
    return SD_ERR_CMD_RESP;
    
	return (SD_ReadRegister(csdlen, recbuf));
}

//读SD卡的CID寄存器
#if SD_ReadCID_EN
INT8U SD_ReadCID(INT8U cidlen, INT8U *recbuf)
{
  INT8U param[4] = {0,0,0,0},resp,ret;
 
  ret = SD_SendCmd(CMD10, param, CMD10_R, &resp);
  if ( ret != SD_NO_ERR)
   	return ret;			  									
   
  if (resp != 0)
    return SD_ERR_CMD_RESP;
      
  return (SD_ReadRegister(cidlen, recbuf));
}
#endif

//停止数据传输
INT8U SD_StopTransmission(void)
{
	INT8U param[4] = {0,0,0,0},resp;
	
 	return (SD_SendCmd(CMD12, param, CMD12_R, &resp));
}

//读SD卡的 Card Status 寄存器
INT8U SD_ReadCard_Status(INT8U len, INT8U *buffer)
{
  INT8U param[4] = {0,0,0,0};

  return (SD_SendCmd(CMD13, param, CMD13_R, buffer));
}

//设置一个块的长度
INT8U SD_SetBlockLen(INT32U length)
{
	INT8U param[4],resp,ret;
  
  SD_PackParam(param, length);
          												
  ret = SD_SendCmd(CMD16, param, CMD16_R, &resp);
  if (ret != SD_NO_ERR)
 		return ret;	
	
	if (resp != 0)
    return SD_ERR_CMD_RESP;
    
    return SD_NO_ERR;
}

//读单块命令
INT8U SD_ReadSingleBlock(INT32U blockaddr)
{
	return (SD_BlockCommand(CMD17, CMD17_R, blockaddr));
}

//读多块命令
INT8U SD_ReadMultipleBlock(INT32U blockaddr)
{
	return (SD_BlockCommand(CMD18, CMD18_R, blockaddr));
}

//写单块命令
INT8U SD_WriteSingleBlock(INT32U blockaddr)
{
	return (SD_BlockCommand(CMD24, CMD24_R, blockaddr));
}

//写多块命令
INT8U SD_WriteMultipleBlock(INT32U blockaddr)
{
	return (SD_BlockCommand(CMD25, CMD25_R, blockaddr));
}

//写CSD寄存器
#if SD_ProgramCSD_EN
INT8U SD_ProgramCSD(INT8U len, INT8U *buff)
{
	INT8U param[4] = {0,0,0,0},resp,ret;
	
	if (len != 16) return SD_ERR_USER_PARAM;

	ret = SD_SendCmd(CMD27, param, CMD27_R, &resp);
	if (ret != SD_NO_ERR)
		return ret;
		        
  if (resp != 0)    
    return SD_ERR_CMD_RESP;
		
	buff[15] = (SD_GetCRC7(buff, 15) << 1) + 0x01; 
		
	return(SD_WriteBlockData(0, 16, buff));
}

//计算CRC7
INT8U SD_GetCRC7(INT8U *pSource, INT16U len)
{
	INT8U i = 0, j;
	INT8U reg = 0;
	
	do
	{
	  for (j = 0; j < 8; j++)
	  {
			reg <<= 1;
			reg ^= ((((pSource[i] << j) ^ reg) & 0x80) ? 0x9 : 0);
	  }
	  i++;
	    
	}while(i < len);
	
	return reg;
}	
#endif	

#if SD_EraseBlock_EN
//设置块擦除起始地址
INT8U SD_EraseStartBlock(INT32U startblock)
{
	return (SD_BlockCommand(CMD32, CMD32_R, startblock));	
}

//设置块擦除终止地址
INT8U SD_EraseEndBlock(INT32U endblock)
{
	return (SD_BlockCommand(CMD33, CMD33_R, endblock));
}

//擦除已选中的块
INT8U SD_EraseSelectedBlock(void)
{
	INT8U param[4],resp,tmp;
	
	SD_PackParam(param, 0);
	
	tmp = SD_SendCmd(CMD38, param, CMD38_R, &resp);
	if (tmp != SD_NO_ERR)
		return tmp;							 	
	
	if (SD_WaitBusy(SD_WAIT_ERASE) != SD_NO_ERR)
		return SD_ERR_TIMEOUT_ERASE;
	else
		return SD_NO_ERR;									
}	
#endif

//读操作条件寄存器OCR
INT8U SD_ReadOCR(INT8U ocrlen, INT8U *recbuf)
{
    INT8U param[4] = {0,0,0,0},resp[5],tmp;

    tmp = SD_SendCmd(CMD58, param, CMD58_R, resp);
    if (tmp != SD_NO_ERR)
    	return tmp;		 										
    												
    if (resp[0] != 0)
        return SD_ERR_CMD_RESP;	
    
    for (tmp = 0; tmp < 4; tmp++)
    	recbuf[tmp] = resp[tmp + 1];
    
    return SD_NO_ERR;
}

//使能SD卡的CRC校验功能
#if SD_CRC_EN
INT8U SD_EnableCRC(INT8U bEnable)
{
	INT8U param[4],resp,ret;
		
	if (bEnable == 1)
		param[0] = 1;	
	else
		param[1] = 0; 

	ret = SD_SendCmd(CMD59, param, CMD59_R, &resp);	
	if (ret != SD_NO_ERR)
    return ret;							 
    
  if (resp != 0)    
    return SD_ERR_CMD_RESP;	
 	
	return SD_NO_ERR;
}
#endif

//读SD卡的 SD_Status 寄存器
#if SD_ReadSD_Status_EN
INT8U SD_ReadSD_Status(INT8U sdslen, INT8U *recbuf)
{
  INT8U param[4] = {0,0,0,0},resp[2],ret;
    
  ret = SD_SendCmd(CMD55, param, CMD55_R, resp);
  if (ret != SD_NO_ERR)
  	return ret;	
    												 
  if (resp[0] != 0)
    return SD_ERR_CMD_RESP;
    
  ret = SD_SendCmd(ACMD13, param, ACMD13_R, resp);
  if (ret != SD_NO_ERR)
  	return ret;	
   												
  if ((resp[0] != 0) || (resp[1] != 0))
    return SD_ERR_CMD_RESP;	
        
	return (SD_ReadBlockData(sdslen, recbuf));
}
#endif

//读SD卡的 SCR 寄存器
#if SD_ReadSCR_EN
INT8U SD_ReadSCR(INT8U scrlen, INT8U *recbuf)
{
  INT8U param[4] = {0,0,0,0},resp,ret;
    
  ret = SD_SendCmd(CMD55, param, CMD55_R, &resp);
  if (ret != SD_NO_ERR)
  	return ret;													
    												 
  if (resp != 0)
    return SD_ERR_CMD_RESP;
    
  ret = SD_SendCmd(ACMD51, param, ACMD51_R, &resp); 
  if (ret != SD_NO_ERR)
  	return ret;													
				    															
  if (resp != 0)
    return SD_ERR_CMD_RESP;
        
	return (SD_ReadBlockData(scrlen, recbuf));
}
#endif

//得到正确写入的块数
#if SD_WriteMultiBlock_EN
INT8U SD_GetNumWRBlcoks(INT32U *blocknum)
{
  INT8U tmp[4] = {0,0,0,0},resp,ret;
  
  ret = SD_SendCmd(CMD55, tmp, CMD55_R, &resp);	 
  if (ret != SD_NO_ERR)
  	return ret;
    	 
  if (resp != 0)
  	return SD_ERR_CMD_RESP;    	
 											
  ret = SD_SendCmd(ACMD22, tmp, ACMD22_R, &resp);
  if (ret != SD_NO_ERR)
  	return ret;											    
   		 														
	if (resp != 0)
  	return SD_ERR_CMD_RESP;
    		
  ret = SD_ReadBlockData(4, tmp);
  if (ret != SD_NO_ERR)
  	return ret;
    	
  *blocknum = (tmp[0] << 24) + (tmp[1] << 16) + (tmp[2] << 8) + tmp[3];	
 
	return SD_NO_ERR;
}
#endif

//从SD卡读取数据
INT8U SD_ReadRegister(INT32U len, INT8U *recbuf)
{	
	INT32U i = 0;
	INT8U resp;

  SPI_CS_Assert();
  do{ 
    resp = SPI_RW_Byte(0xff);
    i++;
  }while((resp == 0xFF) && (i < SD_READREG_TIMEOUT));    
    
  if (i >= SD_READREG_TIMEOUT)
  {
   	SPI_CS_Deassert();
   	return SD_ERR_TIMEOUT_READ;	
  }
  	
  if (resp != SD_TOK_READ_STARTBLOCK)				
  {	
		recbuf[0] = resp;							
		i = 1;
  }
  else
  	i = 0;
   	  	
  for (; i < len; i++)
  	recbuf[i] = SPI_RW_Byte(0xff);
   		
  i = SPI_RW_Byte(0xff);								
  i = (i << 8) + SPI_RW_Byte(0xff);

#if SD_CRC_EN 
 	if (i != SD_GetCRC16(recbuf, len))
 	{	
 		SPI_CS_Deassert();
 		SPI_RW_Byte(0xFF);    						
 		return SD_ERR_DATA_CRC16;	
 	}    
#endif   
  
  SPI_RW_Byte(0xFF);
  SPI_CS_Deassert();	
    	
	return SD_NO_ERR;
}	

//从SD卡中读取数据块
INT8U SD_ReadBlockData(INT32U len, INT8U *recbuf)
{
  INT8U tmp;
  INT32U i = 0;
    
  SPI_CS_Assert();    
  do
  { 
    tmp = SPI_RW_Byte(0xff);
    i++;
   }while((tmp == 0xFF) && (i < sds.timeout_read));
	
	if (i >= sds.timeout_read)
	{
		SPI_CS_Deassert();
    return SD_ERR_TIMEOUT_READ;
	}
		
	if (tmp != SD_TOK_READ_STARTBLOCK)
	{
		SPI_RW_Byte(0xFF);
		SPI_CS_Deassert();
		return SD_ERR_DATA_START_TOK;
	}
	
	for (i = 0; i < len; i++)
   	recbuf[i] = SPI_RW_Byte(0xff);

  i = SPI_RW_Byte(0xff);								
  i = (i << 8) + SPI_RW_Byte(0xff); 

#if SD_CRC_EN 
 	if (i != SD_GetCRC16(recbuf, len))
 	{	
 		SPI_RW_Byte(0xFF); 
 		SPI_CS_Deassert();  						
		return SD_ERR_DATA_CRC16;
	}    
#endif   

	SPI_RW_Byte(0xFF); 
	SPI_CS_Deassert();

  return SD_NO_ERR;	
}

//向sd卡写数据块
INT8U SD_WriteBlockData(INT8U bmulti, INT32U len, INT8U *sendbuf)
{
	INT16U i;
	INT8U tmp;

	SPI_CS_Assert();
		
  SPI_RW_Byte(0xFF);
    
  if (bmulti == 1)
    SPI_RW_Byte(SD_TOK_WRITE_STARTBLOCK_M);
	else
		SPI_RW_Byte(SD_TOK_WRITE_STARTBLOCK);

	for (i = 0; i < len; i++)
    SPI_RW_Byte(sendbuf[i]);

#if SD_CRC_EN	
	i = SD_GetCRC16(sendbuf,len);	
#endif

	SPI_RW_Byte((i >> 8) & 0xFF);
	SPI_RW_Byte(i & 0xFF);
			    
	tmp = SPI_RW_Byte(0xff);
  if ((tmp & SD_RESP_DATA_MSK) != SD_RESP_DATA_ACCETPTED)	
  {		
  	SPI_RW_Byte(0xFF);
  	SPI_CS_Deassert();
  	return SD_ERR_DATA_RESP;
  }
        
  SPI_CS_Deassert();
     		
  if (SD_WaitBusy(SD_WAIT_WRITE) != SD_NO_ERR)			
  	return SD_ERR_TIMEOUT_WRITE;
  else
  	return SD_NO_ERR; 
 }

//发送多块写停止令牌
void SD_StopMultiToken(void)
{
	SPI_CS_Assert();
	
	SPI_RW_Byte(0xFF);
	SPI_RW_Byte(SD_TOK_STOP_MULTI);
	SPI_RW_Byte(0xff);
	
  SPI_CS_Deassert();
}

//查询SD卡是否处于忙状态
INT8U SD_WaitBusy(INT8U waittype)
{
  INT32U timeout, i = 0;
  INT8U tmp;
    
  if (waittype == SD_WAIT_WRITE)
  	timeout = sds.timeout_write;
  else
  	timeout = sds.timeout_erase;

	SPI_CS_Assert();
  do
  {
    tmp = SPI_RW_Byte(0xff);
    i++;
  }while ((tmp != 0xFF) && (i < timeout));
	SPI_CS_Deassert();						
	
	if(i < timeout) 
		return SD_NO_ERR;						
	else 
		return SD_ERR_TIMEOUT_WAIT;	
}

//SPI总线延时
void SD_SPIDelay(INT8U value)
{
  INT8U i;

  for (i = 0; i < value; i++)
    SPI_RW_Byte(0xFF);
}