/**
  ******************************************************************************
  * @file    spi_sd.c
  * @author  MCD Application Team
  * @version V4.5.0
  * @date    07-March-2011
  * @brief   This file provides a set of functions needed to manage the SPI SD 
  *          Card memory mounted on STM32xx-EVAL board (refer to stm32_eval.h
  *          to know about the boards supporting this memory). 
  *          It implements a high level communication layer for read and write 
  *          from/to this memory. The needed STM32 hardware resources (SPI and 
  *          GPIO) are defined in stm32xx_eval.h file, and the initialization is 
  *          performed in SD_LowLevel_Init() function declared in stm32xx_eval.c 
  *          file.
  *          You can easily tailor this driver to any other development board, 
  *          by just adapting the defines for hardware resources and 
  *          SD_LowLevel_Init() function.
  *            
  *          +-------------------------------------------------------+
  *          |                     Pin assignment                    |
  *          +-------------------------+---------------+-------------+
  *          |  STM32 SPI Pins         |     SD        |    Pin      |
  *          +-------------------------+---------------+-------------+
  *          | SD_SPI_CS_PIN           |   ChipSelect  |    1        |
  *          | SD_SPI_MOSI_PIN / MOSI  |   DataIn      |    2        |
  *          |                         |   GND         |    3 (0 V)  |
  *          |                         |   VDD         |    4 (3.3 V)|
  *          | SD_SPI_SCK_PIN / SCLK   |   Clock       |    5        |
  *          |                         |   GND         |    6 (0 V)  |
  *          | SD_SPI_MISO_PIN / MISO  |   DataOut     |    7        |
  *          +-------------------------+---------------+-------------+
  ******************************************************************************
  * @attention
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>
  ******************************************************************************  
  */

/* Includes ------------------------------------------------------------------*/
#include "spi_sd.h"
#include "crc.h"
#include "stm32f1xx_hal.h"

uint32_t delay_init;    // for SD card power on delay 


/**
  * @brief  Initializes the SD/SD communication.
  * @param  None
  * @retval The SD Response: 
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_Init(void)
{
    uint32_t i = 0;
    MakeCRC7Table();
    HAL_SPI_Init(&hspi1);
    /************ TOGGLE THE POWER **************/
    SD_PWR_OFF;
    HAL_SPI_DeInit(&hspi1);
    delay_init = SD_POWER_DELAY;
    while(delay_init--);
    /************ TOGGLE THE POWER **************/
    /*!< Initialize SD_SPI */
    HAL_SPI_Init(&hspi1);
    SD_PWR_ON;
    delay_init = SD_POWER_DELAY;
    while(delay_init--);
    /********************************************/
    /*!< Send dummy byte 0xFF, 10 times with CS high */
    /*!< Rise CS and MOSI for 80 clocks cycles */
    for (i = 0; i <= 9; i++)
    {
        /*!< Send dummy byte 0xFF */
        SD_WriteByte(SD_DUMMY_BYTE);
    }
    /*------------Put SD in SPI mode--------------*/
    /*!< SD initialized and set to SPI mode properly */
    return (SD_GoIdleState());
}

/**
 * @brief  Detect if SD card is correctly plugged in the memory slot.
 * @param  None
 * @retval Return if SD is detected or not
 */
uint8_t SD_Detect(void)
{
    uint8_t status = SD_PRESENT;

    /*!< Check GPIO to detect SD */
    if (HAL_GPIO_ReadPin(SD_DETECT_GPIO_PORT, SD_DETECT_PIN) == GPIO_PIN_SET)
    {
        status = SD_NOT_PRESENT;
    }
    return status;
}

/**
  * @brief  Returns information about specific card.
  * @param  cardinfo: pointer to a SD_CardInfo structure that contains all SD 
  *         card information.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
//SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
//{
//  SD_Error status = SD_RESPONSE_FAILURE;

//  status = SD_GetCSDRegister(&(cardinfo->SD_csd));
//  status = SD_GetCIDRegister(&(cardinfo->SD_cid));
////  cardinfo->CardCapacity = (cardinfo->SD_csd.DeviceSize + 1) ;
////  cardinfo->CardCapacity *= (1 << (cardinfo->SD_csd.DeviceSizeMul + 2));
////  cardinfo->CardBlockSize = 1 << (cardinfo->SD_csd.RdBlockLen);
////  cardinfo->CardCapacity *= cardinfo->CardBlockSize;
//    
//    cardinfo->CardCapacity = (cardinfo->SD_csd.DeviceSize + 1) * (1 << 19);
//    

//  /*!< Returns the reponse */
//  return status;
//}

/**
  * @brief  Reads a block of data from the SD.
  * @param  pBuffer: pointer to the buffer that receives the data read from the 
  *                  SD.
  * @param  ReadAddr: SD's internal address to read from.
  * @param  BlockSize: the SD card Data block size.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_ReadBlock(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize)
{
    uint16_t i = 0;
    SD_Error rvalue = SD_RESPONSE_FAILURE;
    uint16_t crc_16 = 0;
    uint8_t crc_high, crc_low = 0;
    
    /*!< SD chip select low */
    SD_CS_LOW;
    /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
    SD_SendCmd(SD_CMD_READ_SINGLE_BLOCK, ReadAddr);  
    /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
    if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
    {
        /*!< Now look for the data token to signify the start of the data */
        if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
        {
            for(i=0; i < BlockSize; i++) { 		    //read out 512 bytes
                pBuffer[i] = SD_ReadByte();
                //sendchar(pBuffer[i]);
            }
            crc_16 = crc16(pBuffer, BlockSize);
            crc_high = SD_ReadByte(); 		        //receive incoming CRC (16-bit), CRC is ignored here
            crc_low = SD_ReadByte();

            SD_WriteByte(SD_DUMMY_BYTE); 			//extra 8 clock pulses
            SD_CS_HIGH;
            if (((((uint16_t)(crc_high << 8)) & 0xFF00) | crc_low) == crc_16) 
            {
                rvalue = SD_RESPONSE_NO_ERROR;
            }
        }
    } else {
        SD_CS_HIGH;
        SD_WriteByte(SD_DUMMY_BYTE); 			//extra 8 clock pulses       
    }
  
    /*!< Returns the reponse */
    return rvalue;
}

/**
  * @brief  Reads multiple block of data from the SD.
  * @param  pBuffer: pointer to the buffer that receives the data read from the 
  *                  SD.
  * @param  ReadAddr: SD's internal address to read from.
  * @param  BlockSize: the SD card Data block size.
  * @param  NumberOfBlocks: number of blocks to be read.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
//SD_Error SD_ReadMultiBlocks(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
//{
//    uint32_t i = 0, Offset = 0;
//    SD_Error rvalue = SD_RESPONSE_FAILURE;
//  
//    /*!< SD chip select low */
//    SD_CS_LOW;
//    /*!< Data transfer */
//    while (NumberOfBlocks--)
//    {
//        /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
//        SD_SendCmd (SD_CMD_READ_SINGLE_BLOCK, ReadAddr + Offset);
//        /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
//        if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
//        {
//            return  SD_RESPONSE_FAILURE;
//        }
//        /*!< Now look for the data token to signify the start of the data */
//        if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
//        {
//            /*!< Read the SD block data : read NumByteToRead data */
//            for (i = 0; i < BlockSize; i++)
//            {
//                /*!< Read the pointed data */
//                *pBuffer = SD_ReadByte();
//                /*!< Point to the next location where the byte read will be saved */
//                pBuffer++;
//            }   
//            /*!< Set next read address*/
//            Offset += 512;
//            /*!< get CRC bytes (not really needed by us, but required by SD) */
//            SD_ReadByte();
//            SD_ReadByte();
//            /*!< Set response value to success */
//            rvalue = SD_RESPONSE_NO_ERROR;
//        }
//        else
//        {
//            /*!< Set response value to failure */
//            rvalue = SD_RESPONSE_FAILURE;
//        }
//    }
//    /*!< SD chip select high */
//    SD_CS_HIGH;
//    /*!< Send dummy byte: 8 Clock pulses of delay */
//    SD_WriteByte(SD_DUMMY_BYTE);
//    /*!< Returns the reponse */
//    return rvalue;
//}

/**
  * @brief  Writes a block on the SD
  * @param  pBuffer: pointer to the buffer containing the data to be written on 
  *                  the SD.
  * @param  WriteAddr: address to write on.
  * @param  BlockSize: the SD card Data block size.
  * @retval The SD Response: 
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_WriteBlock(const uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize)
{
    uint32_t i = 0;
    uint16_t crc_16;
    SD_Error rvalue = SD_RESPONSE_FAILURE;
    crc_16 = crc16(pBuffer, 512);
    SD_CS_LOW;
    /*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write multiple block */
    SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr);
    /*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
    if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
    {
        SD_WriteByte(SD_DUMMY_BYTE);
        /*!< Send the data token to signify the start of the data */
        SD_WriteByte(0xFE);
        /*!< Write the block data to SD : write count data by block */
        for (i = 0; i < BlockSize; i++)
        {
            /*!< Send the pointed byte */
            SD_WriteByte(*pBuffer);
            /*!< Point to the next location where the byte read will be saved */
            pBuffer++;
        }
        SD_WriteByte((uint8_t)((crc_16 >> 8) & 0x00FF));
        SD_WriteByte((uint8_t)(crc_16 & 0x00FF));
        /*!< Read data response */
        if (SD_GetDataResponse() == SD_DATA_OK)
        {
            rvalue = SD_RESPONSE_NO_ERROR;
        }
    }
    SD_CS_HIGH;
    SD_WriteByte(SD_DUMMY_BYTE);
    return rvalue;
}

/**
  * @brief  Writes many blocks on the SD
  * @param  pBuffer: pointer to the buffer containing the data to be written on 
  *                  the SD.
  * @param  WriteAddr: address to write on.
  * @param  BlockSize: the SD card Data block size.
  * @param  NumberOfBlocks: number of blocks to be written.
  * @retval The SD Response: 
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
//SD_Error SD_WriteMultiBlocks(const uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
//{
//    uint32_t i = 0, Offset = 0;
//    SD_Error rvalue = SD_RESPONSE_FAILURE;

//    /*!< SD chip select low */
//    SD_CS_LOW;
//    /*!< Data transfer */
//    while (NumberOfBlocks--)
//    {
//        /*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write blocks */
//        SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr + Offset);
//        /*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
//        if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
//        {
//            return SD_RESPONSE_FAILURE;
//        }
//        /*!< Send dummy byte */
//        SD_WriteByte(SD_DUMMY_BYTE);
//        /*!< Send the data token to signify the start of the data */
//        SD_WriteByte(SD_START_DATA_SINGLE_BLOCK_WRITE);
//        /*!< Write the block data to SD : write count data by block */
//        for (i = 0; i < BlockSize; i++)
//        {
//            /*!< Send the pointed byte */
//            SD_WriteByte(*pBuffer);
//            /*!< Point to the next location where the byte read will be saved */
//            pBuffer++;
//        }
//        /*!< Set next write address */
//        Offset += 512;
//        /*!< Put CRC bytes (not really needed by us, but required by SD) */
//        SD_ReadByte();
//        SD_ReadByte();
//        /*!< Read data response */
//        if (SD_GetDataResponse() == SD_DATA_OK)
//        {
//            /*!< Set response value to success */
//            rvalue = SD_RESPONSE_NO_ERROR;
//        }
//        else
//        {
//            /*!< Set response value to failure */
//            rvalue = SD_RESPONSE_FAILURE;
//        }
//    }
//    /*!< SD chip select high */
//    SD_CS_HIGH;
//    /*!< Send dummy byte: 8 Clock pulses of delay */
//    SD_WriteByte(SD_DUMMY_BYTE);
//    /*!< Returns the reponse */
//    return rvalue;
//}

/**
  * @brief  Read the CSD card register.
  *         Reading the contents of the CSD register in SPI mode is a simple 
  *         read-block transaction.
  * @param  SD_csd: pointer on an SCD register structure
  * @retval The SD Response: 
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetCSDRegister(SD_CSD* SD_csd)
{
    uint32_t i = 0;
    SD_Error rvalue = SD_RESPONSE_FAILURE;
    uint8_t CSD_Tab[16];

    /*!< SD chip select low */
    SD_CS_LOW;
    /*!< Send CMD9 (CSD register) or CMD10(CSD register) */
    SD_SendCmd(SD_CMD_SEND_CSD, 0);
    /*!< Wait for response in the R1 format (0x00 is no errors) */
    if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
    {
        if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
        {
            for (i = 0; i < 16; i++)
            {
                /*!< Store CSD register value on CSD_Tab */
                CSD_Tab[i] = SD_ReadByte();
            }
        }
        /*!< Get CRC bytes (not really needed by us, but required by SD) */
        SD_WriteByte(SD_DUMMY_BYTE);
        SD_WriteByte(SD_DUMMY_BYTE);
        /*!< Set response value to success */
        rvalue = SD_RESPONSE_NO_ERROR;
    }
    /*!< SD chip select high */
    SD_CS_HIGH;
    /*!< Send dummy byte: 8 Clock pulses of delay */
    SD_WriteByte(SD_DUMMY_BYTE);

    /*!< Byte 0 */
    SD_csd->CSDStruct = (CSD_Tab[0] & 0xC0) >> 6;
    SD_csd->SysSpecVersion = (CSD_Tab[0] & 0x3C) >> 2;
    SD_csd->Reserved1 = CSD_Tab[0] & 0x03;

    /*!< Byte 1 */
    SD_csd->TAAC = CSD_Tab[1];

    /*!< Byte 2 */
    SD_csd->NSAC = CSD_Tab[2];

    /*!< Byte 3 */
    SD_csd->MaxBusClkFrec = CSD_Tab[3];

    /*!< Byte 4 */
    SD_csd->CardComdClasses = CSD_Tab[4] << 4;

    /*!< Byte 5 */
    SD_csd->CardComdClasses |= (CSD_Tab[5] & 0xF0) >> 4;
    SD_csd->RdBlockLen = CSD_Tab[5] & 0x0F;

    /*!< Byte 6 */
    SD_csd->PartBlockRead = (CSD_Tab[6] & 0x80) >> 7;
    SD_csd->WrBlockMisalign = (CSD_Tab[6] & 0x40) >> 6;
    SD_csd->RdBlockMisalign = (CSD_Tab[6] & 0x20) >> 5;
    SD_csd->DSRImpl = (CSD_Tab[6] & 0x10) >> 4;
    SD_csd->Reserved2 = 0; /*!< Reserved */

    SD_csd->DeviceSize = CSD_Tab[9] | ((uint16_t)CSD_Tab[8] << 8);
    
    SD_csd->EraseGrSize = (CSD_Tab[10] & 0x40) >> 6;
    SD_csd->EraseGrMul = (CSD_Tab[10] & 0x3F) << 1;

    /*!< Byte 11 */
    SD_csd->EraseGrMul |= (CSD_Tab[11] & 0x80) >> 7;
    SD_csd->WrProtectGrSize = (CSD_Tab[11] & 0x7F);

    /*!< Byte 12 */
    SD_csd->WrProtectGrEnable = (CSD_Tab[12] & 0x80) >> 7;
    SD_csd->ManDeflECC = (CSD_Tab[12] & 0x60) >> 5;
    SD_csd->WrSpeedFact = (CSD_Tab[12] & 0x1C) >> 2;
    SD_csd->MaxWrBlockLen = (CSD_Tab[12] & 0x03) << 2;

    /*!< Byte 13 */
    SD_csd->MaxWrBlockLen |= (CSD_Tab[13] & 0xC0) >> 6;
    SD_csd->WriteBlockPaPartial = (CSD_Tab[13] & 0x20) >> 5;
    SD_csd->Reserved3 = 0;
    SD_csd->ContentProtectAppli = (CSD_Tab[13] & 0x01);

    /*!< Byte 14 */
    SD_csd->FileFormatGrouop = (CSD_Tab[14] & 0x80) >> 7;
    SD_csd->CopyFlag = (CSD_Tab[14] & 0x40) >> 6;
    SD_csd->PermWrProtect = (CSD_Tab[14] & 0x20) >> 5;
    SD_csd->TempWrProtect = (CSD_Tab[14] & 0x10) >> 4;
    SD_csd->FileFormat = (CSD_Tab[14] & 0x0C) >> 2;
    SD_csd->ECC = (CSD_Tab[14] & 0x03);

    /*!< Byte 15 */
    SD_csd->CSD_CRC = (CSD_Tab[15] & 0xFE) >> 1;
    SD_csd->Reserved4 = 1;

    /*!< Return the reponse */
    return rvalue;
}

/**
  * @brief  Read the CID card register.
  *         Reading the contents of the CID register in SPI mode is a simple 
  *         read-block transaction.
  * @param  SD_cid: pointer on an CID register structure
  * @retval The SD Response: 
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetCIDRegister(SD_CID* SD_cid)
{
    uint32_t i = 0;
    SD_Error rvalue = SD_RESPONSE_FAILURE;
    uint8_t CID_Tab[16];
  
    /*!< SD chip select low */
    SD_CS_LOW;
  
    /*!< Send CMD10 (CID register) */
    SD_SendCmd(SD_CMD_SEND_CID, 0);
  
    /*!< Wait for response in the R1 format (0x00 is no errors) */
    if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
    {
        if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
        {
            /*!< Store CID register value on CID_Tab */
            for (i = 0; i < 16; i++)
            {
                CID_Tab[i] = SD_ReadByte();
            }
        }
        /*!< Get CRC bytes (not really needed by us, but required by SD) */
        SD_WriteByte(SD_DUMMY_BYTE);
        SD_WriteByte(SD_DUMMY_BYTE);
        /*!< Set response value to success */
        rvalue = SD_RESPONSE_NO_ERROR;
    }
    /*!< SD chip select high */
    SD_CS_HIGH;
    /*!< Send dummy byte: 8 Clock pulses of delay */
    SD_WriteByte(SD_DUMMY_BYTE);

    /*!< Byte 0 */
    SD_cid->ManufacturerID = CID_Tab[0];

    /*!< Byte 1 */
    SD_cid->OEM_AppliID = CID_Tab[1] << 8;

    /*!< Byte 2 */
    SD_cid->OEM_AppliID |= CID_Tab[2];

    /*!< Byte 3 */
    SD_cid->ProdName1 = CID_Tab[3] << 24;

    /*!< Byte 4 */
    SD_cid->ProdName1 |= CID_Tab[4] << 16;

    /*!< Byte 5 */
    SD_cid->ProdName1 |= CID_Tab[5] << 8;

    /*!< Byte 6 */
    SD_cid->ProdName1 |= CID_Tab[6];

    /*!< Byte 7 */
    SD_cid->ProdName2 = CID_Tab[7];

    /*!< Byte 8 */
    SD_cid->ProdRev = CID_Tab[8];

    /*!< Byte 9 */
    SD_cid->ProdSN = CID_Tab[9] << 24;

    /*!< Byte 10 */
    SD_cid->ProdSN |= CID_Tab[10] << 16;

    /*!< Byte 11 */
    SD_cid->ProdSN |= CID_Tab[11] << 8;

    /*!< Byte 12 */
    SD_cid->ProdSN |= CID_Tab[12];

    /*!< Byte 13 */
    SD_cid->Reserved1 |= (CID_Tab[13] & 0xF0) >> 4;
    SD_cid->ManufactDate = (CID_Tab[13] & 0x0F) << 8;

    /*!< Byte 14 */
    SD_cid->ManufactDate |= CID_Tab[14];

    /*!< Byte 15 */
    SD_cid->CID_CRC = (CID_Tab[15] & 0xFE) >> 1;
    SD_cid->Reserved2 = 1;

    /*!< Return the reponse */
    return rvalue;
}

/**
  * @brief  Send 5 bytes command to the SD card.
  * @param  Cmd: The user expected command to send to SD card.
  * @param  Arg: The command argument.
  * @param  Crc: The CRC.
  * @retval None
  */
void SD_SendCmd(uint8_t Cmd, uint32_t Arg)
{
    uint8_t crc_buf[6];
  
    SD_WriteByte(crc_buf[0] = (Cmd | 0x40)); /*!< Construct byte 1 */
  
    SD_WriteByte(crc_buf[1] = (uint8_t)(Arg >> 24)); /*!< Construct byte 2 */
  
    SD_WriteByte(crc_buf[2] = (uint8_t)(Arg >> 16)); /*!< Construct byte 3 */
  
    SD_WriteByte(crc_buf[3] = (uint8_t)(Arg >> 8)); /*!< Construct byte 4 */
  
    SD_WriteByte(crc_buf[4] = (uint8_t)(Arg)); /*!< Construct byte 5 */
  
    SD_WriteByte(crc_buf[5] = (crc7(crc_buf))); /*!< Construct CRC: byte 6 */
 
}

/**
  * @brief  Get SD card data response.
  * @param  None
  * @retval The SD status: Read data response xxx0<status>1
  *         - status 010: Data accecpted
  *         - status 101: Data rejected due to a crc error
  *         - status 110: Data rejected due to a Write error.
  *         - status 111: Data rejected due to other error.
  */
uint8_t SD_GetDataResponse(void)
{
    uint32_t i = 0;
    uint8_t response, rvalue;
    while (i <= 64)
    {
        /*!< Read response */
        response = SD_ReadByte();
        /*!< Mask unused bits */
        response &= 0x1F;
        switch (response)
        {
            case SD_DATA_OK:
            {
                rvalue = SD_DATA_OK;
                break;
            }
            case SD_DATA_CRC_ERROR:
                return SD_DATA_CRC_ERROR;
            case SD_DATA_WRITE_ERROR:
                return SD_DATA_WRITE_ERROR;
            default:
            {
                rvalue = SD_DATA_OTHER_ERROR;
                break;
            }
        }
        /*!< Exit loop in case of data ok */
        if (rvalue == SD_DATA_OK)
            break;
        /*!< Increment loop counter */
        i++;
    }
    /*!< Wait null data */
    while (SD_ReadByte() == 0);
    /*!< Return response */
    return response;
}

/**
  * @brief  Returns the SD response.
  * @param  None
  * @retval The SD Response: 
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetResponse(uint8_t Response)
{
    uint32_t Count = 0xFFF;

    /*!< Check if response is got or a timeout is happen */
    while ((SD_ReadByte() != Response) && Count)
    {
        Count--;
    }
    if (Count == 0)
    {
        /*!< After time out */
        return SD_RESPONSE_FAILURE;
    }
    else
    {
        /*!< Right response got */
        return SD_RESPONSE_NO_ERROR;
    }
}

/**
  * @brief  Returns the SD status.
  * @param  None
  * @retval The SD status.
  */
uint16_t SD_GetStatus(void)
{
    uint16_t Status = 0;
    /*!< SD chip select low */
    SD_CS_LOW;
    /*!< Send CMD13 (SD_SEND_STATUS) to get SD status */
    SD_SendCmd(SD_CMD_SEND_STATUS, 0);
    while((Status = SD_ReadByte()) == 0xFF);
    Status |= (uint16_t)(SD_ReadByte() << 8);
    /*!< SD chip select high */
    SD_CS_HIGH;
    /*!< Send dummy byte 0xFF */
    SD_WriteByte(SD_DUMMY_BYTE);
    return Status;
}

/**
  * @brief  Put SD in Idle state.
  * @param  None
  * @retval The SD Response: 
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GoIdleState(void)
{
    
    uint8_t ocr[4] = {0,0,0,0};
    uint8_t i;
    
    SD_CS_LOW;
    /*!< Send CMD0 (SD_CMD_GO_IDLE_STATE) to put SD in SPI mode */
    SD_SendCmd(SD_CMD_GO_IDLE_STATE, 0);
  
    /*!< Wait for In Idle State Response (R1 Format) equal to 0x01 */
    if (SD_GetResponse(SD_IN_IDLE_STATE))
    {
        return SD_RESPONSE_FAILURE;
    }
    /*----------Activates the card initialization process-----------*/
    
    SD_CS_HIGH;
    SD_WriteByte(SD_DUMMY_BYTE);
    SD_CS_LOW;
    SD_SendCmd(SD_CMD_SEND_IF_COND, 0x1AA);
    if(!SD_GetResponse(SD_IN_IDLE_STATE))           // wait for the answer or until delay
    { 
		for (i = 0; i < 4; i++)                    //checking response of CMD8
		{	
            ocr[i] = SD_ReadByte();
		}     		
        if (ocr[2] == 0x01 && ocr[3] == 0xAA)       // The card can operate at vdd range of 2.7-3.6V 	
        {							
            while(1)                             // will hang here if card doesn't work
            {
                SD_CS_HIGH;
                SD_WriteByte(SD_DUMMY_BYTE);
                SD_CS_LOW;
                SD_SendCmd(SD_CMD_APP_CMD, 0x00);
                if(!SD_GetResponse(SD_IN_IDLE_STATE))
                {
                    SD_SendCmd(SD_CMD_SEND_OP_COND, 1 << 30);	
                    if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
                    {
                        break;
                    }
                }
            }
            SD_CS_HIGH;
            SD_WriteByte(SD_DUMMY_BYTE);
            SD_CS_LOW;
            SD_SendCmd(SD_CMD_READ_OCR, 0x00);
            if(!SD_GetResponse(SD_RESPONSE_NO_ERROR))
            {
                for (i=0; i<4; i++)
                {
                    SD_ReadByte();
                }    
            }
            SD_CS_HIGH;
            SD_WriteByte(SD_DUMMY_BYTE);
            
            SD_CS_LOW;
            SD_SendCmd(SD_CMD_SET_BLOCKLEN, 512);
            SD_GetResponse(SD_RESPONSE_NO_ERROR);
            SD_CS_HIGH;
            SD_WriteByte(SD_DUMMY_BYTE);
            
            SD_CS_LOW;
            SD_SendCmd(SD_CMD_CRC_ON_OFF, 1);
            SD_GetResponse(SD_RESPONSE_NO_ERROR);
            SD_CS_HIGH;
            SD_WriteByte(SD_DUMMY_BYTE);
            dprintf_text(" Successful initialization SD card ");
            
        } else {
            SD_CS_HIGH;
            SD_WriteByte(SD_DUMMY_BYTE);
            dprintf_text(" Wrong type of card ");
        }

	} else {
        SD_CS_HIGH;
        SD_WriteByte(SD_DUMMY_BYTE);
        dprintf_text(" Init Failed ");
    }
    
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
    HAL_SPI_Init(&hspi1);
    return SD_RESPONSE_NO_ERROR;
}

/**
  * @brief  Write a byte on the SD.
  * @param  Data: byte to send.
  * @retval None
  */
uint8_t SD_WriteByte(uint8_t Data)
{  
    return (HAL_SPI_Transmit(&hspi1, &Data, 1, 100));
}

/**
  * @brief  Read a byte from the SD.
  * @param  None
  * @retval The received byte.
  */
uint8_t SD_ReadByte(void)
{
    uint8_t Data = 0xFF;
    HAL_SPI_Receive(&hspi1, &Data, 1, 100);
    return Data = *hspi1.pRxBuffPtr;
}

/****************************** END OF FILE *********************************/
