SD.hh

Go to the documentation of this file.

#ifndef COSA_SD_HH
#define COSA_SD_HH

#include "Cosa/Types.h"
#include "Cosa/SPI.hh"

class SD : private SPI::Driver {
public:
  static const size_t BLOCK_MAX = 512;

  enum CARD {
    TYPE_UNKNOWN = 0,
    TYPE_SD1 = 1,
    TYPE_SD2 = 2,
    TYPE_SDHC = 3
  } __attribute__((packed));

  struct cid_t {
    uint8_t mid;                
    char oid[2];                
    char pnm[5];                
    uint8_t prv;                
    uint32_t psn;               
    uint16_t mdt;               
    uint8_t crc;                
  };

  struct csd_v1_t {
    uint8_t reserved1:6;
    uint8_t csd_ver:2;
    uint8_t taac;
    uint8_t nsac;
    uint8_t tran_speed;
    uint8_t ccc_high;
    uint8_t read_bl_len:4;
    uint8_t ccc_low:4;
    uint8_t c_size_high:2;
    uint8_t reserved2:2;
    uint8_t dsr_imp:1;
    uint8_t read_blk_misalign:1;
    uint8_t write_blk_misalign:1;
    uint8_t read_bl_partial:1;
    uint8_t c_size_mid;
    uint8_t vdd_r_curr_max:3;
    uint8_t vdd_r_curr_min:3;
    uint8_t c_size_low :2;
    uint8_t c_size_mult_high:2;
    uint8_t vdd_w_cur_max:3;
    uint8_t vdd_w_curr_min:3;
    uint8_t sector_size_high:6;
    uint8_t erase_blk_en:1;
    uint8_t c_size_mult_low:1;
    uint8_t wp_grp_size:7;
    uint8_t sector_size_low:1;
    uint8_t write_bl_len_high:2;
    uint8_t r2w_factor:3;
    uint8_t reserved3:2;
    uint8_t wp_grp_enable:1;
    uint8_t reserved4:5;
    uint8_t write_partial:1;
    uint8_t write_bl_len_low:2;
    uint8_t reserved5:2;
    uint8_t file_format:2;
    uint8_t tmp_write_protect:1;
    uint8_t perm_write_protect:1;
    uint8_t copy:1;
    uint8_t file_format_grp:1;
    uint8_t crc;
  };

  struct csd_v2_t {
    uint8_t reserved1:6;
    uint8_t csd_ver:2;
    uint8_t taac;
    uint8_t nsac;
    uint8_t tran_speed;
    uint8_t ccc_high;
    uint8_t read_bl_len:4;
    uint8_t ccc_low:4;
    uint8_t reserved2:4;
    uint8_t dsr_imp:1;
    uint8_t read_blk_misalign:1;
    uint8_t write_blk_misalign:1;
    uint8_t read_bl_partial:1;
    uint8_t c_size_high:6;
    uint8_t reserved3:2;
    uint8_t c_size_mid;
    uint8_t c_size_low;
    uint8_t sector_size_high:6;
    uint8_t erase_blk_en:1;
    uint8_t reserved4:1;
    uint8_t wp_grp_size:7;
    uint8_t sector_size_low:1;
    uint8_t write_bl_len_high:2;
    uint8_t r2w_factor:3;
    uint8_t reserved5:2;
    uint8_t wp_grp_enable:1;
    uint8_t reserved6:5;
    uint8_t write_partial:1;
    uint8_t write_bl_len_low:2;
    uint8_t reserved7:2;
    uint8_t file_format:2;
    uint8_t tmp_write_protect:1;
    uint8_t perm_write_protect:1;
    uint8_t copy:1;
    uint8_t file_format_grp:1;
    uint8_t crc;
  };

  union csd_t {
    csd_v1_t v1;
    csd_v2_t v2;
  };

protected:
  enum CMD {
    GO_IDLE_STATE = 0,          
    ALL_SEND_CID = 2,           
    SEND_RELATIVE_ADDR = 3,     
    SET_DSR = 4,                
    SWITCH_FUNC = 6,            
    SELECT_DESELECT_CARD = 7,   
    SEND_IF_COND = 8,           
    SEND_CSD = 9,               
    SEND_CID = 10,              
    VOLTAGE_SWITCH = 11,        
    STOP_TRANSMISSION = 12,     
    SEND_STATUS = 13,           
    GO_INACTIVE_STATE = 15,     
    SET_BLOCKLEN = 16,          
    READ_SINGLE_BLOCK = 17,     
    READ_MULTIPLE_BLOCK = 18,   
    SEND_TUNING_BLOCK = 19,     
    SPEED_CLASS_CONTROL = 20,   
    SET_BLOCK_COUNT = 23,       
    WRITE_BLOCK = 24,           
    WRITE_MULTIPLE_BLOCK = 25,  
    PROGRAM_CSD = 27,           
    SET_WRITE_PROT = 28,        
    CLR_WRITE_PROT = 29,        
    SEND_WRITE_PROT = 30,       
    ERASE_WR_BLK_START = 32,    
    ERASE_WR_BLK_END = 33,      
    ERASE = 38,                 
    LOCK_UNLOCK = 40,           
    APP_CMD = 55,               
    GEN_CMD = 56,               
    READ_OCR = 58,              
    CRC_ON_OFF = 59             
  } __attribute__((packed));

  enum ACMD {
    SET_BUS_WIDTH = 6,          
    SD_STATUS = 13,             
    SEND_NUM_WR_BLOCKS = 22,    
    SET_WR_BLK_ERASE_COUNT = 23, 
    SD_SEND_OP_COND = 41,        
    SET_CLR_CARD_DETECT = 42,    
    SEND_SCR = 51                
  } __attribute__((packed));

  enum STATE {
    IDLE_STATE = 0,
    READY_STATE = 1,
    IDENT_STATE = 2,
    STBY_STATE = 3,
    TRAN_STATE = 4,
    DATA_STATE = 5,
    RCV_STATE = 6,
    PRG_STATE = 7,
    DIS_STATE = 8
  } __attribute__((packed));;

  union R1 {
    uint8_t as_uint8;
    struct {
      uint8_t in_idle_state:1;
      uint8_t erase_reset:1;
      uint8_t illegal_command:1;
      uint8_t com_crc_error:1;
      uint8_t erase_sequence_error:1;
      uint8_t address_error:1;
      uint8_t parameter_error:1;
      uint8_t reserved:1;
    };
    R1(uint8_t value = 0) { as_uint8 = value; }
    bool is_error() const { return ((as_uint8 & 0x7e) != 0); }
    bool is_ready() const { return (as_uint8 == 0); }
  };

  union R2 {
    uint8_t as_uint8;
    struct {
      uint8_t card_is_locked:1;
      uint8_t wp_erased:1;
      uint8_t error:1;
      uint8_t cc_error:1;
      uint8_t card_ecc_failed:1;
      uint8_t wp_violation:1;
      uint8_t erase_param:1;
      uint8_t out_of_range:1;
    };
    R2(uint8_t value = 0) { as_uint8 = value; }
  };

  struct R3 {
    uint32_t vdd_voltage_window:24;
    uint8_t switch_to_1V8_accepted:1;
    uint8_t reserved:4;
    uint8_t uhs_ii_card:1;
    uint8_t card_capacity:1;
    uint8_t card_power_up:1;
  };

  union R6 {
    uint32_t as_uint32;
    struct {
      uint16_t rca;
      uint16_t status;
    };
    R6(uint32_t value = 0L) { as_uint32 = value; }
  };

  union R7 {
    uint32_t as_uint32;
    struct {
      uint8_t check_pattern;
      uint8_t voltage_accepted:4;
      uint32_t reserved:16;
      uint8_t command_version:4;
    };
    R7(uint32_t value = 0L) { as_uint32 = value; }
  };

  static const uint8_t CHECK_PATTERN = 0xAA;

  enum TOKEN {
    DATA_START_BLOCK = 0XFE,
    WRITE_MULTIPLE_TOKEN = 0XFC,
    STOP_TRAN_TOKEN = 0XFD,
    DATA_RES_MASK = 0X1F,
    DATA_RES_ACCEPTED = 0X05,
    DATA_RES_CRC_ERR = 0X0B,
    DATA_RES_WR_ERR = 0X0E
  } __attribute__((packed));

  struct request_t {
    uint8_t command;
    uint32_t arg;
    uint8_t crc;
  };

  static const uint16_t INIT_TIMEOUT = 2000;
  static const uint16_t ERASE_TIMEOUT = 10000;
  static const uint16_t READ_TIMEOUT = 300;
  static const uint16_t WRITE_TIMEOUT = 600;

  static const uint8_t INIT_PULSES = 10;

  static const uint8_t INIT_RETRY = 200;
  static const uint8_t RESPONSE_RETRY = 100;

  uint8_t m_response;

  CARD m_type;

  uint8_t send(CMD command, uint32_t arg = 0L);

  bool send(uint16_t ms, CMD command, uint32_t arg = 0L);

  uint8_t send(ACMD command, uint32_t arg = 0L);

  bool send(uint16_t ms, ACMD command, uint32_t arg = 0L);

  bool await(uint16_t ms = 0, uint8_t token = 0);

  uint32_t receive();

  bool read(CMD command, uint32_t arg, void* buf, size_t count);

public:
#if defined(BOARD_ATTINYX5)
  SD(Board::DigitalPin csn = Board::D3) :
    SPI::Driver(csn, SPI::ACTIVE_LOW, SPI::DIV128_CLOCK, 0, SPI::MSB_ORDER, NULL),
    m_type(TYPE_UNKNOWN)
  {}
#elif defined(WICKEDDEVICE_WILDFIRE)
  SD(Board::DigitalPin csn = Board::D16) :
    SPI::Driver(csn, SPI::ACTIVE_LOW, SPI::DIV128_CLOCK, 0, SPI::MSB_ORDER, NULL),
    m_type(TYPE_UNKNOWN)
  {}
#else
  SD(Board::DigitalPin csn = Board::D8) :
    SPI::Driver(csn, SPI::ACTIVE_LOW, SPI::DIV128_CLOCK, 0, SPI::MSB_ORDER, NULL),
    m_type(TYPE_UNKNOWN)
  {}
#endif

  CARD type() const
  {
    return (m_type);
  }

  bool begin(SPI::Clock rate = SPI::DIV128_CLOCK);

  bool end();

  bool erase(uint32_t start, uint32_t end);

  bool read(uint32_t block, uint8_t* dst)
    __attribute__((always_inline))
  {
    if (m_type != TYPE_SDHC) block <<= 9;
    return (read(READ_SINGLE_BLOCK, block, dst, BLOCK_MAX));
  }

  bool read(cid_t* cid)
    __attribute__((always_inline))
  {
    return (read(SEND_CID, 0, cid, sizeof(cid_t)));
  }

  bool read(csd_t* csd)
    __attribute__((always_inline))
  {
    return (read(SEND_CSD, 0, csd, sizeof(csd_t)));
  }

  bool write(uint32_t block, const uint8_t* src);
};

#endif