cpu/omap3/mmc.c

   1 /*
   2  * (C) Copyright 2008
   3  * Texas Instruments, <www.ti.com>
   4  * Syed Mohammed Khasim <khasim@ti.com>
   5  *
   6  * See file CREDITS for list of people who contributed to this
   7  * project.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation's version 2 of
  12  * the License.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  22  * MA 02111-1307 USA
  23  */
  24
  25
  26 #include <config.h>
  27 #include <common.h>
  28 #include <mmc.h>
  29 #include <part.h>
  30
  31 #ifdef CFG_CMD_MMC
  32
  33 #include "mmc_host_def.h"
  34 #include "mmc_protocol.h"
  35
  36 #define OMAP_MMC_MASTER_CLOCK   96000000
  37 extern int fat_register_device(block_dev_desc_t *dev_desc, int part_no);
  38
  39 mmc_card_data cur_card_data;
  40 static block_dev_desc_t mmc_blk_dev;
  41
  42 block_dev_desc_t *mmc_get_dev(int dev)
  43 {
  44         return ((block_dev_desc_t *) &mmc_blk_dev);
  45 }
  46
  47 unsigned char mmc_board_init(void)
  48 {
  49         unsigned int value = 0;
  50
  51         value = CONTROL_PBIAS_LITE;
  52         CONTROL_PBIAS_LITE = value | (1 << 2) | (1 << 1) | (1 << 9);
  53
  54         value = CONTROL_DEV_CONF0;
  55         CONTROL_DEV_CONF0 = value | (1 << 24);
  56
  57         return 1;
  58 }
  59
  60 void mmc_init_stream(void)
  61 {
  62         OMAP_HSMMC_CON |= INIT_INITSTREAM;
  63
  64         OMAP_HSMMC_CMD = MMC_CMD0;
  65         while (!(OMAP_HSMMC_STAT & CC_MASK));
  66
  67         OMAP_HSMMC_STAT = CC_MASK;
  68
  69         OMAP_HSMMC_CMD = MMC_CMD0;
  70         while (!(OMAP_HSMMC_STAT & CC_MASK));
  71
  72
  73         OMAP_HSMMC_STAT = OMAP_HSMMC_STAT;
  74         OMAP_HSMMC_CON &= ~INIT_INITSTREAM;
  75 }
  76
  77 unsigned char mmc_clock_config(unsigned int iclk, unsigned short clk_div)
  78 {
  79         unsigned int val;
  80
  81         mmc_reg_out(OMAP_HSMMC_SYSCTL, (ICE_MASK | DTO_MASK | CEN_MASK),
  82                     (ICE_STOP | DTO_15THDTO | CEN_DISABLE));
  83
  84         switch (iclk) {
  85         case CLK_INITSEQ:
  86                 val = MMC_INIT_SEQ_CLK / 2;
  87                 break;
  88         case CLK_400KHZ:
  89                 val = MMC_400kHz_CLK;
  90                 break;
  91         case CLK_MISC:
  92                 val = clk_div;
  93                 break;
  94         default:
  95                 return 0;
  96         }
  97         mmc_reg_out(OMAP_HSMMC_SYSCTL,
  98                     ICE_MASK | CLKD_MASK, (val << CLKD_OFFSET) | ICE_OSCILLATE);
  99
 100         while ((OMAP_HSMMC_SYSCTL & ICS_MASK) == ICS_NOTREADY);
 101
 102
 103         OMAP_HSMMC_SYSCTL |= CEN_ENABLE;
 104         return 1;
 105 }
 106
 107 unsigned char mmc_init_setup(void)
 108 {
 109         unsigned int reg_val;
 110         unsigned int val = 0;
 111
 112         mmc_board_init();
 113
 114         OMAP_HSMMC_SYSCONFIG |= MMC_SOFTRESET;
 115         while ((OMAP_HSMMC_SYSSTATUS & RESETDONE) == 0) ;
 116
 117         OMAP_HSMMC_SYSCTL |= SOFTRESETALL;
 118         while ((OMAP_HSMMC_SYSCTL & SOFTRESETALL) != 0x0) ;
 119
 120         OMAP_HSMMC_HCTL = DTW_1_BITMODE | SDBP_PWROFF | SDVS_3V0;
 121         OMAP_HSMMC_CAPA |= VS30_3V0SUP | VS18_1V8SUP;
 122
 123         reg_val = OMAP_HSMMC_CON & RESERVED_MASK;
 124
 125         OMAP_HSMMC_CON = CTPL_MMC_SD | reg_val | WPP_ACTIVEHIGH |
 126             CDP_ACTIVEHIGH | MIT_CTO | DW8_1_4BITMODE | MODE_FUNC |
 127             STR_BLOCK | HR_NOHOSTRESP | INIT_NOINIT | NOOPENDRAIN;
 128
 129         mmc_clock_config(CLK_INITSEQ, 0);
 130         OMAP_HSMMC_HCTL |= SDBP_PWRON;
 131
 132         OMAP_HSMMC_IE = 0x307f0033;
 133
 134         mmc_init_stream();
 135         return 1;
 136 }
 137
 138 unsigned char mmc_send_cmd(unsigned int cmd, unsigned int arg,
 139                            unsigned int *response)
 140 {
 141         unsigned int mmc_stat;
 142
 143         while ((OMAP_HSMMC_PSTATE & DATI_MASK) == DATI_CMDDIS);
 144
 145
 146         OMAP_HSMMC_BLK = BLEN_512BYTESLEN | NBLK_STPCNT;
 147         OMAP_HSMMC_STAT = 0xFFFFFFFF;
 148         OMAP_HSMMC_ARG = arg;
 149         OMAP_HSMMC_CMD = cmd | CMD_TYPE_NORMAL | CICE_NOCHECK |
 150             CCCE_NOCHECK | MSBS_SGLEBLK | ACEN_DISABLE | BCE_DISABLE |
 151             DE_DISABLE;
 152
 153         while (1) {
 154                 do {
 155                         mmc_stat = OMAP_HSMMC_STAT;
 156                 } while (mmc_stat == 0);
 157
 158                 if ((mmc_stat & ERRI_MASK) != 0)
 159                         return (unsigned char)mmc_stat;
 160
 161
 162                 if (mmc_stat & CC_MASK) {
 163                         OMAP_HSMMC_STAT = CC_MASK;
 164                         response[0] = OMAP_HSMMC_RSP10;
 165                         if ((cmd & RSP_TYPE_MASK) == RSP_TYPE_LGHT136) {
 166                                 response[1] = OMAP_HSMMC_RSP32;
 167                                 response[2] = OMAP_HSMMC_RSP54;
 168                                 response[3] = OMAP_HSMMC_RSP76;
 169                         }
 170                         break;
 171                 }
 172         }
 173         return 1;
 174 }
 175
 176 unsigned char mmc_read_data(unsigned int *output_buf)
 177 {
 178         unsigned int mmc_stat;
 179         unsigned int read_count = 0;
 180
 181         /*
 182          * Start Polled Read
 183          */
 184         while (1) {
 185                 do {
 186                         mmc_stat = OMAP_HSMMC_STAT;
 187                 } while (mmc_stat == 0);
 188
 189                 if ((mmc_stat & ERRI_MASK) != 0)
 190                         return (unsigned char)mmc_stat;
 191
 192                 if (mmc_stat & BRR_MASK) {
 193                         unsigned int k;
 194
 195                         OMAP_HSMMC_STAT |= BRR_MASK;
 196                         for (k = 0; k < MMCSD_SECTOR_SIZE / 4; k++) {
 197                                 *output_buf = OMAP_HSMMC_DATA;
 198                                 output_buf++;
 199                                 read_count += 4;
 200                         }
 201                 }
 202
 203                 if (mmc_stat & BWR_MASK)
 204                         OMAP_HSMMC_STAT |= BWR_MASK;
 205
 206                 if (mmc_stat & TC_MASK) {
 207                         OMAP_HSMMC_STAT |= TC_MASK;
 208                         break;
 209                 }
 210         }
 211         return 1;
 212 }
 213
 214 unsigned char mmc_detect_card(mmc_card_data *mmc_card_cur)
 215 {
 216         unsigned char err;
 217         unsigned int argument = 0;
 218         unsigned int ocr_value, ocr_recvd, ret_cmd41, hcs_val;
 219         unsigned int resp[4];
 220         unsigned short retry_cnt = 2000;
 221
 222         /* Set to Initialization Clock */
 223         err = mmc_clock_config(CLK_400KHZ, 0);
 224         if (err != 1)
 225                 return err;
 226
 227         mmc_card_cur->RCA = MMC_RELATIVE_CARD_ADDRESS;
 228         argument = 0x00000000;
 229
 230         ocr_value = (0x1FF << 15);
 231         err = mmc_send_cmd(MMC_CMD0, argument, resp);
 232         if (err != 1)
 233                 return err;
 234
 235         argument = SD_CMD8_CHECK_PATTERN | SD_CMD8_2_7_3_6_V_RANGE;
 236         err = mmc_send_cmd(MMC_SDCMD8, argument, resp);
 237         hcs_val = (err == 1) ?
 238             MMC_OCR_REG_HOST_CAPACITY_SUPPORT_SECTOR :
 239             MMC_OCR_REG_HOST_CAPACITY_SUPPORT_BYTE;
 240
 241         argument = 0x0000 << 16;
 242         err = mmc_send_cmd(MMC_CMD55, argument, resp);
 243         if (err == 1) {
 244                 mmc_card_cur->card_type = SD_CARD;
 245                 ocr_value |= hcs_val;
 246                 ret_cmd41 = MMC_ACMD41;
 247         } else {
 248                 mmc_card_cur->card_type = MMC_CARD;
 249                 ocr_value |= MMC_OCR_REG_ACCESS_MODE_SECTOR;
 250                 ret_cmd41 = MMC_CMD1;
 251                 OMAP_HSMMC_CON &= ~OD;
 252                 OMAP_HSMMC_CON |= OPENDRAIN;
 253         }
 254
 255         argument = ocr_value;
 256         err = mmc_send_cmd(ret_cmd41, argument, resp);
 257         if (err != 1)
 258                 return err;
 259
 260         ocr_recvd = ((mmc_resp_r3 *) resp)->ocr;
 261
 262         while (!(ocr_recvd & (0x1 << 31)) && (retry_cnt > 0)) {
 263                 retry_cnt--;
 264                 if (mmc_card_cur->card_type == SD_CARD) {
 265                         argument = 0x0000 << 16;
 266                         err = mmc_send_cmd(MMC_CMD55, argument, resp);
 267                 }
 268
 269                 argument = ocr_value;
 270                 err = mmc_send_cmd(ret_cmd41, argument, resp);
 271                 if (err != 1)
 272                         return err;
 273                 ocr_recvd = ((mmc_resp_r3 *) resp)->ocr;
 274         }
 275
 276         if (!(ocr_recvd & (0x1 << 31)))
 277                 return 0;
 278
 279         if (mmc_card_cur->card_type == MMC_CARD) {
 280                 if ((ocr_recvd & MMC_OCR_REG_ACCESS_MODE_MASK) ==
 281                     MMC_OCR_REG_ACCESS_MODE_SECTOR) {
 282                         mmc_card_cur->mode = SECTOR_MODE;
 283                 } else {
 284                         mmc_card_cur->mode = BYTE_MODE;
 285                 }
 286
 287                 ocr_recvd &= ~MMC_OCR_REG_ACCESS_MODE_MASK;
 288         } else {
 289                 if ((ocr_recvd & MMC_OCR_REG_HOST_CAPACITY_SUPPORT_MASK)
 290                     == MMC_OCR_REG_HOST_CAPACITY_SUPPORT_SECTOR) {
 291                         mmc_card_cur->mode = SECTOR_MODE;
 292                 } else {
 293                         mmc_card_cur->mode = BYTE_MODE;
 294                 }
 295                 ocr_recvd &= ~MMC_OCR_REG_HOST_CAPACITY_SUPPORT_MASK;
 296         }
 297
 298         ocr_recvd &= ~(0x1 << 31);
 299         if (!(ocr_recvd & ocr_value))
 300                 return 0;
 301
 302         err = mmc_send_cmd(MMC_CMD2, argument, resp);
 303         if (err != 1)
 304                 return err;
 305
 306         if (mmc_card_cur->card_type == MMC_CARD) {
 307                 argument = mmc_card_cur->RCA << 16;
 308                 err = mmc_send_cmd(MMC_CMD3, argument, resp);
 309                 if (err != 1)
 310                         return err;
 311         } else {
 312                 argument = 0x00000000;
 313                 err = mmc_send_cmd(MMC_SDCMD3, argument, resp);
 314                 if (err != 1)
 315                         return err;
 316
 317                 mmc_card_cur->RCA = ((mmc_resp_r6 *) resp)->newpublishedrca;
 318         }
 319
 320         OMAP_HSMMC_CON &= ~OD;
 321         OMAP_HSMMC_CON |= NOOPENDRAIN;
 322         return 1;
 323 }
 324
 325 unsigned char mmc_read_cardsize(mmc_card_data *mmc_dev_data,
 326                                 mmc_csd_reg_t *cur_csd)
 327 {
 328         mmc_extended_csd_reg_t ext_csd;
 329         unsigned int size, count, blk_len, blk_no, card_size, argument;
 330         unsigned char err;
 331         unsigned int resp[4];
 332
 333         if (mmc_dev_data->mode == SECTOR_MODE) {
 334                 if (mmc_dev_data->card_type == SD_CARD) {
 335                         card_size =
 336                             (((mmc_sd2_csd_reg_t *) cur_csd)->
 337                              c_size_lsb & MMC_SD2_CSD_C_SIZE_LSB_MASK) |
 338                             ((((mmc_sd2_csd_reg_t *) cur_csd)->
 339                               c_size_msb & MMC_SD2_CSD_C_SIZE_MSB_MASK)
 340                              << MMC_SD2_CSD_C_SIZE_MSB_OFFSET);
 341                         mmc_dev_data->size = card_size * 1024;
 342                         if (mmc_dev_data->size == 0)
 343                                 return 0;
 344                 } else {
 345                         argument = 0x00000000;
 346                         err = mmc_send_cmd(MMC_CMD8, argument, resp);
 347                         if (err != 1)
 348                                 return err;
 349                         err = mmc_read_data((unsigned int *)&ext_csd);
 350                         if (err != 1)
 351                                 return err;
 352                         mmc_dev_data->size = ext_csd.sectorcount;
 353
 354                         if (mmc_dev_data->size == 0)
 355                                 mmc_dev_data->size = 8388608;
 356                 }
 357         } else {
 358                 if (cur_csd->c_size_mult >= 8)
 359                         return 0;
 360
 361                 if (cur_csd->read_bl_len >= 12)
 362                         return 0;
 363
 364                 /* Compute size */
 365                 count = 1 << (cur_csd->c_size_mult + 2);
 366                 card_size = (cur_csd->c_size_lsb & MMC_CSD_C_SIZE_LSB_MASK) |
 367                     ((cur_csd->c_size_msb & MMC_CSD_C_SIZE_MSB_MASK)
 368                      << MMC_CSD_C_SIZE_MSB_OFFSET);
 369
 370                 blk_no = (card_size + 1) * count;
 371                 blk_len = 1 << cur_csd->read_bl_len;
 372                 size = blk_no * blk_len;
 373
 374                 mmc_dev_data->size = size / MMCSD_SECTOR_SIZE;
 375                 if (mmc_dev_data->size == 0)
 376                         return 0;
 377         }
 378         return 1;
 379 }
 380
 381 unsigned char omap_mmc_read_sect(unsigned int start_sec, unsigned int num_bytes,
 382                                  mmc_card_data *mmc_c,
 383                                  unsigned int *output_buf)
 384 {
 385         unsigned char err;
 386         unsigned int argument;
 387         unsigned int resp[4];
 388         unsigned int num_sec_val =
 389             (num_bytes + (MMCSD_SECTOR_SIZE - 1)) / MMCSD_SECTOR_SIZE;
 390         unsigned int sec_inc_val;
 391
 392         if (num_sec_val == 0)
 393                 return 1;
 394
 395         if (mmc_c->mode == SECTOR_MODE) {
 396                 argument = start_sec;
 397                 sec_inc_val = 1;
 398         } else {
 399                 argument = start_sec * MMCSD_SECTOR_SIZE;
 400                 sec_inc_val = MMCSD_SECTOR_SIZE;
 401         }
 402
 403         while (num_sec_val) {
 404                 err = mmc_send_cmd(MMC_CMD17, argument, resp);
 405                 if (err != 1)
 406                         return err;
 407
 408
 409                 err = mmc_read_data(output_buf);
 410                 if (err != 1)
 411                         return err;
 412
 413                 output_buf += (MMCSD_SECTOR_SIZE / 4);
 414                 argument += sec_inc_val;
 415                 num_sec_val--;
 416         }
 417         return 1;
 418 }
 419
 420 unsigned char configure_mmc(mmc_card_data *mmc_card_cur)
 421 {
 422         unsigned char ret_val;
 423         unsigned int argument;
 424         unsigned int resp[4];
 425         unsigned int trans_fact, trans_unit, retries = 2;
 426         unsigned int max_dtr;
 427         int dsor;
 428         mmc_csd_reg_t Card_CSD;
 429         unsigned char trans_speed;
 430
 431         mmc_init_setup();
 432
 433         do {
 434                 ret_val = mmc_detect_card(mmc_card_cur);
 435                 retries--;
 436         } while ((retries > 0) && (ret_val != 1));
 437
 438         argument = mmc_card_cur->RCA << 16;
 439         ret_val = mmc_send_cmd(MMC_CMD9, argument, resp);
 440         if (ret_val != 1)
 441                 return ret_val;
 442
 443         ((unsigned int *)&Card_CSD)[3] = resp[3];
 444         ((unsigned int *)&Card_CSD)[2] = resp[2];
 445         ((unsigned int *)&Card_CSD)[1] = resp[1];
 446         ((unsigned int *)&Card_CSD)[0] = resp[0];
 447
 448         if (mmc_card_cur->card_type == MMC_CARD)
 449                 mmc_card_cur->version = Card_CSD.spec_vers;
 450
 451         trans_speed = Card_CSD.tran_speed;
 452
 453         ret_val = mmc_send_cmd(MMC_CMD4, MMC_DSR_DEFAULT << 16, resp);
 454         if (ret_val != 1)
 455                 return ret_val;
 456
 457         trans_unit = trans_speed & MMC_CSD_TRAN_SPEED_UNIT_MASK;
 458         trans_fact = trans_speed & MMC_CSD_TRAN_SPEED_FACTOR_MASK;
 459
 460         if (trans_unit > MMC_CSD_TRAN_SPEED_UNIT_100MHZ)
 461                 return 0;
 462
 463         if ((trans_fact < MMC_CSD_TRAN_SPEED_FACTOR_1_0) ||
 464             (trans_fact > MMC_CSD_TRAN_SPEED_FACTOR_8_0))
 465                 return 0;
 466
 467         trans_unit >>= 0;
 468         trans_fact >>= 3;
 469
 470         max_dtr = tran_exp[trans_unit] * tran_mant[trans_fact];
 471         dsor = OMAP_MMC_MASTER_CLOCK / max_dtr;
 472
 473         if (dsor == 4)
 474                 dsor = 5;
 475         if (dsor == 3)
 476                 dsor = 4;
 477
 478         ret_val = mmc_clock_config(CLK_MISC, dsor);
 479         if (ret_val != 1)
 480                 return ret_val;
 481
 482         argument = mmc_card_cur->RCA << 16;
 483         ret_val = mmc_send_cmd(MMC_CMD7_SELECT, argument, resp);
 484         if (ret_val != 1)
 485                 return ret_val;
 486
 487         /* Configure the block length to 512 bytes */
 488         argument = MMCSD_SECTOR_SIZE;
 489         ret_val = mmc_send_cmd(MMC_CMD16, argument, resp);
 490         if (ret_val != 1)
 491                 return ret_val;
 492
 493         /* get the card size in sectors */
 494         ret_val = mmc_read_cardsize(mmc_card_cur, &Card_CSD);
 495         if (ret_val != 1)
 496                 return ret_val;
 497
 498         return 1;
 499 }
 500
 501 unsigned long mmc_bread(int dev_num, ulong blknr, ulong blkcnt, ulong *dst)
 502 {
 503         omap_mmc_read_sect(blknr, (blkcnt * MMCSD_SECTOR_SIZE), &cur_card_data,
 504                            (unsigned long *)dst);
 505 }
 506
 507 int mmc_init(int verbose)
 508 {
 509         unsigned char ret = 0;
 510
 511         ret = configure_mmc(&cur_card_data);
 512         if (ret == 0)
 513                 return 0;
 514
 515         mmc_blk_dev.if_type = IF_TYPE_MMC;
 516         mmc_blk_dev.part_type = PART_TYPE_DOS;
 517         mmc_blk_dev.dev = 0;
 518         mmc_blk_dev.lun = 0;
 519         mmc_blk_dev.type = 0;
 520
 521         /* FIXME fill in the correct size (is set to 32MByte) */
 522         mmc_blk_dev.blksz = MMCSD_SECTOR_SIZE;
 523         mmc_blk_dev.lba = 0x10000;
 524         mmc_blk_dev.removable = 0;
 525         mmc_blk_dev.block_read = mmc_bread;
 526
 527         fat_register_device(&mmc_blk_dev, 1);
 528
 529         return 1;
 530 }
 531
 532 int mmc_read(unsigned int src, unsigned char *dst, int size)
 533 {
 534         /*
 535          * NOT Implemented
 536          */
 537 }
 538 int mmc_write(unsigned char *src, unsigned long dst, int size)
 539 {
 540         /*
 541          * NOT Implemented
 542          */
 543 }
 544
 545 int mmc2info(unsigned int addr)
 546 {
 547         /*
 548          * NOT Implemented
 549          */
 550 }
 551 #endif
 552