bertos/drv/sd.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2007 Develer S.r.l. (http://www.develer.com/)
  30  * -->
  31  *
  32  * \brief Function library for secure digital memory.
  33  *
  34  * \author Francesco Sacchi <batt@develer.com>
  35  */
  36
  37
  38 #include "sd.h"
  39 #include "hw/hw_sd.h"
  40 #include <io/kfile.h>
  41 #include <io/kblock.h>
  42 #include <drv/timer.h>
  43
  44 #include <fs/fat.h>
  45
  46 #include "cfg/cfg_sd.h"
  47
  48 #define LOG_LEVEL  SD_LOG_LEVEL
  49 #define LOG_FORMAT SD_LOG_FORMAT
  50 #include <cfg/log.h>
  51 #include <cpu/power.h>
  52
  53 #include <string.h> /* memset */
  54
  55 /**
  56  * Card Specific Data
  57  * read directly from the card.
  58  */
  59 typedef struct CardCSD
  60 {
  61         uint16_t block_len;  ///< Length of a block
  62         uint32_t block_num;  ///< Number of block on the card
  63         uint16_t capacity;   ///< Card capacity in MB
  64 } CardCSD;
  65
  66 #define SD_IN_IDLE    0x01
  67 #define SD_STARTTOKEN 0xFE
  68
  69 #define TIMEOUT_NAC   16384
  70 #define SD_DEFAULT_BLOCKLEN 512
  71
  72 #define SD_BUSY_TIMEOUT ms_to_ticks(200)
  73
  74 static bool sd_select(Sd *sd, bool state)
  75 {
  76         KFile *fd = sd->ch;
  77
  78         if (state)
  79         {
  80                 SD_CS_ON();
  81
  82                 ticks_t start = timer_clock();
  83                 do
  84                 {
  85                         if (kfile_getc(fd) == 0xff)
  86                                 return true;
  87
  88                         cpu_relax();
  89                 }
  90                 while (timer_clock() - start < SD_BUSY_TIMEOUT);
  91
  92                 SD_CS_OFF();
  93                 LOG_ERR("sd_select timeout\n");
  94                 return false;
  95         }
  96         else
  97         {
  98                 kfile_putc(0xff, fd);
  99                 kfile_flush(fd);
 100                 SD_CS_OFF();
 101                 return true;
 102         }
 103 }
 104
 105 static int16_t sd_waitR1(Sd *sd)
 106 {
 107         uint8_t datain;
 108
 109         for (int i = 0; i < TIMEOUT_NAC; i++)
 110         {
 111                 datain = kfile_getc(sd->ch);
 112                 if (datain != 0xff)
 113                         return (int16_t)datain;
 114         }
 115         LOG_ERR("Timeout waiting R1\n");
 116         return EOF;
 117 }
 118
 119 static int16_t sd_sendCommand(Sd *sd, uint8_t cmd, uint32_t param, uint8_t crc)
 120 {
 121         KFile *fd = sd->ch;
 122         /* The 7th bit of command must be a 1 */
 123         kfile_putc(cmd | 0x40, fd);
 124
 125         /* send parameter */
 126         kfile_putc((param >> 24) & 0xFF, fd);
 127         kfile_putc((param >> 16) & 0xFF, fd);
 128         kfile_putc((param >> 8) & 0xFF, fd);
 129         kfile_putc((param) & 0xFF, fd);
 130
 131         kfile_putc(crc, fd);
 132
 133         return sd_waitR1(sd);
 134 }
 135
 136 static bool sd_getBlock(Sd *sd, void *buf, size_t len)
 137 {
 138         uint8_t token;
 139         uint16_t crc;
 140
 141         KFile *fd = sd->ch;
 142
 143         for (int i = 0; i < TIMEOUT_NAC; i++)
 144         {
 145                 token = kfile_getc(fd);
 146                 if (token != 0xff)
 147                 {
 148                         if (token == SD_STARTTOKEN)
 149                         {
 150                                 if (kfile_read(fd, buf, len) == len)
 151                                 {
 152                                         if (kfile_read(fd, &crc, sizeof(crc)) == sizeof(crc))
 153                                                 /* check CRC here if needed */
 154                                                 return true;
 155                                         else
 156                                                 LOG_ERR("get_block error getting crc\n");
 157                                 }
 158                                 else
 159                                         LOG_ERR("get_block len error: %d\n", (int)len);
 160                         }
 161                         else
 162                                 LOG_ERR("get_block token error: %02X\n", token);
 163
 164                         return false;
 165                 }
 166         }
 167
 168         LOG_ERR("get_block timeout waiting token\n");
 169         return false;
 170 }
 171
 172 #define SD_SELECT(sd) \
 173 do \
 174 { \
 175         if (!sd_select((sd), true)) \
 176         { \
 177                 LOG_ERR("%s failed, card busy\n", __func__); \
 178                 return EOF; \
 179         } \
 180 } \
 181 while (0)
 182
 183 #define SD_SETBLOCKLEN 0x50
 184
 185 static int16_t sd_setBlockLen(Sd *sd, uint32_t newlen)
 186 {
 187         SD_SELECT(sd);
 188
 189         sd->r1 = sd_sendCommand(sd, SD_SETBLOCKLEN, newlen, 0);
 190
 191         sd_select(sd, false);
 192         return sd->r1;
 193 }
 194
 195 #define SD_SEND_CSD 0x49
 196
 197 static int16_t sd_getCSD(Sd *sd, CardCSD *csd)
 198 {
 199         SD_SELECT(sd);
 200
 201         int16_t r1 = sd_sendCommand(sd, SD_SEND_CSD, 0, 0);
 202
 203         if (r1)
 204         {
 205                 LOG_ERR("send_csd failed: %04X\n", sd->r1);
 206                 sd_select(sd, false);
 207                 return r1;
 208         }
 209
 210         uint8_t buf[16];
 211         bool res = sd_getBlock(sd, buf, sizeof(buf));
 212         sd_select(sd, false);
 213
 214         if (res)
 215         {
 216                 #if LOG_LEVEL >= LOG_LVL_INFO
 217                         LOG_INFO("CSD: [");
 218                         for (int i = 0; i < 16; i++)
 219                                 kprintf("%02X ", buf[i]);
 220                         kprintf("]\n");
 221                 #endif
 222
 223                 uint16_t mult = (1L << ((((buf[9] & 0x03) << 1) | ((buf[10] & 0x80) >> 7)) + 2));
 224                 uint16_t c_size = (((uint16_t)(buf[6] & 0x03)) << 10) | (((uint16_t)buf[7]) << 2) |
 225                                   (((uint16_t)(buf[8] & 0xC0)) >> 6);
 226
 227                 csd->block_len = (1L << (buf[5] & 0x0F));
 228                 csd->block_num = (c_size + 1) * mult;
 229                 csd->capacity = (csd->block_len * csd->block_num) >> 20; // in MB
 230
 231                 LOG_INFO("block_len %d bytes, block_num %ld, total capacity %dMB\n", csd->block_len, csd->block_num, csd->capacity);
 232                 return 0;
 233         }
 234         else
 235                 return EOF;
 236 }
 237
 238
 239 #define SD_READ_SINGLEBLOCK 0x51
 240
 241 static size_t sd_readDirect(struct KBlock *b, block_idx_t idx, void *buf, size_t offset, size_t size)
 242 {
 243         Sd *sd = SD_CAST(b);
 244         LOG_INFO("reading from block %ld, offset %d, size %d\n", idx, offset, size);
 245
 246         if (sd->tranfer_len != size)
 247         {
 248                 if ((sd->r1 = sd_setBlockLen(sd, size)))
 249                 {
 250                         LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
 251                         return 0;
 252                 }
 253                 sd->tranfer_len = size;
 254         }
 255
 256         SD_SELECT(sd);
 257
 258         sd->r1 = sd_sendCommand(sd, SD_READ_SINGLEBLOCK, idx * SD_DEFAULT_BLOCKLEN + offset, 0);
 259
 260         if (sd->r1)
 261         {
 262                 LOG_ERR("read single block failed: %04X\n", sd->r1);
 263                 sd_select(sd, false);
 264                 return 0;
 265         }
 266
 267         bool res = sd_getBlock(sd, buf, size);
 268         sd_select(sd, false);
 269         if (!res)
 270         {
 271                 LOG_ERR("read single block failed reading data\n");
 272                 return 0;
 273         }
 274         else
 275                 return size;
 276 }
 277
 278 #define SD_WRITE_SINGLEBLOCK 0x58
 279 #define SD_DATA_ACCEPTED     0x05
 280
 281 static size_t sd_writeDirect(KBlock *b, block_idx_t idx, const void *buf, size_t offset, size_t size)
 282 {
 283         Sd *sd = SD_CAST(b);
 284         KFile *fd = sd->ch;
 285         ASSERT(offset == 0);
 286         ASSERT(size == SD_DEFAULT_BLOCKLEN);
 287
 288         LOG_INFO("writing block %ld\n", idx);
 289         if (sd->tranfer_len != SD_DEFAULT_BLOCKLEN)
 290         {
 291                 if ((sd->r1 = sd_setBlockLen(sd, SD_DEFAULT_BLOCKLEN)))
 292                 {
 293                         LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
 294                         return 0;
 295                 }
 296                 sd->tranfer_len = SD_DEFAULT_BLOCKLEN;
 297         }
 298
 299         SD_SELECT(sd);
 300
 301         sd->r1 = sd_sendCommand(sd, SD_WRITE_SINGLEBLOCK, idx * SD_DEFAULT_BLOCKLEN, 0);
 302
 303         if (sd->r1)
 304         {
 305                 LOG_ERR("write single block failed: %04X\n", sd->r1);
 306                 sd_select(sd, false);
 307                 return 0;
 308         }
 309
 310         kfile_putc(SD_STARTTOKEN, fd);
 311         kfile_write(fd, buf, SD_DEFAULT_BLOCKLEN);
 312         /* send fake crc */
 313         kfile_putc(0, fd);
 314         kfile_putc(0, fd);
 315
 316         uint8_t dataresp = kfile_getc(fd);
 317         sd_select(sd, false);
 318
 319         if ((dataresp & 0x1f) != SD_DATA_ACCEPTED)
 320         {
 321                 LOG_ERR("write block %ld failed: %02X\n", idx, dataresp);
 322                 return EOF;
 323         }
 324
 325         return SD_DEFAULT_BLOCKLEN;
 326 }
 327
 328 void sd_writeTest(Sd *sd)
 329 {
 330         uint8_t buf[SD_DEFAULT_BLOCKLEN];
 331         memset(buf, 0, sizeof(buf));
 332
 333         for (block_idx_t i = 0; i < sd->b.blk_cnt; i++)
 334         {
 335                 LOG_INFO("writing block %ld: %s\n", i, (sd_writeDirect(&sd->b, i, buf, 0, SD_DEFAULT_BLOCKLEN) == SD_DEFAULT_BLOCKLEN) ? "OK" : "FAIL");
 336         }
 337 }
 338
 339
 340 bool sd_test(Sd *sd)
 341 {
 342         uint8_t buf[SD_DEFAULT_BLOCKLEN];
 343
 344         if (sd_readDirect(&sd->b, 0, buf, 0, sd->b.blk_size) != sd->b.blk_size)
 345                 return false;
 346
 347         kputchar('\n');
 348         for (int i = 0; i < SD_DEFAULT_BLOCKLEN; i++)
 349         {
 350                 kprintf("%02X ", buf[i]);
 351                 buf[i] = i;
 352                 if (!((i+1) % 16))
 353                         kputchar('\n');
 354         }
 355
 356         if (sd_writeDirect(&sd->b, 0, buf, 0, SD_DEFAULT_BLOCKLEN) != SD_DEFAULT_BLOCKLEN)
 357                 return false;
 358
 359         memset(buf, 0, sizeof(buf));
 360         if (sd_readDirect(&sd->b, 0, buf, 0, sd->b.blk_size) != sd->b.blk_size)
 361                 return false;
 362
 363         kputchar('\n');
 364         for (block_idx_t i = 0; i < sd->b.blk_size; i++)
 365         {
 366                 kprintf("%02X ", buf[i]);
 367                 buf[i] = i;
 368                 if (!((i+1) % 16))
 369                         kputchar('\n');
 370         }
 371
 372         return true;
 373 }
 374
 375 static int sd_error(KBlock *b)
 376 {
 377         Sd *sd = SD_CAST(b);
 378         return sd->r1;
 379 }
 380
 381 static void sd_clearerr(KBlock *b)
 382 {
 383         Sd *sd = SD_CAST(b);
 384         sd->r1 = 0;
 385 }
 386
 387 static const KBlockVTable sd_unbuffered_vt =
 388 {
 389         .readDirect = sd_readDirect,
 390         .writeDirect = sd_writeDirect,
 391
 392         .error = sd_error,
 393         .clearerr = sd_clearerr,
 394 };
 395
 396 static const KBlockVTable sd_buffered_vt =
 397 {
 398         .readDirect = sd_readDirect,
 399         .writeDirect = sd_writeDirect,
 400
 401         .readBuf = kblock_swReadBuf,
 402         .writeBuf = kblock_swWriteBuf,
 403         .load = kblock_swLoad,
 404         .store = kblock_swStore,
 405
 406         .error = sd_error,
 407         .clearerr = sd_clearerr,
 408 };
 409
 410 #define SD_GO_IDLE_STATE     0x40
 411 #define SD_GO_IDLE_STATE_CRC 0x95
 412 #define SD_SEND_OP_COND      0x41
 413 #define SD_SEND_OP_COND_CRC  0xF9
 414
 415 #define SD_START_DELAY  10
 416 #define SD_INIT_TIMEOUT ms_to_ticks(2000)
 417 #define SD_IDLE_RETRIES 4
 418
 419 static bool sd_blockInit(Sd *sd, KFile *ch)
 420 {
 421         ASSERT(sd);
 422         ASSERT(ch);
 423         memset(sd, 0, sizeof(*sd));
 424         DB(sd->b.priv.type = KBT_SD);
 425         sd->ch = ch;
 426
 427         SD_CS_INIT();
 428         SD_CS_OFF();
 429
 430         /* Wait a few moments for supply voltage to stabilize */
 431         timer_delay(SD_START_DELAY);
 432
 433         /* Give 80 clk pulses to wake up the card */
 434         for (int i = 0; i < 10; i++)
 435                 kfile_putc(0xff, ch);
 436         kfile_flush(ch);
 437
 438         for (int i = 0; i < SD_IDLE_RETRIES; i++)
 439         {
 440                 SD_SELECT(sd);
 441                 sd->r1 = sd_sendCommand(sd, SD_GO_IDLE_STATE, 0, SD_GO_IDLE_STATE_CRC);
 442                 sd_select(sd, false);
 443
 444                 if (sd->r1 == SD_IN_IDLE)
 445                         break;
 446         }
 447
 448         if (sd->r1 != SD_IN_IDLE)
 449         {
 450                 LOG_ERR("go_idle_state failed: %04X\n", sd->r1);
 451                 return false;
 452         }
 453
 454         ticks_t start = timer_clock();
 455
 456         /* Wait for card to start */
 457         do
 458         {
 459                 SD_SELECT(sd);
 460                 sd->r1 = sd_sendCommand(sd, SD_SEND_OP_COND, 0, SD_SEND_OP_COND_CRC);
 461                 sd_select(sd, false);
 462                 cpu_relax();
 463         }
 464         while (sd->r1 != 0 && timer_clock() - start < SD_INIT_TIMEOUT);
 465
 466         if (sd->r1)
 467         {
 468                 LOG_ERR("send_op_cond failed: %04X\n", sd->r1);
 469                 return false;
 470         }
 471
 472         sd->r1 = sd_setBlockLen(sd, SD_DEFAULT_BLOCKLEN);
 473         sd->tranfer_len = SD_DEFAULT_BLOCKLEN;
 474
 475         if (sd->r1)
 476         {
 477                 LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
 478                 return false;
 479         }
 480
 481         /* Avoid warning for uninitialized csd use (gcc bug?) */
 482         CardCSD csd = csd;
 483
 484         sd->r1 = sd_getCSD(sd, &csd);
 485
 486         if (sd->r1)
 487         {
 488                 LOG_ERR("getCSD failed: %04X\n", sd->r1);
 489                 return false;
 490         }
 491
 492         sd->b.blk_size = SD_DEFAULT_BLOCKLEN;
 493         sd->b.blk_cnt = csd.block_num * (csd.block_len / SD_DEFAULT_BLOCKLEN);
 494         LOG_INFO("blk_size %d, blk_cnt %ld\n", sd->b.blk_size, sd->b.blk_cnt);
 495
 496 #if CONFIG_SD_AUTOASSIGN_FAT
 497         disk_assignDrive(&sd->b, 0);
 498 #endif
 499
 500         return true;
 501 }
 502
 503 #if CPU_CM3_SAM3X8
 504
 505 #include <drv/hsmci_sam3.h>
 506
 507 /* SD commands                           type  argument     response */
 508   /* class 0 */
 509 /* This is basically the same command as for MMC with some quirks. */
 510 #define SD_SEND_RELATIVE_ADDR     3   /* bcr                     R6  */
 511 #define SD_SEND_IF_COND           8   /* bcr  [11:0] See below   R7  */
 512 #define SD_SWITCH_VOLTAGE         11  /* ac                      R1  */
 513
 514   /* class 10 */
 515 #define SD_SWITCH                 6   /* adtc [31:0] See below   R1  */
 516
 517   /* class 5 */
 518 #define SD_ERASE_WR_BLK_START    32   /* ac   [31:0] data addr   R1  */
 519 #define SD_ERASE_WR_BLK_END      33   /* ac   [31:0] data addr   R1  */
 520
 521   /* Application commands */
 522 #define SD_APP_SET_BUS_WIDTH      6   /* ac   [1:0] bus width    R1  */
 523 #define SD_APP_SD_STATUS         13   /* adtc                    R1  */
 524 #define SD_APP_SEND_NUM_WR_BLKS  22   /* adtc                    R1  */
 525 #define SD_APP_OP_COND           41   /* bcr  [31:0] OCR         R3  */
 526 #define SD_APP_SEND_SCR          51   /* adtc                    R1  */
 527
 528 /* OCR bit definitions */
 529 #define SD_OCR_S18R     (1 << 24)    /* 1.8V switching request */
 530 #define SD_ROCR_S18A        SD_OCR_S18R  /* 1.8V switching accepted by card */
 531 #define SD_OCR_XPC      (1 << 28)    /* SDXC power control */
 532
 533 /*
 534  * SD_SWITCH argument format:
 535  *
 536  *      [31] Check (0) or switch (1)
 537  *      [30:24] Reserved (0)
 538  *      [23:20] Function group 6
 539  *      [19:16] Function group 5
 540  *      [15:12] Function group 4
 541  *      [11:8] Function group 3
 542  *      [7:4] Function group 2
 543  *      [3:0] Function group 1
 544  */
 545
 546 /*
 547  * SD_SEND_IF_COND argument format:
 548  *
 549  *  [31:12] Reserved (0)
 550  *  [11:8] Host Voltage Supply Flags
 551  *  [7:0] Check Pattern (0xAA)
 552  */
 553
 554 /*
 555  * SCR field definitions
 556  */
 557
 558 #define SCR_SPEC_VER_0      0   /* Implements system specification 1.0 - 1.01 */
 559 #define SCR_SPEC_VER_1      1   /* Implements system specification 1.10 */
 560 #define SCR_SPEC_VER_2      2   /* Implements system specification 2.00-3.0X */
 561
 562 #define UNSTUFF_BITS(resp, start, size)                   \
 563     ({                              \
 564         const uint32_t __size = size;                \
 565         const uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1; \
 566         const uint32_t __off = 3 - ((start) / 32);           \
 567         const uint32_t __shft = (start) & 31;            \
 568         uint32_t __res;                      \
 569                                     \
 570         __res = resp[__off] >> __shft;              \
 571         if (__size + __shft > 32)               \
 572             __res |= resp[__off-1] << ((32 - __shft) % 32); \
 573         __res & __mask;                     \
 574     })
 575
 576
 577 #define SD_ADDR_TO_RCA(addr)    (uint32_t)(((addr) << 16) & 0xFFFF0000)
 578
 579 #define BCD_TO_INT_32BIT(bcd)  ((uint32_t )((bcd) & 0xf) * 1 +  \
 580                                                                 (((bcd) >> 4) & 0xf)  * 10 +      \
 581                                                                 (((bcd) >> 8) & 0xf)  * 100 +     \
 582                                                                 (((bcd) >> 12) & 0xf) * 1000 +   \
 583                                                                 (((bcd) >> 16) & 0xf) * 10000 +   \
 584                                                                 (((bcd) >> 20) & 0xf) * 100000 +  \
 585                                                                 (((bcd) >> 24) & 0xf) * 1000000 + \
 586                                                                 (((bcd) >> 28) & 0xf) * 10000000) \
 587
 588 LOG_INFOB(
 589 static void dump(const char *label, uint32_t *r, size_t len)
 590 {
 591         ASSERT(r);
 592         kprintf("%s [ ", label);
 593         for (size_t i = 0; i < len; i++)
 594                 kprintf("%lx ", r[i]);
 595         kputs("]\n");
 596 }
 597 )
 598
 599
 600 static int sd_decodeCsd(SDcsd *csd, uint32_t *resp, size_t len)
 601 {
 602         ASSERT(csd);
 603         ASSERT(resp);
 604         ASSERT(len >= 4);
 605
 606     csd->structure = UNSTUFF_BITS(resp, 126, 2);
 607         csd->ccc = UNSTUFF_BITS(resp, 84, 12);
 608
 609
 610         /*
 611          * CSD structure:
 612          * - 0:
 613          *              - Version 1.01-1.10
 614          *              - Version 2.00/Standard Capacity
 615          * - 1:
 616          *              - Version 2.00/High Capacity
 617          * - >1: not defined.
 618          */
 619
 620     if (csd->structure == 0)
 621         {
 622                 // (C_size + 1) x 2^(C_SIZE_MUL+2)
 623                 csd->blk_num = (1 + UNSTUFF_BITS(resp, 62, 12)) << (UNSTUFF_BITS(resp, 47, 3) + 2);
 624
 625                 csd->read_blk_bits = UNSTUFF_BITS(resp, 80, 4);
 626                 csd->write_blk_bits = UNSTUFF_BITS(resp, 22, 4);
 627
 628                 csd->blk_len = 1 << csd->read_blk_bits;
 629         csd->capacity  = csd->blk_num * csd->blk_len;
 630
 631         csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 632         csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 633
 634         csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 635         csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 636
 637         if (UNSTUFF_BITS(resp, 46, 1))
 638                 {
 639             csd->erase_size = 1;
 640         }
 641                 else if(csd->write_blk_bits >= 9)
 642                 {
 643             csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
 644             csd->erase_size <<= csd->write_blk_bits - 9;
 645         }
 646
 647                 return 0;
 648         }
 649         else if (csd->structure == 1)
 650         {
 651                 kprintf("csize %ld\n", UNSTUFF_BITS(resp, 48, 22));
 652         csd->capacity  = (1 + UNSTUFF_BITS(resp, 48, 22)) << 10;
 653
 654                 csd->write_blk_bits = 9;
 655                 csd->write_partial = 0;
 656         csd->write_misalign = 0;
 657
 658                 csd->read_blk_bits = 9;
 659                 csd->read_partial = 0;
 660         csd->read_misalign = 0;
 661
 662         csd->erase_size = 1;
 663                 // the block size if fixed to 512kb
 664                 csd->blk_len = (1 << csd->write_blk_bits) << 10;
 665
 666         return 0;
 667         }
 668     else
 669         {
 670         kprintf("Unrecognised CSD structure version %d\n", csd->structure);
 671         return -1;
 672     }
 673
 674     return 0;
 675 }
 676
 677
 678 void sd_dumpCsd(Sd *sd)
 679 {
 680         ASSERT(sd);
 681
 682         LOG_INFO("VERSION: %d.0\n", sd->csd.structure ? 2 : 1);
 683     LOG_INFO("CARD COMMAND CLASS: %d\n", sd->csd.ccc);
 684         LOG_INFO("WRITE BLK LEN BITS: %ld\n", sd->csd.write_blk_bits);
 685         LOG_INFO("READ BLK LEN BITS: %ld\n", sd->csd.read_blk_bits);
 686         LOG_INFO("ERASE SIZE: %ld\n", sd->csd.erase_size);
 687         LOG_INFO("BLK NUM: %ld\n", sd->csd.blk_num);
 688         LOG_INFO("BLK LEN: %ld\n", sd->csd.blk_len);
 689         LOG_INFO("CAPACITY %ld\n", sd->csd.capacity);
 690         LOG_INFO("FLAG Write: WP %d, W MISALIGN %d\n", sd->csd.write_partial, sd->csd.write_misalign);
 691         LOG_INFO("FLAG Read: RP %d, R MISALIGN %d\n", sd->csd.read_partial, sd->csd.read_misalign);
 692
 693 }
 694
 695 void sd_dumpCid(Sd *sd)
 696 {
 697         ASSERT(sd);
 698
 699         LOG_INFO("MANFID: %d\n", sd->cid.manfid);
 700     LOG_INFO("OEMID: %d\n", sd->cid.oemid);
 701         LOG_INFO("SERIAL: %ld\n", sd->cid.serial);
 702     LOG_INFO("PROD_NAME: %s\n", sd->cid.prod_name);
 703     LOG_INFO("REV: %d.%d\n", sd->cid.m_rev, sd->cid.l_rev);
 704     LOG_INFO("OFF,Y,M: %lx, %ld %ld\n", sd->cid.year_off, (BCD_TO_INT_32BIT(sd->cid.year_off) / 12) + 2000,
 705                                                                                                 (BCD_TO_INT_32BIT(sd->cid.year_off) % 12));
 706 }
 707
 708 void sd_sendInit(void)
 709 {
 710         if (hsmci_sendCmd(0, 0, HSMCI_CMDR_SPCMD_INIT | HSMCI_CMDR_RSPTYP_NORESP))
 711                 LOG_ERR("INIT: %lx\n", HSMCI_SR);
 712 }
 713
 714
 715 void sd_goIdle(void)
 716 {
 717         if (hsmci_sendCmd(0, 0, HSMCI_CMDR_RSPTYP_NORESP))
 718                 LOG_ERR("GO_IDLE: %lx\n", HSMCI_SR);
 719 }
 720
 721 int sd_sendIfCond(void)
 722 {
 723         if (hsmci_sendCmd(8, CMD8_V_RANGE_27V_36V, HSMCI_CMDR_RSPTYP_48_BIT))
 724         {
 725                 LOG_ERR("IF_COND %lx\n", HSMCI_SR);
 726                 return -1;
 727         }
 728         else
 729         {
 730                 uint32_t r = HSMCI_RSPR;
 731                 if ((r & 0xFFF) == CMD8_V_RANGE_27V_36V)
 732                 {
 733                         LOG_INFO("IF_COND: %lx\n", r);
 734                         return 0;
 735                 }
 736                 LOG_ERR("IF_COND: %lx\n", r);
 737         }
 738         return -1;
 739 }
 740
 741 int sd_sendAppOpCond(void)
 742 {
 743         if (hsmci_sendCmd(55, 0, HSMCI_CMDR_RSPTYP_48_BIT))
 744         {
 745                 LOG_ERR("APP_CMD %lx\n", HSMCI_SR);
 746                 return -1;
 747         }
 748         else
 749         {
 750                 LOG_INFO("APP_CMD %lx\n", HSMCI_RSPR);
 751         }
 752
 753         if (hsmci_sendCmd(41, SD_HOST_VOLTAGE_RANGE | SD_OCR_CCS, HSMCI_CMDR_RSPTYP_48_BIT))// se cmd 8 va ok.
 754         {
 755                 LOG_ERR("APP_OP_COND %lx\n", HSMCI_SR);
 756                 return -1;
 757         }
 758         else
 759         {
 760                 uint32_t status = HSMCI_RSPR;
 761                 if (status & SD_OCR_BUSY)
 762                 {
 763                         LOG_INFO("SD power up! Hight Capability [%d]\n", (bool)(status & SD_OCR_CCS));
 764                         return 0;
 765                 }
 766
 767                 LOG_ERR("sd not ready.\n");
 768         }
 769
 770         return -1;
 771 }
 772
 773
 774 int sd_getCid(Sd *sd, uint32_t addr, uint8_t flag)
 775 {
 776         ASSERT(sd);
 777         memset(&(sd->cid), 0, sizeof(SDcid));
 778
 779         uint8_t idx = 9; // CMD9 get cid from gived sd address (RCA)
 780         if (flag & SD_SEND_ALL_CID)
 781                 idx = 2;
 782
 783
 784         if (hsmci_sendCmd(idx, SD_ADDR_TO_RCA(addr), HSMCI_CMDR_RSPTYP_136_BIT))
 785         {
 786                 LOG_ERR("GET_CID %lx\n", HSMCI_SR);
 787                 return -1;
 788         }
 789         else
 790         {
 791                 uint32_t resp[4];
 792                 hsmci_readResp(resp, 4);
 793                 LOG_INFOB(dump("CID", resp, 4););
 794
 795                 sd->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
 796                 sd->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
 797                 sd->cid.prod_name[0]      = UNSTUFF_BITS(resp, 96, 8);
 798                 sd->cid.prod_name[1]      = UNSTUFF_BITS(resp, 88, 8);
 799                 sd->cid.prod_name[2]      = UNSTUFF_BITS(resp, 80, 8);
 800                 sd->cid.prod_name[3]      = UNSTUFF_BITS(resp, 72, 8);
 801                 sd->cid.prod_name[4]      = UNSTUFF_BITS(resp, 64, 8);
 802                 sd->cid.m_rev         = UNSTUFF_BITS(resp, 60, 4);
 803                 sd->cid.l_rev         = UNSTUFF_BITS(resp, 56, 4);
 804                 sd->cid.serial        = (uint32_t)UNSTUFF_BITS(resp, 24, 32);
 805                 sd->cid.year_off      = UNSTUFF_BITS(resp, 8, 12);
 806         }
 807
 808         return 0;
 809 }
 810
 811 int sd_getCsd(Sd *sd)
 812 {
 813         ASSERT(sd);
 814         memset(&(sd->csd), 0, sizeof(SDcsd));
 815
 816         LOG_INFO("Send to RCA: %lx\n", SD_ADDR_TO_RCA(sd->addr));
 817         if (hsmci_sendCmd(9, SD_ADDR_TO_RCA(sd->addr), HSMCI_CMDR_RSPTYP_136_BIT))
 818         {
 819                 LOG_ERR("GET_CSD %lx\n", HSMCI_SR);
 820                 return -1;
 821         }
 822         else
 823         {
 824                 uint32_t resp[4];
 825                 hsmci_readResp(resp, 4);
 826                 LOG_INFOB(dump("CSD", resp, 4););
 827                 sd_decodeCsd(&(sd->csd), resp, 4);
 828         }
 829
 830         return 0;
 831 }
 832
 833 int sd_appStatus(Sd *sd)
 834 {
 835         ASSERT(sd);
 836         LOG_INFO("Send to RCA: %lx\n", SD_ADDR_TO_RCA(sd->addr));
 837         if (hsmci_sendCmd(13, SD_ADDR_TO_RCA(sd->addr), HSMCI_CMDR_RSPTYP_48_BIT))
 838         {
 839                 LOG_ERR("STATUS: %lx\n", HSMCI_SR);
 840                 return -1;
 841         }
 842         else
 843         {
 844                 hsmci_readResp(&(sd->status), 1);
 845                 LOG_INFOB(dump("STATUS", &(sd->status), 1););
 846         }
 847
 848         return 0;
 849 }
 850
 851 int sd_getRelativeAddr(Sd *sd)
 852 {
 853         ASSERT(sd);
 854         if (hsmci_sendCmd(3, 0, HSMCI_CMDR_RSPTYP_48_BIT))
 855         {
 856                 LOG_ERR("RCA: %lx\n", HSMCI_SR);
 857                 return -1;
 858         }
 859         else
 860         {
 861                 hsmci_readResp(&sd->addr, 1);
 862                 LOG_INFOB(dump("RCA", &sd->addr, 1););
 863
 864                 sd->addr = sd->addr >> 16;
 865         }
 866
 867         return 0;
 868 }
 869
 870 int sd_selectCard(Sd *sd)
 871 {
 872         ASSERT(sd);
 873         LOG_INFO("Select RCA: %lx\n", SD_ADDR_TO_RCA(sd->addr));
 874         if (hsmci_sendCmd(7, SD_ADDR_TO_RCA(sd->addr), HSMCI_CMDR_RSPTYP_R1B))
 875         {
 876                 LOG_ERR("SELECT_SD: %lx\n", HSMCI_SR);
 877                 return -1;
 878         }
 879         else
 880         {
 881                 HSMCI_CHECK_BUSY();
 882
 883                 hsmci_readResp(&(sd->status), 1);
 884                 LOG_INFOB(dump("SELECT_SD", &(sd->status), 1););
 885         }
 886
 887         return 0;
 888 }
 889
 890 int sd_setBusWidth(Sd *sd, size_t len)
 891 {
 892         ASSERT(sd);
 893
 894         if (hsmci_sendCmd(55, 0, HSMCI_CMDR_RSPTYP_48_BIT))
 895         {
 896                 LOG_ERR("APP_CMD %lx\n", HSMCI_SR);
 897                 return -1;
 898         }
 899         else
 900         {
 901                 LOG_INFO("APP_CMD %lx\n", HSMCI_RSPR);
 902         }
 903
 904
 905         if (hsmci_sendCmd(6, len, HSMCI_CMDR_RSPTYP_48_BIT))
 906         {
 907                 LOG_ERR("SET_BUS_WIDTH: %lx\n", HSMCI_SR);
 908                 return -1;
 909         }
 910         else
 911         {
 912                 hsmci_readResp(&(sd->status), 1);
 913                 LOG_INFOB(dump("SET_BUS_WIDTH", &(sd->status), 1););
 914
 915                 HSMCI_CHECK_BUSY();
 916         }
 917
 918         return 0;
 919 }
 920
 921
 922 int sd_set_BlockLen(Sd *sd, size_t len)
 923 {
 924         ASSERT(sd);
 925
 926         if (hsmci_sendCmd(16, len, HSMCI_CMDR_RSPTYP_48_BIT))
 927         {
 928                 LOG_ERR("SET_BUS_WIDTH: %lx\n", HSMCI_SR);
 929                 return -1;
 930         }
 931         else
 932         {
 933                 hsmci_readResp(&(sd->status), 1);
 934                 LOG_INFOB(dump("SET_BUS_WIDTH", &(sd->status), 1););
 935
 936                 HSMCI_CHECK_BUSY();
 937         }
 938
 939         return 0;
 940 }
 941
 942
 943 #endif
 944
 945
 946 bool sd_initUnbuf(Sd *sd, KFile *ch)
 947 {
 948         if (sd_blockInit(sd, ch))
 949         {
 950                 sd->b.priv.vt = &sd_unbuffered_vt;
 951                 return true;
 952         }
 953         else
 954                 return false;
 955 }
 956
 957 static uint8_t sd_buf[SD_DEFAULT_BLOCKLEN];
 958
 959 bool sd_initBuf(Sd *sd, KFile *ch)
 960 {
 961         if (sd_blockInit(sd, ch))
 962         {
 963                 sd->b.priv.buf = sd_buf;
 964                 sd->b.priv.flags |= KB_BUFFERED | KB_PARTIAL_WRITE;
 965                 sd->b.priv.vt = &sd_buffered_vt;
 966                 sd->b.priv.vt->load(&sd->b, 0);
 967                 return true;
 968         }
 969         else
 970                 return false;
 971 }
 972
 973
 974