drivers/mmc/host/mmci.c

   1 /*
   2  *  linux/drivers/mmc/host/mmci.c - ARM PrimeCell MMCI PL180/1 driver
   3  *
   4  *  Copyright (C) 2003 Deep Blue Solutions, Ltd, All Rights Reserved.
   5  *  Copyright (C) 2010 ST-Ericsson AB.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include <linux/module.h>
  12 #include <linux/moduleparam.h>
  13 #include <linux/init.h>
  14 #include <linux/ioport.h>
  15 #include <linux/device.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/delay.h>
  18 #include <linux/err.h>
  19 #include <linux/highmem.h>
  20 #include <linux/log2.h>
  21 #include <linux/mmc/host.h>
  22 #include <linux/amba/bus.h>
  23 #include <linux/clk.h>
  24 #include <linux/scatterlist.h>
  25 #if defined (CONFIG_ARCH_LPC32XX)
  26 #include <linux/dma-mapping.h>
  27 #endif
  28 #include <linux/gpio.h>
  29 #include <linux/amba/mmci.h>
  30 #include <linux/regulator/consumer.h>
  31
  32 #include <asm/cacheflush.h>
  33 #include <asm/div64.h>
  34 #include <asm/io.h>
  35 #include <asm/sizes.h>
  36
  37 #if defined (CONFIG_ARCH_LPC32XX)
  38 #include <mach/clkdev.h>
  39 #include <mach/dmac.h>
  40 #include <mach/sdcard.h>
  41 #include <mach/dma.h>
  42 #include <mach/hardware.h>
  43 #endif
  44
  45 #include "mmci.h"
  46
  47 #define DRIVER_NAME "mmci-pl18x"
  48
  49 #if defined (CONFIG_ARCH_LPC32XX)
  50 static unsigned int fmax = 26000000; /* 26MHz bit rate max */
  51
  52 #define DMA_BUFF_SIZE SZ_64K
  53 static void *dma_p_base, *dma_v_base;
  54 static struct dma_config dmacfgrx, dmacfgtx;
  55 static int lastch = DMA_CH_SDCARD_TX;
  56
  57 #define MCI_WIDEBUS (1 << 11)
  58 #undef MCI_IRQENABLE
  59 #define MCI_IRQENABLE   \
  60         (MCI_CMDCRCFAILMASK|MCI_DATACRCFAILMASK|MCI_CMDTIMEOUTMASK|     \
  61         MCI_DATATIMEOUTMASK|MCI_TXUNDERRUNMASK|MCI_RXOVERRUNMASK|       \
  62         MCI_CMDRESPENDMASK|MCI_CMDSENTMASK)
  63
  64 #else
  65 static unsigned int fmax = 515633;
  66 #endif
  67
  68 #if defined (CONFIG_ARCH_LPC32XX)
  69 static int mmc_dma_setup(void)
  70 {
  71         /* Setup TX DMA channel */
  72         dmacfgtx.ch = DMA_CH_SDCARD_TX;
  73         dmacfgtx.tc_inten = 0;
  74         dmacfgtx.err_inten = 0;
  75         dmacfgtx.src_size = 4;
  76         dmacfgtx.src_inc = 1;
  77         dmacfgtx.src_ahb1 = 0;
  78         dmacfgtx.src_bsize = DMAC_CHAN_SRC_BURST_8;
  79         dmacfgtx.src_prph = DMAC_SRC_PERIP(DMA_PERID_SDCARD);
  80         dmacfgtx.dst_size = 4;
  81         dmacfgtx.dst_inc = 0;
  82         dmacfgtx.dst_ahb1 = 0;
  83         dmacfgtx.dst_bsize = DMAC_CHAN_DEST_BURST_8;
  84         dmacfgtx.dst_prph = DMAC_DEST_PERIP(DMA_PERID_SDCARD);
  85         dmacfgtx.flowctrl = DMAC_CHAN_FLOW_P_M2P;
  86         if (lpc32xx_dma_ch_get(&dmacfgtx, "dma_sd_tx", NULL, NULL) < 0)
  87         {
  88                 printk(KERN_ERR "Error setting up SD card TX DMA channel\n");
  89                 return -ENODEV;
  90         }
  91
  92         /* Setup RX DMA channel */
  93         dmacfgrx.ch = DMA_CH_SDCARD_RX;
  94         dmacfgrx.tc_inten = 0;
  95         dmacfgrx.err_inten = 0;
  96         dmacfgrx.src_size = 4;
  97         dmacfgrx.src_inc = 0;
  98         dmacfgrx.src_ahb1 = 0;
  99         dmacfgrx.src_bsize = DMAC_CHAN_SRC_BURST_8;
 100         dmacfgrx.src_prph = DMAC_SRC_PERIP(DMA_PERID_SDCARD);
 101         dmacfgrx.dst_size = 4;
 102         dmacfgrx.dst_inc = 1;
 103         dmacfgrx.dst_ahb1 = 0;
 104         dmacfgrx.dst_bsize = DMAC_CHAN_DEST_BURST_8;
 105         dmacfgrx.dst_prph = DMAC_DEST_PERIP(DMA_PERID_SDCARD);
 106         dmacfgrx.flowctrl = DMAC_CHAN_FLOW_P_P2M;
 107         if (lpc32xx_dma_ch_get(&dmacfgrx, "dma_sd_rx", NULL, NULL) < 0)
 108         {
 109                 printk(KERN_ERR "Error setting up SD card RX DMA channel\n");
 110                 return -ENODEV;
 111         }
 112
 113         return 0;
 114 }
 115
 116 static void mmc_dma_start(int ch)
 117 {
 118         if (ch == DMA_CH_SDCARD_TX)
 119         {
 120                 lpc32xx_dma_start_pflow_xfer(DMA_CH_SDCARD_TX,
 121                         dma_p_base, (void *) SD_FIFO(LPC32XX_SD_BASE), 1);
 122         }
 123         else
 124         {
 125                 lpc32xx_dma_start_pflow_xfer(DMA_CH_SDCARD_RX,
 126                         (void *) SD_FIFO(LPC32XX_SD_BASE), dma_p_base, 1);
 127         }
 128 }
 129
 130 static void mmc_dma_stop(int ch)
 131 {
 132         lpc32xx_dma_ch_disable(ch);
 133 }
 134
 135 static void mmc_tx_dma_copy(struct mmci_host *host)
 136 {
 137         char *src_buffer, *dst_buffer;
 138         unsigned long flags;
 139
 140         dst_buffer = (char *) dma_v_base;
 141         do
 142         {
 143                 /*
 144                  * Map the current scatter buffer, copy data, and unmap
 145                  */
 146                 src_buffer = mmci_kmap_atomic(host, &flags) + host->sg_off;
 147                 memcpy(dst_buffer, src_buffer, host->sg_ptr->length);
 148                 dst_buffer += host->sg_ptr->length;
 149                 mmci_kunmap_atomic(host, src_buffer, &flags);
 150
 151                 if (!mmci_next_sg(host))
 152                         break;
 153         } while (1);
 154 }
 155
 156 static void mmc_dma_rx_copy(struct mmci_host *host)
 157 {
 158         char *src_buffer, *dst_buffer;
 159         unsigned long flags;
 160
 161         src_buffer = (char *) dma_v_base;
 162         do
 163         {
 164                 /*
 165                  * Map the current scatter buffer, copy data, and unmap
 166                  */
 167                 dst_buffer = mmci_kmap_atomic(host, &flags) + host->sg_off;
 168                 memcpy(dst_buffer, src_buffer, host->sg_ptr->length);
 169                 src_buffer += host->sg_ptr->length;
 170                 mmci_kunmap_atomic(host, dst_buffer, &flags);
 171
 172                 flush_dcache_page(sg_page(host->sg_ptr));
 173
 174                 if (!mmci_next_sg(host))
 175                         break;
 176         } while (1);
 177 }
 178 #endif
 179
 180 /*
 181  * This must be called with host->lock held
 182  */
 183 static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
 184 {
 185         u32 clk = 0;
 186
 187         if (desired) {
 188                 if (desired >= host->mclk) {
 189                         clk = MCI_CLK_BYPASS;
 190                         host->cclk = host->mclk;
 191                 } else {
 192                         clk = host->mclk / (2 * desired) - 1;
 193                         if (clk >= 256)
 194                                 clk = 255;
 195                         host->cclk = host->mclk / (2 * (clk + 1));
 196                 }
 197                 if (host->hw_designer == AMBA_VENDOR_ST)
 198                         clk |= MCI_FCEN; /* Bug fix in ST IP block */
 199                 clk |= MCI_CLK_ENABLE;
 200                 /* This hasn't proven to be worthwhile */
 201                 /* clk |= MCI_CLK_PWRSAVE; */
 202         }
 203
 204         if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_4)
 205                 clk |= MCI_WIDE_BUS;
 206
 207         writel(clk, host->base + MMCICLOCK);
 208 }
 209
 210 static void
 211 mmci_request_end(struct mmci_host *host, struct mmc_request *mrq)
 212 {
 213         writel(0, host->base + MMCICOMMAND);
 214
 215         BUG_ON(host->data);
 216
 217         host->mrq = NULL;
 218         host->cmd = NULL;
 219
 220         if (mrq->data)
 221                 mrq->data->bytes_xfered = host->data_xfered;
 222
 223         /*
 224          * Need to drop the host lock here; mmc_request_done may call
 225          * back into the driver...
 226          */
 227         spin_unlock(&host->lock);
 228         mmc_request_done(host->mmc, mrq);
 229         spin_lock(&host->lock);
 230 }
 231
 232 static void mmci_stop_data(struct mmci_host *host)
 233 {
 234         writel(0, host->base + MMCIDATACTRL);
 235         writel(0, host->base + MMCIMASK1);
 236         host->data = NULL;
 237 #if defined(CONFIG_ARCH_LPC32XX)
 238         mmc_dma_stop(lastch);
 239 #endif
 240 }
 241
 242 static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
 243 {
 244         unsigned int datactrl, timeout, irqmask = 0;
 245         unsigned long long clks;
 246         void __iomem *base;
 247         int blksz_bits;
 248
 249         dev_dbg(mmc_dev(host->mmc), "blksz %04x blks %04x flags %08x\n",
 250                 data->blksz, data->blocks, data->flags);
 251
 252         host->data = data;
 253         host->size = data->blksz;
 254         host->data_xfered = 0;
 255
 256         mmci_init_sg(host, data);
 257
 258         clks = (unsigned long long)data->timeout_ns * host->cclk;
 259         do_div(clks, 1000000000UL);
 260
 261         timeout = data->timeout_clks + (unsigned int)clks;
 262
 263         base = host->base;
 264         writel(timeout, base + MMCIDATATIMER);
 265 #if defined (CONFIG_ARCH_LPC32XX)
 266         writel((host->size * data->blocks), base + MMCIDATALENGTH);
 267
 268         blksz_bits = ffs(data->blksz) - 1;
 269         BUG_ON(1 << blksz_bits != data->blksz);
 270
 271         datactrl = MCI_DPSM_ENABLE | MCI_DPSM_DMAENABLE | blksz_bits << 4;
 272         if (data->flags & MMC_DATA_READ) {
 273                 datactrl |= MCI_DPSM_DIRECTION;
 274                 lastch = DMA_CH_SDCARD_RX;
 275         } else {
 276                 /* Copy data buffer to DMA buffer and start transfer */
 277                 lastch = DMA_CH_SDCARD_TX;
 278                 mmc_tx_dma_copy(host);
 279         }
 280         mmc_dma_start(lastch);
 281
 282         writel(datactrl, base + MMCIDATACTRL);
 283         datactrl = readl(base + MMCIMASK0) & ~MCI_DATABLOCKENDMASK;
 284         writel(datactrl | MCI_DATAENDMASK, base + MMCIMASK0);
 285
 286 #else
 287         writel(host->size, base + MMCIDATALENGTH);
 288
 289         blksz_bits = ffs(data->blksz) - 1;
 290         BUG_ON(1 << blksz_bits != data->blksz);
 291
 292         datactrl = MCI_DPSM_ENABLE | blksz_bits << 4;
 293         if (data->flags & MMC_DATA_READ) {
 294                 datactrl |= MCI_DPSM_DIRECTION;
 295                 irqmask = MCI_RXFIFOHALFFULLMASK;
 296
 297                 /*
 298                  * If we have less than a FIFOSIZE of bytes to transfer,
 299                  * trigger a PIO interrupt as soon as any data is available.
 300                  */
 301                 if (host->size < MCI_FIFOSIZE)
 302                         irqmask |= MCI_RXDATAAVLBLMASK;
 303         } else {
 304                 /*
 305                  * We don't actually need to include "FIFO empty" here
 306                  * since its implicit in "FIFO half empty".
 307                  */
 308                 irqmask = MCI_TXFIFOHALFEMPTYMASK;
 309         }
 310
 311         writel(datactrl, base + MMCIDATACTRL);
 312         writel(readl(base + MMCIMASK0) & ~MCI_DATAENDMASK, base + MMCIMASK0);
 313 #endif
 314         writel(irqmask, base + MMCIMASK1);
 315 }
 316
 317 static void
 318 mmci_start_command(struct mmci_host *host, struct mmc_command *cmd, u32 c)
 319 {
 320         void __iomem *base = host->base;
 321
 322         dev_dbg(mmc_dev(host->mmc), "op %02x arg %08x flags %08x\n",
 323             cmd->opcode, cmd->arg, cmd->flags);
 324
 325         if (readl(base + MMCICOMMAND) & MCI_CPSM_ENABLE) {
 326                 writel(0, base + MMCICOMMAND);
 327                 udelay(1);
 328         }
 329
 330         c |= cmd->opcode | MCI_CPSM_ENABLE;
 331         if (cmd->flags & MMC_RSP_PRESENT) {
 332                 if (cmd->flags & MMC_RSP_136)
 333                         c |= MCI_CPSM_LONGRSP;
 334                 c |= MCI_CPSM_RESPONSE;
 335         }
 336         if (/*interrupt*/0)
 337                 c |= MCI_CPSM_INTERRUPT;
 338
 339         host->cmd = cmd;
 340
 341         writel(cmd->arg, base + MMCIARGUMENT);
 342         writel(c, base + MMCICOMMAND);
 343 }
 344
 345 static void
 346 mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
 347               unsigned int status)
 348 {
 349 #if defined (CONFIG_ARCH_LPC32XX)
 350         if (status & MCI_DATAEND) {
 351                 host->data_xfered += data->blksz * data->blocks;
 352 #else
 353
 354         if (status & MCI_DATABLOCKEND) {
 355                 host->data_xfered += data->blksz;
 356 #endif
 357 #ifdef CONFIG_ARCH_U300
 358                 /*
 359                  * On the U300 some signal or other is
 360                  * badly routed so that a data write does
 361                  * not properly terminate with a MCI_DATAEND
 362                  * status flag. This quirk will make writes
 363                  * work again.
 364                  */
 365                 if (data->flags & MMC_DATA_WRITE)
 366                         status |= MCI_DATAEND;
 367 #endif
 368         }
 369         if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) {
 370                 dev_dbg(mmc_dev(host->mmc), "MCI ERROR IRQ (status %08x)\n", status);
 371                 if (status & MCI_DATACRCFAIL)
 372                         data->error = -EILSEQ;
 373                 else if (status & MCI_DATATIMEOUT)
 374                         data->error = -ETIMEDOUT;
 375                 else if (status & (MCI_TXUNDERRUN|MCI_RXOVERRUN))
 376                         data->error = -EIO;
 377                 status |= MCI_DATAEND;
 378
 379 #if !defined (CONFIG_ARCH_LPC32XX)
 380                 /*
 381                  * We hit an error condition.  Ensure that any data
 382                  * partially written to a page is properly coherent.
 383                  */
 384                 if (host->sg_len && data->flags & MMC_DATA_READ)
 385                         flush_dcache_page(sg_page(host->sg_ptr));
 386 #endif
 387         }
 388         if (status & MCI_DATAEND) {
 389                 mmci_stop_data(host);
 390 #if defined (CONFIG_ARCH_LPC32XX)
 391                 /* Copy DMA buffer to MMC buffer */
 392                 if (lastch == DMA_CH_SDCARD_RX)
 393                 {
 394                         /* Copy DMA buffer to data buffer */
 395                         mmc_dma_rx_copy(host);
 396                 }
 397 #endif
 398                 if (!data->stop) {
 399                         mmci_request_end(host, data->mrq);
 400                 } else {
 401                         mmci_start_command(host, data->stop, 0);
 402                 }
 403         }
 404 }
 405
 406 static void
 407 mmci_cmd_irq(struct mmci_host *host, struct mmc_command *cmd,
 408              unsigned int status)
 409 {
 410         void __iomem *base = host->base;
 411
 412         host->cmd = NULL;
 413
 414         cmd->resp[0] = readl(base + MMCIRESPONSE0);
 415         cmd->resp[1] = readl(base + MMCIRESPONSE1);
 416         cmd->resp[2] = readl(base + MMCIRESPONSE2);
 417         cmd->resp[3] = readl(base + MMCIRESPONSE3);
 418
 419         if (status & MCI_CMDTIMEOUT) {
 420                 cmd->error = -ETIMEDOUT;
 421         } else if (status & MCI_CMDCRCFAIL && cmd->flags & MMC_RSP_CRC) {
 422                 cmd->error = -EILSEQ;
 423         }
 424
 425         if (!cmd->data || cmd->error) {
 426                 if (host->data)
 427                         mmci_stop_data(host);
 428                 mmci_request_end(host, cmd->mrq);
 429         } else if (!(cmd->data->flags & MMC_DATA_READ)) {
 430                 mmci_start_data(host, cmd->data);
 431         }
 432 }
 433
 434 static int mmci_pio_read(struct mmci_host *host, char *buffer, unsigned int remain)
 435 {
 436         void __iomem *base = host->base;
 437         char *ptr = buffer;
 438         u32 status;
 439         int host_remain = host->size;
 440
 441         do {
 442                 int count = host_remain - (readl(base + MMCIFIFOCNT) << 2);
 443
 444                 if (count > remain)
 445                         count = remain;
 446
 447                 if (count <= 0)
 448                         break;
 449
 450                 readsl(base + MMCIFIFO, ptr, count >> 2);
 451
 452                 ptr += count;
 453                 remain -= count;
 454                 host_remain -= count;
 455
 456                 if (remain == 0)
 457                         break;
 458
 459                 status = readl(base + MMCISTATUS);
 460         } while (status & MCI_RXDATAAVLBL);
 461
 462         return ptr - buffer;
 463 }
 464
 465 static int mmci_pio_write(struct mmci_host *host, char *buffer, unsigned int remain, u32 status)
 466 {
 467         void __iomem *base = host->base;
 468         char *ptr = buffer;
 469
 470         do {
 471                 unsigned int count, maxcnt;
 472
 473                 maxcnt = status & MCI_TXFIFOEMPTY ? MCI_FIFOSIZE : MCI_FIFOHALFSIZE;
 474                 count = min(remain, maxcnt);
 475
 476                 writesl(base + MMCIFIFO, ptr, count >> 2);
 477
 478                 ptr += count;
 479                 remain -= count;
 480
 481                 if (remain == 0)
 482                         break;
 483
 484                 status = readl(base + MMCISTATUS);
 485         } while (status & MCI_TXFIFOHALFEMPTY);
 486
 487         return ptr - buffer;
 488 }
 489
 490 /*
 491  * PIO data transfer IRQ handler.
 492  */
 493 static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
 494 {
 495         struct mmci_host *host = dev_id;
 496         void __iomem *base = host->base;
 497         u32 status;
 498
 499         status = readl(base + MMCISTATUS);
 500
 501         dev_dbg(mmc_dev(host->mmc), "irq1 (pio) %08x\n", status);
 502
 503         do {
 504                 unsigned long flags;
 505                 unsigned int remain, len;
 506                 char *buffer;
 507
 508                 /*
 509                  * For write, we only need to test the half-empty flag
 510                  * here - if the FIFO is completely empty, then by
 511                  * definition it is more than half empty.
 512                  *
 513                  * For read, check for data available.
 514                  */
 515                 if (!(status & (MCI_TXFIFOHALFEMPTY|MCI_RXDATAAVLBL)))
 516                         break;
 517
 518                 /*
 519                  * Map the current scatter buffer.
 520                  */
 521                 buffer = mmci_kmap_atomic(host, &flags) + host->sg_off;
 522                 remain = host->sg_ptr->length - host->sg_off;
 523
 524                 len = 0;
 525                 if (status & MCI_RXACTIVE)
 526                         len = mmci_pio_read(host, buffer, remain);
 527                 if (status & MCI_TXACTIVE)
 528                         len = mmci_pio_write(host, buffer, remain, status);
 529
 530                 /*
 531                  * Unmap the buffer.
 532                  */
 533                 mmci_kunmap_atomic(host, buffer, &flags);
 534
 535                 host->sg_off += len;
 536                 host->size -= len;
 537                 remain -= len;
 538
 539                 if (remain)
 540                         break;
 541
 542                 /*
 543                  * If we were reading, and we have completed this
 544                  * page, ensure that the data cache is coherent.
 545                  */
 546                 if (status & MCI_RXACTIVE)
 547                         flush_dcache_page(sg_page(host->sg_ptr));
 548
 549                 if (!mmci_next_sg(host))
 550                         break;
 551
 552                 status = readl(base + MMCISTATUS);
 553         } while (1);
 554
 555         /*
 556          * If we're nearing the end of the read, switch to
 557          * "any data available" mode.
 558          */
 559         if (status & MCI_RXACTIVE && host->size < MCI_FIFOSIZE)
 560                 writel(MCI_RXDATAAVLBLMASK, base + MMCIMASK1);
 561
 562         /*
 563          * If we run out of data, disable the data IRQs; this
 564          * prevents a race where the FIFO becomes empty before
 565          * the chip itself has disabled the data path, and
 566          * stops us racing with our data end IRQ.
 567          */
 568         if (host->size == 0) {
 569                 writel(0, base + MMCIMASK1);
 570                 writel(readl(base + MMCIMASK0) | MCI_DATAENDMASK, base + MMCIMASK0);
 571         }
 572
 573         return IRQ_HANDLED;
 574 }
 575
 576 /*
 577  * Handle completion of command and data transfers.
 578  */
 579 static irqreturn_t mmci_irq(int irq, void *dev_id)
 580 {
 581         struct mmci_host *host = dev_id;
 582         u32 status;
 583         int ret = 0;
 584
 585         spin_lock(&host->lock);
 586
 587         do {
 588                 struct mmc_command *cmd;
 589                 struct mmc_data *data;
 590
 591                 status = readl(host->base + MMCISTATUS);
 592                 status &= readl(host->base + MMCIMASK0);
 593 #if defined (CONFIG_ARCH_LPC32XX)
 594                 writel((status | MCI_DATABLOCKEND), host->base + MMCICLEAR);
 595 #else
 596                 writel(status, host->base + MMCICLEAR);
 597 #endif
 598
 599                 dev_dbg(mmc_dev(host->mmc), "irq0 (data+cmd) %08x\n", status);
 600
 601                 data = host->data;
 602                 if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|
 603                               MCI_RXOVERRUN|MCI_DATAEND|MCI_DATABLOCKEND) && data)
 604                         mmci_data_irq(host, data, status);
 605
 606                 cmd = host->cmd;
 607                 if (status & (MCI_CMDCRCFAIL|MCI_CMDTIMEOUT|MCI_CMDSENT|MCI_CMDRESPEND) && cmd)
 608                         mmci_cmd_irq(host, cmd, status);
 609
 610                 ret = 1;
 611         } while (status);
 612
 613         spin_unlock(&host->lock);
 614
 615         return IRQ_RETVAL(ret);
 616 }
 617
 618 static void mmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 619 {
 620         struct mmci_host *host = mmc_priv(mmc);
 621         unsigned long flags;
 622
 623         WARN_ON(host->mrq != NULL);
 624
 625         if (mrq->data && !is_power_of_2(mrq->data->blksz)) {
 626                 dev_err(mmc_dev(mmc), "unsupported block size (%d bytes)\n",
 627                         mrq->data->blksz);
 628                 mrq->cmd->error = -EINVAL;
 629                 mmc_request_done(mmc, mrq);
 630                 return;
 631         }
 632
 633         spin_lock_irqsave(&host->lock, flags);
 634
 635         host->mrq = mrq;
 636
 637         if (mrq->data && mrq->data->flags & MMC_DATA_READ)
 638                 mmci_start_data(host, mrq->data);
 639
 640         mmci_start_command(host, mrq->cmd, 0);
 641
 642         spin_unlock_irqrestore(&host->lock, flags);
 643 }
 644
 645 static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 646 {
 647         struct mmci_host *host = mmc_priv(mmc);
 648         u32 pwr = 0;
 649         unsigned long flags;
 650
 651         switch (ios->power_mode) {
 652         case MMC_POWER_OFF:
 653                 if(host->vcc &&
 654                    regulator_is_enabled(host->vcc))
 655                         regulator_disable(host->vcc);
 656                 break;
 657         case MMC_POWER_UP:
 658 #ifdef CONFIG_REGULATOR
 659                 if (host->vcc)
 660                         /* This implicitly enables the regulator */
 661                         mmc_regulator_set_ocr(host->vcc, ios->vdd);
 662 #endif
 663                 /*
 664                  * The translate_vdd function is not used if you have
 665                  * an external regulator, or your design is really weird.
 666                  * Using it would mean sending in power control BOTH using
 667                  * a regulator AND the 4 MMCIPWR bits. If we don't have
 668                  * a regulator, we might have some other platform specific
 669                  * power control behind this translate function.
 670                  */
 671                 if (!host->vcc && host->plat->translate_vdd)
 672                         pwr |= host->plat->translate_vdd(mmc_dev(mmc), ios->vdd);
 673                 /* The ST version does not have this, fall through to POWER_ON */
 674                 if (host->hw_designer != AMBA_VENDOR_ST) {
 675                         pwr |= MCI_PWR_UP;
 676                         break;
 677                 }
 678         case MMC_POWER_ON:
 679                 pwr |= MCI_PWR_ON;
 680                 break;
 681         }
 682
 683         if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN) {
 684                 if (host->hw_designer != AMBA_VENDOR_ST)
 685                         pwr |= MCI_ROD;
 686                 else {
 687                         /*
 688                          * The ST Micro variant use the ROD bit for something
 689                          * else and only has OD (Open Drain).
 690                          */
 691                         pwr |= MCI_OD;
 692                 }
 693         }
 694
 695         spin_lock_irqsave(&host->lock, flags);
 696
 697         mmci_set_clkreg(host, ios->clock);
 698
 699         if (host->pwr != pwr) {
 700                 host->pwr = pwr;
 701                 writel(pwr, host->base + MMCIPOWER);
 702         }
 703
 704         spin_unlock_irqrestore(&host->lock, flags);
 705 }
 706
 707 static int mmci_get_ro(struct mmc_host *mmc)
 708 {
 709         struct mmci_host *host = mmc_priv(mmc);
 710
 711         if (host->gpio_wp == -ENOSYS)
 712                 return -ENOSYS;
 713
 714         return gpio_get_value(host->gpio_wp);
 715 }
 716
 717 static int mmci_get_cd(struct mmc_host *mmc)
 718 {
 719         struct mmci_host *host = mmc_priv(mmc);
 720         unsigned int status;
 721
 722         if (host->gpio_cd == -ENOSYS)
 723                 status = host->plat->status(mmc_dev(host->mmc));
 724         else
 725                 status = gpio_get_value(host->gpio_cd);
 726
 727         return !status;
 728 }
 729
 730 static const struct mmc_host_ops mmci_ops = {
 731         .request        = mmci_request,
 732         .set_ios        = mmci_set_ios,
 733         .get_ro         = mmci_get_ro,
 734         .get_cd         = mmci_get_cd,
 735 };
 736
 737 static void mmci_check_status(unsigned long data)
 738 {
 739         struct mmci_host *host = (struct mmci_host *)data;
 740         unsigned int status = mmci_get_cd(host->mmc);
 741
 742         if (status ^ host->oldstat)
 743                 mmc_detect_change(host->mmc, 0);
 744
 745         host->oldstat = status;
 746         mod_timer(&host->timer, jiffies + HZ);
 747 }
 748
 749 static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
 750 {
 751         struct mmci_platform_data *plat = dev->dev.platform_data;
 752         struct mmci_host *host;
 753         struct mmc_host *mmc;
 754         int ret;
 755 #if defined (CONFIG_ARCH_LPC32XX)
 756         dma_addr_t dma_handle;
 757 #endif
 758
 759         /* must have platform data */
 760         if (!plat) {
 761                 ret = -EINVAL;
 762                 goto out;
 763         }
 764
 765 #if defined (CONFIG_ARCH_LPC32XX)
 766         /* Allocate a chunk of memory for the DMA buffers */
 767         dma_v_base = dma_alloc_coherent(&dev->dev, DMA_BUFF_SIZE,
 768                 &dma_handle, GFP_KERNEL);
 769         if (dma_v_base == NULL)
 770         {
 771                 printk("%s: error getting DMA region.\n", DRIVER_NAME);
 772                 ret = -ENOMEM;
 773                 goto out;
 774         }
 775         dma_p_base = (void *) dma_handle;
 776         printk(KERN_INFO "%s: DMA buffer(%x bytes), P:0x%08x, V:0x%08x\n",
 777                 DRIVER_NAME, DMA_BUFF_SIZE, (u32) dma_p_base, (u32) dma_v_base);
 778 #endif
 779
 780         ret = amba_request_regions(dev, DRIVER_NAME);
 781         if (ret) {
 782 #if defined (CONFIG_ARCH_LPC32XX)
 783                 goto out_free_dma;
 784 #else
 785                 goto out;
 786 #endif
 787         }
 788         mmc = mmc_alloc_host(sizeof(struct mmci_host), &dev->dev);
 789         if (!mmc) {
 790                 ret = -ENOMEM;
 791                 goto rel_regions;
 792         }
 793
 794         host = mmc_priv(mmc);
 795         host->mmc = mmc;
 796
 797         host->gpio_wp = -ENOSYS;
 798         host->gpio_cd = -ENOSYS;
 799
 800         host->hw_designer = amba_manf(dev);
 801         host->hw_revision = amba_rev(dev);
 802         dev_dbg(mmc_dev(mmc), "designer ID = 0x%02x\n", host->hw_designer);
 803         dev_dbg(mmc_dev(mmc), "revision = 0x%01x\n", host->hw_revision);
 804
 805         host->clk = clk_get(&dev->dev, NULL);
 806         if (IS_ERR(host->clk)) {
 807                 ret = PTR_ERR(host->clk);
 808                 host->clk = NULL;
 809                 goto host_free;
 810         }
 811
 812         ret = clk_enable(host->clk);
 813         if (ret)
 814                 goto clk_free;
 815
 816         host->plat = plat;
 817         host->mclk = clk_get_rate(host->clk);
 818         /*
 819          * According to the spec, mclk is max 100 MHz,
 820          * so we try to adjust the clock down to this,
 821          * (if possible).
 822          */
 823         if (host->mclk > 100000000) {
 824                 ret = clk_set_rate(host->clk, 100000000);
 825                 if (ret < 0)
 826                         goto clk_disable;
 827                 host->mclk = clk_get_rate(host->clk);
 828                 dev_dbg(mmc_dev(mmc), "eventual mclk rate: %u Hz\n",
 829                         host->mclk);
 830         }
 831         host->base = ioremap(dev->res.start, resource_size(&dev->res));
 832         if (!host->base) {
 833                 ret = -ENOMEM;
 834                 goto clk_disable;
 835         }
 836
 837         mmc->ops = &mmci_ops;
 838         mmc->f_min = (host->mclk + 511) / 512;
 839         mmc->f_max = min(host->mclk, fmax);
 840         dev_dbg(mmc_dev(mmc), "clocking block at %u Hz\n", mmc->f_max);
 841
 842 #ifdef CONFIG_REGULATOR
 843         /* If we're using the regulator framework, try to fetch a regulator */
 844         host->vcc = regulator_get(&dev->dev, "vmmc");
 845         if (IS_ERR(host->vcc))
 846                 host->vcc = NULL;
 847         else {
 848                 int mask = mmc_regulator_get_ocrmask(host->vcc);
 849
 850                 if (mask < 0)
 851                         dev_err(&dev->dev, "error getting OCR mask (%d)\n",
 852                                 mask);
 853                 else {
 854                         host->mmc->ocr_avail = (u32) mask;
 855                         if (plat->ocr_mask)
 856                                 dev_warn(&dev->dev,
 857                                  "Provided ocr_mask/setpower will not be used "
 858                                  "(using regulator instead)\n");
 859                 }
 860         }
 861 #endif
 862         /* Fall back to platform data if no regulator is found */
 863         if (host->vcc == NULL)
 864                 mmc->ocr_avail = plat->ocr_mask;
 865         mmc->caps = plat->capabilities;
 866
 867         /*
 868          * We can do SGIO
 869          */
 870         mmc->max_hw_segs = 16;
 871         mmc->max_phys_segs = NR_SG;
 872
 873         /*
 874          * Since we only have a 16-bit data length register, we must
 875          * ensure that we don't exceed 2^16-1 bytes in a single request.
 876          */
 877         mmc->max_req_size = 65535;
 878
 879         /*
 880          * Set the maximum segment size.  Since we aren't doing DMA
 881          * (yet) we are only limited by the data length register.
 882          */
 883         mmc->max_seg_size = mmc->max_req_size;
 884
 885         /*
 886          * Block size can be up to 2048 bytes, but must be a power of two.
 887          */
 888         mmc->max_blk_size = 2048;
 889
 890         /*
 891          * No limit on the number of blocks transferred.
 892          */
 893         mmc->max_blk_count = mmc->max_req_size;
 894
 895 #if defined (CONFIG_ARCH_LPC32XX)
 896         /*
 897          * Setup DMA for the interface
 898          */
 899         mmc_dma_setup();
 900 #endif
 901
 902         spin_lock_init(&host->lock);
 903
 904         writel(0, host->base + MMCIMASK0);
 905         writel(0, host->base + MMCIMASK1);
 906         writel(0xfff, host->base + MMCICLEAR);
 907
 908         if (gpio_is_valid(plat->gpio_cd)) {
 909                 ret = gpio_request(plat->gpio_cd, DRIVER_NAME " (cd)");
 910                 if (ret == 0)
 911                         ret = gpio_direction_input(plat->gpio_cd);
 912                 if (ret == 0)
 913                         host->gpio_cd = plat->gpio_cd;
 914                 else if (ret != -ENOSYS)
 915                         goto err_gpio_cd;
 916         }
 917         if (gpio_is_valid(plat->gpio_wp)) {
 918                 ret = gpio_request(plat->gpio_wp, DRIVER_NAME " (wp)");
 919                 if (ret == 0)
 920                         ret = gpio_direction_input(plat->gpio_wp);
 921                 if (ret == 0)
 922                         host->gpio_wp = plat->gpio_wp;
 923                 else if (ret != -ENOSYS)
 924                         goto err_gpio_wp;
 925         }
 926
 927         ret = request_irq(dev->irq[0], mmci_irq, IRQF_SHARED, DRIVER_NAME " (cmd)", host);
 928         if (ret)
 929                 goto unmap;
 930
 931         ret = request_irq(dev->irq[1], mmci_pio_irq, IRQF_SHARED, DRIVER_NAME " (pio)", host);
 932         if (ret)
 933                 goto irq0_free;
 934 #if defined (CONFIG_ARCH_LPC32XX)
 935         writel(MCI_IRQENABLE|MCI_DATAENDMASK, host->base + MMCIMASK0);
 936 #else
 937         writel(MCI_IRQENABLE, host->base + MMCIMASK0);
 938 #endif
 939         amba_set_drvdata(dev, mmc);
 940         host->oldstat = mmci_get_cd(host->mmc);
 941
 942         mmc_add_host(mmc);
 943
 944         dev_info(&dev->dev, "%s: MMCI rev %x cfg %02x at 0x%016llx irq %d,%d\n",
 945                 mmc_hostname(mmc), amba_rev(dev), amba_config(dev),
 946                 (unsigned long long)dev->res.start, dev->irq[0], dev->irq[1]);
 947
 948         init_timer(&host->timer);
 949         host->timer.data = (unsigned long)host;
 950         host->timer.function = mmci_check_status;
 951         host->timer.expires = jiffies + HZ;
 952         add_timer(&host->timer);
 953
 954         return 0;
 955
 956  irq0_free:
 957         free_irq(dev->irq[0], host);
 958  unmap:
 959         if (host->gpio_wp != -ENOSYS)
 960                 gpio_free(host->gpio_wp);
 961  err_gpio_wp:
 962         if (host->gpio_cd != -ENOSYS)
 963                 gpio_free(host->gpio_cd);
 964  err_gpio_cd:
 965         iounmap(host->base);
 966  clk_disable:
 967         clk_disable(host->clk);
 968  clk_free:
 969         clk_put(host->clk);
 970  host_free:
 971         mmc_free_host(mmc);
 972  rel_regions:
 973         amba_release_regions(dev);
 974 #if defined (CONFIG_ARCH_LPC32XX)
 975  out_free_dma:
 976         dma_free_coherent(&dev->dev, DMA_BUFF_SIZE,
 977                 dma_v_base, (dma_addr_t) dma_p_base);
 978 #endif
 979  out:
 980         return ret;
 981 }
 982
 983 static int __devexit mmci_remove(struct amba_device *dev)
 984 {
 985         struct mmc_host *mmc = amba_get_drvdata(dev);
 986
 987         amba_set_drvdata(dev, NULL);
 988
 989         if (mmc) {
 990                 struct mmci_host *host = mmc_priv(mmc);
 991
 992                 del_timer_sync(&host->timer);
 993
 994                 mmc_remove_host(mmc);
 995
 996                 writel(0, host->base + MMCIMASK0);
 997                 writel(0, host->base + MMCIMASK1);
 998
 999                 writel(0, host->base + MMCICOMMAND);
1000                 writel(0, host->base + MMCIDATACTRL);
1001
1002                 free_irq(dev->irq[0], host);
1003                 free_irq(dev->irq[1], host);
1004
1005                 if (host->gpio_wp != -ENOSYS)
1006                         gpio_free(host->gpio_wp);
1007                 if (host->gpio_cd != -ENOSYS)
1008                         gpio_free(host->gpio_cd);
1009
1010                 iounmap(host->base);
1011                 clk_disable(host->clk);
1012                 clk_put(host->clk);
1013
1014                 if (regulator_is_enabled(host->vcc))
1015                         regulator_disable(host->vcc);
1016                 regulator_put(host->vcc);
1017
1018                 mmc_free_host(mmc);
1019
1020                 amba_release_regions(dev);
1021 #if defined (CONFIG_ARCH_LPC32XX)
1022                 dma_free_coherent(&dev->dev, DMA_BUFF_SIZE,
1023                         dma_v_base, (dma_addr_t) dma_p_base);
1024 #endif
1025         }
1026
1027         return 0;
1028 }
1029
1030 #ifdef CONFIG_PM
1031 static int mmci_suspend(struct amba_device *dev, pm_message_t state)
1032 {
1033         struct mmc_host *mmc = amba_get_drvdata(dev);
1034         int ret = 0;
1035
1036         if (mmc) {
1037                 struct mmci_host *host = mmc_priv(mmc);
1038
1039                 ret = mmc_suspend_host(mmc, state);
1040                 if (ret == 0)
1041                         writel(0, host->base + MMCIMASK0);
1042         }
1043
1044         return ret;
1045 }
1046
1047 static int mmci_resume(struct amba_device *dev)
1048 {
1049         struct mmc_host *mmc = amba_get_drvdata(dev);
1050         int ret = 0;
1051
1052         if (mmc) {
1053                 struct mmci_host *host = mmc_priv(mmc);
1054
1055                 writel(MCI_IRQENABLE, host->base + MMCIMASK0);
1056
1057                 ret = mmc_resume_host(mmc);
1058         }
1059
1060         return ret;
1061 }
1062 #else
1063 #define mmci_suspend    NULL
1064 #define mmci_resume     NULL
1065 #endif
1066
1067 static struct amba_id mmci_ids[] = {
1068         {
1069                 .id     = 0x00041180,
1070                 .mask   = 0x000fffff,
1071         },
1072         {
1073                 .id     = 0x00041181,
1074                 .mask   = 0x000fffff,
1075         },
1076         /* ST Micro variants */
1077         {
1078                 .id     = 0x00180180,
1079                 .mask   = 0x00ffffff,
1080         },
1081         {
1082                 .id     = 0x00280180,
1083                 .mask   = 0x00ffffff,
1084         },
1085         { 0, 0 },
1086 };
1087
1088 static struct amba_driver mmci_driver = {
1089         .drv            = {
1090                 .name   = DRIVER_NAME,
1091         },
1092         .probe          = mmci_probe,
1093         .remove         = __devexit_p(mmci_remove),
1094         .suspend        = mmci_suspend,
1095         .resume         = mmci_resume,
1096         .id_table       = mmci_ids,
1097 };
1098
1099 static int __init mmci_init(void)
1100 {
1101         return amba_driver_register(&mmci_driver);
1102 }
1103
1104 static void __exit mmci_exit(void)
1105 {
1106         amba_driver_unregister(&mmci_driver);
1107 }
1108
1109 module_init(mmci_init);
1110 module_exit(mmci_exit);
1111 module_param(fmax, uint, 0444);
1112
1113 MODULE_DESCRIPTION("ARM PrimeCell PL180/181 Multimedia Card Interface driver");
1114 MODULE_LICENSE("GPL");