drivers/mmc/ftsdc010_esdhc.c

   1 /*
   2  * Copyright (C) 2011 Andes Technology Corporation
   3  * Macpaul Lin, Andes Technology Corporation <macpaul@andestech.com>
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 #include <config.h>
  25 #include <common.h>
  26 #include <mmc.h>
  27
  28 #include <asm/io.h>
  29 #include <faraday/ftsdc010.h>
  30
  31 /*
  32  * supported mmc hosts
  33  * setting the number CONFIG_FTSDC010_NUMBER in your configuration file.
  34  */
  35 static struct mmc ftsdc010_dev[CONFIG_FTSDC010_NUMBER];
  36 static struct mmc_host ftsdc010_host[CONFIG_FTSDC010_NUMBER];
  37
  38 static struct ftsdc010_mmc *ftsdc010_get_base_mmc(int dev_index)
  39 {
  40         return (struct ftsdc010_mmc *)CONFIG_FTSDC010_BASE + dev_index;
  41 }
  42
  43 #ifdef DEBUG
  44 static void ftsdc010_dump_reg(struct mmc_host *host)
  45 {
  46         debug("cmd: %08x\n",            readl(&host->reg->cmd));
  47         debug("argu: %08x\n",           readl(&host->reg->argu));
  48         debug("rsp0: %08x\n",           readl(&host->reg->rsp0));
  49         debug("rsp1: %08x\n",           readl(&host->reg->rsp1));
  50         debug("rsp2: %08x\n",           readl(&host->reg->rsp2));
  51         debug("rsp3: %08x\n",           readl(&host->reg->rsp3));
  52         debug("rsp_cmd: %08x\n",        readl(&host->reg->rsp_cmd));
  53         debug("dcr: %08x\n",            readl(&host->reg->dcr));
  54         debug("dtr: %08x\n",            readl(&host->reg->dtr));
  55         debug("dlr: %08x\n",            readl(&host->reg->dlr));
  56         debug("status: %08x\n",         readl(&host->reg->status));
  57         debug("clr: %08x\n",            readl(&host->reg->clr));
  58         debug("int_mask: %08x\n",       readl(&host->reg->int_mask));
  59         debug("pcr: %08x\n",            readl(&host->reg->pcr));
  60         debug("ccr: %08x\n",            readl(&host->reg->ccr));
  61         debug("bwr: %08x\n",            readl(&host->reg->bwr));
  62         debug("dwr: %08x\n",            readl(&host->reg->dwr));
  63         debug("feature: %08x\n",        readl(&host->reg->feature));
  64         debug("rev: %08x\n",            readl(&host->reg->rev));
  65 }
  66 #endif
  67
  68 static unsigned int enable_imask(struct ftsdc010_mmc *reg, unsigned int imask)
  69 {
  70         unsigned int newmask;
  71
  72         newmask = readl(&reg->int_mask);
  73         newmask |= imask;
  74
  75         writel(newmask, &reg->int_mask);
  76
  77         return newmask;
  78 }
  79
  80 static void ftsdc010_pio_read(struct mmc_host *host, char *buf, unsigned int size)
  81 {
  82         unsigned int fifo;
  83         unsigned int fifo_words;
  84         unsigned int *ptr;
  85         unsigned int status;
  86         unsigned int retry = 0;
  87
  88         /* get_data_buffer */
  89         ptr = (unsigned int *)buf;
  90
  91         while (size) {
  92                 status = readl(&host->reg->status);
  93                 debug("%s: size: %08x\n", __func__, size);
  94
  95                 if (status & FTSDC010_STATUS_FIFO_ORUN) {
  96
  97                         debug("%s: FIFO OVERRUN: sta: %08x\n",
  98                                         __func__, status);
  99
 100                         fifo = host->fifo_len > size ?
 101                                 size : host->fifo_len;
 102
 103                         size -= fifo;
 104
 105                         fifo_words = fifo >> 2;
 106
 107                         while (fifo_words--)
 108                                 *ptr++ = readl(&host->reg->dwr);
 109
 110                         /*
 111                          * for adding some delays for SD card to put
 112                          * data into FIFO again
 113                          */
 114                         udelay(4*FTSDC010_DELAY_UNIT);
 115
 116 #ifdef CONFIG_FTSDC010_SDIO
 117                         /* sdio allow non-power-of-2 blksz */
 118                         if (fifo & 3) {
 119                                 unsigned int n = fifo & 3;
 120                                 unsigned int data = readl(&host->reg->dwr);
 121
 122                                 unsigned char *p = (unsigned char *)ptr;
 123
 124                                 while (n--) {
 125                                         *p++ = data;
 126                                         data >>= 8;
 127                                 }
 128                         }
 129 #endif
 130                 } else {
 131                         udelay(1);
 132                         if (++retry >= FTSDC010_PIO_RETRY) {
 133                                 debug("%s: PIO_RETRY timeout\n", __func__);
 134                                 return;
 135                         }
 136                 }
 137         }
 138 }
 139
 140 static void ftsdc010_pio_write(struct mmc_host *host, const char *buf,
 141                         unsigned int size)
 142 {
 143         unsigned int fifo;
 144         unsigned int *ptr;
 145         unsigned int status;
 146         unsigned int retry = 0;
 147
 148         /* get data buffer */
 149         ptr = (unsigned int *)buf;
 150
 151         while (size) {
 152                 status = readl(&host->reg->status);
 153
 154                 if (status & FTSDC010_STATUS_FIFO_URUN) {
 155                         fifo = host->fifo_len > size ?
 156                                 size : host->fifo_len;
 157
 158                         size -= fifo;
 159
 160                         fifo = (fifo + 3) >> 2;
 161
 162                         while (fifo--) {
 163                                 writel(*ptr, &host->reg->dwr);
 164                                 ptr++;
 165                         }
 166                 } else {
 167                         udelay(1);
 168                         if (++retry >= FTSDC010_PIO_RETRY) {
 169                                 debug("%s: PIO_RETRY timeout\n", __func__);
 170                                 return;
 171                         }
 172                 }
 173         }
 174 }
 175
 176 static int ftsdc010_check_rsp(struct mmc *mmc, struct mmc_cmd *cmd,
 177                         struct mmc_data *data)
 178 {
 179         struct mmc_host *host = mmc->priv;
 180         unsigned int sta, clear;
 181
 182         sta = readl(&host->reg->status);
 183         debug("%s: sta: %08x cmd %d\n", __func__, sta, cmd->cmdidx);
 184
 185         /* check RSP TIMEOUT or FAIL */
 186         if (sta & FTSDC010_STATUS_RSP_TIMEOUT) {
 187                 /* RSP TIMEOUT */
 188                 debug("%s: RSP timeout: sta: %08x\n", __func__, sta);
 189
 190                 clear |= FTSDC010_CLR_RSP_TIMEOUT;
 191                 writel(clear, &host->reg->clr);
 192
 193                 return TIMEOUT;
 194         } else if (sta & FTSDC010_STATUS_RSP_CRC_FAIL) {
 195                 /* clear response fail bit */
 196                 debug("%s: RSP CRC FAIL: sta: %08x\n", __func__, sta);
 197
 198                 clear |= FTSDC010_CLR_RSP_CRC_FAIL;
 199                 writel(clear, &host->reg->clr);
 200
 201                 return COMM_ERR;
 202         } else if (sta & FTSDC010_STATUS_RSP_CRC_OK) {
 203
 204                 /* clear response CRC OK bit */
 205                 clear |= FTSDC010_CLR_RSP_CRC_OK;
 206         }
 207
 208         writel(clear, &host->reg->clr);
 209         return 0;
 210 }
 211
 212 static int ftsdc010_check_data(struct mmc *mmc, struct mmc_cmd *cmd,
 213                         struct mmc_data *data)
 214 {
 215         struct mmc_host *host = mmc->priv;
 216         unsigned int sta, clear;
 217
 218         sta = readl(&host->reg->status);
 219         debug("%s: sta: %08x cmd %d\n", __func__, sta, cmd->cmdidx);
 220
 221         /* check DATA TIMEOUT or FAIL */
 222         if (data) {
 223
 224                 /* Transfer Complete */
 225                 if (sta & FTSDC010_STATUS_DATA_END)
 226                         clear |= FTSDC010_STATUS_DATA_END;
 227
 228                 /* Data CRC_OK */
 229                 if (sta & FTSDC010_STATUS_DATA_CRC_OK)
 230                         clear |= FTSDC010_STATUS_DATA_CRC_OK;
 231
 232                 /* DATA TIMEOUT or DATA CRC FAIL */
 233                 if (sta & FTSDC010_STATUS_DATA_TIMEOUT) {
 234                         /* DATA TIMEOUT */
 235                         debug("%s: DATA TIMEOUT: sta: %08x\n", __func__, sta);
 236
 237                         clear |= FTSDC010_STATUS_DATA_TIMEOUT;
 238                         writel(clear, &host->reg->clr);
 239
 240                         return TIMEOUT;
 241                 } else if (sta & FTSDC010_STATUS_DATA_CRC_FAIL) {
 242                         /* DATA CRC FAIL */
 243                         debug("%s: DATA CRC FAIL: sta: %08x\n", __func__, sta);
 244
 245                         clear |= FTSDC010_STATUS_DATA_CRC_FAIL;
 246                         writel(clear, &host->reg->clr);
 247
 248                         return COMM_ERR;
 249                 }
 250                 writel(clear, &host->reg->clr);
 251         }
 252         return 0;
 253 }
 254
 255 static int ftsdc010_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
 256                         struct mmc_data *data)
 257 {
 258         struct mmc_host *host = mmc->priv;
 259
 260 #ifdef CONFIG_FTSDC010_SDIO
 261         unsigned int scon;
 262 #endif
 263         unsigned int ccon;
 264         unsigned int mask, tmpmask;
 265         unsigned int ret;
 266         unsigned int sta, i;
 267
 268         ret = 0;
 269
 270         if (data)
 271                 mask = FTSDC010_INT_MASK_RSP_TIMEOUT;
 272         else if (cmd->resp_type & MMC_RSP_PRESENT)
 273                 mask = FTSDC010_INT_MASK_RSP_TIMEOUT;
 274         else
 275                 mask = FTSDC010_INT_MASK_CMD_SEND;
 276
 277         /* write argu reg */
 278         debug("%s: argu: %08x\n", __func__, host->reg->argu);
 279         writel(cmd->cmdarg, &host->reg->argu);
 280
 281         /* setup commnad */
 282         ccon = FTSDC010_CMD_IDX(cmd->cmdidx);
 283
 284         /* setup command flags */
 285         ccon |= FTSDC010_CMD_CMD_EN;
 286
 287         /*
 288          * This hardware didn't support specific commands for mapping
 289          * MMC_RSP_BUSY and MMC_RSP_OPCODE. Hence we don't deal with it.
 290          */
 291         if (cmd->resp_type & MMC_RSP_PRESENT) {
 292                 ccon |= FTSDC010_CMD_NEED_RSP;
 293                 mask |= FTSDC010_INT_MASK_RSP_CRC_OK |
 294                         FTSDC010_INT_MASK_RSP_CRC_FAIL;
 295         }
 296
 297         if (cmd->resp_type & MMC_RSP_136)
 298                 ccon |= FTSDC010_CMD_LONG_RSP;
 299
 300         /* In Linux driver, MMC_CMD_APP_CMD is checked in last_opcode */
 301         if (host->last_opcode == MMC_CMD_APP_CMD)
 302                 ccon |= FTSDC010_CMD_APP_CMD;
 303
 304 #ifdef CONFIG_FTSDC010_SDIO
 305         scon = readl(&host->reg->sdio_ctrl1);
 306         if (host->card_type == MMC_TYPE_SDIO)
 307                 scon |= FTSDC010_SDIO_CTRL1_SDIO_ENABLE;
 308         else
 309                 scon &= ~FTSDC010_SDIO_CTRL1_SDIO_ENABLE;
 310         writel(scon, &host->reg->sdio_ctrl1);
 311 #endif
 312
 313         /* record last opcode for specifing the command type to hardware */
 314         host->last_opcode = cmd->cmdidx;
 315
 316         /* write int_mask reg */
 317         tmpmask = readl(&host->reg->int_mask);
 318         tmpmask |= mask;
 319         writel(tmpmask, &host->reg->int_mask);
 320
 321         /* write cmd reg */
 322         debug("%s: ccon: %08x\n", __func__, ccon);
 323         writel(ccon, &host->reg->cmd);
 324
 325         /* check CMD_SEND */
 326         for (i = 0; i < FTSDC010_CMD_RETRY; i++) {
 327                 /*
 328                  * If we read status register too fast
 329                  * will lead hardware error and the RSP_TIMEOUT
 330                  * flag will be raised incorrectly.
 331                  */
 332                 udelay(16*FTSDC010_DELAY_UNIT);
 333                 sta = readl(&host->reg->status);
 334
 335                 /* Command Complete */
 336                 /*
 337                  * Note:
 338                  *      Do not clear FTSDC010_CLR_CMD_SEND flag.
 339                  *      (by writing FTSDC010_CLR_CMD_SEND bit to clear register)
 340                  *      It will make the driver becomes very slow.
 341                  *      If the operation hasn't been finished, hardware will
 342                  *      clear this bit automatically.
 343                  *      In origin, the driver will clear this flag if there is
 344                  *      no data need to be read.
 345                  */
 346                 if (sta & FTSDC010_STATUS_CMD_SEND)
 347                         break;
 348         }
 349
 350         if (i > FTSDC010_CMD_RETRY) {
 351                 printf("%s: send command timeout\n", __func__);
 352                 return TIMEOUT;
 353         }
 354
 355         /* check rsp status */
 356         ret = ftsdc010_check_rsp(mmc, cmd, data);
 357         if (ret)
 358                 return ret;
 359
 360         /* read response if we have RSP_OK */
 361         if (ccon & FTSDC010_CMD_LONG_RSP) {
 362                 cmd->response[0] = readl(&host->reg->rsp3);
 363                 cmd->response[1] = readl(&host->reg->rsp2);
 364                 cmd->response[2] = readl(&host->reg->rsp1);
 365                 cmd->response[3] = readl(&host->reg->rsp0);
 366         } else {
 367                 cmd->response[0] = readl(&host->reg->rsp0);
 368         }
 369
 370         /* read/write data */
 371         if (data && (data->flags & MMC_DATA_READ)) {
 372                 ftsdc010_pio_read(host, data->dest,
 373                                 data->blocksize * data->blocks);
 374         } else if (data && (data->flags & MMC_DATA_WRITE)) {
 375                 ftsdc010_pio_write(host, data->src,
 376                                 data->blocksize * data->blocks);
 377         }
 378
 379         /* check data status */
 380         if (data) {
 381                 ret = ftsdc010_check_data(mmc, cmd, data);
 382                 if (ret)
 383                         return ret;
 384         }
 385
 386         udelay(FTSDC010_DELAY_UNIT);
 387         return ret;
 388 }
 389
 390 static unsigned int cal_blksz(unsigned int blksz)
 391 {
 392         unsigned int blksztwo = 0;
 393
 394         while (blksz >>= 1)
 395                 blksztwo++;
 396
 397         return blksztwo;
 398 }
 399
 400 static int ftsdc010_setup_data(struct mmc *mmc, struct mmc_data *data)
 401 {
 402         struct mmc_host *host = mmc->priv;
 403         unsigned int dcon, newmask;
 404
 405         /* configure data transfer paramter */
 406         if (!data)
 407                 return 0;
 408
 409         if (((data->blocksize - 1) & data->blocksize) != 0) {
 410                 printf("%s: can't do non-power-of 2 sized block transfers"
 411                         " (blksz %d)\n", __func__, data->blocksize);
 412                 return -1;
 413         }
 414
 415         /*
 416          * We cannot deal with unaligned blocks with more than
 417          * one block being transfered.
 418          */
 419         if ((data->blocksize <= 2) && (data->blocks > 1)) {
 420                         printf("%s: can't do non-word sized block transfers"
 421                                 " (blksz %d)\n", __func__, data->blocksize);
 422                         return -1;
 423         }
 424
 425         /* data length */
 426         dcon = data->blocksize * data->blocks;
 427         writel(dcon, &host->reg->dlr);
 428
 429         /* write data control */
 430         dcon = cal_blksz(data->blocksize);
 431
 432         /* add to IMASK register */
 433         newmask = (FTSDC010_STATUS_RSP_CRC_FAIL | FTSDC010_STATUS_DATA_TIMEOUT);
 434
 435         /*
 436          * enable UNDERRUN will trigger interrupt immediatedly
 437          * So setup it when rsp is received successfully
 438          */
 439         if (data->flags & MMC_DATA_WRITE) {
 440                 dcon |= FTSDC010_DCR_DATA_WRITE;
 441         } else {
 442                 dcon &= ~FTSDC010_DCR_DATA_WRITE;
 443                 newmask |= FTSDC010_STATUS_FIFO_ORUN;
 444         }
 445         enable_imask(host->reg, newmask);
 446
 447 #ifdef CONFIG_FTSDC010_SDIO
 448         /* always reset fifo since last transfer may fail */
 449         dcon |= FTSDC010_DCR_FIFO_RST;
 450
 451         if (data->blocks > 1)
 452                 dcon |= FTSDC010_SDIO_CTRL1_SDIO_BLK_MODE;
 453 #endif
 454
 455         /* enable data transfer which will be pended until cmd is send */
 456         dcon |= FTSDC010_DCR_DATA_EN;
 457         writel(dcon, &host->reg->dcr);
 458
 459         return 0;
 460 }
 461
 462 static int ftsdc010_send_request(struct mmc *mmc, struct mmc_cmd *cmd,
 463                         struct mmc_data *data)
 464 {
 465         int ret;
 466
 467         if (data) {
 468                 ret = ftsdc010_setup_data(mmc, data);
 469
 470                 if (ret) {
 471                         printf("%s: setup data error\n", __func__);
 472                         return -1;
 473                 }
 474
 475                 if ((data->flags & MMC_DATA_BOTH_DIR) == MMC_DATA_BOTH_DIR) {
 476                         printf("%s: data is both direction\n", __func__);
 477                         return -1;
 478                 }
 479         }
 480
 481         /* Send command */
 482         ret = ftsdc010_send_cmd(mmc, cmd, data);
 483         return ret;
 484 }
 485
 486 static int ftsdc010_card_detect(struct mmc *mmc)
 487 {
 488         struct mmc_host *host = mmc->priv;
 489         unsigned int sta;
 490
 491         sta = readl(&host->reg->status);
 492         debug("%s: card status: %08x\n", __func__, sta);
 493
 494         return (sta & FTSDC010_STATUS_CARD_DETECT) ? 0 : 1;
 495 }
 496
 497 static int ftsdc010_request(struct mmc *mmc, struct mmc_cmd *cmd,
 498                         struct mmc_data *data)
 499 {
 500         int ret;
 501
 502         if (ftsdc010_card_detect(mmc) == 0) {
 503                 printf("%s: no medium present\n", __func__);
 504                 return -1;
 505         } else {
 506                 ret = ftsdc010_send_request(mmc, cmd, data);
 507                 return ret;
 508         }
 509 }
 510
 511 static void ftsdc010_set_clk(struct mmc *mmc)
 512 {
 513         struct mmc_host *host = mmc->priv;
 514         unsigned char clk_div;
 515         unsigned int real_rate;
 516         unsigned int clock;
 517
 518         debug("%s: mmc_set_clock: %x\n", __func__, mmc->clock);
 519         clock = readl(&host->reg->ccr);
 520
 521         if (mmc->clock == 0) {
 522                 real_rate = 0;
 523                 clock |= FTSDC010_CCR_CLK_DIS;
 524         } else {
 525                 debug("%s, mmc->clock: %08x, origin clock: %08x\n",
 526                          __func__, mmc->clock, clock);
 527
 528                 for (clk_div = 0; clk_div <= 127; clk_div++) {
 529                         real_rate = (CONFIG_SYS_CLK_FREQ / 2) /
 530                                         (2 * (clk_div + 1));
 531
 532                         if (real_rate <= mmc->clock)
 533                                 break;
 534                 }
 535
 536                 debug("%s: computed real_rate: %x, clk_div: %x\n",
 537                          __func__, real_rate, clk_div);
 538
 539                 if (clk_div > 127)
 540                         debug("%s: no match clock rate, %x\n",
 541                                 __func__, mmc->clock);
 542
 543                 clock = (clock & ~FTSDC010_CCR_CLK_DIV(0x7f)) |
 544                                 FTSDC010_CCR_CLK_DIV(clk_div);
 545
 546                 clock &= ~FTSDC010_CCR_CLK_DIS;
 547         }
 548
 549         debug("%s, set clock: %08x\n", __func__, clock);
 550         writel(clock, &host->reg->ccr);
 551 }
 552
 553 static void ftsdc010_set_ios(struct mmc *mmc)
 554 {
 555         struct mmc_host *host = mmc->priv;
 556         unsigned int power;
 557         unsigned long val;
 558         unsigned int bus_width;
 559
 560         debug("%s: bus_width: %x, clock: %d\n",
 561                 __func__, mmc->bus_width, mmc->clock);
 562
 563         /* set pcr: power on */
 564         power = readl(&host->reg->pcr);
 565         power |= FTSDC010_PCR_POWER_ON;
 566         writel(power, &host->reg->pcr);
 567
 568         if (mmc->clock)
 569                 ftsdc010_set_clk(mmc);
 570
 571         /* set bwr: bus width reg */
 572         bus_width = readl(&host->reg->bwr);
 573         bus_width &= ~(FTSDC010_BWR_WIDE_8_BUS | FTSDC010_BWR_WIDE_4_BUS |
 574                         FTSDC010_BWR_SINGLE_BUS);
 575
 576         if (mmc->bus_width == 8)
 577                 bus_width |= FTSDC010_BWR_WIDE_8_BUS;
 578         else if (mmc->bus_width == 4)
 579                 bus_width |= FTSDC010_BWR_WIDE_4_BUS;
 580         else
 581                 bus_width |= FTSDC010_BWR_SINGLE_BUS;
 582
 583         writel(bus_width, &host->reg->bwr);
 584
 585         /* set fifo depth */
 586         val = readl(&host->reg->feature);
 587         host->fifo_len = FTSDC010_FEATURE_FIFO_DEPTH(val) * 4; /* 4 bytes */
 588
 589         /* set data timeout register */
 590         val = -1;
 591         writel(val, &host->reg->dtr);
 592 }
 593
 594 static void ftsdc010_reset(struct mmc_host *host)
 595 {
 596         unsigned int timeout;
 597         unsigned int sta;
 598
 599         /* Do SDC_RST: Software reset for all register */
 600         writel(FTSDC010_CMD_SDC_RST, &host->reg->cmd);
 601
 602         host->clock = 0;
 603
 604         /* this hardware has no reset finish flag to read */
 605         /* wait 100ms maximum */
 606         timeout = 100;
 607
 608         /* hw clears the bit when it's done */
 609         while (readl(&host->reg->dtr) != 0) {
 610                 if (timeout == 0) {
 611                         printf("%s: reset timeout error\n", __func__);
 612                         return;
 613                 }
 614                 timeout--;
 615                 udelay(10*FTSDC010_DELAY_UNIT);
 616         }
 617
 618         sta = readl(&host->reg->status);
 619         if (sta & FTSDC010_STATUS_CARD_CHANGE)
 620                 writel(FTSDC010_CLR_CARD_CHANGE, &host->reg->clr);
 621 }
 622
 623 static int ftsdc010_core_init(struct mmc *mmc)
 624 {
 625         struct mmc_host *host = mmc->priv;
 626         unsigned int mask;
 627         unsigned int major, minor, revision;
 628
 629         /* get hardware version */
 630         host->version = readl(&host->reg->rev);
 631
 632         major = FTSDC010_REV_MAJOR(host->version);
 633         minor = FTSDC010_REV_MINOR(host->version);
 634         revision = FTSDC010_REV_REVISION(host->version);
 635
 636         printf("ftsdc010 hardware ver: %d_%d_r%d\n", major, minor, revision);
 637
 638         /* Interrupt MASK register init - mask all */
 639         writel(0x0, &host->reg->int_mask);
 640
 641         mask = FTSDC010_INT_MASK_CMD_SEND |
 642                 FTSDC010_INT_MASK_DATA_END |
 643                 FTSDC010_INT_MASK_CARD_CHANGE;
 644 #ifdef CONFIG_FTSDC010_SDIO
 645         mask |= FTSDC010_INT_MASK_CP_READY |
 646                 FTSDC010_INT_MASK_CP_BUF_READY |
 647                 FTSDC010_INT_MASK_PLAIN_TEXT_READY |
 648                 FTSDC010_INT_MASK_SDIO_IRPT;
 649 #endif
 650
 651         writel(mask, &host->reg->int_mask);
 652
 653         return 0;
 654 }
 655
 656 int ftsdc010_mmc_init(int dev_index)
 657 {
 658         struct mmc *mmc;
 659         struct mmc_host *host;
 660
 661         mmc = &ftsdc010_dev[dev_index];
 662
 663         sprintf(mmc->name, "FTSDC010 SD/MMC");
 664         mmc->priv = &ftsdc010_host[dev_index];
 665         mmc->send_cmd = ftsdc010_request;
 666         mmc->set_ios = ftsdc010_set_ios;
 667         mmc->init = ftsdc010_core_init;
 668         mmc->getcd = NULL;
 669
 670         mmc->voltages = MMC_VDD_32_33 | MMC_VDD_33_34;
 671
 672         mmc->host_caps = MMC_MODE_4BIT | MMC_MODE_8BIT;
 673
 674         mmc->f_min = CONFIG_SYS_CLK_FREQ / 2 / (2*128);
 675         mmc->f_max = CONFIG_SYS_CLK_FREQ / 2 / 2;
 676
 677         ftsdc010_host[dev_index].clock = 0;
 678         ftsdc010_host[dev_index].reg = ftsdc010_get_base_mmc(dev_index);
 679         mmc_register(mmc);
 680
 681         /* reset mmc */
 682         host = (struct mmc_host *)mmc->priv;
 683         ftsdc010_reset(host);
 684
 685         return 0;
 686 }