sdcard: add reading data block
This commit is contained in:
parent
30c72a78a8
commit
0de7f8213c
8
global.h
8
global.h
|
|
@ -15,7 +15,7 @@
|
|||
/** global definitions and methods (API)
|
||||
* @file global.h
|
||||
* @author King Kévin <kingkevin@cuvoodoo.info>
|
||||
* @date 2016
|
||||
* @date 2016-2017
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
|
|
@ -252,6 +252,12 @@
|
|||
#define SPI_MISO_PIN(x) CAT3(GPIO_SPI,x,_MISO)
|
||||
/** get SPI pin for MOSI signal based on SPI identifier */
|
||||
#define SPI_MOSI_PIN(x) CAT3(GPIO_SPI,x,_MOSI)
|
||||
/** get SPI CRC polynomial register based on SPI identifier */
|
||||
#define SPI_CRC_PR(x) CAT3(SPI,x,_CRCPR)
|
||||
/** get SPI CRC transmit register based on SPI identifier */
|
||||
#define SPI_CRC_TXR(x) CAT3(SPI,x,_TXCRCR)
|
||||
/** get SPI CRC receive register based on SPI identifier */
|
||||
#define SPI_CRC_RXR(x) CAT3(SPI,x,_RXCRCR)
|
||||
/** @} */
|
||||
|
||||
/** @defgroup board_led board LED GPIO
|
||||
|
|
|
|||
|
|
@ -40,6 +40,11 @@
|
|||
#define FLASH_SDCARD_SPI 1 /**< SPI peripheral */
|
||||
/** @} */
|
||||
|
||||
/** maximum N_AC value (time between the response token R1 and data block when reading data (see section 7.5.4)
|
||||
* @note this is set to N_CR until we can read CSD (see section 7.2.6)
|
||||
*/
|
||||
static uint16_t n_ac = 8;
|
||||
|
||||
/** table for CRC-7 calculation for the command messages (see section 4.5)
|
||||
* @note faster than calculating the CRC and doesn't cost a lot of space
|
||||
* @note generated using pycrc --width=7 --poly=0x09 --reflect-in=false --reflect-out=false --xor-in=0x00 --xor-out=0x00 --generate=table
|
||||
|
|
@ -77,7 +82,7 @@ static uint16_t flash_sdcard_spi_read(void)
|
|||
{
|
||||
spi_send(SPI(FLASH_SDCARD_SPI), 0xffff); // send not command token (i.e. starting with 1)
|
||||
while (!(SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_TXE)); // wait until Tx buffer is empty before clearing the (previous) RXNE flag
|
||||
SPI_DR(SPI(FLASH_SDCARD_SPI)); // clear RXNE flag (by reading previously received data (not done by spi_read or spi_xref)
|
||||
(void)SPI_DR(SPI(FLASH_SDCARD_SPI)); // clear RXNE flag (by reading previously received data (not done by spi_read or spi_xref)
|
||||
while (!(SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_RXNE)); // wait for next data to be available
|
||||
return SPI_DR(SPI(FLASH_SDCARD_SPI)); // return received adat
|
||||
}
|
||||
|
|
@ -120,14 +125,15 @@ static void flash_sdcard_send_command(uint8_t index, uint32_t argument)
|
|||
static bool flash_sdcard_command_response(uint8_t index, uint32_t argument, uint8_t* response, size_t size)
|
||||
{
|
||||
// send command token
|
||||
while (SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_BSY); // wait until not busy
|
||||
gpio_clear(SPI_NSS_PORT(FLASH_SDCARD_SPI), SPI_NSS_PIN(FLASH_SDCARD_SPI)); // set CS low to select slave and start SPI mode (see section 7.2)
|
||||
flash_sdcard_spi_wait(); // wait for N_CS before writing command (see section 7.5.1.1)
|
||||
flash_sdcard_spi_wait(); // wait for N_CS (min. 0, but it works better with 8 clock cycles) before writing command (see section 7.5.1.1)
|
||||
flash_sdcard_send_command(index, argument); // send command token
|
||||
|
||||
// verify response token R1
|
||||
flash_sdcard_spi_wait(); // wait for N_CR before reading response (see section 7.5.1.1)
|
||||
uint8_t r1 = flash_sdcard_spi_read(); // get response (see section 7.3.2.1)
|
||||
// get response token R1
|
||||
uint8_t r1 = 0xff; // response token R1 (see section 7.3.2.1)
|
||||
for (uint8_t i=0; i<8 && r1&0x80; i++) { // wait for N_CR (1 to 8 8 clock cycles) before reading response (see section 7.5.1.1)
|
||||
r1 = flash_sdcard_spi_read(); // get response (see section 7.3.2.1)
|
||||
}
|
||||
if (0x00==(r1&0xfe) && 0!=size && NULL!=response) { // we have to read a response
|
||||
for (size_t i=0; i<size; i++) {
|
||||
response[i] = flash_sdcard_spi_read(); // get byte
|
||||
|
|
@ -135,13 +141,71 @@ static bool flash_sdcard_command_response(uint8_t index, uint32_t argument, uint
|
|||
}
|
||||
|
||||
// end communication
|
||||
flash_sdcard_spi_wait(); // wait for N_EC before closing communication (see section 7.5.1.1)
|
||||
while (!(SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_TXE)); // wait until Tx buffer is empty
|
||||
while (SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_BSY); // wait until not busy (= transmission completed)
|
||||
// wait for N_EC (min. 0) before closing communication (see section 7.5.1.1)
|
||||
gpio_set(SPI_NSS_PORT(FLASH_SDCARD_SPI), SPI_NSS_PIN(FLASH_SDCARD_SPI)); // set CS high to unselect card
|
||||
flash_sdcard_spi_wait(); // wait for N_DS before allowing any further communication (see section 7.5.1.1)
|
||||
while (!(SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_TXE)); // wait until Tx buffer is empty
|
||||
// wait for N_DS (min. 0) before allowing any further communication (see section 7.5.1.1)
|
||||
return r1;
|
||||
}
|
||||
|
||||
/** transmit command token, receive response token and data block
|
||||
* @param[in] index command index
|
||||
* @param[in] argument command argument
|
||||
* @param[out] data data block to read (if no error occurred)
|
||||
* @param[in] size size of response to read (a multiple of 2)
|
||||
* @return response token R1 of 0xff if error occurred or card is not present
|
||||
*/
|
||||
static bool flash_sdcard_data_read(uint8_t index, uint32_t argument, uint8_t* data, size_t size)
|
||||
{
|
||||
|
||||
// send command token
|
||||
gpio_clear(SPI_NSS_PORT(FLASH_SDCARD_SPI), SPI_NSS_PIN(FLASH_SDCARD_SPI)); // set CS low to select slave and start SPI mode (see section 7.2)
|
||||
flash_sdcard_spi_wait(); // wait for N_CS (min. 0, but it works better with 8 clock cycles) before writing command (see section 7.5.2.1)
|
||||
flash_sdcard_send_command(index, argument); // send command token
|
||||
|
||||
// get response token R1
|
||||
uint8_t r1 = 0xff; // response token R1 (see section 7.3.2.1)
|
||||
for (uint8_t i=0; i<8 && r1&0x80; i++) { // wait for N_CR (1 to 8 8 clock cycles) before reading response (see section 7.5.1.1)
|
||||
r1 = flash_sdcard_spi_read(); // get response (see section 7.3.2.1)
|
||||
}
|
||||
if (0x00==r1 && 0!=size && 0==size%2 && NULL!=data) { // we have to read a response
|
||||
uint8_t sbt = 0; // to save the start block token (see section 7.3.3.2)
|
||||
for (uint16_t i=0; i<n_ac && sbt!=0xfe; i++) { // wait for N_AC before reading data block (see section 7.5.2.1)
|
||||
sbt = flash_sdcard_spi_read(); // get start block token (see section 7.3.3.2)
|
||||
}
|
||||
if (0xfe==sbt) { // start block token received (see section 7.3.3.2)
|
||||
// switch to 16-bits SPI data frame so we can use use built-in CRC-16
|
||||
while (!(SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_TXE)); // wait until the end of any transmission
|
||||
while (SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_BSY); // wait until not busy before disabling
|
||||
spi_disable(SPI(FLASH_SDCARD_SPI)); // disable SPI to change format
|
||||
spi_set_dff_16bit(SPI(FLASH_SDCARD_SPI)); // set SPI frame to 16 bits
|
||||
SPI_CRC_PR(FLASH_SDCARD_SPI) = 0x1021; // set CRC-16-CCITT polynomial for data blocks (x^16+x^12+x^5+1) (see section 7.2.3)
|
||||
spi_enable_crc(SPI(FLASH_SDCARD_SPI)); // enable and clear CRC
|
||||
spi_enable(SPI(FLASH_SDCARD_SPI)); // enable SPI back
|
||||
// get block data
|
||||
for (size_t i=0; i<size/2; i++) {
|
||||
data[i*2] = flash_sdcard_spi_read(); // get word
|
||||
}
|
||||
flash_sdcard_spi_read(); // read CRC (the CRC after the data block should clear the computed CRC)
|
||||
if (SPI_CRC_RXR(FLASH_SDCARD_SPI)) { // CRC is wrong
|
||||
r1 |= (1<<3); // set communication CRC error
|
||||
}
|
||||
// switch back to 8-bit SPI frames
|
||||
while (!(SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_TXE)); // wait until the end of any transmission
|
||||
while (SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_BSY); // wait until not busy before disabling
|
||||
spi_disable(SPI(FLASH_SDCARD_SPI)); // disable SPI to change format
|
||||
spi_set_dff_8bit(SPI(FLASH_SDCARD_SPI)); // set SPI frame to 8 bits
|
||||
spi_enable(SPI(FLASH_SDCARD_SPI)); // enable SPI back
|
||||
} else { // start block token not received
|
||||
r1 |= (1<<3); // set communication CRC error
|
||||
}
|
||||
}
|
||||
|
||||
// end communication
|
||||
while (SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_BSY); // wait until not busy (= transmission completed)
|
||||
// wait for N_EC (min. 0) before closing communication (see section 7.5.1.1)
|
||||
gpio_set(SPI_NSS_PORT(FLASH_SDCARD_SPI), SPI_NSS_PIN(FLASH_SDCARD_SPI)); // set CS high to unselect card
|
||||
// wait for N_DS (min. 0) before allowing any further communication (see section 7.5.1.1)
|
||||
return r1;
|
||||
}
|
||||
|
||||
|
|
@ -149,7 +213,7 @@ bool flash_sdcard_setup(void)
|
|||
{
|
||||
// check if card is present
|
||||
if (!flash_sdcard_card_detect()) {
|
||||
//return false;
|
||||
return false;
|
||||
}
|
||||
|
||||
// configure SPI peripheral
|
||||
|
|
@ -169,7 +233,7 @@ bool flash_sdcard_setup(void)
|
|||
spi_set_full_duplex_mode(SPI(FLASH_SDCARD_SPI)); // ensure we are in full duplex mode
|
||||
spi_enable_software_slave_management(SPI(FLASH_SDCARD_SPI)); // control NSS (CS) manually
|
||||
spi_set_nss_high(SPI(FLASH_SDCARD_SPI)); // set NSS high (internally) so we can output
|
||||
spi_enable_ss_output(SPI(FLASH_SDCARD_SPI)); // disable NSS output since we control CS manually
|
||||
spi_disable_ss_output(SPI(FLASH_SDCARD_SPI)); // disable NSS output since we control CS manually
|
||||
gpio_set(SPI_NSS_PORT(FLASH_SDCARD_SPI), SPI_NSS_PIN(FLASH_SDCARD_SPI)); // set CS high to unselect card
|
||||
// sadly we can't use the interrupts as events to sleep (WFE) since sleep disables also communication (e.g. going to sleep until Rx buffer is not empty prevents transmission)
|
||||
spi_enable(SPI(FLASH_SDCARD_SPI)); // enable SPI
|
||||
|
|
@ -215,11 +279,28 @@ bool flash_sdcard_setup(void)
|
|||
} while (0x00!=r1); // wait until card is ready (see section 7.2.1)
|
||||
// send CMD58 (READ_OCR) to read Card Capacity Status (CCS) (see section 7.2.1)
|
||||
r1 = flash_sdcard_command_response(58, 0, r3, sizeof(r3)); // (see table 7-3)
|
||||
if (r1&0xfe) { // error occurred
|
||||
if (r1) { // error occurred
|
||||
return false;
|
||||
}
|
||||
// card power up status bit (bit 31) is set when power up is complete (see table 5-1)
|
||||
// CCS is bit 30 in OCR, but we don't really care about the result (see table 5-1)
|
||||
// for High Capacity cards (CCS set to 1) the data block is always 512 bytes, else this should be set using CMD16 (see section 7.2.3)
|
||||
// now the card identification is complete and we should be in data-transfer mode (see figure 7-1)
|
||||
|
||||
// we can switch clock frequency to fPP (max. 25 MHz) (see section 4.3/6.6.6)
|
||||
while (!(SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_TXE)); // wait until the end of any transmission
|
||||
while (SPI_SR(SPI(FLASH_SDCARD_SPI))&SPI_SR_BSY); // wait until not busy before disabling
|
||||
spi_disable(SPI(FLASH_SDCARD_SPI)); // disable SPI to change clock speed
|
||||
spi_set_baudrate_prescaler(SPI(FLASH_SDCARD_SPI), SPI_CR1_BR_FPCLK_DIV_4); // set clock speed to 18 MHz (72/4=18, < 25 MHz)
|
||||
spi_enable(SPI(FLASH_SDCARD_SPI)); // enable SPI back
|
||||
|
||||
// send CMD9 (SEND_CSD) to get Card Specific Data (CSD) (see table section 7.2.6)
|
||||
uint8_t csd[16] = {0}; // CSD response (see chapter 7.2.6)
|
||||
r1 = flash_sdcard_data_read(9, 0, csd, sizeof(csd)); // (see table 7-3)
|
||||
if (r1) { // error occurred
|
||||
return false;
|
||||
}
|
||||
// we can switch to high speed mode clock frequency to fPP (max. 50 MHz) (see section 6.6.7)
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue