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->r1 = sd_setBlockLen(sd, size)))
 247         {
 248                 LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
 249                 return 0;
 250         }
 251
 252         SD_SELECT(sd);
 253
 254         sd->r1 = sd_sendCommand(sd, SD_READ_SINGLEBLOCK, idx * SD_DEFAULT_BLOCKLEN + offset, 0);
 255
 256         if (sd->r1)
 257         {
 258                 LOG_ERR("read single block failed: %04X\n", sd->r1);
 259                 sd_select(sd, false);
 260                 return 0;
 261         }
 262
 263         bool res = sd_getBlock(sd, buf, size);
 264         sd_select(sd, false);
 265         if (!res)
 266         {
 267                 LOG_ERR("read single block failed reading data\n");
 268                 return 0;
 269         }
 270         else
 271                 return size;
 272 }
 273
 274 #define SD_WRITE_SINGLEBLOCK 0x58
 275 #define SD_DATA_ACCEPTED     0x05
 276
 277 static int sd_writeBlock(KBlock *b, block_idx_t idx, const void *buf)
 278 {
 279         Sd *sd = SD_CAST(b);
 280         KFile *fd = sd->ch;
 281
 282         LOG_INFO("writing block %ld\n", idx);
 283         if ((sd->r1 = sd_setBlockLen(sd, SD_DEFAULT_BLOCKLEN)))
 284         {
 285                 LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
 286                 return sd->r1;
 287         }
 288
 289         SD_SELECT(sd);
 290
 291         sd->r1 = sd_sendCommand(sd, SD_WRITE_SINGLEBLOCK, idx * SD_DEFAULT_BLOCKLEN, 0);
 292
 293         if (sd->r1)
 294         {
 295                 LOG_ERR("write single block failed: %04X\n", sd->r1);
 296                 sd_select(sd, false);
 297                 return sd->r1;
 298         }
 299
 300         kfile_putc(SD_STARTTOKEN, fd);
 301         kfile_write(fd, buf, SD_DEFAULT_BLOCKLEN);
 302         /* send fake crc */
 303         kfile_putc(0, fd);
 304         kfile_putc(0, fd);
 305
 306         uint8_t dataresp = kfile_getc(fd);
 307         sd_select(sd, false);
 308
 309         if ((dataresp & 0x1f) != SD_DATA_ACCEPTED)
 310         {
 311                 LOG_ERR("write block %ld failed: %02X\n", idx, dataresp);
 312                 return EOF;
 313         }
 314
 315         return 0;
 316 }
 317
 318 void sd_writeTest(Sd *sd)
 319 {
 320         uint8_t buf[SD_DEFAULT_BLOCKLEN];
 321         memset(buf, 0, sizeof(buf));
 322
 323         for (block_idx_t i = 0; i < sd->b.blk_cnt; i++)
 324         {
 325                 LOG_INFO("writing block %ld: %s\n", i, (sd_writeBlock(&sd->b, i, buf) == 0) ? "OK" : "FAIL");
 326         }
 327 }
 328
 329
 330 bool sd_test(Sd *sd)
 331 {
 332         uint8_t buf[SD_DEFAULT_BLOCKLEN];
 333
 334         if (sd_readDirect(&sd->b, 0, buf, 0, sd->b.blk_size) != sd->b.blk_size)
 335                 return false;
 336
 337         kputchar('\n');
 338         for (int i = 0; i < SD_DEFAULT_BLOCKLEN; i++)
 339         {
 340                 kprintf("%02X ", buf[i]);
 341                 buf[i] = i;
 342                 if (!((i+1) % 16))
 343                         kputchar('\n');
 344         }
 345
 346         if (sd_writeBlock(&sd->b, 0, buf) != 0)
 347                 return false;
 348
 349         memset(buf, 0, sizeof(buf));
 350         if (sd_readDirect(&sd->b, 0, buf, 0, sd->b.blk_size) != sd->b.blk_size)
 351                 return false;
 352
 353         kputchar('\n');
 354         for (block_idx_t i = 0; i < sd->b.blk_size; i++)
 355         {
 356                 kprintf("%02X ", buf[i]);
 357                 buf[i] = i;
 358                 if (!((i+1) % 16))
 359                         kputchar('\n');
 360         }
 361
 362         return true;
 363 }
 364
 365 static int sd_error(KBlock *b)
 366 {
 367         Sd *sd = SD_CAST(b);
 368         return sd->r1;
 369 }
 370
 371 static int sd_clearerr(KBlock *b)
 372 {
 373         Sd *sd = SD_CAST(b);
 374         sd->r1 = 0;
 375         return 0;
 376 }
 377
 378 static const KBlockVTable sd_unbuffered_vt =
 379 {
 380         .readDirect = sd_readDirect,
 381         .writeBlock = sd_writeBlock,
 382
 383         .error = sd_error,
 384         .clearerr = sd_clearerr,
 385 };
 386
 387 static const KBlockVTable sd_buffered_vt =
 388 {
 389         .readDirect = sd_readDirect,
 390         .writeBlock = sd_writeBlock,
 391
 392         .readBuf = kblock_swReadBuf,
 393         .writeBuf = kblock_swWriteBuf,
 394         .load = kblock_swLoad,
 395         .store = kblock_swStore,
 396
 397         .error = sd_error,
 398         .clearerr = sd_clearerr,
 399 };
 400
 401 #define SD_GO_IDLE_STATE     0x40
 402 #define SD_GO_IDLE_STATE_CRC 0x95
 403 #define SD_SEND_OP_COND      0x41
 404 #define SD_SEND_OP_COND_CRC  0xF9
 405
 406 #define SD_START_DELAY  ms_to_ticks(10)
 407 #define SD_INIT_TIMEOUT ms_to_ticks(1000)
 408 #define SD_IDLE_RETRIES 4
 409
 410 static bool sd_blockInit(Sd *sd, KFile *ch)
 411 {
 412         ASSERT(sd);
 413         ASSERT(ch);
 414         memset(sd, 0, sizeof(*sd));
 415         DB(sd->b.priv.type = KBT_SD);
 416         sd->ch = ch;
 417
 418         SD_CS_INIT();
 419         SD_CS_OFF();
 420
 421         /* Wait a few moments for supply voltage to stabilize */
 422         timer_delay(SD_START_DELAY);
 423
 424         /* Give 80 clk pulses to wake up the card */
 425         for (int i = 0; i < 10; i++)
 426                 kfile_putc(0xff, ch);
 427         kfile_flush(ch);
 428
 429         for (int i = 0; i < SD_IDLE_RETRIES; i++)
 430         {
 431                 SD_SELECT(sd);
 432                 sd->r1 = sd_sendCommand(sd, SD_GO_IDLE_STATE, 0, SD_GO_IDLE_STATE_CRC);
 433                 sd_select(sd, false);
 434
 435                 if (sd->r1 == SD_IN_IDLE)
 436                         break;
 437         }
 438
 439         if (sd->r1 != SD_IN_IDLE)
 440         {
 441                 LOG_ERR("go_idle_state failed: %04X\n", sd->r1);
 442                 return false;
 443         }
 444
 445         ticks_t start = timer_clock();
 446
 447         /* Wait for card to start */
 448         do
 449         {
 450                 SD_SELECT(sd);
 451                 sd->r1 = sd_sendCommand(sd, SD_SEND_OP_COND, 0, SD_SEND_OP_COND_CRC);
 452                 sd_select(sd, false);
 453                 cpu_relax();
 454         }
 455         while (sd->r1 != 0 && timer_clock() - start < SD_INIT_TIMEOUT);
 456
 457         if (sd->r1)
 458         {
 459                 LOG_ERR("send_op_cond failed: %04X\n", sd->r1);
 460                 return false;
 461         }
 462
 463         sd->r1 = sd_setBlockLen(sd, SD_DEFAULT_BLOCKLEN);
 464
 465         if (sd->r1)
 466         {
 467                 LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
 468                 return false;
 469         }
 470
 471         /* Avoid warning for uninitialized csd use (gcc bug?) */
 472         CardCSD csd = csd;
 473
 474         sd->r1 = sd_getCSD(sd, &csd);
 475
 476         if (sd->r1)
 477         {
 478                 LOG_ERR("getCSD failed: %04X\n", sd->r1);
 479                 return false;
 480         }
 481
 482         sd->b.blk_size = SD_DEFAULT_BLOCKLEN;
 483         sd->b.blk_cnt = csd.block_num * (csd.block_len / SD_DEFAULT_BLOCKLEN);
 484         LOG_INFO("blk_size %d, blk_cnt %ld\n", sd->b.blk_size, sd->b.blk_cnt);
 485
 486 #if CONFIG_SD_AUTOASSIGN_FAT
 487         disk_assignDrive(&sd->b, 0);
 488 #endif
 489
 490         return true;
 491 }
 492
 493 bool sd_initUnbuf(Sd *sd, KFile *ch)
 494 {
 495         if (sd_blockInit(sd, ch))
 496         {
 497                 sd->b.priv.vt = &sd_unbuffered_vt;
 498                 return true;
 499         }
 500         else
 501                 return false;
 502 }
 503
 504 static uint8_t sd_buf[SD_DEFAULT_BLOCKLEN];
 505
 506 bool sd_initBuf(Sd *sd, KFile *ch)
 507 {
 508         if (sd_blockInit(sd, ch))
 509         {
 510                 sd->b.priv.buf = sd_buf;
 511                 sd->b.priv.flags |= KB_BUFFERED;
 512                 sd->b.priv.vt = &sd_buffered_vt;
 513                 sd->b.priv.vt->load(&sd->b, 0);
 514                 return true;
 515         }
 516         else
 517                 return false;
 518 }
 519