SDIO. Common code moved from sdc.c to mmcsd superclass.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@7690 35acf78f-673a-0410-8e92-d51de3d6d3f4

3 files changed, 340 insertions, 317 deletions

diff --git a/os/hal/include/hal_mmcsd.h b/os/hal/include/hal_mmcsd.h
index b310124af..18af3bd69 100644
--- a/os/hal/include/hal_mmcsd.h
+++ b/os/hal/include/hal_mmcsd.h
@@ -288,6 +288,140 @@ typedef struct {
   _mmcsd_block_device_data

 } MMCSDBlockDevice;

 

+/**

+ * @brief   Unpacked CID register from SDC.

+ */

+typedef struct {

+  uint8_t   mid;

+  uint16_t  oid;

+  char      pnm[5];

+  uint8_t   prv_n;

+  uint8_t   prv_m;

+  uint32_t  psn;

+  uint8_t   mdt_m;

+  uint16_t  mdt_y;

+  uint8_t   crc;

+} unpacked_sdc_cid_t;

+

+/**

+ * @brief   Unpacked CID register from MMC.

+ */

+typedef struct {

+  uint8_t   mid;

+  uint16_t  oid;

+  char      pnm[6];

+  uint8_t   prv_n;

+  uint8_t   prv_m;

+  uint32_t  psn;

+  uint8_t   mdt_m;

+  uint16_t  mdt_y;

+  uint8_t   crc;

+} unpacked_mmc_cid_t;

+

+/**

+ * @brief   Unpacked CSD v1.0 register from SDC.

+ */

+typedef struct {

+  uint8_t   csd_structure;

+  uint8_t   taac;

+  uint8_t   nsac;

+  uint8_t   tran_speed;

+  uint16_t  ccc;

+  uint8_t   read_bl_len;

+  uint8_t   read_bl_partial;

+  uint8_t   write_blk_misalign;

+  uint8_t   read_blk_misalign;

+  uint8_t   dsr_imp;

+  uint16_t  c_size;

+  uint8_t   vdd_r_curr_min;

+  uint8_t   vdd_r_curr_max;

+  uint8_t   vdd_w_curr_min;

+  uint8_t   vdd_w_curr_max;

+  uint8_t   c_size_mult;

+  uint8_t   erase_blk_en;

+  uint8_t   erase_sector_size;

+  uint8_t   wp_grp_size;

+  uint8_t   wp_grp_enable;

+  uint8_t   r2w_factor;

+  uint8_t   write_bl_len;

+  uint8_t   write_bl_partial;

+  uint8_t   file_format_grp;

+  uint8_t   copy;

+  uint8_t   perm_write_protect;

+  uint8_t   tmp_write_protect;

+  uint8_t   file_format;

+  uint8_t   crc;

+} unpacked_sdc_csd_10_t;

+

+/**

+ * @brief   Unpacked CSD v2.0 register from SDC.

+ */

+typedef struct {

+  uint8_t   csd_structure;

+  uint8_t   taac;

+  uint8_t   nsac;

+  uint8_t   tran_speed;

+  uint16_t  ccc;

+  uint8_t   read_bl_len;

+  uint8_t   read_bl_partial;

+  uint8_t   write_blk_misalign;

+  uint8_t   read_blk_misalign;

+  uint8_t   dsr_imp;

+  uint32_t  c_size;

+  uint8_t   erase_blk_en;

+  uint8_t   erase_sector_size;

+  uint8_t   wp_grp_size;

+  uint8_t   wp_grp_enable;

+  uint8_t   r2w_factor;

+  uint8_t   write_bl_len;

+  uint8_t   write_bl_partial;

+  uint8_t   file_format_grp;

+  uint8_t   copy;

+  uint8_t   perm_write_protect;

+  uint8_t   tmp_write_protect;

+  uint8_t   file_format;

+  uint8_t   crc;

+} unmacked_sdc_csd_20_t;

+

+/**

+ * @brief   Unpacked CSD register from MMC.

+ */

+typedef struct {

+  uint8_t   csd_structure;

+  uint8_t   spec_vers;

+  uint8_t   taac;

+  uint8_t   nsac;

+  uint8_t   tran_speed;

+  uint16_t  ccc;

+  uint8_t   read_bl_len;

+  uint8_t   read_bl_partial;

+  uint8_t   write_blk_misalign;

+  uint8_t   read_blk_misalign;

+  uint8_t   dsr_imp;

+  uint16_t  c_size;

+  uint8_t   vdd_r_curr_min;

+  uint8_t   vdd_r_curr_max;

+  uint8_t   vdd_w_curr_min;

+  uint8_t   vdd_w_curr_max;

+  uint8_t   c_size_mult;

+  uint8_t   erase_grp_size;

+  uint8_t   erase_grp_mult;

+  uint8_t   wp_grp_size;

+  uint8_t   wp_grp_enable;

+  uint8_t   default_ecc;

+  uint8_t   r2w_factor;

+  uint8_t   write_bl_len;

+  uint8_t   write_bl_partial;

+  uint8_t   content_prot_app;

+  uint8_t   file_format_grp;

+  uint8_t   copy;

+  uint8_t   perm_write_protect;

+  uint8_t   tmp_write_protect;

+  uint8_t   file_format;

+  uint8_t   ecc;

+  uint8_t   crc;

+} unpacked_mmc_csd_t;

+

 /*===========================================================================*/

 /* Driver macros.                                                            */

 /*===========================================================================*/

@@ -341,9 +475,15 @@ typedef struct {
 #ifdef __cplusplus

 extern "C" {

 #endif

-  uint32_t mmcsd_get_slice(const uint32_t *data, uint32_t end, uint32_t start);

+  uint32_t mmcsdGetSlice(const uint32_t *data, uint32_t end, uint32_t start);

   uint32_t mmcsdGetCapacity(const uint32_t *csd);

   uint32_t mmcsdGetCapacityMMC(const uint32_t *csd, const uint8_t *ext_csd);

+  void sdcUnpackCID(const MMCSDBlockDevice *sdcp, unpacked_sdc_cid_t *cidsdc);

+  void mmcUnpackCID(const MMCSDBlockDevice *sdcp, unpacked_mmc_cid_t *cidmmc);

+  void sdcUnpackCSDv10(const MMCSDBlockDevice *sdcp,

+                       unpacked_sdc_csd_10_t *csd10);

+  void sdcUnpackCSDv20(const MMCSDBlockDevice *sdcp,

+                       unmacked_sdc_csd_20_t *csd20);

 #ifdef __cplusplus

 }

 #endif

diff --git a/os/hal/src/hal_mmcsd.c b/os/hal/src/hal_mmcsd.c
index e9ae05966..d113c5ebd 100644
--- a/os/hal/src/hal_mmcsd.c
+++ b/os/hal/src/hal_mmcsd.c
@@ -61,7 +61,7 @@
  *

  * @notapi

  */

-uint32_t mmcsd_get_slice(const uint32_t *data, uint32_t end, uint32_t start) {

+uint32_t mmcsdGetSlice(const uint32_t *data, uint32_t end, uint32_t start) {

   unsigned startidx, endidx, startoff;

   uint32_t endmask;

 

@@ -93,16 +93,16 @@ uint32_t mmcsdGetCapacity(const uint32_t *csd) {
 

   osalDbgCheck(NULL != csd);

 

-  switch (mmcsd_get_slice(csd, MMCSD_CSD_10_CSD_STRUCTURE_SLICE)) {

+  switch (mmcsdGetSlice(csd, MMCSD_CSD_10_CSD_STRUCTURE_SLICE)) {

   case 0:

     /* CSD version 1.0 */

-    a = mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_SLICE);

-    b = mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_MULT_SLICE);

-    c = mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BL_LEN_SLICE);

+    a = mmcsdGetSlice(csd, MMCSD_CSD_10_C_SIZE_SLICE);

+    b = mmcsdGetSlice(csd, MMCSD_CSD_10_C_SIZE_MULT_SLICE);

+    c = mmcsdGetSlice(csd, MMCSD_CSD_10_READ_BL_LEN_SLICE);

     return (a + 1) << (b + 2) << (c - 9);       /* 2^9 == MMCSD_BLOCK_SIZE. */

   case 1:

     /* CSD version 2.0.*/

-    return 1024 * (mmcsd_get_slice(csd, MMCSD_CSD_20_C_SIZE_SLICE) + 1);

+    return 1024 * (mmcsdGetSlice(csd, MMCSD_CSD_20_C_SIZE_SLICE) + 1);

   default:

     /* Reserved value detected.*/

     return 0;

@@ -123,10 +123,10 @@ uint32_t mmcsdGetCapacityMMC(const uint32_t *csd, const uint8_t *ext_csd) {
 

   osalDbgCheck(NULL != csd);

 

-  a = mmcsd_get_slice(csd, MMCSD_CSD_MMC_C_SIZE_SLICE);

+  a = mmcsdGetSlice(csd, MMCSD_CSD_MMC_C_SIZE_SLICE);

   if (0xFFF != a) {

-    b = mmcsd_get_slice(csd, MMCSD_CSD_MMC_C_SIZE_MULT_SLICE);

-    c = mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BL_LEN_SLICE);

+    b = mmcsdGetSlice(csd, MMCSD_CSD_MMC_C_SIZE_MULT_SLICE);

+    c = mmcsdGetSlice(csd, MMCSD_CSD_MMC_READ_BL_LEN_SLICE);

     return (a + 1) << (b + 2) << (c - 9);       /* 2^9 == MMCSD_BLOCK_SIZE. */

   }

   else if (NULL != ext_csd) {

@@ -139,6 +139,195 @@ uint32_t mmcsdGetCapacityMMC(const uint32_t *csd, const uint8_t *ext_csd) {
     return 0;

 }

 

+/**

+ * @brief   Unpacks SDC CID array in structure.

+ *

+ * @param[in] sdcp      pointer to the @p MMCSDBlockDevice object

+ * @param[out] cidsdc   pointer to the @p unpacked_sdc_cid_t object

+ *

+ * @api

+ */

+void sdcUnpackCID(const MMCSDBlockDevice *sdcp, unpacked_sdc_cid_t *cidsdc) {

+  const uint32_t *cid;

+

+  osalDbgCheck((NULL != sdcp) && (NULL != cidsdc));

+  cid = sdcp->cid;

+

+  cidsdc->crc    = mmcsdGetSlice(cid, MMCSD_CID_SDC_CRC_SLICE);

+  cidsdc->mdt_y  = mmcsdGetSlice(cid, MMCSD_CID_SDC_MDT_Y_SLICE) + 2000;

+  cidsdc->mdt_m  = mmcsdGetSlice(cid, MMCSD_CID_SDC_MDT_M_SLICE);

+  cidsdc->mid    = mmcsdGetSlice(cid, MMCSD_CID_SDC_MID_SLICE);

+  cidsdc->oid    = mmcsdGetSlice(cid, MMCSD_CID_SDC_OID_SLICE);

+  cidsdc->pnm[4] = mmcsdGetSlice(cid, MMCSD_CID_SDC_PNM0_SLICE);

+  cidsdc->pnm[3] = mmcsdGetSlice(cid, MMCSD_CID_SDC_PNM1_SLICE);

+  cidsdc->pnm[2] = mmcsdGetSlice(cid, MMCSD_CID_SDC_PNM2_SLICE);

+  cidsdc->pnm[1] = mmcsdGetSlice(cid, MMCSD_CID_SDC_PNM3_SLICE);

+  cidsdc->pnm[0] = mmcsdGetSlice(cid, MMCSD_CID_SDC_PNM4_SLICE);

+  cidsdc->prv_n  = mmcsdGetSlice(cid, MMCSD_CID_SDC_PRV_N_SLICE);

+  cidsdc->prv_m  = mmcsdGetSlice(cid, MMCSD_CID_SDC_PRV_M_SLICE);

+  cidsdc->psn    = mmcsdGetSlice(cid, MMCSD_CID_SDC_PSN_SLICE);

+}

+

+/**

+ * @brief   Unpacks MMC CID array in structure.

+ *

+ * @param[in] sdcp      pointer to the @p MMCSDBlockDevice object

+ * @param[out] cidmmc   pointer to the @p unpacked_mmc_cid_t object

+ *

+ * @api

+ */

+void mmcUnpackCID(const MMCSDBlockDevice *sdcp, unpacked_mmc_cid_t *cidmmc) {

+  const uint32_t *cid;

+

+  osalDbgCheck((NULL != sdcp) && (NULL != cidmmc));

+  cid = sdcp->cid;

+

+  cidmmc->crc    = mmcsdGetSlice(cid, MMCSD_CID_MMC_CRC_SLICE);

+  cidmmc->mdt_y  = mmcsdGetSlice(cid, MMCSD_CID_MMC_MDT_Y_SLICE) + 1997;

+  cidmmc->mdt_m  = mmcsdGetSlice(cid, MMCSD_CID_MMC_MDT_M_SLICE);

+  cidmmc->mid    = mmcsdGetSlice(cid, MMCSD_CID_MMC_MID_SLICE);

+  cidmmc->oid    = mmcsdGetSlice(cid, MMCSD_CID_MMC_OID_SLICE);

+  cidmmc->pnm[5] = mmcsdGetSlice(cid, MMCSD_CID_MMC_PNM0_SLICE);

+  cidmmc->pnm[4] = mmcsdGetSlice(cid, MMCSD_CID_MMC_PNM1_SLICE);

+  cidmmc->pnm[3] = mmcsdGetSlice(cid, MMCSD_CID_MMC_PNM2_SLICE);

+  cidmmc->pnm[2] = mmcsdGetSlice(cid, MMCSD_CID_MMC_PNM3_SLICE);

+  cidmmc->pnm[1] = mmcsdGetSlice(cid, MMCSD_CID_MMC_PNM4_SLICE);

+  cidmmc->pnm[0] = mmcsdGetSlice(cid, MMCSD_CID_MMC_PNM5_SLICE);

+  cidmmc->prv_n  = mmcsdGetSlice(cid, MMCSD_CID_MMC_PRV_N_SLICE);

+  cidmmc->prv_m  = mmcsdGetSlice(cid, MMCSD_CID_MMC_PRV_M_SLICE);

+  cidmmc->psn    = mmcsdGetSlice(cid, MMCSD_CID_MMC_PSN_SLICE);

+}

+

+/**

+ * @brief   Unpacks MMC CSD array in structure.

+ *

+ * @param[in] sdcp      pointer to the @p MMCSDBlockDevice object

+ * @param[out] csdmmc   pointer to the @p unpacked_mmc_csd_t object

+ *

+ * @api

+ */

+void mmcUnpackCSD(const MMCSDBlockDevice *sdcp, unpacked_mmc_csd_t *csdmmc) {

+  const uint32_t *csd;

+

+  osalDbgCheck((NULL != sdcp) && (NULL != csdmmc));

+  csd = sdcp->csd;

+

+  csdmmc->c_size             = mmcsdGetSlice(csd, MMCSD_CSD_MMC_C_SIZE_SLICE);

+  csdmmc->c_size_mult        = mmcsdGetSlice(csd, MMCSD_CSD_MMC_C_SIZE_MULT_SLICE);

+  csdmmc->ccc                = mmcsdGetSlice(csd, MMCSD_CSD_MMC_CCC_SLICE);

+  csdmmc->copy               = mmcsdGetSlice(csd, MMCSD_CSD_MMC_COPY_SLICE);

+  csdmmc->crc                = mmcsdGetSlice(csd, MMCSD_CSD_MMC_CRC_SLICE);

+  csdmmc->csd_structure      = mmcsdGetSlice(csd, MMCSD_CSD_MMC_CSD_STRUCTURE_SLICE);

+  csdmmc->dsr_imp            = mmcsdGetSlice(csd, MMCSD_CSD_MMC_DSR_IMP_SLICE);

+  csdmmc->ecc                = mmcsdGetSlice(csd, MMCSD_CSD_MMC_ECC_SLICE);

+  csdmmc->erase_grp_mult     = mmcsdGetSlice(csd, MMCSD_CSD_MMC_ERASE_GRP_MULT_SLICE);

+  csdmmc->erase_grp_size     = mmcsdGetSlice(csd, MMCSD_CSD_MMC_ERASE_GRP_SIZE_SLICE);

+  csdmmc->file_format        = mmcsdGetSlice(csd, MMCSD_CSD_MMC_FILE_FORMAT_SLICE);

+  csdmmc->file_format_grp    = mmcsdGetSlice(csd, MMCSD_CSD_MMC_FILE_FORMAT_GRP_SLICE);

+  csdmmc->nsac               = mmcsdGetSlice(csd, MMCSD_CSD_MMC_NSAC_SLICE);

+  csdmmc->perm_write_protect = mmcsdGetSlice(csd, MMCSD_CSD_MMC_PERM_WRITE_PROTECT_SLICE);

+  csdmmc->r2w_factor         = mmcsdGetSlice(csd, MMCSD_CSD_MMC_R2W_FACTOR_SLICE);

+  csdmmc->read_bl_len        = mmcsdGetSlice(csd, MMCSD_CSD_MMC_READ_BL_LEN_SLICE);

+  csdmmc->read_bl_partial    = mmcsdGetSlice(csd, MMCSD_CSD_MMC_READ_BL_PARTIAL_SLICE);

+  csdmmc->read_blk_misalign  = mmcsdGetSlice(csd, MMCSD_CSD_MMC_READ_BLK_MISALIGN_SLICE);

+  csdmmc->spec_vers          = mmcsdGetSlice(csd, MMCSD_CSD_MMC_SPEC_VERS_SLICE);

+  csdmmc->taac               = mmcsdGetSlice(csd, MMCSD_CSD_MMC_TAAC_SLICE);

+  csdmmc->tmp_write_protect  = mmcsdGetSlice(csd, MMCSD_CSD_MMC_TMP_WRITE_PROTECT_SLICE);

+  csdmmc->tran_speed         = mmcsdGetSlice(csd, MMCSD_CSD_MMC_TRAN_SPEED_SLICE);

+  csdmmc->vdd_r_curr_max     = mmcsdGetSlice(csd, MMCSD_CSD_MMC_VDD_R_CURR_MAX_SLICE);

+  csdmmc->vdd_r_curr_min     = mmcsdGetSlice(csd, MMCSD_CSD_MMC_VDD_R_CURR_MIN_SLICE);

+  csdmmc->vdd_w_curr_max     = mmcsdGetSlice(csd, MMCSD_CSD_MMC_VDD_W_CURR_MAX_SLICE);

+  csdmmc->vdd_w_curr_min     = mmcsdGetSlice(csd, MMCSD_CSD_MMC_VDD_W_CURR_MIN_SLICE);

+  csdmmc->wp_grp_enable      = mmcsdGetSlice(csd, MMCSD_CSD_MMC_WP_GRP_ENABLE_SLICE);

+  csdmmc->wp_grp_size        = mmcsdGetSlice(csd, MMCSD_CSD_MMC_WP_GRP_SIZE_SLICE);

+  csdmmc->write_bl_len       = mmcsdGetSlice(csd, MMCSD_CSD_MMC_WRITE_BL_LEN_SLICE);

+  csdmmc->write_bl_partial   = mmcsdGetSlice(csd, MMCSD_CSD_MMC_WRITE_BL_PARTIAL_SLICE);

+  csdmmc->write_blk_misalign = mmcsdGetSlice(csd, MMCSD_CSD_MMC_WRITE_BLK_MISALIGN_SLICE);

+}

+

+/**

+ * @brief   Unpacks SDC CSD v1.0 array in structure.

+ *

+ * @param[in] sdcp      pointer to the @p MMCSDBlockDevice object

+ * @param[out] csd10    pointer to the @p unpacked_sdc_csd_10_t object

+ *

+ * @api

+ */

+void sdcUnpackCSDv10(const MMCSDBlockDevice *sdcp,

+                     unpacked_sdc_csd_10_t *csd10) {

+  const uint32_t *csd;

+

+  osalDbgCheck(NULL != sdcp);

+  csd = sdcp->csd;

+

+  csd10->c_size              = mmcsdGetSlice(csd, MMCSD_CSD_10_C_SIZE_SLICE);

+  csd10->c_size_mult         = mmcsdGetSlice(csd, MMCSD_CSD_10_C_SIZE_MULT_SLICE);

+  csd10->ccc                 = mmcsdGetSlice(csd, MMCSD_CSD_10_CCC_SLICE);

+  csd10->copy                = mmcsdGetSlice(csd, MMCSD_CSD_10_COPY_SLICE);

+  csd10->crc                 = mmcsdGetSlice(csd, MMCSD_CSD_10_CRC_SLICE);

+  csd10->csd_structure       = mmcsdGetSlice(csd, MMCSD_CSD_10_CSD_STRUCTURE_SLICE);

+  csd10->dsr_imp             = mmcsdGetSlice(csd, MMCSD_CSD_10_DSR_IMP_SLICE);

+  csd10->erase_blk_en        = mmcsdGetSlice(csd, MMCSD_CSD_10_ERASE_BLK_EN_SLICE);

+  csd10->erase_sector_size   = mmcsdGetSlice(csd, MMCSD_CSD_10_ERASE_SECTOR_SIZE_SLICE);

+  csd10->file_format         = mmcsdGetSlice(csd, MMCSD_CSD_10_FILE_FORMAT_SLICE);

+  csd10->file_format_grp     = mmcsdGetSlice(csd, MMCSD_CSD_10_FILE_FORMAT_GRP_SLICE);

+  csd10->nsac                = mmcsdGetSlice(csd, MMCSD_CSD_10_NSAC_SLICE);

+  csd10->perm_write_protect  = mmcsdGetSlice(csd, MMCSD_CSD_10_PERM_WRITE_PROTECT_SLICE);

+  csd10->r2w_factor          = mmcsdGetSlice(csd, MMCSD_CSD_10_R2W_FACTOR_SLICE);

+  csd10->read_bl_len         = mmcsdGetSlice(csd, MMCSD_CSD_10_READ_BL_LEN_SLICE);

+  csd10->read_bl_partial     = mmcsdGetSlice(csd, MMCSD_CSD_10_READ_BL_PARTIAL_SLICE);

+  csd10->read_blk_misalign   = mmcsdGetSlice(csd, MMCSD_CSD_10_READ_BLK_MISALIGN_SLICE);

+  csd10->taac                = mmcsdGetSlice(csd, MMCSD_CSD_10_TAAC_SLICE);

+  csd10->tmp_write_protect   = mmcsdGetSlice(csd, MMCSD_CSD_10_TMP_WRITE_PROTECT_SLICE);

+  csd10->tran_speed          = mmcsdGetSlice(csd, MMCSD_CSD_10_TRANS_SPEED_SLICE);

+  csd10->wp_grp_enable       = mmcsdGetSlice(csd, MMCSD_CSD_10_WP_GRP_ENABLE_SLICE);

+  csd10->wp_grp_size         = mmcsdGetSlice(csd, MMCSD_CSD_10_WP_GRP_SIZE_SLICE);

+  csd10->write_bl_len        = mmcsdGetSlice(csd, MMCSD_CSD_10_WRITE_BL_LEN_SLICE);

+  csd10->write_bl_partial    = mmcsdGetSlice(csd, MMCSD_CSD_10_WRITE_BL_PARTIAL_SLICE);

+  csd10->write_blk_misalign  = mmcsdGetSlice(csd, MMCSD_CSD_10_WRITE_BLK_MISALIGN_SLICE);

+}

+

+/**

+ * @brief   Unpacks SDC CSD v2.0 array in structure.

+ *

+ * @param[in] sdcp      pointer to the @p MMCSDBlockDevice object

+ * @param[out] csd20    pointer to the @p unpacked_sdc_csd_20_t object

+ *

+ * @api

+ */

+void sdcUnpackCSDv20(const MMCSDBlockDevice *sdcp,

+                     unmacked_sdc_csd_20_t *csd20) {

+  const uint32_t *csd;

+

+  osalDbgCheck(NULL != sdcp);

+  csd = sdcp->csd;

+

+  csd20->c_size              = mmcsdGetSlice(csd, MMCSD_CSD_20_C_SIZE_SLICE);

+  csd20->crc                 = mmcsdGetSlice(csd, MMCSD_CSD_20_CRC_SLICE);

+  csd20->ccc                 = mmcsdGetSlice(csd, MMCSD_CSD_20_CCC_SLICE);

+  csd20->copy                = mmcsdGetSlice(csd, MMCSD_CSD_20_COPY_SLICE);

+  csd20->csd_structure       = mmcsdGetSlice(csd, MMCSD_CSD_20_CSD_STRUCTURE_SLICE);

+  csd20->dsr_imp             = mmcsdGetSlice(csd, MMCSD_CSD_20_DSR_IMP_SLICE);

+  csd20->erase_blk_en        = mmcsdGetSlice(csd, MMCSD_CSD_20_ERASE_BLK_EN_SLICE);

+  csd20->file_format         = mmcsdGetSlice(csd, MMCSD_CSD_20_FILE_FORMAT_SLICE);

+  csd20->file_format_grp     = mmcsdGetSlice(csd, MMCSD_CSD_20_FILE_FORMAT_GRP_SLICE);

+  csd20->nsac                = mmcsdGetSlice(csd, MMCSD_CSD_20_NSAC_SLICE);

+  csd20->perm_write_protect  = mmcsdGetSlice(csd, MMCSD_CSD_20_PERM_WRITE_PROTECT_SLICE);

+  csd20->r2w_factor          = mmcsdGetSlice(csd, MMCSD_CSD_20_R2W_FACTOR_SLICE);

+  csd20->read_bl_len         = mmcsdGetSlice(csd, MMCSD_CSD_20_READ_BL_LEN_SLICE);

+  csd20->read_bl_partial     = mmcsdGetSlice(csd, MMCSD_CSD_20_READ_BL_PARTIAL_SLICE);

+  csd20->read_blk_misalign   = mmcsdGetSlice(csd, MMCSD_CSD_20_READ_BLK_MISALIGN_SLICE);

+  csd20->erase_sector_size   = mmcsdGetSlice(csd, MMCSD_CSD_20_ERASE_SECTOR_SIZE_SLICE);

+  csd20->taac                = mmcsdGetSlice(csd, MMCSD_CSD_20_TAAC_SLICE);

+  csd20->tmp_write_protect   = mmcsdGetSlice(csd, MMCSD_CSD_20_TMP_WRITE_PROTECT_SLICE);

+  csd20->tran_speed          = mmcsdGetSlice(csd, MMCSD_CSD_20_TRANS_SPEED_SLICE);

+  csd20->wp_grp_enable       = mmcsdGetSlice(csd, MMCSD_CSD_20_WP_GRP_ENABLE_SLICE);

+  csd20->wp_grp_size         = mmcsdGetSlice(csd, MMCSD_CSD_20_WP_GRP_SIZE_SLICE);

+  csd20->write_bl_len        = mmcsdGetSlice(csd, MMCSD_CSD_20_WRITE_BL_LEN_SLICE);

+  csd20->write_bl_partial    = mmcsdGetSlice(csd, MMCSD_CSD_20_WRITE_BL_PARTIAL_SLICE);

+  csd20->write_blk_misalign  = mmcsdGetSlice(csd, MMCSD_CSD_20_WRITE_BLK_MISALIGN_SLICE);

+}

+

 #endif /* HAL_USE_MMC_SPI || HAL_USE_SDC */

 

 /** @} */

diff --git a/os/hal/src/sdc.c b/os/hal/src/sdc.c
index 422fb9e93..115a513c4 100644
--- a/os/hal/src/sdc.c
+++ b/os/hal/src/sdc.c
@@ -35,127 +35,6 @@
 /* Driver local definitions.                                                 */

 /*===========================================================================*/

 

-#if CH_DBG_ENABLE_CHECKS

-typedef struct {

-  uint8_t   mid;

-  uint16_t  oid;

-  char      pnm[5];

-  uint8_t   prv_n;

-  uint8_t   prv_m;

-  uint32_t  psn;

-  uint8_t   mdt_m;

-  uint16_t  mdt_y;

-  uint8_t   crc;

-} unpacked_sdc_cid_t;

-

-typedef struct {

-  uint8_t   mid;

-  uint16_t  oid;

-  char      pnm[6];

-  uint8_t   prv_n;

-  uint8_t   prv_m;

-  uint32_t  psn;

-  uint8_t   mdt_m;

-  uint16_t  mdt_y;

-  uint8_t   crc;

-} unpacked_mmc_cid_t;

-

-typedef struct {

-  uint8_t   csd_structure;

-  uint8_t   taac;

-  uint8_t   nsac;

-  uint8_t   tran_speed;

-  uint16_t  ccc;

-  uint8_t   read_bl_len;

-  uint8_t   read_bl_partial;

-  uint8_t   write_blk_misalign;

-  uint8_t   read_blk_misalign;

-  uint8_t   dsr_imp;

-  uint16_t  c_size;

-  uint8_t   vdd_r_curr_min;

-  uint8_t   vdd_r_curr_max;

-  uint8_t   vdd_w_curr_min;

-  uint8_t   vdd_w_curr_max;

-  uint8_t   c_size_mult;

-  uint8_t   erase_blk_en;

-  uint8_t   erase_sector_size;

-  uint8_t   wp_grp_size;

-  uint8_t   wp_grp_enable;

-  uint8_t   r2w_factor;

-  uint8_t   write_bl_len;

-  uint8_t   write_bl_partial;

-  uint8_t   file_format_grp;

-  uint8_t   copy;

-  uint8_t   perm_write_protect;

-  uint8_t   tmp_write_protect;

-  uint8_t   file_format;

-  uint8_t   crc;

-} unpacked_sdc_csd_10_t;

-

-typedef struct {

-  uint8_t   csd_structure;

-  uint8_t   taac;

-  uint8_t   nsac;

-  uint8_t   tran_speed;

-  uint16_t  ccc;

-  uint8_t   read_bl_len;

-  uint8_t   read_bl_partial;

-  uint8_t   write_blk_misalign;

-  uint8_t   read_blk_misalign;

-  uint8_t   dsr_imp;

-  uint32_t  c_size;

-  uint8_t   erase_blk_en;

-  uint8_t   erase_sector_size;

-  uint8_t   wp_grp_size;

-  uint8_t   wp_grp_enable;

-  uint8_t   r2w_factor;

-  uint8_t   write_bl_len;

-  uint8_t   write_bl_partial;

-  uint8_t   file_format_grp;

-  uint8_t   copy;

-  uint8_t   perm_write_protect;

-  uint8_t   tmp_write_protect;

-  uint8_t   file_format;

-  uint8_t   crc;

-} unmacked_sdc_csd_20_t;

-

-typedef struct {

-  uint8_t   csd_structure;

-  uint8_t   spec_vers;

-  uint8_t   taac;

-  uint8_t   nsac;

-  uint8_t   tran_speed;

-  uint16_t  ccc;

-  uint8_t   read_bl_len;

-  uint8_t   read_bl_partial;

-  uint8_t   write_blk_misalign;

-  uint8_t   read_blk_misalign;

-  uint8_t   dsr_imp;

-  uint16_t  c_size;

-  uint8_t   vdd_r_curr_min;

-  uint8_t   vdd_r_curr_max;

-  uint8_t   vdd_w_curr_min;

-  uint8_t   vdd_w_curr_max;

-  uint8_t   c_size_mult;

-  uint8_t   erase_grp_size;

-  uint8_t   erase_grp_mult;

-  uint8_t   wp_grp_size;

-  uint8_t   wp_grp_enable;

-  uint8_t   default_ecc;

-  uint8_t   r2w_factor;

-  uint8_t   write_bl_len;

-  uint8_t   write_bl_partial;

-  uint8_t   content_prot_app;

-  uint8_t   file_format_grp;

-  uint8_t   copy;

-  uint8_t   perm_write_protect;

-  uint8_t   tmp_write_protect;

-  uint8_t   file_format;

-  uint8_t   ecc;

-  uint8_t   crc;

-} unpacked_mmc_csd_t;

-#endif /* CH_DBG_ENABLE_CHECKS */

-

 typedef enum {

   MMC_SWITCH_COMMAND_SET = 0,

   MMC_SWITCH_SET_BITS    = 1,

@@ -197,14 +76,6 @@ static const struct SDCDriverVMT sdc_vmt = {
   (bool (*)(void *, BlockDeviceInfo *))sdcGetInfo

 };

 

-#if CH_DBG_ENABLE_CHECKS

-static unmacked_sdc_csd_20_t  csd20;

-static unpacked_sdc_csd_10_t  csd10;

-static unpacked_mmc_csd_t     csdmmc;

-static unpacked_sdc_cid_t     cidsdc;

-static unpacked_mmc_cid_t     cidmmc;

-#endif /* CH_DBG_ENABLE_CHECKS */

-

 /**

  * @brief     Temporal storage for different purposes (extended CSD, etc.).

  */

@@ -213,179 +84,6 @@ static uint8_t scratchpad[512];
 /*===========================================================================*/

 /* Driver local functions.                                                   */

 /*===========================================================================*/

-

-/**

- * @brief   Unpacks CID array in structure.

- *

- * @param[in] sdcp      pointer to the @p SDCDriver object

- *

- * @notapi

- */

-static void unpack_cid(const SDCDriver *sdcp) {

-#if CH_DBG_ENABLE_CHECKS

-  const uint32_t *cid;

-

-  osalDbgCheck(NULL != sdcp);

-  cid = sdcp->cid;

-

-  switch(sdcp->cardmode &  SDC_MODE_CARDTYPE_MASK){

-  case SDC_MODE_CARDTYPE_SDV11:

-  case SDC_MODE_CARDTYPE_SDV20:

-    cidsdc.crc    = mmcsd_get_slice(cid, MMCSD_CID_SDC_CRC_SLICE);

-    cidsdc.mdt_y  = mmcsd_get_slice(cid, MMCSD_CID_SDC_MDT_Y_SLICE) + 2000;

-    cidsdc.mdt_m  = mmcsd_get_slice(cid, MMCSD_CID_SDC_MDT_M_SLICE);

-    cidsdc.mid    = mmcsd_get_slice(cid, MMCSD_CID_SDC_MID_SLICE);

-    cidsdc.oid    = mmcsd_get_slice(cid, MMCSD_CID_SDC_OID_SLICE);

-    cidsdc.pnm[4] = mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM0_SLICE);

-    cidsdc.pnm[3] = mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM1_SLICE);

-    cidsdc.pnm[2] = mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM2_SLICE);

-    cidsdc.pnm[1] = mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM3_SLICE);

-    cidsdc.pnm[0] = mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM4_SLICE);

-    cidsdc.prv_n  = mmcsd_get_slice(cid, MMCSD_CID_SDC_PRV_N_SLICE);

-    cidsdc.prv_m  = mmcsd_get_slice(cid, MMCSD_CID_SDC_PRV_M_SLICE);

-    cidsdc.psn    = mmcsd_get_slice(cid, MMCSD_CID_SDC_PSN_SLICE);

-    break;

-

-  case SDC_MODE_CARDTYPE_MMC:

-    cidmmc.crc    = mmcsd_get_slice(cid, MMCSD_CID_MMC_CRC_SLICE);

-    cidmmc.mdt_y  = mmcsd_get_slice(cid, MMCSD_CID_MMC_MDT_Y_SLICE) + 1997;

-    cidmmc.mdt_m  = mmcsd_get_slice(cid, MMCSD_CID_MMC_MDT_M_SLICE);

-    cidmmc.mid    = mmcsd_get_slice(cid, MMCSD_CID_MMC_MID_SLICE);

-    cidmmc.oid    = mmcsd_get_slice(cid, MMCSD_CID_MMC_OID_SLICE);

-    cidmmc.pnm[5] = mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM0_SLICE);

-    cidmmc.pnm[4] = mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM1_SLICE);

-    cidmmc.pnm[3] = mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM2_SLICE);

-    cidmmc.pnm[2] = mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM3_SLICE);

-    cidmmc.pnm[1] = mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM4_SLICE);

-    cidmmc.pnm[0] = mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM5_SLICE);

-    cidmmc.prv_n  = mmcsd_get_slice(cid, MMCSD_CID_MMC_PRV_N_SLICE);

-    cidmmc.prv_m  = mmcsd_get_slice(cid, MMCSD_CID_MMC_PRV_M_SLICE);

-    cidmmc.psn    = mmcsd_get_slice(cid, MMCSD_CID_MMC_PSN_SLICE);

-    break;

-

-  default:

-    osalSysHalt("Unhanlded case");

-    break;

-  }

-#else

-  (void)sdcp;

-#endif /* CH_DBG_ENABLE_CHECKS */

-}

-

-/**

- * @brief   Unpacks CSD array in structure.

- *

- * @param[in] sdcp      pointer to the @p SDCDriver object

- *

- * @notapi

- */

-static void unpack_csd(const SDCDriver *sdcp) {

-#if CH_DBG_ENABLE_CHECKS

-  const uint32_t *csd;

-

-  osalDbgCheck(NULL != sdcp);

-  csd = sdcp->csd;

-

-  if (SDC_MODE_CARDTYPE_MMC == (sdcp->cardmode &  SDC_MODE_CARDTYPE_MASK)) {

-    csdmmc.c_size             = mmcsd_get_slice(csd, MMCSD_CSD_MMC_C_SIZE_SLICE);

-    csdmmc.c_size_mult        = mmcsd_get_slice(csd, MMCSD_CSD_MMC_C_SIZE_MULT_SLICE);

-    csdmmc.ccc                = mmcsd_get_slice(csd, MMCSD_CSD_MMC_CCC_SLICE);

-    csdmmc.copy               = mmcsd_get_slice(csd, MMCSD_CSD_MMC_COPY_SLICE);

-    csdmmc.crc                = mmcsd_get_slice(csd, MMCSD_CSD_MMC_CRC_SLICE);

-    csdmmc.csd_structure      = mmcsd_get_slice(csd, MMCSD_CSD_MMC_CSD_STRUCTURE_SLICE);

-    csdmmc.dsr_imp            = mmcsd_get_slice(csd, MMCSD_CSD_MMC_DSR_IMP_SLICE);

-    csdmmc.ecc                = mmcsd_get_slice(csd, MMCSD_CSD_MMC_ECC_SLICE);

-    csdmmc.erase_grp_mult     = mmcsd_get_slice(csd, MMCSD_CSD_MMC_ERASE_GRP_MULT_SLICE);

-    csdmmc.erase_grp_size     = mmcsd_get_slice(csd, MMCSD_CSD_MMC_ERASE_GRP_SIZE_SLICE);

-    csdmmc.file_format        = mmcsd_get_slice(csd, MMCSD_CSD_MMC_FILE_FORMAT_SLICE);

-    csdmmc.file_format_grp    = mmcsd_get_slice(csd, MMCSD_CSD_MMC_FILE_FORMAT_GRP_SLICE);

-    csdmmc.nsac               = mmcsd_get_slice(csd, MMCSD_CSD_MMC_NSAC_SLICE);

-    csdmmc.perm_write_protect = mmcsd_get_slice(csd, MMCSD_CSD_MMC_PERM_WRITE_PROTECT_SLICE);

-    csdmmc.r2w_factor         = mmcsd_get_slice(csd, MMCSD_CSD_MMC_R2W_FACTOR_SLICE);

-    csdmmc.read_bl_len        = mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BL_LEN_SLICE);

-    csdmmc.read_bl_partial    = mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BL_PARTIAL_SLICE);

-    csdmmc.read_blk_misalign  = mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BLK_MISALIGN_SLICE);

-    csdmmc.spec_vers          = mmcsd_get_slice(csd, MMCSD_CSD_MMC_SPEC_VERS_SLICE);

-    csdmmc.taac               = mmcsd_get_slice(csd, MMCSD_CSD_MMC_TAAC_SLICE);

-    csdmmc.tmp_write_protect  = mmcsd_get_slice(csd, MMCSD_CSD_MMC_TMP_WRITE_PROTECT_SLICE);

-    csdmmc.tran_speed         = mmcsd_get_slice(csd, MMCSD_CSD_MMC_TRAN_SPEED_SLICE);

-    csdmmc.vdd_r_curr_max     = mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_R_CURR_MAX_SLICE);

-    csdmmc.vdd_r_curr_min     = mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_R_CURR_MIN_SLICE);

-    csdmmc.vdd_w_curr_max     = mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_W_CURR_MAX_SLICE);

-    csdmmc.vdd_w_curr_min     = mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_W_CURR_MIN_SLICE);

-    csdmmc.wp_grp_enable      = mmcsd_get_slice(csd, MMCSD_CSD_MMC_WP_GRP_ENABLE_SLICE);

-    csdmmc.wp_grp_size        = mmcsd_get_slice(csd, MMCSD_CSD_MMC_WP_GRP_SIZE_SLICE);

-    csdmmc.write_bl_len       = mmcsd_get_slice(csd, MMCSD_CSD_MMC_WRITE_BL_LEN_SLICE);

-    csdmmc.write_bl_partial   = mmcsd_get_slice(csd, MMCSD_CSD_MMC_WRITE_BL_PARTIAL_SLICE);

-    csdmmc.write_blk_misalign = mmcsd_get_slice(csd, MMCSD_CSD_MMC_WRITE_BLK_MISALIGN_SLICE);

-  }

-  else {

-    switch (mmcsd_get_slice(csd, MMCSD_CSD_10_CSD_STRUCTURE_SLICE)) {

-    case 0:

-      /* CSD version 1.0 */

-      csd10.c_size              = mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_SLICE);

-      csd10.c_size_mult         = mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_MULT_SLICE);

-      csd10.ccc                 = mmcsd_get_slice(csd, MMCSD_CSD_10_CCC_SLICE);

-      csd10.copy                = mmcsd_get_slice(csd, MMCSD_CSD_10_COPY_SLICE);

-      csd10.crc                 = mmcsd_get_slice(csd, MMCSD_CSD_10_CRC_SLICE);

-      csd10.csd_structure       = mmcsd_get_slice(csd, MMCSD_CSD_10_CSD_STRUCTURE_SLICE);

-      csd10.dsr_imp             = mmcsd_get_slice(csd, MMCSD_CSD_10_DSR_IMP_SLICE);

-      csd10.erase_blk_en        = mmcsd_get_slice(csd, MMCSD_CSD_10_ERASE_BLK_EN_SLICE);

-      csd10.erase_sector_size   = mmcsd_get_slice(csd, MMCSD_CSD_10_ERASE_SECTOR_SIZE_SLICE);

-      csd10.file_format         = mmcsd_get_slice(csd, MMCSD_CSD_10_FILE_FORMAT_SLICE);

-      csd10.file_format_grp     = mmcsd_get_slice(csd, MMCSD_CSD_10_FILE_FORMAT_GRP_SLICE);

-      csd10.nsac                = mmcsd_get_slice(csd, MMCSD_CSD_10_NSAC_SLICE);

-      csd10.perm_write_protect  = mmcsd_get_slice(csd, MMCSD_CSD_10_PERM_WRITE_PROTECT_SLICE);

-      csd10.r2w_factor          = mmcsd_get_slice(csd, MMCSD_CSD_10_R2W_FACTOR_SLICE);

-      csd10.read_bl_len         = mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BL_LEN_SLICE);

-      csd10.read_bl_partial     = mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BL_PARTIAL_SLICE);

-      csd10.read_blk_misalign   = mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BLK_MISALIGN_SLICE);

-      csd10.taac                = mmcsd_get_slice(csd, MMCSD_CSD_10_TAAC_SLICE);

-      csd10.tmp_write_protect   = mmcsd_get_slice(csd, MMCSD_CSD_10_TMP_WRITE_PROTECT_SLICE);

-      csd10.tran_speed          = mmcsd_get_slice(csd, MMCSD_CSD_10_TRANS_SPEED_SLICE);

-      csd10.wp_grp_enable       = mmcsd_get_slice(csd, MMCSD_CSD_10_WP_GRP_ENABLE_SLICE);

-      csd10.wp_grp_size         = mmcsd_get_slice(csd, MMCSD_CSD_10_WP_GRP_SIZE_SLICE);

-      csd10.write_bl_len        = mmcsd_get_slice(csd, MMCSD_CSD_10_WRITE_BL_LEN_SLICE);

-      csd10.write_bl_partial    = mmcsd_get_slice(csd, MMCSD_CSD_10_WRITE_BL_PARTIAL_SLICE);

-      csd10.write_blk_misalign  = mmcsd_get_slice(csd, MMCSD_CSD_10_WRITE_BLK_MISALIGN_SLICE);

-      break;

-    case 1:

-      /* CSD version 2.0.*/

-      csd20.c_size              = mmcsd_get_slice(csd, MMCSD_CSD_20_C_SIZE_SLICE);

-      csd20.crc                 = mmcsd_get_slice(csd, MMCSD_CSD_20_CRC_SLICE);

-      csd20.ccc                 = mmcsd_get_slice(csd, MMCSD_CSD_20_CCC_SLICE);

-      csd20.copy                = mmcsd_get_slice(csd, MMCSD_CSD_20_COPY_SLICE);

-      csd20.csd_structure       = mmcsd_get_slice(csd, MMCSD_CSD_20_CSD_STRUCTURE_SLICE);

-      csd20.dsr_imp             = mmcsd_get_slice(csd, MMCSD_CSD_20_DSR_IMP_SLICE);

-      csd20.erase_blk_en        = mmcsd_get_slice(csd, MMCSD_CSD_20_ERASE_BLK_EN_SLICE);

-      csd20.file_format         = mmcsd_get_slice(csd, MMCSD_CSD_20_FILE_FORMAT_SLICE);

-      csd20.file_format_grp     = mmcsd_get_slice(csd, MMCSD_CSD_20_FILE_FORMAT_GRP_SLICE);

-      csd20.nsac                = mmcsd_get_slice(csd, MMCSD_CSD_20_NSAC_SLICE);

-      csd20.perm_write_protect  = mmcsd_get_slice(csd, MMCSD_CSD_20_PERM_WRITE_PROTECT_SLICE);

-      csd20.r2w_factor          = mmcsd_get_slice(csd, MMCSD_CSD_20_R2W_FACTOR_SLICE);

-      csd20.read_bl_len         = mmcsd_get_slice(csd, MMCSD_CSD_20_READ_BL_LEN_SLICE);

-      csd20.read_bl_partial     = mmcsd_get_slice(csd, MMCSD_CSD_20_READ_BL_PARTIAL_SLICE);

-      csd20.read_blk_misalign   = mmcsd_get_slice(csd, MMCSD_CSD_20_READ_BLK_MISALIGN_SLICE);

-      csd20.erase_sector_size   = mmcsd_get_slice(csd, MMCSD_CSD_20_ERASE_SECTOR_SIZE_SLICE);

-      csd20.taac                = mmcsd_get_slice(csd, MMCSD_CSD_20_TAAC_SLICE);

-      csd20.tmp_write_protect   = mmcsd_get_slice(csd, MMCSD_CSD_20_TMP_WRITE_PROTECT_SLICE);

-      csd20.tran_speed          = mmcsd_get_slice(csd, MMCSD_CSD_20_TRANS_SPEED_SLICE);

-      csd20.wp_grp_enable       = mmcsd_get_slice(csd, MMCSD_CSD_20_WP_GRP_ENABLE_SLICE);

-      csd20.wp_grp_size         = mmcsd_get_slice(csd, MMCSD_CSD_20_WP_GRP_SIZE_SLICE);

-      csd20.write_bl_len        = mmcsd_get_slice(csd, MMCSD_CSD_20_WRITE_BL_LEN_SLICE);

-      csd20.write_bl_partial    = mmcsd_get_slice(csd, MMCSD_CSD_20_WRITE_BL_PARTIAL_SLICE);

-      csd20.write_blk_misalign  = mmcsd_get_slice(csd, MMCSD_CSD_20_WRITE_BLK_MISALIGN_SLICE);

-      break;

-    default:

-      /* Reserved value detected.*/

-      return;

-    }

-  }

-#else

-  (void)sdcp;

-#endif /* CH_DBG_ENABLE_CHECKS */

-}

-

 /**

  * @brief   Detects card mode.

  *

@@ -902,8 +600,6 @@ bool sdcConnect(SDCDriver *sdcp) {
   /* Reads CID.*/

   if (sdc_lld_send_cmd_long_crc(sdcp, MMCSD_CMD_ALL_SEND_CID, 0, sdcp->cid))

     goto failed;

-  else

-    unpack_cid(sdcp);

 

   /* Asks for the RCA.*/

   if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_SEND_RELATIVE_ADDR,

@@ -914,8 +610,6 @@ bool sdcConnect(SDCDriver *sdcp) {
   if (sdc_lld_send_cmd_long_crc(sdcp, MMCSD_CMD_SEND_CSD,

                                 sdcp->rca, sdcp->csd))

     goto failed;

-  else

-    unpack_csd(sdcp);

 

   /* Selects the card for operations.*/

   if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_SEL_DESEL_CARD,

@@ -929,7 +623,7 @@ bool sdcConnect(SDCDriver *sdcp) {
 

   /* Reads extended CSD if needed.*/

   if (SDC_MODE_CARDTYPE_MMC == (sdcp->cardmode & SDC_MODE_CARDTYPE_MASK) &&

-          mmcsd_get_slice(sdcp->csd, MMCSD_CSD_MMC_CSD_STRUCTURE_SLICE) > 1) {

+          mmcsdGetSlice(sdcp->csd, MMCSD_CSD_MMC_CSD_STRUCTURE_SLICE) > 1) {

     if(sdc_lld_read_special(sdcp, scratchpad, 512, MMCSD_CMD_SEND_EXT_CSD, 0))

       goto failed;

   }