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