From 0de7f8213c7eaf65614d5ad0eea97acad63d0ee1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?King=20K=C3=A9vin?= <kingkevin@cuvoodoo.info>
Date: Wed, 28 Jun 2017 10:27:53 +0200
Subject: [PATCH] sdcard: add reading data block

---
 global.h           |   8 +++-
 lib/flash_sdcard.c | 107 +++++++++++++++++++++++++++++++++++++++------
 2 files changed, 101 insertions(+), 14 deletions(-)

diff --git a/global.h b/global.h
index 03598e4..49185ab 100644
--- a/global.h
+++ b/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
diff --git a/lib/flash_sdcard.c b/lib/flash_sdcard.c
index aa16655..8095903 100644
--- a/lib/flash_sdcard.c
+++ b/lib/flash_sdcard.c
@@ -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;
 }