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