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         size_t i;
 593         int j = 0;
 594         kprintf("\n%s [\n", label);
 595         for (i = 0; i < len; i++)
 596         {
 597                 if (j == 5)
 598                 {
 599                         kputs("\n");
 600                         j = 0;
 601                 }
 602                 kprintf("%08lx ", r[i]);
 603                 j++;
 604         }
 605         kprintf("\n] len=%d\n\n", i);
 606 }
 607 )
 608
 609
 610 static int sd_decodeCsd(SDcsd *csd, uint32_t *resp, size_t len)
 611 {
 612         ASSERT(csd);
 613         ASSERT(resp);
 614         ASSERT(len >= 4);
 615
 616     csd->structure = UNSTUFF_BITS(resp, 126, 2);
 617         csd->ccc = UNSTUFF_BITS(resp, 84, 12);
 618
 619
 620         /*
 621          * CSD structure:
 622          * - 0:
 623          *              - Version 1.01-1.10
 624          *              - Version 2.00/Standard Capacity
 625          * - 1:
 626          *              - Version 2.00/High Capacity
 627          * - >1: not defined.
 628          */
 629
 630     if (csd->structure == 0)
 631         {
 632                 // (C_size + 1) x 2^(C_SIZE_MUL+2)
 633                 csd->blk_num = (1 + UNSTUFF_BITS(resp, 62, 12)) << (UNSTUFF_BITS(resp, 47, 3) + 2);
 634
 635                 csd->read_blk_bits = UNSTUFF_BITS(resp, 80, 4);
 636                 csd->write_blk_bits = UNSTUFF_BITS(resp, 22, 4);
 637
 638                 csd->blk_len = 1 << csd->read_blk_bits;
 639         csd->capacity  = csd->blk_num * csd->blk_len;
 640
 641         csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 642         csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 643
 644         csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 645         csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 646
 647         if (UNSTUFF_BITS(resp, 46, 1))
 648                 {
 649             csd->erase_size = 1;
 650         }
 651                 else if(csd->write_blk_bits >= 9)
 652                 {
 653             csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
 654             csd->erase_size <<= csd->write_blk_bits - 9;
 655         }
 656
 657                 return 0;
 658         }
 659         else if (csd->structure == 1)
 660         {
 661                 kprintf("csize %ld\n", UNSTUFF_BITS(resp, 48, 22));
 662         csd->capacity  = (1 + UNSTUFF_BITS(resp, 48, 22)) << 10;
 663
 664                 csd->write_blk_bits = 9;
 665                 csd->write_partial = 0;
 666         csd->write_misalign = 0;
 667
 668                 csd->read_blk_bits = 9;
 669                 csd->read_partial = 0;
 670         csd->read_misalign = 0;
 671
 672         csd->erase_size = 1;
 673                 // the block size if fixed to 512kb
 674                 csd->blk_len = (1 << csd->write_blk_bits) << 10;
 675
 676         return 0;
 677         }
 678     else
 679         {
 680         kprintf("Unrecognised CSD structure version %d\n", csd->structure);
 681         return -1;
 682     }
 683
 684     return 0;
 685 }
 686
 687
 688 void sd_dumpCsd(Sd *sd)
 689 {
 690         ASSERT(sd);
 691
 692         LOG_INFO("VERSION: %d.0\n", sd->csd.structure ? 2 : 1);
 693     LOG_INFO("CARD COMMAND CLASS: %d\n", sd->csd.ccc);
 694         LOG_INFO("WRITE BLK LEN BITS: %ld\n", sd->csd.write_blk_bits);
 695         LOG_INFO("READ BLK LEN BITS: %ld\n", sd->csd.read_blk_bits);
 696         LOG_INFO("ERASE SIZE: %ld\n", sd->csd.erase_size);
 697         LOG_INFO("BLK NUM: %ld\n", sd->csd.blk_num);
 698         LOG_INFO("BLK LEN: %ld\n", sd->csd.blk_len);
 699         LOG_INFO("CAPACITY %ld\n", sd->csd.capacity);
 700         LOG_INFO("FLAG Write: WP %d, W MISALIGN %d\n", sd->csd.write_partial, sd->csd.write_misalign);
 701         LOG_INFO("FLAG Read: RP %d, R MISALIGN %d\n", sd->csd.read_partial, sd->csd.read_misalign);
 702
 703 }
 704
 705 void sd_dumpCid(Sd *sd)
 706 {
 707         ASSERT(sd);
 708
 709         LOG_INFO("MANFID: %d\n", sd->cid.manfid);
 710     LOG_INFO("OEMID: %d\n", sd->cid.oemid);
 711         LOG_INFO("SERIAL: %ld\n", sd->cid.serial);
 712     LOG_INFO("PROD_NAME: %s\n", sd->cid.prod_name);
 713     LOG_INFO("REV: %d.%d\n", sd->cid.m_rev, sd->cid.l_rev);
 714     LOG_INFO("OFF,Y,M: %lx, %ld %ld\n", sd->cid.year_off, (BCD_TO_INT_32BIT(sd->cid.year_off) / 12) + 2000,
 715                                                                                                 (BCD_TO_INT_32BIT(sd->cid.year_off) % 12));
 716 }
 717
 718 void sd_sendInit(void)
 719 {
 720         if (hsmci_sendCmd(0, 0, HSMCI_CMDR_SPCMD_INIT | HSMCI_CMDR_RSPTYP_NORESP))
 721                 LOG_ERR("INIT: %lx\n", HSMCI_SR);
 722 }
 723
 724
 725 void sd_goIdle(void)
 726 {
 727         if (hsmci_sendCmd(0, 0, HSMCI_CMDR_RSPTYP_NORESP))
 728                 LOG_ERR("GO_IDLE: %lx\n", HSMCI_SR);
 729 }
 730
 731 int sd_sendIfCond(void)
 732 {
 733         if (hsmci_sendCmd(8, CMD8_V_RANGE_27V_36V, HSMCI_CMDR_RSPTYP_48_BIT))
 734         {
 735                 LOG_ERR("IF_COND %lx\n", HSMCI_SR);
 736                 return -1;
 737         }
 738         else
 739         {
 740                 uint32_t r = HSMCI_RSPR;
 741                 if ((r & 0xFFF) == CMD8_V_RANGE_27V_36V)
 742                 {
 743                         LOG_INFO("IF_COND: %lx\n", r);
 744                         return 0;
 745                 }
 746                 LOG_ERR("IF_COND: %lx\n", r);
 747         }
 748         return -1;
 749 }
 750
 751 int sd_sendAppOpCond(void)
 752 {
 753         if (hsmci_sendCmd(55, 0, HSMCI_CMDR_RSPTYP_48_BIT))
 754         {
 755                 LOG_ERR("APP_CMD %lx\n", HSMCI_SR);
 756                 return -1;
 757         }
 758         else
 759         {
 760                 LOG_INFO("APP_CMD %lx\n", HSMCI_RSPR);
 761         }
 762
 763         if (hsmci_sendCmd(41, SD_HOST_VOLTAGE_RANGE | SD_OCR_CCS, HSMCI_CMDR_RSPTYP_48_BIT))// se cmd 8 va ok.
 764         {
 765                 LOG_ERR("APP_OP_COND %lx\n", HSMCI_SR);
 766                 return -1;
 767         }
 768         else
 769         {
 770                 uint32_t status = HSMCI_RSPR;
 771                 if (status & SD_OCR_BUSY)
 772                 {
 773                         LOG_INFO("SD power up! Hight Capability [%d]\n", (bool)(status & SD_OCR_CCS));
 774                         return 0;
 775                 }
 776
 777                 LOG_ERR("sd not ready.\n");
 778         }
 779
 780         return -1;
 781 }
 782
 783
 784 int sd_getCid(Sd *sd, uint32_t addr, uint8_t flag)
 785 {
 786         ASSERT(sd);
 787         memset(&(sd->cid), 0, sizeof(SDcid));
 788
 789         uint8_t idx = 9; // CMD9 get cid from gived sd address (RCA)
 790         if (flag & SD_SEND_ALL_CID)
 791                 idx = 2;
 792
 793
 794         if (hsmci_sendCmd(idx, SD_ADDR_TO_RCA(addr), HSMCI_CMDR_RSPTYP_136_BIT))
 795         {
 796                 LOG_ERR("GET_CID %lx\n", HSMCI_SR);
 797                 return -1;
 798         }
 799         else
 800         {
 801                 uint32_t resp[4];
 802                 hsmci_readResp(resp, 4);
 803                 LOG_INFOB(dump("CID", resp, 4););
 804
 805                 sd->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
 806                 sd->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
 807                 sd->cid.prod_name[0]      = UNSTUFF_BITS(resp, 96, 8);
 808                 sd->cid.prod_name[1]      = UNSTUFF_BITS(resp, 88, 8);
 809                 sd->cid.prod_name[2]      = UNSTUFF_BITS(resp, 80, 8);
 810                 sd->cid.prod_name[3]      = UNSTUFF_BITS(resp, 72, 8);
 811                 sd->cid.prod_name[4]      = UNSTUFF_BITS(resp, 64, 8);
 812                 sd->cid.m_rev         = UNSTUFF_BITS(resp, 60, 4);
 813                 sd->cid.l_rev         = UNSTUFF_BITS(resp, 56, 4);
 814                 sd->cid.serial        = (uint32_t)UNSTUFF_BITS(resp, 24, 32);
 815                 sd->cid.year_off      = UNSTUFF_BITS(resp, 8, 12);
 816         }
 817
 818         return 0;
 819 }
 820
 821 int sd_getCsd(Sd *sd)
 822 {
 823         ASSERT(sd);
 824         memset(&(sd->csd), 0, sizeof(SDcsd));
 825
 826         LOG_INFO("Send to RCA: %lx\n", SD_ADDR_TO_RCA(sd->addr));
 827         if (hsmci_sendCmd(9, SD_ADDR_TO_RCA(sd->addr), HSMCI_CMDR_RSPTYP_136_BIT))
 828         {
 829                 LOG_ERR("GET_CSD %lx\n", HSMCI_SR);
 830                 return -1;
 831         }
 832         else
 833         {
 834                 uint32_t resp[4];
 835                 hsmci_readResp(resp, 4);
 836                 LOG_INFOB(dump("CSD", resp, 4););
 837                 sd_decodeCsd(&(sd->csd), resp, 4);
 838         }
 839
 840         return 0;
 841 }
 842
 843 int sd_getRelativeAddr(Sd *sd)
 844 {
 845         ASSERT(sd);
 846         if (hsmci_sendCmd(3, 0, HSMCI_CMDR_RSPTYP_48_BIT))
 847         {
 848                 LOG_ERR("RCA: %lx\n", HSMCI_SR);
 849                 return -1;
 850         }
 851         else
 852         {
 853                 hsmci_readResp(&sd->addr, 1);
 854                 LOG_INFOB(dump("RCA", &sd->addr, 1););
 855
 856                 sd->addr = sd->addr >> 16;
 857         }
 858
 859         return 0;
 860 }
 861
 862 #define SD_STATUS_APP_CMD      BV(5)
 863 #define SD_STATUS_READY        BV(8)
 864 #define SD_STATUS_CURR_MASK    0x1E00
 865 #define SD_STATUS_CURR_SHIFT   9
 866
 867 #define SD_GET_STATE(status)    (uint8_t)(((status) & SD_STATUS_CURR_MASK) >> SD_STATUS_CURR_SHIFT)
 868
 869 int sd_appStatus(Sd *sd)
 870 {
 871         ASSERT(sd);
 872         LOG_INFO("Send to RCA: %lx\n", SD_ADDR_TO_RCA(sd->addr));
 873         if (hsmci_sendCmd(13, SD_ADDR_TO_RCA(sd->addr), HSMCI_CMDR_RSPTYP_48_BIT))
 874         {
 875                 LOG_ERR("STATUS: %lx\n", HSMCI_SR);
 876                 return -1;
 877         }
 878
 879         hsmci_readResp(&(sd->status), 1);
 880         LOG_INFOB(dump("STATUS", &(sd->status), 1););
 881
 882         LOG_INFO("State[%d]\n", SD_GET_STATE(sd->status));
 883
 884         if (sd->status & SD_STATUS_READY)
 885                 return 0;
 886
 887         return -1;
 888 }
 889
 890
 891 INLINE int sd_cardSelection(Sd *sd, size_t rca)
 892 {
 893         ASSERT(sd);
 894         LOG_INFO("Select RCA: %lx\n", SD_ADDR_TO_RCA(sd->addr));
 895         if (hsmci_sendCmd(7, rca, HSMCI_CMDR_RSPTYP_R1B))
 896         {
 897                 LOG_ERR("SELECT_SD: %lx\n", HSMCI_SR);
 898                 return -1;
 899         }
 900
 901         HSMCI_CHECK_BUSY();
 902         hsmci_readResp(&(sd->status), 1);
 903         LOG_INFOB(dump("SELECT_SD", &(sd->status), 1););
 904
 905         LOG_INFO("State[%d]\n", SD_GET_STATE(sd->status));
 906
 907         if (sd->status & SD_STATUS_READY)
 908                 return 0;
 909
 910         return -1;
 911 }
 912
 913 int sd_selectCard(Sd *sd)
 914 {
 915         return sd_cardSelection(sd, SD_ADDR_TO_RCA(sd->addr));
 916 }
 917
 918 int sd_deSelectCard(Sd *sd)
 919 {
 920         uint32_t rca = 0;
 921         if (!sd->addr)
 922                 rca = SD_ADDR_TO_RCA(sd->addr + 1);
 923
 924         return sd_cardSelection(sd, rca);
 925 }
 926
 927
 928 int sd_setBusWidth(Sd *sd, size_t len)
 929 {
 930         ASSERT(sd);
 931
 932         if (hsmci_sendCmd(55, SD_ADDR_TO_RCA(sd->addr), HSMCI_CMDR_RSPTYP_48_BIT))
 933         {
 934                 LOG_ERR("APP_CMD %lx\n", HSMCI_SR);
 935                 return -1;
 936         }
 937
 938         uint32_t status = HSMCI_RSPR;
 939         if (status & (SD_STATUS_APP_CMD | SD_STATUS_READY))
 940         {
 941                 hsmci_setBusWidth(len);
 942
 943                 if (hsmci_sendCmd(6, len, HSMCI_CMDR_RSPTYP_48_BIT))
 944                 {
 945                         LOG_ERR("SET_BUS_WIDTH CMD: %lx\n", HSMCI_SR);
 946                         return -1;
 947                 }
 948
 949                 hsmci_readResp(&(sd->status), 1);
 950                 HSMCI_CHECK_BUSY();
 951
 952                 LOG_INFOB(dump("SET_BUS_WIDTH", &(sd->status), 1););
 953                 LOG_INFO("State[%d]\n", SD_GET_STATE(sd->status));
 954
 955                 if (sd->status & SD_STATUS_READY)
 956                         return 0;
 957         }
 958
 959         LOG_ERR("SET_BUS_WIDTH REP %lx\n", status);
 960         return -1;
 961 }
 962
 963
 964 int sd_set_BlockLen(Sd *sd, size_t len)
 965 {
 966         ASSERT(sd);
 967
 968         if (hsmci_sendCmd(16, len, HSMCI_CMDR_RSPTYP_48_BIT))
 969         {
 970                 LOG_ERR("SET_BLK_LEN: %lx\n", HSMCI_SR);
 971                 return -1;
 972         }
 973
 974         hsmci_readResp(&(sd->status), 1);
 975         HSMCI_CHECK_BUSY();
 976
 977         LOG_INFOB(dump("SET_BLK_LEN", &(sd->status), 1););
 978         LOG_INFO("State[%d]\n", SD_GET_STATE(sd->status));
 979
 980         sd->csd.blk_len = len;
 981
 982         if (sd->status & SD_STATUS_READY)
 983                 return 0;
 984
 985         return -1;
 986 }
 987
 988 int sd_readSingleBlock(Sd *sd, size_t index, void *_buf, size_t len)
 989 {
 990         ASSERT(sd);
 991         ASSERT(_buf);
 992         ASSERT(!(len % sd->csd.blk_len));
 993
 994         uint32_t *buf = (uint32_t *)_buf;
 995
 996         hsmci_setBlkSize(sd->csd.blk_len);
 997
 998         if (hsmci_sendCmd(17, index * sd->csd.blk_len, HSMCI_CMDR_RSPTYP_48_BIT))
 999         {
1000                 LOG_ERR("SIGLE_BLK_READ: %lx\n", HSMCI_SR);
1001                 return -1;
1002         }
1003         hsmci_readResp(&(sd->status), 1);
1004         HSMCI_CHECK_BUSY();
1005
1006         LOG_INFOB(dump("SIGLE_BLK_READ", &(sd->status), 1););
1007         LOG_INFO("State[%d]\n", SD_GET_STATE(sd->status));
1008
1009         if (sd->status & SD_STATUS_READY)
1010         {
1011                 hsmci_read(buf, len / sizeof(uint32_t));
1012                 LOG_INFOB(dump("BLK", buf, 8););
1013                 return len;
1014         }
1015
1016         return -1;
1017 }
1018
1019
1020 #endif
1021
1022
1023 bool sd_initUnbuf(Sd *sd, KFile *ch)
1024 {
1025         if (sd_blockInit(sd, ch))
1026         {
1027                 sd->b.priv.vt = &sd_unbuffered_vt;
1028                 return true;
1029         }
1030         else
1031                 return false;
1032 }
1033
1034 static uint8_t sd_buf[SD_DEFAULT_BLOCKLEN];
1035
1036 bool sd_initBuf(Sd *sd, KFile *ch)
1037 {
1038         if (sd_blockInit(sd, ch))
1039         {
1040                 sd->b.priv.buf = sd_buf;
1041                 sd->b.priv.flags |= KB_BUFFERED | KB_PARTIAL_WRITE;
1042                 sd->b.priv.vt = &sd_buffered_vt;
1043                 sd->b.priv.vt->load(&sd->b, 0);
1044                 return true;
1045         }
1046         else
1047                 return false;
1048 }
1049
1050
1051