libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

[BSP] Add RT_DEVICE_CTRL_BLK_GETGEOME command handling in device control of LPC176x bsp

This commit is contained in:
Bernard Xiong 2014-08-27 09:23:32 +08:00
parent 7f45ac18bc
commit a5119d696c
2 changed files with 421 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

705
bsp/lpc176x/drivers/sd.c
View File

@ -5,12 +5,12 @@
#include "sd.h" #include "sd.h"
/* 512 bytes for each sector */ /* 512 bytes for each sector */
#define SD_SECTOR_SIZE 512 #define SD_SECTOR_SIZE 512
/* token for write operation */ /* token for write operation */
#define TOKEN_SINGLE_BLOCK 0xFE #define TOKEN_SINGLE_BLOCK 0xFE
#define TOKEN_MULTI_BLOCK 0xFC #define TOKEN_MULTI_BLOCK 0xFC
#define TOKEN_STOP_TRAN 0xFD #define TOKEN_STOP_TRAN 0xFD
/* Local variables */ /* Local variables */
static uint8_t CardType; static uint8_t CardType;
@ -19,440 +19,511 @@ static struct rt_device sdcard_device;
static struct dfs_partition part; static struct dfs_partition part;
/* Local Function Prototypes */ /* Local Function Prototypes */
static bool LPC17xx_SD_Init (void); static bool LPC17xx_SD_Init(void);
static uint8_t LPC17xx_SD_SendCmd (uint8_t cmd, uint32_t arg); static uint8_t LPC17xx_SD_SendCmd(uint8_t cmd, uint32_t arg);
static bool LPC17xx_SD_ReadSector (uint32_t sector, uint8_t *buff, uint32_t count); static bool LPC17xx_SD_ReadSector(uint32_t sector, uint8_t *buff, uint32_t count);
static bool LPC17xx_SD_ReadDataBlock ( uint8_t *buff, uint32_t cnt); static bool LPC17xx_SD_ReadDataBlock(uint8_t *buff, uint32_t cnt);
static bool LPC17xx_SD_WriteSector (uint32_t sector, const uint8_t *buff, uint32_t count); static bool LPC17xx_SD_WriteSector(uint32_t sector, const uint8_t *buff, uint32_t count);
static bool LPC17xx_SD_WirteDataBlock (const uint8_t *buff, uint8_t token); static bool LPC17xx_SD_WirteDataBlock(const uint8_t *buff, uint8_t token);
static bool LPC17xx_SD_ReadCfg (SDCFG *cfg); static bool LPC17xx_SD_ReadCfg(SDCFG *cfg);
static bool LPC17xx_SD_WaitForReady (void); static bool LPC17xx_SD_WaitForReady(void);
/* wait until the card is not busy */ /* wait until the card is not busy */
static bool LPC17xx_SD_WaitForReady (void) static bool LPC17xx_SD_WaitForReady(void)
{ {
uint8_t res; uint8_t res;
/* timeout should be large enough to make sure the write operaion can be completed. */ /* timeout should be large enough to make sure the write operaion can be completed. */
uint32_t timeout = 400000; uint32_t timeout = 400000;
LPC17xx_SPI_SendByte(0xFF); LPC17xx_SPI_SendByte(0xFF);
do { do
res = LPC17xx_SPI_RecvByte(); {
} while ((res != 0xFF) && timeout--); res = LPC17xx_SPI_RecvByte();
}
while ((res != 0xFF) && timeout--);
return (res == 0xFF ? true : false); return (res == 0xFF ? true : false);
} }
/* Initialize SD/MMC card. */ /* Initialize SD/MMC card. */
static bool LPC17xx_SD_Init (void) static bool LPC17xx_SD_Init(void)
{ {
uint32_t i, timeout; uint32_t i, timeout;
uint8_t cmd, ct, ocr[4]; uint8_t cmd, ct, ocr[4];
bool ret = false; bool ret = false;
/* Initialize SPI interface and enable Flash Card SPI mode. */ /* Initialize SPI interface and enable Flash Card SPI mode. */
LPC17xx_SPI_Init (); LPC17xx_SPI_Init();
/* At least 74 clock cycles are required prior to starting bus communication */ /* At least 74 clock cycles are required prior to starting bus communication */
for (i = 0; i < 80; i++) { /* 80 dummy clocks */ for (i = 0; i < 80; i++) /* 80 dummy clocks */
LPC17xx_SPI_SendByte (0xFF); {
} LPC17xx_SPI_SendByte(0xFF);
}
ct = CT_NONE; ct = CT_NONE;
if (LPC17xx_SD_SendCmd (GO_IDLE_STATE, 0) == 0x1) if (LPC17xx_SD_SendCmd(GO_IDLE_STATE, 0) == 0x1)
{ {
timeout = 50000; timeout = 50000;
if (LPC17xx_SD_SendCmd(CMD8, 0x1AA) == 1) { /* SDHC */ if (LPC17xx_SD_SendCmd(CMD8, 0x1AA) == 1) /* SDHC */
/* Get trailing return value of R7 resp */ {
for (i = 0; i < 4; i++) ocr[i] = LPC17xx_SPI_RecvByte(); /* Get trailing return value of R7 resp */
if (ocr[2] == 0x01 && ocr[3] == 0xAA) { /* The card can work at vdd range of 2.7-3.6V */ for (i = 0; i < 4; i++) ocr[i] = LPC17xx_SPI_RecvByte();
/* Wait for leaving idle state (ACMD41 with HCS bit) */ if (ocr[2] == 0x01 && ocr[3] == 0xAA) /* The card can work at vdd range of 2.7-3.6V */
while (timeout-- && LPC17xx_SD_SendCmd(SD_SEND_OP_COND, 1UL << 30)); {
/* Check CCS bit in the OCR */ /* Wait for leaving idle state (ACMD41 with HCS bit) */
if (timeout && LPC17xx_SD_SendCmd(READ_OCR, 0) == 0) { while (timeout-- && LPC17xx_SD_SendCmd(SD_SEND_OP_COND, 1UL << 30));
for (i = 0; i < 4; i++) ocr[i] = LPC17xx_SPI_RecvByte(); /* Check CCS bit in the OCR */
ct = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2; if (timeout && LPC17xx_SD_SendCmd(READ_OCR, 0) == 0)
} {
} else { /* SDSC or MMC */ for (i = 0; i < 4; i++) ocr[i] = LPC17xx_SPI_RecvByte();
if (LPC17xx_SD_SendCmd(SD_SEND_OP_COND, 0) <= 1) { ct = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2;
ct = CT_SD1; cmd = SD_SEND_OP_COND; /* SDSC */ }
} else { }
ct = CT_MMC; cmd = SEND_OP_COND; /* MMC */ else /* SDSC or MMC */
} {
/* Wait for leaving idle state */ if (LPC17xx_SD_SendCmd(SD_SEND_OP_COND, 0) <= 1)
while (timeout-- && LPC17xx_SD_SendCmd(cmd, 0)); {
/* Set R/W block length to 512 */ ct = CT_SD1;
if (!timeout || LPC17xx_SD_SendCmd(SET_BLOCKLEN, SD_SECTOR_SIZE) != 0) cmd = SD_SEND_OP_COND; /* SDSC */
ct = CT_NONE; }
} else
} {
else { /* SDSC or MMC */ ct = CT_MMC;
if (LPC17xx_SD_SendCmd(SD_SEND_OP_COND, 0) <= 1) { cmd = SEND_OP_COND; /* MMC */
ct = CT_SD1; cmd = SD_SEND_OP_COND; /* SDSC */ }
} else { /* Wait for leaving idle state */
ct = CT_MMC; cmd = SEND_OP_COND; /* MMC */ while (timeout-- && LPC17xx_SD_SendCmd(cmd, 0));
} /* Set R/W block length to 512 */
/* Wait for leaving idle state */ if (!timeout || LPC17xx_SD_SendCmd(SET_BLOCKLEN, SD_SECTOR_SIZE) != 0)
while (timeout-- && LPC17xx_SD_SendCmd(cmd, 0)); ct = CT_NONE;
/* Set R/W block length to 512 */ }
if (!timeout || LPC17xx_SD_SendCmd(SET_BLOCKLEN, SD_SECTOR_SIZE) != 0) }
ct = CT_NONE; else /* SDSC or MMC */
} {
} if (LPC17xx_SD_SendCmd(SD_SEND_OP_COND, 0) <= 1)
CardType = ct; {
LPC17xx_SPI_Release(); ct = CT_SD1;
cmd = SD_SEND_OP_COND; /* SDSC */
}
else
{
ct = CT_MMC;
cmd = SEND_OP_COND; /* MMC */
}
/* Wait for leaving idle state */
while (timeout-- && LPC17xx_SD_SendCmd(cmd, 0));
/* Set R/W block length to 512 */
if (!timeout || LPC17xx_SD_SendCmd(SET_BLOCKLEN, SD_SECTOR_SIZE) != 0)
ct = CT_NONE;
}
}
CardType = ct;
LPC17xx_SPI_Release();
if (ct) { /* Initialization succeeded */ if (ct) /* Initialization succeeded */
ret = true; {
if ( ct == CT_MMC ) { ret = true;
LPC17xx_SPI_SetSpeed(SPI_SPEED_20MHz); if (ct == CT_MMC)
} else { {
LPC17xx_SPI_SetSpeed(SPI_SPEED_20MHz); LPC17xx_SPI_SetSpeed(SPI_SPEED_20MHz);
} }
} else { /* Initialization failed */ else
LPC17xx_SPI_Select (); {
LPC17xx_SD_WaitForReady (); LPC17xx_SPI_SetSpeed(SPI_SPEED_20MHz);
LPC17xx_SPI_DeInit(); }
} }
else /* Initialization failed */
{
LPC17xx_SPI_Select();
LPC17xx_SD_WaitForReady();
LPC17xx_SPI_DeInit();
}
return ret; return ret;
} }
/***************************************************************************** /*****************************************************************************
Send a Command to Flash card and get a Response Send a Command to Flash card and get a Response
cmd: cmd index cmd: cmd index
arg: argument for the cmd arg: argument for the cmd
return the received response of the commond return the received response of the commond
*****************************************************************************/ *****************************************************************************/
static uint8_t LPC17xx_SD_SendCmd (uint8_t cmd, uint32_t arg) static uint8_t LPC17xx_SD_SendCmd(uint8_t cmd, uint32_t arg)
{ {
uint32_t r1, n; uint32_t r1, n;
if (cmd & 0x80) { /* ACMD<n> is the command sequence of CMD55-CMD<n> */ if (cmd & 0x80) /* ACMD<n> is the command sequence of CMD55-CMD<n> */
cmd &= 0x7F; {
r1 = LPC17xx_SD_SendCmd(APP_CMD, 0); /* CMD55 */ cmd &= 0x7F;
if (r1 > 1) return r1; /* cmd send failed */ r1 = LPC17xx_SD_SendCmd(APP_CMD, 0); /* CMD55 */
} if (r1 > 1) return r1; /* cmd send failed */
}
/* Select the card and wait for ready */ /* Select the card and wait for ready */
LPC17xx_SPI_DeSelect(); LPC17xx_SPI_DeSelect();
LPC17xx_SPI_Select(); LPC17xx_SPI_Select();
if (LPC17xx_SD_WaitForReady() == false ) return 0xFF; if (LPC17xx_SD_WaitForReady() == false) return 0xFF;
LPC17xx_SPI_SendByte (0xFF); /* prepare 8 clocks */ LPC17xx_SPI_SendByte(0xFF); /* prepare 8 clocks */
LPC17xx_SPI_SendByte (cmd); LPC17xx_SPI_SendByte(cmd);
LPC17xx_SPI_SendByte (arg >> 24); LPC17xx_SPI_SendByte(arg >> 24);
LPC17xx_SPI_SendByte (arg >> 16); LPC17xx_SPI_SendByte(arg >> 16);
LPC17xx_SPI_SendByte (arg >> 8); LPC17xx_SPI_SendByte(arg >> 8);
LPC17xx_SPI_SendByte (arg); LPC17xx_SPI_SendByte(arg);
/* Checksum, should only be valid for the first command.CMD0 */ /* Checksum, should only be valid for the first command.CMD0 */
n = 0x01; /* Dummy CRC + Stop */ n = 0x01; /* Dummy CRC + Stop */
if (cmd == GO_IDLE_STATE) n = 0x95; /* Valid CRC for CMD0(0) */ if (cmd == GO_IDLE_STATE) n = 0x95; /* Valid CRC for CMD0(0) */
if (cmd == CMD8) n = 0x87; /* Valid CRC for CMD8(0x1AA) */ if (cmd == CMD8) n = 0x87; /* Valid CRC for CMD8(0x1AA) */
LPC17xx_SPI_SendByte(n); LPC17xx_SPI_SendByte(n);
if (cmd == STOP_TRAN) LPC17xx_SPI_RecvByte (); /* Skip a stuff byte when stop reading */ if (cmd == STOP_TRAN) LPC17xx_SPI_RecvByte(); /* Skip a stuff byte when stop reading */
n = 10; /* Wait for a valid response in timeout of 10 attempts */ n = 10; /* Wait for a valid response in timeout of 10 attempts */
do { do
r1 = LPC17xx_SPI_RecvByte (); {
} while ((r1 & 0x80) && --n); r1 = LPC17xx_SPI_RecvByte();
}
while ((r1 & 0x80) && --n);
return (r1); /* Return with the response value */ return (r1); /* Return with the response value */
} }
/***************************************************************************** /*****************************************************************************
Read "count" Sector(s) starting from sector index "sector", Read "count" Sector(s) starting from sector index "sector",
buff <- [sector, sector+1, ... sector+count-1] buff <- [sector, sector+1, ... sector+count-1]
if success, return true, otherwise return false if success, return true, otherwise return false
*****************************************************************************/ *****************************************************************************/
static bool LPC17xx_SD_ReadSector (uint32_t sector, uint8_t *buff, uint32_t count) static bool LPC17xx_SD_ReadSector(uint32_t sector, uint8_t *buff, uint32_t count)
{ {
/* Convert to byte address if needed */ /* Convert to byte address if needed */
if (!(CardType & CT_BLOCK)) sector *= SD_SECTOR_SIZE; if (!(CardType & CT_BLOCK)) sector *= SD_SECTOR_SIZE;
if (count == 1) { /* Single block read */ if (count == 1) /* Single block read */
if ((LPC17xx_SD_SendCmd(READ_BLOCK, sector) == 0) {
&& LPC17xx_SD_ReadDataBlock(buff, SD_SECTOR_SIZE)) if ((LPC17xx_SD_SendCmd(READ_BLOCK, sector) == 0)
count = 0; && LPC17xx_SD_ReadDataBlock(buff, SD_SECTOR_SIZE))
} else { /* Multiple block read */ count = 0;
if (LPC17xx_SD_SendCmd(READ_MULT_BLOCK, sector) == 0) { }
do { else /* Multiple block read */
if (!LPC17xx_SD_ReadDataBlock(buff, SD_SECTOR_SIZE)) break; {
buff += SD_SECTOR_SIZE; if (LPC17xx_SD_SendCmd(READ_MULT_BLOCK, sector) == 0)
} while (--count); {
LPC17xx_SD_SendCmd(STOP_TRAN, 0); /* STOP_TRANSMISSION */ do
} {
} if (!LPC17xx_SD_ReadDataBlock(buff, SD_SECTOR_SIZE)) break;
LPC17xx_SPI_Release(); buff += SD_SECTOR_SIZE;
}
while (--count);
LPC17xx_SD_SendCmd(STOP_TRAN, 0); /* STOP_TRANSMISSION */
}
}
LPC17xx_SPI_Release();
return count ? false : true; return count ? false : true;
} }
/***************************************************************************** /*****************************************************************************
read specified number of data to specified buffer. read specified number of data to specified buffer.
buff: Data buffer to store received data buff: Data buffer to store received data
cnt: Byte count (must be multiple of 4, normally 512) cnt: Byte count (must be multiple of 4, normally 512)
*****************************************************************************/ *****************************************************************************/
static bool LPC17xx_SD_ReadDataBlock ( uint8_t *buff, uint32_t cnt) static bool LPC17xx_SD_ReadDataBlock(uint8_t *buff, uint32_t cnt)
{ {
uint8_t token; uint8_t token;
uint32_t timeout; uint32_t timeout;
timeout = 20000; timeout = 20000;
do { /* Wait for data packet in timeout of 100ms */ do /* Wait for data packet in timeout of 100ms */
token = LPC17xx_SPI_RecvByte(); {
} while ((token == 0xFF) && timeout--); token = LPC17xx_SPI_RecvByte();
if(token != 0xFE) return false; /* If not valid data token, return with error */ }
while ((token == 0xFF) && timeout--);
if (token != 0xFE) return false; /* If not valid data token, return with error */
#if USE_FIFO #if USE_FIFO
LPC17xx_SPI_RecvBlock_FIFO (buff, cnt); LPC17xx_SPI_RecvBlock_FIFO(buff, cnt);
#else #else
do { /* Receive the data block into buffer */ do /* Receive the data block into buffer */
*buff++ = LPC17xx_SPI_RecvByte (); {
*buff++ = LPC17xx_SPI_RecvByte (); *buff++ = LPC17xx_SPI_RecvByte();
*buff++ = LPC17xx_SPI_RecvByte (); *buff++ = LPC17xx_SPI_RecvByte();
*buff++ = LPC17xx_SPI_RecvByte (); *buff++ = LPC17xx_SPI_RecvByte();
} while (cnt -= 4); *buff++ = LPC17xx_SPI_RecvByte();
}
while (cnt -= 4);
#endif /* USE_FIFO */ #endif /* USE_FIFO */
LPC17xx_SPI_RecvByte (); /* Discard CRC */ LPC17xx_SPI_RecvByte(); /* Discard CRC */
LPC17xx_SPI_RecvByte (); LPC17xx_SPI_RecvByte();
return true; /* Return with success */ return true; /* Return with success */
} }
/***************************************************************************** /*****************************************************************************
Write "count" Sector(s) starting from sector index "sector", Write "count" Sector(s) starting from sector index "sector",
buff -> [sector, sector+1, ... sector+count-1] buff -> [sector, sector+1, ... sector+count-1]
if success, return true, otherwise return false if success, return true, otherwise return false
*****************************************************************************/ *****************************************************************************/
static bool LPC17xx_SD_WriteSector (uint32_t sector, const uint8_t *buff, uint32_t count) static bool LPC17xx_SD_WriteSector(uint32_t sector, const uint8_t *buff, uint32_t count)
{ {
if (!(CardType & CT_BLOCK)) sector *= 512; /* Convert to byte address if needed */ if (!(CardType & CT_BLOCK)) sector *= 512; /* Convert to byte address if needed */
if (count == 1) { /* Single block write */ if (count == 1) /* Single block write */
if ((LPC17xx_SD_SendCmd(WRITE_BLOCK, sector) == 0) {
&& LPC17xx_SD_WirteDataBlock(buff, TOKEN_SINGLE_BLOCK)) if ((LPC17xx_SD_SendCmd(WRITE_BLOCK, sector) == 0)
count = 0; && LPC17xx_SD_WirteDataBlock(buff, TOKEN_SINGLE_BLOCK))
} else { /* Multiple block write */ count = 0;
if (CardType & CT_SDC) LPC17xx_SD_SendCmd(SET_WR_BLK_ERASE_COUNT, count); }
if (LPC17xx_SD_SendCmd(WRITE_MULT_BLOCK, sector) == 0) { else /* Multiple block write */
do { {
if (!LPC17xx_SD_WirteDataBlock(buff, TOKEN_MULTI_BLOCK)) break; if (CardType & CT_SDC) LPC17xx_SD_SendCmd(SET_WR_BLK_ERASE_COUNT, count);
buff += 512; if (LPC17xx_SD_SendCmd(WRITE_MULT_BLOCK, sector) == 0)
} while (--count); {
#if 1 do
if (!LPC17xx_SD_WirteDataBlock(0, TOKEN_STOP_TRAN)) /* STOP_TRAN token */ {
count = 1; if (!LPC17xx_SD_WirteDataBlock(buff, TOKEN_MULTI_BLOCK)) break;
#else buff += 512;
LPC17xx_SPI_SendByte(TOKEN_STOP_TRAN); }
#endif while (--count);
} #if 1
} if (!LPC17xx_SD_WirteDataBlock(0, TOKEN_STOP_TRAN)) /* STOP_TRAN token */
LPC17xx_SPI_Release(); count = 1;
return count ? false : true; #else
LPC17xx_SPI_SendByte(TOKEN_STOP_TRAN);
#endif
}
}
LPC17xx_SPI_Release();
return count ? false : true;
} }
/***************************************************************************** /*****************************************************************************
Write 512 bytes Write 512 bytes
buffer: 512 byte data block to be transmitted buffer: 512 byte data block to be transmitted
token: 0xFE -> single block token: 0xFE -> single block
0xFC -> multi block 0xFC -> multi block
0xFD -> Stop 0xFD -> Stop
*****************************************************************************/ *****************************************************************************/
static bool LPC17xx_SD_WirteDataBlock (const uint8_t *buff, uint8_t token) static bool LPC17xx_SD_WirteDataBlock(const uint8_t *buff, uint8_t token)
{ {
uint8_t resp, i; uint8_t resp, i;
i = i; // avoid warning i = i; // avoid warning
LPC17xx_SPI_SendByte (token); /* send data token first*/ LPC17xx_SPI_SendByte(token); /* send data token first*/
if (token != TOKEN_STOP_TRAN) { if (token != TOKEN_STOP_TRAN)
{
#if USE_FIFO #if USE_FIFO
LPC17xx_SPI_SendBlock_FIFO (buff); LPC17xx_SPI_SendBlock_FIFO(buff);
#else #else
/* Send data. */ /* Send data. */
for (i = 512/4; i ; i--) { for (i = 512 / 4; i ; i--)
LPC17xx_SPI_SendByte (*buff++); {
LPC17xx_SPI_SendByte (*buff++); LPC17xx_SPI_SendByte(*buff++);
LPC17xx_SPI_SendByte (*buff++); LPC17xx_SPI_SendByte(*buff++);
LPC17xx_SPI_SendByte (*buff++); LPC17xx_SPI_SendByte(*buff++);
} LPC17xx_SPI_SendByte(*buff++);
}
#endif /* USE_FIFO */ #endif /* USE_FIFO */
LPC17xx_SPI_SendByte(0xFF); /* 16-bit CRC (Dummy) */ LPC17xx_SPI_SendByte(0xFF); /* 16-bit CRC (Dummy) */
LPC17xx_SPI_SendByte(0xFF); LPC17xx_SPI_SendByte(0xFF);
resp = LPC17xx_SPI_RecvByte(); /* Receive data response */ resp = LPC17xx_SPI_RecvByte(); /* Receive data response */
if ((resp & 0x1F) != 0x05) /* If not accepted, return with error */ if ((resp & 0x1F) != 0x05) /* If not accepted, return with error */
return false; return false;
if ( LPC17xx_SD_WaitForReady() == false) /* Wait while Flash Card is busy. */ if (LPC17xx_SD_WaitForReady() == false) /* Wait while Flash Card is busy. */
return false; return false;
} }
return true; return true;
} }
/* Read MMC/SD Card device configuration. */ /* Read MMC/SD Card device configuration. */
static bool LPC17xx_SD_ReadCfg (SDCFG *cfg) static bool LPC17xx_SD_ReadCfg(SDCFG *cfg)
{ {
uint8_t i; uint8_t i;
uint16_t csize; uint16_t csize;
uint8_t n, csd[16]; uint8_t n, csd[16];
bool retv = false; bool retv = false;
/* Read the OCR - Operations Condition Register. */ /* Read the OCR - Operations Condition Register. */
if (LPC17xx_SD_SendCmd (READ_OCR, 0) != 0x00) goto x; if (LPC17xx_SD_SendCmd(READ_OCR, 0) != 0x00) goto x;
for (i = 0; i < 4; i++) cfg->ocr[i] = LPC17xx_SPI_RecvByte (); for (i = 0; i < 4; i++) cfg->ocr[i] = LPC17xx_SPI_RecvByte();
/* Read the CID - Card Identification. */ /* Read the CID - Card Identification. */
if ((LPC17xx_SD_SendCmd (SEND_CID, 0) != 0x00) || if ((LPC17xx_SD_SendCmd(SEND_CID, 0) != 0x00) ||
(LPC17xx_SD_ReadDataBlock (cfg->cid, 16) == false)) (LPC17xx_SD_ReadDataBlock(cfg->cid, 16) == false))
goto x; goto x;
/* Read the CSD - Card Specific Data. */ /* Read the CSD - Card Specific Data. */
if ((LPC17xx_SD_SendCmd (SEND_CSD, 0) != 0x00) || if ((LPC17xx_SD_SendCmd(SEND_CSD, 0) != 0x00) ||
(LPC17xx_SD_ReadDataBlock (cfg->csd, 16) == false)) (LPC17xx_SD_ReadDataBlock(cfg->csd, 16) == false))
goto x; goto x;
cfg -> sectorsize = SD_SECTOR_SIZE; cfg -> sectorsize = SD_SECTOR_SIZE;
/* Get number of sectors on the disk (DWORD) */ /* Get number of sectors on the disk (DWORD) */
if ((cfg->csd[0] >> 6) == 1) { /* SDC ver 2.00 */ if ((cfg->csd[0] >> 6) == 1) /* SDC ver 2.00 */
csize = cfg->csd[9] + ((uint16_t)cfg->csd[8] << 8) + 1; {
cfg -> sectorcnt = (uint32_t)csize << 10; csize = cfg->csd[9] + ((uint16_t)cfg->csd[8] << 8) + 1;
} else { /* SDC ver 1.XX or MMC*/ cfg -> sectorcnt = (uint32_t)csize << 10;
n = (cfg->csd[5] & 15) + ((cfg->csd[10] & 128) >> 7) + ((cfg->csd[9] & 3) << 1) + 2; // 19 }
csize = (cfg->csd[8] >> 6) + ((uint16_t)cfg->csd[7] << 2) + ((uint16_t)(cfg->csd[6] & 3) << 10) + 1; // 3752 else /* SDC ver 1.XX or MMC*/
cfg -> sectorcnt = (uint32_t)csize << (n - 9); // 3842048 {
} n = (cfg->csd[5] & 15) + ((cfg->csd[10] & 128) >> 7) + ((cfg->csd[9] & 3) << 1) + 2; // 19
csize = (cfg->csd[8] >> 6) + ((uint16_t)cfg->csd[7] << 2) + ((uint16_t)(cfg->csd[6] & 3) << 10) + 1; // 3752
cfg -> sectorcnt = (uint32_t)csize << (n - 9); // 3842048
}
cfg->size = cfg -> sectorcnt * cfg -> sectorsize; // 512*3842048=1967128576Byte (1.83GB) cfg->size = cfg -> sectorcnt * cfg -> sectorsize; // 512*3842048=1967128576Byte (1.83GB)
/* Get erase block size in unit of sector (DWORD) */ /* Get erase block size in unit of sector (DWORD) */
if (CardType & CT_SD2) { /* SDC ver 2.00 */ if (CardType & CT_SD2) /* SDC ver 2.00 */
if (LPC17xx_SD_SendCmd(SD_STATUS /*ACMD13*/, 0) == 0) { /* Read SD status */ {
LPC17xx_SPI_RecvByte(); if (LPC17xx_SD_SendCmd(SD_STATUS /*ACMD13*/, 0) == 0) /* Read SD status */
if (LPC17xx_SD_ReadDataBlock(csd, 16)) { /* Read partial block */ {
for (n = 64 - 16; n; n--) LPC17xx_SPI_RecvByte(); /* Purge trailing data */ LPC17xx_SPI_RecvByte();
cfg->blocksize = 16UL << (csd[10] >> 4); if (LPC17xx_SD_ReadDataBlock(csd, 16)) /* Read partial block */
retv = true; {
} for (n = 64 - 16; n; n--) LPC17xx_SPI_RecvByte(); /* Purge trailing data */
} cfg->blocksize = 16UL << (csd[10] >> 4);
} else { /* SDC ver 1.XX or MMC */ retv = true;
if ((LPC17xx_SD_SendCmd(SEND_CSD, 0) == 0) && LPC17xx_SD_ReadDataBlock(csd, 16)) { /* Read CSD */ }
if (CardType & CT_SD1) { /* SDC ver 1.XX */ }
cfg->blocksize = (((csd[10] & 63) << 1) + ((uint16_t)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1); }
} else { /* MMC */ else /* SDC ver 1.XX or MMC */
// cfg->blocksize = ((uint16_t)((buf[10] & 124) >> 2) + 1) * (((buf[11] & 3) << 3) + ((buf[11] & 224) >> 5) + 1); {
cfg->blocksize = ((uint16_t)((cfg->csd[10] & 124) >> 2) + 1) * (((cfg->csd[10] & 3) << 3) + ((cfg->csd[11] & 224) >> 5) + 1); if ((LPC17xx_SD_SendCmd(SEND_CSD, 0) == 0) && LPC17xx_SD_ReadDataBlock(csd, 16)) /* Read CSD */
} {
retv = true; if (CardType & CT_SD1) /* SDC ver 1.XX */
} {
} cfg->blocksize = (((csd[10] & 63) << 1) + ((uint16_t)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);
}
else /* MMC */
{
// cfg->blocksize = ((uint16_t)((buf[10] & 124) >> 2) + 1) * (((buf[11] & 3) << 3) + ((buf[11] & 224) >> 5) + 1);
cfg->blocksize = ((uint16_t)((cfg->csd[10] & 124) >> 2) + 1) * (((cfg->csd[10] & 3) << 3) + ((cfg->csd[11] & 224) >> 5) + 1);
}
retv = true;
}
}
x: LPC17xx_SPI_Release(); x:
LPC17xx_SPI_Release();
return (retv); return (retv);
} }
static rt_err_t rt_sdcard_init(rt_device_t dev) static rt_err_t rt_sdcard_init(rt_device_t dev)
{ {
return RT_EOK; return RT_EOK;
} }
static rt_err_t rt_sdcard_open(rt_device_t dev, rt_uint16_t oflag) static rt_err_t rt_sdcard_open(rt_device_t dev, rt_uint16_t oflag)
{ {
return RT_EOK; return RT_EOK;
} }
static rt_err_t rt_sdcard_close(rt_device_t dev) static rt_err_t rt_sdcard_close(rt_device_t dev)
{ {
return RT_EOK; return RT_EOK;
} }
static rt_size_t rt_sdcard_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size) static rt_size_t rt_sdcard_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{ {
bool status; bool status;
status = LPC17xx_SD_ReadSector(part.offset + pos, buffer, size); status = LPC17xx_SD_ReadSector(part.offset + pos, buffer, size);
if (status == true) return size; if (status == true) return size;
rt_kprintf("read failed: %d, pos 0x%08x, size %d\n", status, pos, size); rt_kprintf("read failed: %d, pos 0x%08x, size %d\n", status, pos, size);
return 0; return 0;
} }
static rt_size_t rt_sdcard_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size) static rt_size_t rt_sdcard_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{ {
bool status; bool status;
status = LPC17xx_SD_WriteSector(part.offset + pos, buffer, size); status = LPC17xx_SD_WriteSector(part.offset + pos, buffer, size);
if (status == true) return size; if (status == true) return size;
rt_kprintf("write failed: %d, pos 0x%08x, size %d\n", status, pos, size); rt_kprintf("write failed: %d, pos 0x%08x, size %d\n", status, pos, size);
return 0; return 0;
} }
static rt_err_t rt_sdcard_control(rt_device_t dev, rt_uint8_t cmd, void *args) static rt_err_t rt_sdcard_control(rt_device_t dev, rt_uint8_t cmd, void *args)
{ {
return RT_EOK; if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME)
{
struct rt_device_blk_geometry *geometry;
geometry = (struct rt_device_blk_geometry *)args;
if (geometry == RT_NULL) return -RT_ERROR;
geometry->bytes_per_sector = SDCfg.sectorsize;
geometry->block_size = SDCfg.blocksize;
geometry->sector_count = SDCfg.sectorcnt;
}
return RT_EOK;
} }
void rt_hw_sdcard_init() void rt_hw_sdcard_init()
{ {
if (LPC17xx_SD_Init() && LPC17xx_SD_ReadCfg(&SDCfg)) if (LPC17xx_SD_Init() && LPC17xx_SD_ReadCfg(&SDCfg))
{ {
bool status; bool status;
rt_uint8_t *sector; rt_uint8_t *sector;
/* get the first sector to read partition table */ /* get the first sector to read partition table */
sector = (rt_uint8_t*) rt_malloc (512); sector = (rt_uint8_t *) rt_malloc(512);
if (sector == RT_NULL) if (sector == RT_NULL)
{ {
rt_kprintf("allocate partition sector buffer failed\n"); rt_kprintf("allocate partition sector buffer failed\n");
return; return;
} }
status = LPC17xx_SD_ReadSector(0, sector, 1); status = LPC17xx_SD_ReadSector(0, sector, 1);
if (status == true) if (status == true)
{ {
/* get the first partition */ /* get the first partition */
if (dfs_filesystem_get_partition(&part, sector, 0) != 0) if (dfs_filesystem_get_partition(&part, sector, 0) != 0)
{ {
/* there is no partition */ /* there is no partition */
part.offset = 0; part.offset = 0;
part.size = 0; part.size = 0;
} }
} }
else else
{ {
/* there is no partition table */ /* there is no partition table */
part.offset = 0; part.offset = 0;
part.size = 0; part.size = 0;
} }
/* release sector buffer */ /* release sector buffer */
rt_free(sector); rt_free(sector);
/* register sdcard device */ /* register sdcard device */
sdcard_device.type = RT_Device_Class_Block; sdcard_device.type = RT_Device_Class_Block;
sdcard_device.init = rt_sdcard_init; sdcard_device.init = rt_sdcard_init;
sdcard_device.open = rt_sdcard_open; sdcard_device.open = rt_sdcard_open;
sdcard_device.close = rt_sdcard_close; sdcard_device.close = rt_sdcard_close;
sdcard_device.read = rt_sdcard_read; sdcard_device.read = rt_sdcard_read;
sdcard_device.write = rt_sdcard_write; sdcard_device.write = rt_sdcard_write;
sdcard_device.control = rt_sdcard_control; sdcard_device.control = rt_sdcard_control;
/* no private */ /* no private */
sdcard_device.user_data = &SDCfg; sdcard_device.user_data = &SDCfg;
rt_device_register(&sdcard_device, "sd0", rt_device_register(&sdcard_device, "sd0",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE); RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
return; return;
} }
rt_kprintf("sdcard init failed\n"); rt_kprintf("sdcard init failed\n");
} }

65
bsp/lpc176x/drivers/sd.h
View File

@ -4,42 +4,43 @@
#include <stdint.h> #include <stdint.h>
/* SD/MMC Commands */ /* SD/MMC Commands */
#define GO_IDLE_STATE (0x40 + 0) // CMD0 #define GO_IDLE_STATE (0x40 + 0) // CMD0
#define SEND_OP_COND (0x40 + 1) #define SEND_OP_COND (0x40 + 1)
#define CMD8 (0x40 + 8) // CMD8 #define CMD8 (0x40 + 8) // CMD8
#define SEND_CSD (0x40 + 9) #define SEND_CSD (0x40 + 9)
#define SEND_CID (0x40 + 10) // CMD10 #define SEND_CID (0x40 + 10) // CMD10
#define STOP_TRAN (0x40 + 12) // CMD12 #define STOP_TRAN (0x40 + 12) // CMD12
#define SET_BLOCKLEN (0x40 + 16) // CMD16 #define SET_BLOCKLEN (0x40 + 16) // CMD16
#define READ_BLOCK (0x40 + 17) #define READ_BLOCK (0x40 + 17)
#define READ_MULT_BLOCK (0x40 + 18) #define READ_MULT_BLOCK (0x40 + 18)
#define WRITE_BLOCK (0x40 + 24) #define WRITE_BLOCK (0x40 + 24)
#define WRITE_MULT_BLOCK (0x40 + 25) #define WRITE_MULT_BLOCK (0x40 + 25)
#define APP_CMD (0x40 + 55) // CMD55 #define APP_CMD (0x40 + 55) // CMD55
#define READ_OCR (0x40 + 58) // CMD58 #define READ_OCR (0x40 + 58) // CMD58
#define CRC_ON_OFF (0x40 + 59) #define CRC_ON_OFF (0x40 + 59)
#define SD_SEND_OP_COND (0xC0 + 41) // ACMD41 #define SD_SEND_OP_COND (0xC0 + 41) // ACMD41
#define SD_STATUS (0xC0 + 13) // ACMD13, SD_STATUS (SDC) #define SD_STATUS (0xC0 + 13) // ACMD13, SD_STATUS (SDC)
#define SET_WR_BLK_ERASE_COUNT (0xC0 + 23) // ACMD23 (SDC) #define SET_WR_BLK_ERASE_COUNT (0xC0 + 23) // ACMD23 (SDC)
/* Card type flags (CardType) */ /* Card type flags (CardType) */
#define CT_NONE 0x00 #define CT_NONE 0x00
#define CT_MMC 0x01 #define CT_MMC 0x01
#define CT_SD1 0x02 #define CT_SD1 0x02
#define CT_SD2 0x04 #define CT_SD2 0x04
#define CT_SDC (CT_SD1|CT_SD2) #define CT_SDC (CT_SD1|CT_SD2)
#define CT_BLOCK 0x08 #define CT_BLOCK 0x08
/* MMC device configuration */ /* MMC device configuration */
typedef struct tagSDCFG{ typedef struct tagSDCFG
uint32_t sernum; // serial number {
uint32_t size; // size=sectorsize*sectorcnt uint32_t sernum; // serial number
uint32_t sectorcnt; // uint32_t size; // size=sectorsize*sectorcnt
uint32_t sectorsize; // 512 uint32_t sectorcnt; //
uint32_t blocksize; // erase block size uint32_t sectorsize; // 512
uint8_t ocr[4]; // OCR uint32_t blocksize; // erase block size
uint8_t cid[16]; // CID uint8_t ocr[4]; // OCR
uint8_t csd[16]; // CSD uint8_t cid[16]; // CID
uint8_t csd[16]; // CSD
} SDCFG; } SDCFG;
void rt_hw_sdcard_init(void); void rt_hw_sdcard_init(void);