drivers/mmc/host/mxcmmc.c

   1 /*
   2  *  linux/drivers/mmc/host/mxcmmc.c - Freescale i.MX MMCI driver
   3  *
   4  *  This is a driver for the SDHC controller found in Freescale MX2/MX3
   5  *  SoCs. It is basically the same hardware as found on MX1 (imxmmc.c).
   6  *  Unlike the hardware found on MX1, this hardware just works and does
   7  *  not need all the quirks found in imxmmc.c, hence the separate driver.
   8  *
   9  *  Copyright (C) 2008 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de>
  10  *  Copyright (C) 2006 Pavel Pisa, PiKRON <ppisa@pikron.com>
  11  *
  12  *  derived from pxamci.c by Russell King
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License version 2 as
  16  * published by the Free Software Foundation.
  17  *
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/init.h>
  22 #include <linux/ioport.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/irq.h>
  26 #include <linux/blkdev.h>
  27 #include <linux/dma-mapping.h>
  28 #include <linux/mmc/host.h>
  29 #include <linux/mmc/card.h>
  30 #include <linux/delay.h>
  31 #include <linux/clk.h>
  32 #include <linux/io.h>
  33 #include <linux/gpio.h>
  34 #include <linux/regulator/consumer.h>
  35
  36 #include <asm/dma.h>
  37 #include <asm/irq.h>
  38 #include <asm/sizes.h>
  39 #include <mach/mmc.h>
  40
  41 #ifdef CONFIG_ARCH_MX2
  42 #include <mach/dma-mx1-mx2.h>
  43 #define HAS_DMA
  44 #endif
  45
  46 #define DRIVER_NAME "mxc-mmc"
  47
  48 #define MMC_REG_STR_STP_CLK             0x00
  49 #define MMC_REG_STATUS                  0x04
  50 #define MMC_REG_CLK_RATE                0x08
  51 #define MMC_REG_CMD_DAT_CONT            0x0C
  52 #define MMC_REG_RES_TO                  0x10
  53 #define MMC_REG_READ_TO                 0x14
  54 #define MMC_REG_BLK_LEN                 0x18
  55 #define MMC_REG_NOB                     0x1C
  56 #define MMC_REG_REV_NO                  0x20
  57 #define MMC_REG_INT_CNTR                0x24
  58 #define MMC_REG_CMD                     0x28
  59 #define MMC_REG_ARG                     0x2C
  60 #define MMC_REG_RES_FIFO                0x34
  61 #define MMC_REG_BUFFER_ACCESS           0x38
  62
  63 #define STR_STP_CLK_RESET               (1 << 3)
  64 #define STR_STP_CLK_START_CLK           (1 << 1)
  65 #define STR_STP_CLK_STOP_CLK            (1 << 0)
  66
  67 #define STATUS_CARD_INSERTION           (1 << 31)
  68 #define STATUS_CARD_REMOVAL             (1 << 30)
  69 #define STATUS_YBUF_EMPTY               (1 << 29)
  70 #define STATUS_XBUF_EMPTY               (1 << 28)
  71 #define STATUS_YBUF_FULL                (1 << 27)
  72 #define STATUS_XBUF_FULL                (1 << 26)
  73 #define STATUS_BUF_UND_RUN              (1 << 25)
  74 #define STATUS_BUF_OVFL                 (1 << 24)
  75 #define STATUS_SDIO_INT_ACTIVE          (1 << 14)
  76 #define STATUS_END_CMD_RESP             (1 << 13)
  77 #define STATUS_WRITE_OP_DONE            (1 << 12)
  78 #define STATUS_DATA_TRANS_DONE          (1 << 11)
  79 #define STATUS_READ_OP_DONE             (1 << 11)
  80 #define STATUS_WR_CRC_ERROR_CODE_MASK   (3 << 10)
  81 #define STATUS_CARD_BUS_CLK_RUN         (1 << 8)
  82 #define STATUS_BUF_READ_RDY             (1 << 7)
  83 #define STATUS_BUF_WRITE_RDY            (1 << 6)
  84 #define STATUS_RESP_CRC_ERR             (1 << 5)
  85 #define STATUS_CRC_READ_ERR             (1 << 3)
  86 #define STATUS_CRC_WRITE_ERR            (1 << 2)
  87 #define STATUS_TIME_OUT_RESP            (1 << 1)
  88 #define STATUS_TIME_OUT_READ            (1 << 0)
  89 #define STATUS_ERR_MASK                 0x2f
  90
  91 #define CMD_DAT_CONT_CMD_RESP_LONG_OFF  (1 << 12)
  92 #define CMD_DAT_CONT_STOP_READWAIT      (1 << 11)
  93 #define CMD_DAT_CONT_START_READWAIT     (1 << 10)
  94 #define CMD_DAT_CONT_BUS_WIDTH_4        (2 << 8)
  95 #define CMD_DAT_CONT_INIT               (1 << 7)
  96 #define CMD_DAT_CONT_WRITE              (1 << 4)
  97 #define CMD_DAT_CONT_DATA_ENABLE        (1 << 3)
  98 #define CMD_DAT_CONT_RESPONSE_48BIT_CRC (1 << 0)
  99 #define CMD_DAT_CONT_RESPONSE_136BIT    (2 << 0)
 100 #define CMD_DAT_CONT_RESPONSE_48BIT     (3 << 0)
 101
 102 #define INT_SDIO_INT_WKP_EN             (1 << 18)
 103 #define INT_CARD_INSERTION_WKP_EN       (1 << 17)
 104 #define INT_CARD_REMOVAL_WKP_EN         (1 << 16)
 105 #define INT_CARD_INSERTION_EN           (1 << 15)
 106 #define INT_CARD_REMOVAL_EN             (1 << 14)
 107 #define INT_SDIO_IRQ_EN                 (1 << 13)
 108 #define INT_DAT0_EN                     (1 << 12)
 109 #define INT_BUF_READ_EN                 (1 << 4)
 110 #define INT_BUF_WRITE_EN                (1 << 3)
 111 #define INT_END_CMD_RES_EN              (1 << 2)
 112 #define INT_WRITE_OP_DONE_EN            (1 << 1)
 113 #define INT_READ_OP_EN                  (1 << 0)
 114
 115 struct mxcmci_host {
 116         struct mmc_host         *mmc;
 117         struct resource         *res;
 118         void __iomem            *base;
 119         int                     irq;
 120         int                     detect_irq;
 121         int                     dma;
 122         int                     do_dma;
 123         int                     default_irq_mask;
 124         int                     use_sdio;
 125         unsigned int            power_mode;
 126         struct imxmmc_platform_data *pdata;
 127
 128         struct mmc_request      *req;
 129         struct mmc_command      *cmd;
 130         struct mmc_data         *data;
 131
 132         unsigned int            dma_nents;
 133         unsigned int            datasize;
 134         unsigned int            dma_dir;
 135
 136         u16                     rev_no;
 137         unsigned int            cmdat;
 138
 139         struct clk              *clk;
 140
 141         int                     clock;
 142
 143         struct work_struct      datawork;
 144         spinlock_t              lock;
 145
 146         struct regulator        *vcc;
 147 };
 148
 149 static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios);
 150
 151 static inline void mxcmci_init_ocr(struct mxcmci_host *host)
 152 {
 153 #ifdef CONFIG_REGULATOR
 154         host->vcc = regulator_get(mmc_dev(host->mmc), "vmmc");
 155
 156         if (IS_ERR(host->vcc)) {
 157                 host->vcc = NULL;
 158         } else {
 159                 host->mmc->ocr_avail = mmc_regulator_get_ocrmask(host->vcc);
 160                 if (host->pdata && host->pdata->ocr_avail)
 161                         dev_warn(mmc_dev(host->mmc),
 162                                 "pdata->ocr_avail will not be used\n");
 163         }
 164 #endif
 165         if (host->vcc == NULL) {
 166                 /* fall-back to platform data */
 167                 if (host->pdata && host->pdata->ocr_avail)
 168                         host->mmc->ocr_avail = host->pdata->ocr_avail;
 169                 else
 170                         host->mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
 171         }
 172 }
 173
 174 static inline void mxcmci_set_power(struct mxcmci_host *host, unsigned int vdd)
 175 {
 176 #ifdef CONFIG_REGULATOR
 177         if (host->vcc)
 178                 mmc_regulator_set_ocr(host->vcc, vdd);
 179 #endif
 180         if (host->pdata && host->pdata->setpower)
 181                 host->pdata->setpower(mmc_dev(host->mmc), vdd);
 182 }
 183
 184 static inline int mxcmci_use_dma(struct mxcmci_host *host)
 185 {
 186         return host->do_dma;
 187 }
 188
 189 static void mxcmci_softreset(struct mxcmci_host *host)
 190 {
 191         int i;
 192
 193         dev_dbg(mmc_dev(host->mmc), "mxcmci_softreset\n");
 194
 195         /* reset sequence */
 196         writew(STR_STP_CLK_RESET, host->base + MMC_REG_STR_STP_CLK);
 197         writew(STR_STP_CLK_RESET | STR_STP_CLK_START_CLK,
 198                         host->base + MMC_REG_STR_STP_CLK);
 199
 200         for (i = 0; i < 8; i++)
 201                 writew(STR_STP_CLK_START_CLK, host->base + MMC_REG_STR_STP_CLK);
 202
 203         writew(0xff, host->base + MMC_REG_RES_TO);
 204 }
 205
 206 static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data)
 207 {
 208         unsigned int nob = data->blocks;
 209         unsigned int blksz = data->blksz;
 210         unsigned int datasize = nob * blksz;
 211 #ifdef HAS_DMA
 212         struct scatterlist *sg;
 213         int i;
 214         int ret;
 215 #endif
 216         if (data->flags & MMC_DATA_STREAM)
 217                 nob = 0xffff;
 218
 219         host->data = data;
 220         data->bytes_xfered = 0;
 221
 222         writew(nob, host->base + MMC_REG_NOB);
 223         writew(blksz, host->base + MMC_REG_BLK_LEN);
 224         host->datasize = datasize;
 225
 226 #ifdef HAS_DMA
 227         for_each_sg(data->sg, sg, data->sg_len, i) {
 228                 if (sg->offset & 3 || sg->length & 3) {
 229                         host->do_dma = 0;
 230                         return 0;
 231                 }
 232         }
 233
 234         if (data->flags & MMC_DATA_READ) {
 235                 host->dma_dir = DMA_FROM_DEVICE;
 236                 host->dma_nents = dma_map_sg(mmc_dev(host->mmc), data->sg,
 237                                              data->sg_len,  host->dma_dir);
 238
 239                 ret = imx_dma_setup_sg(host->dma, data->sg, host->dma_nents,
 240                                 datasize,
 241                                 host->res->start + MMC_REG_BUFFER_ACCESS,
 242                                 DMA_MODE_READ);
 243         } else {
 244                 host->dma_dir = DMA_TO_DEVICE;
 245                 host->dma_nents = dma_map_sg(mmc_dev(host->mmc), data->sg,
 246                                              data->sg_len,  host->dma_dir);
 247
 248                 ret = imx_dma_setup_sg(host->dma, data->sg, host->dma_nents,
 249                                 datasize,
 250                                 host->res->start + MMC_REG_BUFFER_ACCESS,
 251                                 DMA_MODE_WRITE);
 252         }
 253
 254         if (ret) {
 255                 dev_err(mmc_dev(host->mmc), "failed to setup DMA : %d\n", ret);
 256                 return ret;
 257         }
 258         wmb();
 259
 260         imx_dma_enable(host->dma);
 261 #endif /* HAS_DMA */
 262         return 0;
 263 }
 264
 265 static int mxcmci_start_cmd(struct mxcmci_host *host, struct mmc_command *cmd,
 266                 unsigned int cmdat)
 267 {
 268         u32 int_cntr = host->default_irq_mask;
 269         unsigned long flags;
 270
 271         WARN_ON(host->cmd != NULL);
 272         host->cmd = cmd;
 273
 274         switch (mmc_resp_type(cmd)) {
 275         case MMC_RSP_R1: /* short CRC, OPCODE */
 276         case MMC_RSP_R1B:/* short CRC, OPCODE, BUSY */
 277                 cmdat |= CMD_DAT_CONT_RESPONSE_48BIT_CRC;
 278                 break;
 279         case MMC_RSP_R2: /* long 136 bit + CRC */
 280                 cmdat |= CMD_DAT_CONT_RESPONSE_136BIT;
 281                 break;
 282         case MMC_RSP_R3: /* short */
 283                 cmdat |= CMD_DAT_CONT_RESPONSE_48BIT;
 284                 break;
 285         case MMC_RSP_NONE:
 286                 break;
 287         default:
 288                 dev_err(mmc_dev(host->mmc), "unhandled response type 0x%x\n",
 289                                 mmc_resp_type(cmd));
 290                 cmd->error = -EINVAL;
 291                 return -EINVAL;
 292         }
 293
 294         int_cntr = INT_END_CMD_RES_EN;
 295
 296         if (mxcmci_use_dma(host))
 297                 int_cntr |= INT_READ_OP_EN | INT_WRITE_OP_DONE_EN;
 298
 299         spin_lock_irqsave(&host->lock, flags);
 300         if (host->use_sdio)
 301                 int_cntr |= INT_SDIO_IRQ_EN;
 302         writel(int_cntr, host->base + MMC_REG_INT_CNTR);
 303         spin_unlock_irqrestore(&host->lock, flags);
 304
 305         writew(cmd->opcode, host->base + MMC_REG_CMD);
 306         writel(cmd->arg, host->base + MMC_REG_ARG);
 307         writew(cmdat, host->base + MMC_REG_CMD_DAT_CONT);
 308
 309         return 0;
 310 }
 311
 312 static void mxcmci_finish_request(struct mxcmci_host *host,
 313                 struct mmc_request *req)
 314 {
 315         u32 int_cntr = host->default_irq_mask;
 316         unsigned long flags;
 317
 318         spin_lock_irqsave(&host->lock, flags);
 319         if (host->use_sdio)
 320                 int_cntr |= INT_SDIO_IRQ_EN;
 321         writel(int_cntr, host->base + MMC_REG_INT_CNTR);
 322         spin_unlock_irqrestore(&host->lock, flags);
 323
 324         host->req = NULL;
 325         host->cmd = NULL;
 326         host->data = NULL;
 327
 328         mmc_request_done(host->mmc, req);
 329 }
 330
 331 static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat)
 332 {
 333         struct mmc_data *data = host->data;
 334         int data_error;
 335
 336 #ifdef HAS_DMA
 337         if (mxcmci_use_dma(host)) {
 338                 imx_dma_disable(host->dma);
 339                 dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->dma_nents,
 340                                 host->dma_dir);
 341         }
 342 #endif
 343
 344         if (stat & STATUS_ERR_MASK) {
 345                 dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n",
 346                                 stat);
 347                 if (stat & STATUS_CRC_READ_ERR) {
 348                         dev_err(mmc_dev(host->mmc), "%s: -EILSEQ\n", __func__);
 349                         data->error = -EILSEQ;
 350                 } else if (stat & STATUS_CRC_WRITE_ERR) {
 351                         u32 err_code = (stat >> 9) & 0x3;
 352                         if (err_code == 2) { /* No CRC response */
 353                                 dev_err(mmc_dev(host->mmc),
 354                                         "%s: No CRC -ETIMEDOUT\n", __func__);
 355                                 data->error = -ETIMEDOUT;
 356                         } else {
 357                                 dev_err(mmc_dev(host->mmc),
 358                                         "%s: -EILSEQ\n", __func__);
 359                                 data->error = -EILSEQ;
 360                         }
 361                 } else if (stat & STATUS_TIME_OUT_READ) {
 362                         dev_err(mmc_dev(host->mmc),
 363                                 "%s: read -ETIMEDOUT\n", __func__);
 364                         data->error = -ETIMEDOUT;
 365                 } else {
 366                         dev_err(mmc_dev(host->mmc), "%s: -EIO\n", __func__);
 367                         data->error = -EIO;
 368                 }
 369         } else {
 370                 data->bytes_xfered = host->datasize;
 371         }
 372
 373         data_error = data->error;
 374
 375         host->data = NULL;
 376
 377         return data_error;
 378 }
 379
 380 static void mxcmci_read_response(struct mxcmci_host *host, unsigned int stat)
 381 {
 382         struct mmc_command *cmd = host->cmd;
 383         int i;
 384         u32 a, b, c;
 385
 386         if (!cmd)
 387                 return;
 388
 389         if (stat & STATUS_TIME_OUT_RESP) {
 390                 dev_dbg(mmc_dev(host->mmc), "CMD TIMEOUT\n");
 391                 cmd->error = -ETIMEDOUT;
 392         } else if (stat & STATUS_RESP_CRC_ERR && cmd->flags & MMC_RSP_CRC) {
 393                 dev_dbg(mmc_dev(host->mmc), "cmd crc error\n");
 394                 cmd->error = -EILSEQ;
 395         }
 396
 397         if (cmd->flags & MMC_RSP_PRESENT) {
 398                 if (cmd->flags & MMC_RSP_136) {
 399                         for (i = 0; i < 4; i++) {
 400                                 a = readw(host->base + MMC_REG_RES_FIFO);
 401                                 b = readw(host->base + MMC_REG_RES_FIFO);
 402                                 cmd->resp[i] = a << 16 | b;
 403                         }
 404                 } else {
 405                         a = readw(host->base + MMC_REG_RES_FIFO);
 406                         b = readw(host->base + MMC_REG_RES_FIFO);
 407                         c = readw(host->base + MMC_REG_RES_FIFO);
 408                         cmd->resp[0] = a << 24 | b << 8 | c >> 8;
 409                 }
 410         }
 411 }
 412
 413 static int mxcmci_poll_status(struct mxcmci_host *host, u32 mask)
 414 {
 415         u32 stat;
 416         unsigned long timeout = jiffies + HZ;
 417
 418         do {
 419                 stat = readl(host->base + MMC_REG_STATUS);
 420                 if (stat & STATUS_ERR_MASK)
 421                         return stat;
 422                 if (time_after(jiffies, timeout)) {
 423                         mxcmci_softreset(host);
 424                         mxcmci_set_clk_rate(host, host->clock);
 425                         return STATUS_TIME_OUT_READ;
 426                 }
 427                 if (stat & mask)
 428                         return 0;
 429                 cpu_relax();
 430         } while (1);
 431 }
 432
 433 static int mxcmci_pull(struct mxcmci_host *host, void *_buf, int bytes)
 434 {
 435         unsigned int stat;
 436         u32 *buf = _buf;
 437
 438         while (bytes > 3) {
 439                 stat = mxcmci_poll_status(host,
 440                                 STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE);
 441                 if (stat)
 442                         return stat;
 443                 *buf++ = readl(host->base + MMC_REG_BUFFER_ACCESS);
 444                 bytes -= 4;
 445         }
 446
 447         if (bytes) {
 448                 u8 *b = (u8 *)buf;
 449                 u32 tmp;
 450
 451                 stat = mxcmci_poll_status(host,
 452                                 STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE);
 453                 if (stat)
 454                         return stat;
 455                 tmp = readl(host->base + MMC_REG_BUFFER_ACCESS);
 456                 memcpy(b, &tmp, bytes);
 457         }
 458
 459         return 0;
 460 }
 461
 462 static int mxcmci_push(struct mxcmci_host *host, void *_buf, int bytes)
 463 {
 464         unsigned int stat;
 465         u32 *buf = _buf;
 466
 467         while (bytes > 3) {
 468                 stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY);
 469                 if (stat)
 470                         return stat;
 471                 writel(*buf++, host->base + MMC_REG_BUFFER_ACCESS);
 472                 bytes -= 4;
 473         }
 474
 475         if (bytes) {
 476                 u8 *b = (u8 *)buf;
 477                 u32 tmp;
 478
 479                 stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY);
 480                 if (stat)
 481                         return stat;
 482
 483                 memcpy(&tmp, b, bytes);
 484                 writel(tmp, host->base + MMC_REG_BUFFER_ACCESS);
 485         }
 486
 487         stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY);
 488         if (stat)
 489                 return stat;
 490
 491         return 0;
 492 }
 493
 494 static int mxcmci_transfer_data(struct mxcmci_host *host)
 495 {
 496         struct mmc_data *data = host->req->data;
 497         struct scatterlist *sg;
 498         int stat, i;
 499
 500         host->data = data;
 501         host->datasize = 0;
 502
 503         if (data->flags & MMC_DATA_READ) {
 504                 for_each_sg(data->sg, sg, data->sg_len, i) {
 505                         stat = mxcmci_pull(host, sg_virt(sg), sg->length);
 506                         if (stat)
 507                                 return stat;
 508                         host->datasize += sg->length;
 509                 }
 510         } else {
 511                 for_each_sg(data->sg, sg, data->sg_len, i) {
 512                         stat = mxcmci_push(host, sg_virt(sg), sg->length);
 513                         if (stat)
 514                                 return stat;
 515                         host->datasize += sg->length;
 516                 }
 517                 stat = mxcmci_poll_status(host, STATUS_WRITE_OP_DONE);
 518                 if (stat)
 519                         return stat;
 520         }
 521         return 0;
 522 }
 523
 524 static void mxcmci_datawork(struct work_struct *work)
 525 {
 526         struct mxcmci_host *host = container_of(work, struct mxcmci_host,
 527                                                   datawork);
 528         int datastat = mxcmci_transfer_data(host);
 529
 530         writel(STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE,
 531                 host->base + MMC_REG_STATUS);
 532         mxcmci_finish_data(host, datastat);
 533
 534         if (host->req->stop) {
 535                 if (mxcmci_start_cmd(host, host->req->stop, 0)) {
 536                         mxcmci_finish_request(host, host->req);
 537                         return;
 538                 }
 539         } else {
 540                 mxcmci_finish_request(host, host->req);
 541         }
 542 }
 543
 544 #ifdef HAS_DMA
 545 static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat)
 546 {
 547         struct mmc_data *data = host->data;
 548         int data_error;
 549
 550         if (!data)
 551                 return;
 552
 553         data_error = mxcmci_finish_data(host, stat);
 554
 555         mxcmci_read_response(host, stat);
 556         host->cmd = NULL;
 557
 558         if (host->req->stop) {
 559                 if (mxcmci_start_cmd(host, host->req->stop, 0)) {
 560                         mxcmci_finish_request(host, host->req);
 561                         return;
 562                 }
 563         } else {
 564                 mxcmci_finish_request(host, host->req);
 565         }
 566 }
 567 #endif /* HAS_DMA */
 568
 569 static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat)
 570 {
 571         mxcmci_read_response(host, stat);
 572         host->cmd = NULL;
 573
 574         if (!host->data && host->req) {
 575                 mxcmci_finish_request(host, host->req);
 576                 return;
 577         }
 578
 579         /* For the DMA case the DMA engine handles the data transfer
 580          * automatically. For non DMA we have to do it ourselves.
 581          * Don't do it in interrupt context though.
 582          */
 583         if (!mxcmci_use_dma(host) && host->data)
 584                 schedule_work(&host->datawork);
 585
 586 }
 587
 588 static irqreturn_t mxcmci_irq(int irq, void *devid)
 589 {
 590         struct mxcmci_host *host = devid;
 591         unsigned long flags;
 592         bool sdio_irq;
 593         u32 stat;
 594
 595         stat = readl(host->base + MMC_REG_STATUS);
 596         writel(stat & ~(STATUS_SDIO_INT_ACTIVE | STATUS_DATA_TRANS_DONE |
 597                         STATUS_WRITE_OP_DONE), host->base + MMC_REG_STATUS);
 598
 599         dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat);
 600
 601         spin_lock_irqsave(&host->lock, flags);
 602         sdio_irq = (stat & STATUS_SDIO_INT_ACTIVE) && host->use_sdio;
 603         spin_unlock_irqrestore(&host->lock, flags);
 604
 605 #ifdef HAS_DMA
 606         if (mxcmci_use_dma(host) &&
 607             (stat & (STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE)))
 608                 writel(STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE,
 609                         host->base + MMC_REG_STATUS);
 610 #endif
 611
 612         if (sdio_irq) {
 613                 writel(STATUS_SDIO_INT_ACTIVE, host->base + MMC_REG_STATUS);
 614                 mmc_signal_sdio_irq(host->mmc);
 615         }
 616
 617         if (stat & STATUS_END_CMD_RESP)
 618                 mxcmci_cmd_done(host, stat);
 619
 620 #ifdef HAS_DMA
 621         if (mxcmci_use_dma(host) &&
 622                   (stat & (STATUS_DATA_TRANS_DONE | STATUS_WRITE_OP_DONE)))
 623                 mxcmci_data_done(host, stat);
 624 #endif
 625         if (host->default_irq_mask &&
 626                   (stat & (STATUS_CARD_INSERTION | STATUS_CARD_REMOVAL)))
 627                 mmc_detect_change(host->mmc, msecs_to_jiffies(200));
 628         return IRQ_HANDLED;
 629 }
 630
 631 static void mxcmci_request(struct mmc_host *mmc, struct mmc_request *req)
 632 {
 633         struct mxcmci_host *host = mmc_priv(mmc);
 634         unsigned int cmdat = host->cmdat;
 635         int error;
 636
 637         WARN_ON(host->req != NULL);
 638
 639         host->req = req;
 640         host->cmdat &= ~CMD_DAT_CONT_INIT;
 641 #ifdef HAS_DMA
 642         host->do_dma = 1;
 643 #endif
 644         if (req->data) {
 645                 error = mxcmci_setup_data(host, req->data);
 646                 if (error) {
 647                         req->cmd->error = error;
 648                         goto out;
 649                 }
 650
 651
 652                 cmdat |= CMD_DAT_CONT_DATA_ENABLE;
 653
 654                 if (req->data->flags & MMC_DATA_WRITE)
 655                         cmdat |= CMD_DAT_CONT_WRITE;
 656         }
 657
 658         error = mxcmci_start_cmd(host, req->cmd, cmdat);
 659 out:
 660         if (error)
 661                 mxcmci_finish_request(host, req);
 662 }
 663
 664 static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios)
 665 {
 666         unsigned int divider;
 667         int prescaler = 0;
 668         unsigned int clk_in = clk_get_rate(host->clk);
 669
 670         while (prescaler <= 0x800) {
 671                 for (divider = 1; divider <= 0xF; divider++) {
 672                         int x;
 673
 674                         x = (clk_in / (divider + 1));
 675
 676                         if (prescaler)
 677                                 x /= (prescaler * 2);
 678
 679                         if (x <= clk_ios)
 680                                 break;
 681                 }
 682                 if (divider < 0x10)
 683                         break;
 684
 685                 if (prescaler == 0)
 686                         prescaler = 1;
 687                 else
 688                         prescaler <<= 1;
 689         }
 690
 691         writew((prescaler << 4) | divider, host->base + MMC_REG_CLK_RATE);
 692
 693         dev_dbg(mmc_dev(host->mmc), "scaler: %d divider: %d in: %d out: %d\n",
 694                         prescaler, divider, clk_in, clk_ios);
 695 }
 696
 697 static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 698 {
 699         struct mxcmci_host *host = mmc_priv(mmc);
 700 #ifdef HAS_DMA
 701         unsigned int blen;
 702         /*
 703          * use burstlen of 64 in 4 bit mode (--> reg value  0)
 704          * use burstlen of 16 in 1 bit mode (--> reg value 16)
 705          */
 706         if (ios->bus_width == MMC_BUS_WIDTH_4)
 707                 blen = 0;
 708         else
 709                 blen = 16;
 710
 711         imx_dma_config_burstlen(host->dma, blen);
 712 #endif
 713         if (ios->bus_width == MMC_BUS_WIDTH_4)
 714                 host->cmdat |= CMD_DAT_CONT_BUS_WIDTH_4;
 715         else
 716                 host->cmdat &= ~CMD_DAT_CONT_BUS_WIDTH_4;
 717
 718         if (host->power_mode != ios->power_mode) {
 719                 mxcmci_set_power(host, ios->vdd);
 720                 host->power_mode = ios->power_mode;
 721
 722                 if (ios->power_mode == MMC_POWER_ON)
 723                         host->cmdat |= CMD_DAT_CONT_INIT;
 724         }
 725
 726         if (ios->clock) {
 727                 mxcmci_set_clk_rate(host, ios->clock);
 728                 writew(STR_STP_CLK_START_CLK, host->base + MMC_REG_STR_STP_CLK);
 729         } else {
 730                 writew(STR_STP_CLK_STOP_CLK, host->base + MMC_REG_STR_STP_CLK);
 731         }
 732
 733         host->clock = ios->clock;
 734 }
 735
 736 static irqreturn_t mxcmci_detect_irq(int irq, void *data)
 737 {
 738         struct mmc_host *mmc = data;
 739
 740         dev_dbg(mmc_dev(mmc), "%s\n", __func__);
 741
 742         mmc_detect_change(mmc, msecs_to_jiffies(250));
 743         return IRQ_HANDLED;
 744 }
 745
 746 static int mxcmci_get_ro(struct mmc_host *mmc)
 747 {
 748         struct mxcmci_host *host = mmc_priv(mmc);
 749
 750         if (host->pdata && host->pdata->get_ro)
 751                 return !!host->pdata->get_ro(mmc_dev(mmc));
 752         /*
 753          * Board doesn't support read only detection; let the mmc core
 754          * decide what to do.
 755          */
 756         return -ENOSYS;
 757 }
 758
 759 static void mxcmci_enable_sdio_irq(struct mmc_host *mmc, int enable)
 760 {
 761         struct mxcmci_host *host = mmc_priv(mmc);
 762         unsigned long flags;
 763         u32 int_cntr;
 764
 765         spin_lock_irqsave(&host->lock, flags);
 766         host->use_sdio = enable;
 767         int_cntr = readl(host->base + MMC_REG_INT_CNTR);
 768
 769         if (enable)
 770                 int_cntr |= INT_SDIO_IRQ_EN;
 771         else
 772                 int_cntr &= ~INT_SDIO_IRQ_EN;
 773
 774         writel(int_cntr, host->base + MMC_REG_INT_CNTR);
 775         spin_unlock_irqrestore(&host->lock, flags);
 776 }
 777
 778 static void mxcmci_init_card(struct mmc_host *host, struct mmc_card *card)
 779 {
 780         /*
 781          * MX3 SoCs have a silicon bug which corrupts CRC calculation of
 782          * multi-block transfers when connected SDIO peripheral doesn't
 783          * drive the BUSY line as required by the specs.
 784          * One way to prevent this is to only allow 1-bit transfers.
 785          */
 786
 787         if (cpu_is_mx3() && card->type == MMC_TYPE_SDIO)
 788                 host->caps &= ~MMC_CAP_4_BIT_DATA;
 789         else
 790                 host->caps |= MMC_CAP_4_BIT_DATA;
 791 }
 792
 793 static const struct mmc_host_ops mxcmci_ops = {
 794         .request                = mxcmci_request,
 795         .set_ios                = mxcmci_set_ios,
 796         .get_ro                 = mxcmci_get_ro,
 797         .enable_sdio_irq        = mxcmci_enable_sdio_irq,
 798         .init_card              = mxcmci_init_card,
 799 };
 800
 801 static int mxcmci_probe(struct platform_device *pdev)
 802 {
 803         struct mmc_host *mmc;
 804         struct mxcmci_host *host = NULL;
 805         struct resource *iores, *r;
 806         int ret = 0, irq;
 807
 808         printk(KERN_INFO "i.MX SDHC driver\n");
 809
 810         iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 811         irq = platform_get_irq(pdev, 0);
 812         if (!iores || irq < 0)
 813                 return -EINVAL;
 814
 815         r = request_mem_region(iores->start, resource_size(iores), pdev->name);
 816         if (!r)
 817                 return -EBUSY;
 818
 819         mmc = mmc_alloc_host(sizeof(struct mxcmci_host), &pdev->dev);
 820         if (!mmc) {
 821                 ret = -ENOMEM;
 822                 goto out_release_mem;
 823         }
 824
 825         mmc->ops = &mxcmci_ops;
 826         mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
 827
 828         /* MMC core transfer sizes tunable parameters */
 829         mmc->max_segs = 64;
 830         mmc->max_blk_size = 2048;
 831         mmc->max_blk_count = 65535;
 832         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
 833         mmc->max_seg_size = mmc->max_req_size;
 834
 835         host = mmc_priv(mmc);
 836         host->base = ioremap(r->start, resource_size(r));
 837         if (!host->base) {
 838                 ret = -ENOMEM;
 839                 goto out_free;
 840         }
 841
 842         host->mmc = mmc;
 843         host->pdata = pdev->dev.platform_data;
 844         spin_lock_init(&host->lock);
 845
 846         mxcmci_init_ocr(host);
 847
 848         if (host->pdata && host->pdata->dat3_card_detect)
 849                 host->default_irq_mask =
 850                         INT_CARD_INSERTION_EN | INT_CARD_REMOVAL_EN;
 851         else
 852                 host->default_irq_mask = 0;
 853
 854         host->res = r;
 855         host->irq = irq;
 856
 857         host->clk = clk_get(&pdev->dev, NULL);
 858         if (IS_ERR(host->clk)) {
 859                 ret = PTR_ERR(host->clk);
 860                 goto out_iounmap;
 861         }
 862         clk_enable(host->clk);
 863
 864         mxcmci_softreset(host);
 865
 866         host->rev_no = readw(host->base + MMC_REG_REV_NO);
 867         if (host->rev_no != 0x400) {
 868                 ret = -ENODEV;
 869                 dev_err(mmc_dev(host->mmc), "wrong rev.no. 0x%08x. aborting.\n",
 870                         host->rev_no);
 871                 goto out_clk_put;
 872         }
 873
 874         mmc->f_min = clk_get_rate(host->clk) >> 16;
 875         mmc->f_max = clk_get_rate(host->clk) >> 1;
 876
 877         /* recommended in data sheet */
 878         writew(0x2db4, host->base + MMC_REG_READ_TO);
 879
 880         writel(host->default_irq_mask, host->base + MMC_REG_INT_CNTR);
 881
 882 #ifdef HAS_DMA
 883         host->dma = imx_dma_request_by_prio(DRIVER_NAME, DMA_PRIO_LOW);
 884         if (host->dma < 0) {
 885                 dev_err(mmc_dev(host->mmc), "imx_dma_request_by_prio failed\n");
 886                 ret = -EBUSY;
 887                 goto out_clk_put;
 888         }
 889
 890         r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
 891         if (!r) {
 892                 ret = -EINVAL;
 893                 goto out_free_dma;
 894         }
 895
 896         ret = imx_dma_config_channel(host->dma,
 897                                      IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_FIFO,
 898                                      IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
 899                                      r->start, 0);
 900         if (ret) {
 901                 dev_err(mmc_dev(host->mmc), "failed to config DMA channel\n");
 902                 goto out_free_dma;
 903         }
 904 #endif
 905         INIT_WORK(&host->datawork, mxcmci_datawork);
 906
 907         ret = request_irq(host->irq, mxcmci_irq, 0, DRIVER_NAME, host);
 908         if (ret)
 909                 goto out_free_dma;
 910
 911         platform_set_drvdata(pdev, mmc);
 912
 913         if (host->pdata && host->pdata->init) {
 914                 ret = host->pdata->init(&pdev->dev, mxcmci_detect_irq,
 915                                 host->mmc);
 916                 if (ret)
 917                         goto out_free_irq;
 918         }
 919
 920         mmc_add_host(mmc);
 921
 922         return 0;
 923
 924 out_free_irq:
 925         free_irq(host->irq, host);
 926 out_free_dma:
 927 #ifdef HAS_DMA
 928         imx_dma_free(host->dma);
 929 #endif
 930 out_clk_put:
 931         clk_disable(host->clk);
 932         clk_put(host->clk);
 933 out_iounmap:
 934         iounmap(host->base);
 935 out_free:
 936         mmc_free_host(mmc);
 937 out_release_mem:
 938         release_mem_region(iores->start, resource_size(iores));
 939         return ret;
 940 }
 941
 942 static int mxcmci_remove(struct platform_device *pdev)
 943 {
 944         struct mmc_host *mmc = platform_get_drvdata(pdev);
 945         struct mxcmci_host *host = mmc_priv(mmc);
 946
 947         platform_set_drvdata(pdev, NULL);
 948
 949         mmc_remove_host(mmc);
 950
 951         if (host->vcc)
 952                 regulator_put(host->vcc);
 953
 954         if (host->pdata && host->pdata->exit)
 955                 host->pdata->exit(&pdev->dev, mmc);
 956
 957         free_irq(host->irq, host);
 958         iounmap(host->base);
 959 #ifdef HAS_DMA
 960         imx_dma_free(host->dma);
 961 #endif
 962         clk_disable(host->clk);
 963         clk_put(host->clk);
 964
 965         release_mem_region(host->res->start, resource_size(host->res));
 966         release_resource(host->res);
 967
 968         mmc_free_host(mmc);
 969
 970         return 0;
 971 }
 972
 973 #ifdef CONFIG_PM
 974 static int mxcmci_suspend(struct device *dev)
 975 {
 976         struct mmc_host *mmc = dev_get_drvdata(dev);
 977         struct mxcmci_host *host = mmc_priv(mmc);
 978         int ret = 0;
 979
 980         if (mmc)
 981                 ret = mmc_suspend_host(mmc);
 982         clk_disable(host->clk);
 983
 984         return ret;
 985 }
 986
 987 static int mxcmci_resume(struct device *dev)
 988 {
 989         struct mmc_host *mmc = dev_get_drvdata(dev);
 990         struct mxcmci_host *host = mmc_priv(mmc);
 991         int ret = 0;
 992
 993         clk_enable(host->clk);
 994         if (mmc)
 995                 ret = mmc_resume_host(mmc);
 996
 997         return ret;
 998 }
 999
1000 static const struct dev_pm_ops mxcmci_pm_ops = {
1001         .suspend        = mxcmci_suspend,
1002         .resume         = mxcmci_resume,
1003 };
1004 #endif
1005
1006 static struct platform_driver mxcmci_driver = {
1007         .probe          = mxcmci_probe,
1008         .remove         = mxcmci_remove,
1009         .driver         = {
1010                 .name           = DRIVER_NAME,
1011                 .owner          = THIS_MODULE,
1012 #ifdef CONFIG_PM
1013                 .pm     = &mxcmci_pm_ops,
1014 #endif
1015         }
1016 };
1017
1018 static int __init mxcmci_init(void)
1019 {
1020         return platform_driver_register(&mxcmci_driver);
1021 }
1022
1023 static void __exit mxcmci_exit(void)
1024 {
1025         platform_driver_unregister(&mxcmci_driver);
1026 }
1027
1028 module_init(mxcmci_init);
1029 module_exit(mxcmci_exit);
1030
1031 MODULE_DESCRIPTION("i.MX Multimedia Card Interface Driver");
1032 MODULE_AUTHOR("Sascha Hauer, Pengutronix");
1033 MODULE_LICENSE("GPL");
1034 MODULE_ALIAS("platform:imx-mmc");