1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2d96be879SSascha Hauer /* 3d96be879SSascha Hauer * linux/drivers/mmc/host/mxcmmc.c - Freescale i.MX MMCI driver 4d96be879SSascha Hauer * 5d96be879SSascha Hauer * This is a driver for the SDHC controller found in Freescale MX2/MX3 6d96be879SSascha Hauer * SoCs. It is basically the same hardware as found on MX1 (imxmmc.c). 7d96be879SSascha Hauer * Unlike the hardware found on MX1, this hardware just works and does 83ad2f3fbSDaniel Mack * not need all the quirks found in imxmmc.c, hence the separate driver. 9d96be879SSascha Hauer * 10d96be879SSascha Hauer * Copyright (C) 2008 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de> 11d96be879SSascha Hauer * Copyright (C) 2006 Pavel Pisa, PiKRON <ppisa@pikron.com> 12d96be879SSascha Hauer * 13d96be879SSascha Hauer * derived from pxamci.c by Russell King 14d96be879SSascha Hauer */ 15d96be879SSascha Hauer 16d96be879SSascha Hauer #include <linux/module.h> 17d96be879SSascha Hauer #include <linux/init.h> 18d96be879SSascha Hauer #include <linux/ioport.h> 19d96be879SSascha Hauer #include <linux/platform_device.h> 20a639bb72SArnd Bergmann #include <linux/highmem.h> 21d96be879SSascha Hauer #include <linux/interrupt.h> 22d96be879SSascha Hauer #include <linux/irq.h> 23d96be879SSascha Hauer #include <linux/blkdev.h> 24d96be879SSascha Hauer #include <linux/dma-mapping.h> 25d96be879SSascha Hauer #include <linux/mmc/host.h> 26d96be879SSascha Hauer #include <linux/mmc/card.h> 27d96be879SSascha Hauer #include <linux/delay.h> 28d96be879SSascha Hauer #include <linux/clk.h> 29d96be879SSascha Hauer #include <linux/io.h> 3074b66954SAlberto Panizzo #include <linux/regulator/consumer.h> 31f53fbde4SSascha Hauer #include <linux/dmaengine.h> 32258aea76SViresh Kumar #include <linux/types.h> 337ff747c4SMarkus Pargmann #include <linux/of.h> 347ff747c4SMarkus Pargmann #include <linux/of_device.h> 357ff747c4SMarkus Pargmann #include <linux/of_dma.h> 36bcf53524SAnatolij Gustschin #include <linux/mmc/slot-gpio.h> 37d96be879SSascha Hauer 38d96be879SSascha Hauer #include <asm/dma.h> 39d96be879SSascha Hauer #include <asm/irq.h> 4082906b13SArnd Bergmann #include <linux/platform_data/mmc-mxcmmc.h> 41d96be879SSascha Hauer 4282906b13SArnd Bergmann #include <linux/platform_data/dma-imx.h> 43d96be879SSascha Hauer 449563b1dbSSascha Hauer #define DRIVER_NAME "mxc-mmc" 45f6ad0a48SJavier Martin #define MXCMCI_TIMEOUT_MS 10000 46d96be879SSascha Hauer 47d96be879SSascha Hauer #define MMC_REG_STR_STP_CLK 0x00 48d96be879SSascha Hauer #define MMC_REG_STATUS 0x04 49d96be879SSascha Hauer #define MMC_REG_CLK_RATE 0x08 50d96be879SSascha Hauer #define MMC_REG_CMD_DAT_CONT 0x0C 51d96be879SSascha Hauer #define MMC_REG_RES_TO 0x10 52d96be879SSascha Hauer #define MMC_REG_READ_TO 0x14 53d96be879SSascha Hauer #define MMC_REG_BLK_LEN 0x18 54d96be879SSascha Hauer #define MMC_REG_NOB 0x1C 55d96be879SSascha Hauer #define MMC_REG_REV_NO 0x20 56d96be879SSascha Hauer #define MMC_REG_INT_CNTR 0x24 57d96be879SSascha Hauer #define MMC_REG_CMD 0x28 58d96be879SSascha Hauer #define MMC_REG_ARG 0x2C 59d96be879SSascha Hauer #define MMC_REG_RES_FIFO 0x34 60d96be879SSascha Hauer #define MMC_REG_BUFFER_ACCESS 0x38 61d96be879SSascha Hauer 62d96be879SSascha Hauer #define STR_STP_CLK_RESET (1 << 3) 63d96be879SSascha Hauer #define STR_STP_CLK_START_CLK (1 << 1) 64d96be879SSascha Hauer #define STR_STP_CLK_STOP_CLK (1 << 0) 65d96be879SSascha Hauer 66d96be879SSascha Hauer #define STATUS_CARD_INSERTION (1 << 31) 67d96be879SSascha Hauer #define STATUS_CARD_REMOVAL (1 << 30) 68d96be879SSascha Hauer #define STATUS_YBUF_EMPTY (1 << 29) 69d96be879SSascha Hauer #define STATUS_XBUF_EMPTY (1 << 28) 70d96be879SSascha Hauer #define STATUS_YBUF_FULL (1 << 27) 71d96be879SSascha Hauer #define STATUS_XBUF_FULL (1 << 26) 72d96be879SSascha Hauer #define STATUS_BUF_UND_RUN (1 << 25) 73d96be879SSascha Hauer #define STATUS_BUF_OVFL (1 << 24) 74d96be879SSascha Hauer #define STATUS_SDIO_INT_ACTIVE (1 << 14) 75d96be879SSascha Hauer #define STATUS_END_CMD_RESP (1 << 13) 76d96be879SSascha Hauer #define STATUS_WRITE_OP_DONE (1 << 12) 77d96be879SSascha Hauer #define STATUS_DATA_TRANS_DONE (1 << 11) 78d96be879SSascha Hauer #define STATUS_READ_OP_DONE (1 << 11) 79d96be879SSascha Hauer #define STATUS_WR_CRC_ERROR_CODE_MASK (3 << 10) 80d96be879SSascha Hauer #define STATUS_CARD_BUS_CLK_RUN (1 << 8) 81d96be879SSascha Hauer #define STATUS_BUF_READ_RDY (1 << 7) 82d96be879SSascha Hauer #define STATUS_BUF_WRITE_RDY (1 << 6) 83d96be879SSascha Hauer #define STATUS_RESP_CRC_ERR (1 << 5) 84d96be879SSascha Hauer #define STATUS_CRC_READ_ERR (1 << 3) 85d96be879SSascha Hauer #define STATUS_CRC_WRITE_ERR (1 << 2) 86d96be879SSascha Hauer #define STATUS_TIME_OUT_RESP (1 << 1) 87d96be879SSascha Hauer #define STATUS_TIME_OUT_READ (1 << 0) 88d96be879SSascha Hauer #define STATUS_ERR_MASK 0x2f 89d96be879SSascha Hauer 90d96be879SSascha Hauer #define CMD_DAT_CONT_CMD_RESP_LONG_OFF (1 << 12) 91d96be879SSascha Hauer #define CMD_DAT_CONT_STOP_READWAIT (1 << 11) 92d96be879SSascha Hauer #define CMD_DAT_CONT_START_READWAIT (1 << 10) 93d96be879SSascha Hauer #define CMD_DAT_CONT_BUS_WIDTH_4 (2 << 8) 94d96be879SSascha Hauer #define CMD_DAT_CONT_INIT (1 << 7) 95d96be879SSascha Hauer #define CMD_DAT_CONT_WRITE (1 << 4) 96d96be879SSascha Hauer #define CMD_DAT_CONT_DATA_ENABLE (1 << 3) 97d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_48BIT_CRC (1 << 0) 98d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_136BIT (2 << 0) 99d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_48BIT (3 << 0) 100d96be879SSascha Hauer 101d96be879SSascha Hauer #define INT_SDIO_INT_WKP_EN (1 << 18) 102d96be879SSascha Hauer #define INT_CARD_INSERTION_WKP_EN (1 << 17) 103d96be879SSascha Hauer #define INT_CARD_REMOVAL_WKP_EN (1 << 16) 104d96be879SSascha Hauer #define INT_CARD_INSERTION_EN (1 << 15) 105d96be879SSascha Hauer #define INT_CARD_REMOVAL_EN (1 << 14) 106d96be879SSascha Hauer #define INT_SDIO_IRQ_EN (1 << 13) 107d96be879SSascha Hauer #define INT_DAT0_EN (1 << 12) 108d96be879SSascha Hauer #define INT_BUF_READ_EN (1 << 4) 109d96be879SSascha Hauer #define INT_BUF_WRITE_EN (1 << 3) 110d96be879SSascha Hauer #define INT_END_CMD_RES_EN (1 << 2) 111d96be879SSascha Hauer #define INT_WRITE_OP_DONE_EN (1 << 1) 112d96be879SSascha Hauer #define INT_READ_OP_EN (1 << 0) 113d96be879SSascha Hauer 1147f917a8dSShawn Guo enum mxcmci_type { 1157f917a8dSShawn Guo IMX21_MMC, 1167f917a8dSShawn Guo IMX31_MMC, 117c7ceab02SAnatolij Gustschin MPC512X_MMC, 1187f917a8dSShawn Guo }; 1197f917a8dSShawn Guo 120d96be879SSascha Hauer struct mxcmci_host { 121d96be879SSascha Hauer struct mmc_host *mmc; 122d96be879SSascha Hauer void __iomem *base; 12301e4f958SAlexander Shiyan dma_addr_t phys_base; 124d96be879SSascha Hauer int detect_irq; 125f53fbde4SSascha Hauer struct dma_chan *dma; 126f53fbde4SSascha Hauer struct dma_async_tx_descriptor *desc; 127d96be879SSascha Hauer int do_dma; 12816b3bf8cSEric Bénard int default_irq_mask; 129f441b993SDaniel Mack int use_sdio; 130d96be879SSascha Hauer unsigned int power_mode; 131d96be879SSascha Hauer struct imxmmc_platform_data *pdata; 132d96be879SSascha Hauer 133d96be879SSascha Hauer struct mmc_request *req; 134d96be879SSascha Hauer struct mmc_command *cmd; 135d96be879SSascha Hauer struct mmc_data *data; 136d96be879SSascha Hauer 137d96be879SSascha Hauer unsigned int datasize; 138d96be879SSascha Hauer unsigned int dma_dir; 139d96be879SSascha Hauer 140d96be879SSascha Hauer u16 rev_no; 141d96be879SSascha Hauer unsigned int cmdat; 142d96be879SSascha Hauer 143529aa29eSSascha Hauer struct clk *clk_ipg; 144529aa29eSSascha Hauer struct clk *clk_per; 145d96be879SSascha Hauer 146d96be879SSascha Hauer int clock; 147d96be879SSascha Hauer 148d96be879SSascha Hauer struct work_struct datawork; 149f441b993SDaniel Mack spinlock_t lock; 15074b66954SAlberto Panizzo 151f53fbde4SSascha Hauer int burstlen; 152f53fbde4SSascha Hauer int dmareq; 153f53fbde4SSascha Hauer struct dma_slave_config dma_slave_config; 154f53fbde4SSascha Hauer struct imx_dma_data dma_data; 155f6ad0a48SJavier Martin 156f6ad0a48SJavier Martin struct timer_list watchdog; 1577f917a8dSShawn Guo enum mxcmci_type devtype; 158d96be879SSascha Hauer }; 159d96be879SSascha Hauer 1607ff747c4SMarkus Pargmann static const struct of_device_id mxcmci_of_match[] = { 1617ff747c4SMarkus Pargmann { 1627ff747c4SMarkus Pargmann .compatible = "fsl,imx21-mmc", 1638223e885SFabio Estevam .data = (void *) IMX21_MMC, 1647ff747c4SMarkus Pargmann }, { 1657ff747c4SMarkus Pargmann .compatible = "fsl,imx31-mmc", 1668223e885SFabio Estevam .data = (void *) IMX31_MMC, 1677ff747c4SMarkus Pargmann }, { 168c7ceab02SAnatolij Gustschin .compatible = "fsl,mpc5121-sdhc", 1698223e885SFabio Estevam .data = (void *) MPC512X_MMC, 170c7ceab02SAnatolij Gustschin }, { 1717ff747c4SMarkus Pargmann /* sentinel */ 1727ff747c4SMarkus Pargmann } 1737ff747c4SMarkus Pargmann }; 1747ff747c4SMarkus Pargmann MODULE_DEVICE_TABLE(of, mxcmci_of_match); 1757ff747c4SMarkus Pargmann 1767f917a8dSShawn Guo static inline int is_imx31_mmc(struct mxcmci_host *host) 1777f917a8dSShawn Guo { 1787f917a8dSShawn Guo return host->devtype == IMX31_MMC; 1797f917a8dSShawn Guo } 1807f917a8dSShawn Guo 181c7ceab02SAnatolij Gustschin static inline int is_mpc512x_mmc(struct mxcmci_host *host) 182c7ceab02SAnatolij Gustschin { 183c7ceab02SAnatolij Gustschin return host->devtype == MPC512X_MMC; 184c7ceab02SAnatolij Gustschin } 185c7ceab02SAnatolij Gustschin 186c7ceab02SAnatolij Gustschin static inline u32 mxcmci_readl(struct mxcmci_host *host, int reg) 187c7ceab02SAnatolij Gustschin { 188c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 189c7ceab02SAnatolij Gustschin return ioread32be(host->base + reg); 190c7ceab02SAnatolij Gustschin else 191c7ceab02SAnatolij Gustschin return readl(host->base + reg); 192c7ceab02SAnatolij Gustschin } 193c7ceab02SAnatolij Gustschin 194c7ceab02SAnatolij Gustschin static inline void mxcmci_writel(struct mxcmci_host *host, u32 val, int reg) 195c7ceab02SAnatolij Gustschin { 196c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 197c7ceab02SAnatolij Gustschin iowrite32be(val, host->base + reg); 198c7ceab02SAnatolij Gustschin else 199c7ceab02SAnatolij Gustschin writel(val, host->base + reg); 200c7ceab02SAnatolij Gustschin } 201c7ceab02SAnatolij Gustschin 202c7ceab02SAnatolij Gustschin static inline u16 mxcmci_readw(struct mxcmci_host *host, int reg) 203c7ceab02SAnatolij Gustschin { 204c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 205c7ceab02SAnatolij Gustschin return ioread32be(host->base + reg); 206c7ceab02SAnatolij Gustschin else 207c7ceab02SAnatolij Gustschin return readw(host->base + reg); 208c7ceab02SAnatolij Gustschin } 209c7ceab02SAnatolij Gustschin 210c7ceab02SAnatolij Gustschin static inline void mxcmci_writew(struct mxcmci_host *host, u16 val, int reg) 211c7ceab02SAnatolij Gustschin { 212c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 213c7ceab02SAnatolij Gustschin iowrite32be(val, host->base + reg); 214c7ceab02SAnatolij Gustschin else 215c7ceab02SAnatolij Gustschin writew(val, host->base + reg); 216c7ceab02SAnatolij Gustschin } 217c7ceab02SAnatolij Gustschin 21818489fa2SMartin Fuzzey static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios); 21918489fa2SMartin Fuzzey 220bc3c1771SAlexander Shiyan static void mxcmci_set_power(struct mxcmci_host *host, unsigned int vdd) 22174b66954SAlberto Panizzo { 222bc3c1771SAlexander Shiyan if (!IS_ERR(host->mmc->supply.vmmc)) { 223bc3c1771SAlexander Shiyan if (host->power_mode == MMC_POWER_UP) 224bc3c1771SAlexander Shiyan mmc_regulator_set_ocr(host->mmc, 225bc3c1771SAlexander Shiyan host->mmc->supply.vmmc, vdd); 226bc3c1771SAlexander Shiyan else if (host->power_mode == MMC_POWER_OFF) 227bc3c1771SAlexander Shiyan mmc_regulator_set_ocr(host->mmc, 228bc3c1771SAlexander Shiyan host->mmc->supply.vmmc, 0); 229d078d242SAlberto Panizzo } 230d078d242SAlberto Panizzo 23174b66954SAlberto Panizzo if (host->pdata && host->pdata->setpower) 23274b66954SAlberto Panizzo host->pdata->setpower(mmc_dev(host->mmc), vdd); 23374b66954SAlberto Panizzo } 23474b66954SAlberto Panizzo 235d96be879SSascha Hauer static inline int mxcmci_use_dma(struct mxcmci_host *host) 236d96be879SSascha Hauer { 237d96be879SSascha Hauer return host->do_dma; 238d96be879SSascha Hauer } 239d96be879SSascha Hauer 240d96be879SSascha Hauer static void mxcmci_softreset(struct mxcmci_host *host) 241d96be879SSascha Hauer { 242d96be879SSascha Hauer int i; 243d96be879SSascha Hauer 2444725f6f1SDaniel Mack dev_dbg(mmc_dev(host->mmc), "mxcmci_softreset\n"); 2454725f6f1SDaniel Mack 246d96be879SSascha Hauer /* reset sequence */ 247c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_RESET, MMC_REG_STR_STP_CLK); 248c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_RESET | STR_STP_CLK_START_CLK, 249c7ceab02SAnatolij Gustschin MMC_REG_STR_STP_CLK); 250d96be879SSascha Hauer 251d96be879SSascha Hauer for (i = 0; i < 8; i++) 252c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_START_CLK, MMC_REG_STR_STP_CLK); 253d96be879SSascha Hauer 254c7ceab02SAnatolij Gustschin mxcmci_writew(host, 0xff, MMC_REG_RES_TO); 255d96be879SSascha Hauer } 256d96be879SSascha Hauer 257e48fc15aSAnatolij Gustschin #if IS_ENABLED(CONFIG_PPC_MPC512x) 258e48fc15aSAnatolij Gustschin static inline void buffer_swap32(u32 *buf, int len) 259e48fc15aSAnatolij Gustschin { 260e48fc15aSAnatolij Gustschin int i; 261e48fc15aSAnatolij Gustschin 262e48fc15aSAnatolij Gustschin for (i = 0; i < ((len + 3) / 4); i++) { 2637a8bf874SDavid Gibson *buf = swab32(*buf); 264e48fc15aSAnatolij Gustschin buf++; 265e48fc15aSAnatolij Gustschin } 266e48fc15aSAnatolij Gustschin } 267e48fc15aSAnatolij Gustschin 268e48fc15aSAnatolij Gustschin static void mxcmci_swap_buffers(struct mmc_data *data) 269e48fc15aSAnatolij Gustschin { 270e48fc15aSAnatolij Gustschin struct scatterlist *sg; 271e48fc15aSAnatolij Gustschin int i; 272e48fc15aSAnatolij Gustschin 2732b77158fSAlexander Shiyan for_each_sg(data->sg, sg, data->sg_len, i) 2742b77158fSAlexander Shiyan buffer_swap32(sg_virt(sg), sg->length); 2753b1074bfSKees Cook } 276e48fc15aSAnatolij Gustschin #else 277e48fc15aSAnatolij Gustschin static inline void mxcmci_swap_buffers(struct mmc_data *data) {} 278e48fc15aSAnatolij Gustschin #endif 279e48fc15aSAnatolij Gustschin 280656217d2SMartin Fuzzey static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data) 281d96be879SSascha Hauer { 282d96be879SSascha Hauer unsigned int nob = data->blocks; 283d96be879SSascha Hauer unsigned int blksz = data->blksz; 284d96be879SSascha Hauer unsigned int datasize = nob * blksz; 285d96be879SSascha Hauer struct scatterlist *sg; 28605f5799cSVinod Koul enum dma_transfer_direction slave_dirn; 287f53fbde4SSascha Hauer int i, nents; 288f53fbde4SSascha Hauer 289d96be879SSascha Hauer host->data = data; 290d96be879SSascha Hauer data->bytes_xfered = 0; 291d96be879SSascha Hauer 292c7ceab02SAnatolij Gustschin mxcmci_writew(host, nob, MMC_REG_NOB); 293c7ceab02SAnatolij Gustschin mxcmci_writew(host, blksz, MMC_REG_BLK_LEN); 294d96be879SSascha Hauer host->datasize = datasize; 295d96be879SSascha Hauer 296f53fbde4SSascha Hauer if (!mxcmci_use_dma(host)) 297f53fbde4SSascha Hauer return 0; 298f53fbde4SSascha Hauer 299d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 3002cb53552SJavier Martin if (sg->offset & 3 || sg->length & 3 || sg->length < 512) { 301d96be879SSascha Hauer host->do_dma = 0; 302656217d2SMartin Fuzzey return 0; 303d96be879SSascha Hauer } 304d96be879SSascha Hauer } 305d96be879SSascha Hauer 30605f5799cSVinod Koul if (data->flags & MMC_DATA_READ) { 307d96be879SSascha Hauer host->dma_dir = DMA_FROM_DEVICE; 30805f5799cSVinod Koul slave_dirn = DMA_DEV_TO_MEM; 30905f5799cSVinod Koul } else { 310d96be879SSascha Hauer host->dma_dir = DMA_TO_DEVICE; 31105f5799cSVinod Koul slave_dirn = DMA_MEM_TO_DEV; 312e48fc15aSAnatolij Gustschin 313e48fc15aSAnatolij Gustschin mxcmci_swap_buffers(data); 31405f5799cSVinod Koul } 315f53fbde4SSascha Hauer 316f53fbde4SSascha Hauer nents = dma_map_sg(host->dma->device->dev, data->sg, 317d96be879SSascha Hauer data->sg_len, host->dma_dir); 318f53fbde4SSascha Hauer if (nents != data->sg_len) 319f53fbde4SSascha Hauer return -EINVAL; 320d96be879SSascha Hauer 32116052827SAlexandre Bounine host->desc = dmaengine_prep_slave_sg(host->dma, 32205f5799cSVinod Koul data->sg, data->sg_len, slave_dirn, 323f53fbde4SSascha Hauer DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 324d96be879SSascha Hauer 325f53fbde4SSascha Hauer if (!host->desc) { 326f53fbde4SSascha Hauer dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len, 327f53fbde4SSascha Hauer host->dma_dir); 328f53fbde4SSascha Hauer host->do_dma = 0; 329f53fbde4SSascha Hauer return 0; /* Fall back to PIO */ 330656217d2SMartin Fuzzey } 331d96be879SSascha Hauer wmb(); 332d96be879SSascha Hauer 333f53fbde4SSascha Hauer dmaengine_submit(host->desc); 334439aa0efSSascha Hauer dma_async_issue_pending(host->dma); 335f53fbde4SSascha Hauer 336f6ad0a48SJavier Martin mod_timer(&host->watchdog, jiffies + msecs_to_jiffies(MXCMCI_TIMEOUT_MS)); 337f6ad0a48SJavier Martin 338656217d2SMartin Fuzzey return 0; 339d96be879SSascha Hauer } 340d96be879SSascha Hauer 341f6ad0a48SJavier Martin static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat); 342f6ad0a48SJavier Martin static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat); 343f6ad0a48SJavier Martin 344f6ad0a48SJavier Martin static void mxcmci_dma_callback(void *data) 345f6ad0a48SJavier Martin { 346f6ad0a48SJavier Martin struct mxcmci_host *host = data; 347f6ad0a48SJavier Martin u32 stat; 348f6ad0a48SJavier Martin 349f6ad0a48SJavier Martin del_timer(&host->watchdog); 350f6ad0a48SJavier Martin 351c7ceab02SAnatolij Gustschin stat = mxcmci_readl(host, MMC_REG_STATUS); 352f6ad0a48SJavier Martin 353f6ad0a48SJavier Martin dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat); 354f6ad0a48SJavier Martin 355f6ad0a48SJavier Martin mxcmci_data_done(host, stat); 356f6ad0a48SJavier Martin } 357f6ad0a48SJavier Martin 358d96be879SSascha Hauer static int mxcmci_start_cmd(struct mxcmci_host *host, struct mmc_command *cmd, 359d96be879SSascha Hauer unsigned int cmdat) 360d96be879SSascha Hauer { 36116b3bf8cSEric Bénard u32 int_cntr = host->default_irq_mask; 362f441b993SDaniel Mack unsigned long flags; 363f441b993SDaniel Mack 364d96be879SSascha Hauer WARN_ON(host->cmd != NULL); 365d96be879SSascha Hauer host->cmd = cmd; 366d96be879SSascha Hauer 367d96be879SSascha Hauer switch (mmc_resp_type(cmd)) { 368d96be879SSascha Hauer case MMC_RSP_R1: /* short CRC, OPCODE */ 369d96be879SSascha Hauer case MMC_RSP_R1B:/* short CRC, OPCODE, BUSY */ 370d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_48BIT_CRC; 371d96be879SSascha Hauer break; 372d96be879SSascha Hauer case MMC_RSP_R2: /* long 136 bit + CRC */ 373d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_136BIT; 374d96be879SSascha Hauer break; 375d96be879SSascha Hauer case MMC_RSP_R3: /* short */ 376d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_48BIT; 377d96be879SSascha Hauer break; 378d96be879SSascha Hauer case MMC_RSP_NONE: 379d96be879SSascha Hauer break; 380d96be879SSascha Hauer default: 381d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "unhandled response type 0x%x\n", 382d96be879SSascha Hauer mmc_resp_type(cmd)); 383d96be879SSascha Hauer cmd->error = -EINVAL; 384d96be879SSascha Hauer return -EINVAL; 385d96be879SSascha Hauer } 386d96be879SSascha Hauer 387f441b993SDaniel Mack int_cntr = INT_END_CMD_RES_EN; 388f441b993SDaniel Mack 389f6ad0a48SJavier Martin if (mxcmci_use_dma(host)) { 390f6ad0a48SJavier Martin if (host->dma_dir == DMA_FROM_DEVICE) { 391f6ad0a48SJavier Martin host->desc->callback = mxcmci_dma_callback; 392f6ad0a48SJavier Martin host->desc->callback_param = host; 393f6ad0a48SJavier Martin } else { 394f6ad0a48SJavier Martin int_cntr |= INT_WRITE_OP_DONE_EN; 395f6ad0a48SJavier Martin } 396f6ad0a48SJavier Martin } 397f441b993SDaniel Mack 398f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 399f441b993SDaniel Mack if (host->use_sdio) 400f441b993SDaniel Mack int_cntr |= INT_SDIO_IRQ_EN; 401c7ceab02SAnatolij Gustschin mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 402f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 403d96be879SSascha Hauer 404c7ceab02SAnatolij Gustschin mxcmci_writew(host, cmd->opcode, MMC_REG_CMD); 405c7ceab02SAnatolij Gustschin mxcmci_writel(host, cmd->arg, MMC_REG_ARG); 406c7ceab02SAnatolij Gustschin mxcmci_writew(host, cmdat, MMC_REG_CMD_DAT_CONT); 407d96be879SSascha Hauer 408d96be879SSascha Hauer return 0; 409d96be879SSascha Hauer } 410d96be879SSascha Hauer 411d96be879SSascha Hauer static void mxcmci_finish_request(struct mxcmci_host *host, 412d96be879SSascha Hauer struct mmc_request *req) 413d96be879SSascha Hauer { 41416b3bf8cSEric Bénard u32 int_cntr = host->default_irq_mask; 415f441b993SDaniel Mack unsigned long flags; 416f441b993SDaniel Mack 417f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 418f441b993SDaniel Mack if (host->use_sdio) 419f441b993SDaniel Mack int_cntr |= INT_SDIO_IRQ_EN; 420c7ceab02SAnatolij Gustschin mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 421f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 422d96be879SSascha Hauer 423d96be879SSascha Hauer host->req = NULL; 424d96be879SSascha Hauer host->cmd = NULL; 425d96be879SSascha Hauer host->data = NULL; 426d96be879SSascha Hauer 427d96be879SSascha Hauer mmc_request_done(host->mmc, req); 428d96be879SSascha Hauer } 429d96be879SSascha Hauer 430d96be879SSascha Hauer static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat) 431d96be879SSascha Hauer { 432d96be879SSascha Hauer struct mmc_data *data = host->data; 433d96be879SSascha Hauer int data_error; 434d96be879SSascha Hauer 435e48fc15aSAnatolij Gustschin if (mxcmci_use_dma(host)) { 436f53fbde4SSascha Hauer dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len, 437d96be879SSascha Hauer host->dma_dir); 438e48fc15aSAnatolij Gustschin mxcmci_swap_buffers(data); 439e48fc15aSAnatolij Gustschin } 440d96be879SSascha Hauer 441d96be879SSascha Hauer if (stat & STATUS_ERR_MASK) { 442d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n", 443d96be879SSascha Hauer stat); 444d96be879SSascha Hauer if (stat & STATUS_CRC_READ_ERR) { 4454725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), "%s: -EILSEQ\n", __func__); 446d96be879SSascha Hauer data->error = -EILSEQ; 447d96be879SSascha Hauer } else if (stat & STATUS_CRC_WRITE_ERR) { 448d96be879SSascha Hauer u32 err_code = (stat >> 9) & 0x3; 4494725f6f1SDaniel Mack if (err_code == 2) { /* No CRC response */ 4504725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), 4514725f6f1SDaniel Mack "%s: No CRC -ETIMEDOUT\n", __func__); 452d96be879SSascha Hauer data->error = -ETIMEDOUT; 453d96be879SSascha Hauer } else { 4544725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), 4554725f6f1SDaniel Mack "%s: -EILSEQ\n", __func__); 4564725f6f1SDaniel Mack data->error = -EILSEQ; 4574725f6f1SDaniel Mack } 4584725f6f1SDaniel Mack } else if (stat & STATUS_TIME_OUT_READ) { 4594725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), 4604725f6f1SDaniel Mack "%s: read -ETIMEDOUT\n", __func__); 4614725f6f1SDaniel Mack data->error = -ETIMEDOUT; 4624725f6f1SDaniel Mack } else { 4634725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), "%s: -EIO\n", __func__); 464d96be879SSascha Hauer data->error = -EIO; 465d96be879SSascha Hauer } 466d96be879SSascha Hauer } else { 467d96be879SSascha Hauer data->bytes_xfered = host->datasize; 468d96be879SSascha Hauer } 469d96be879SSascha Hauer 470d96be879SSascha Hauer data_error = data->error; 471d96be879SSascha Hauer 472d96be879SSascha Hauer host->data = NULL; 473d96be879SSascha Hauer 474d96be879SSascha Hauer return data_error; 475d96be879SSascha Hauer } 476d96be879SSascha Hauer 477d96be879SSascha Hauer static void mxcmci_read_response(struct mxcmci_host *host, unsigned int stat) 478d96be879SSascha Hauer { 479d96be879SSascha Hauer struct mmc_command *cmd = host->cmd; 480d96be879SSascha Hauer int i; 481d96be879SSascha Hauer u32 a, b, c; 482d96be879SSascha Hauer 483d96be879SSascha Hauer if (!cmd) 484d96be879SSascha Hauer return; 485d96be879SSascha Hauer 486d96be879SSascha Hauer if (stat & STATUS_TIME_OUT_RESP) { 487d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "CMD TIMEOUT\n"); 488d96be879SSascha Hauer cmd->error = -ETIMEDOUT; 489d96be879SSascha Hauer } else if (stat & STATUS_RESP_CRC_ERR && cmd->flags & MMC_RSP_CRC) { 490d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "cmd crc error\n"); 491d96be879SSascha Hauer cmd->error = -EILSEQ; 492d96be879SSascha Hauer } 493d96be879SSascha Hauer 494d96be879SSascha Hauer if (cmd->flags & MMC_RSP_PRESENT) { 495d96be879SSascha Hauer if (cmd->flags & MMC_RSP_136) { 496d96be879SSascha Hauer for (i = 0; i < 4; i++) { 497c7ceab02SAnatolij Gustschin a = mxcmci_readw(host, MMC_REG_RES_FIFO); 498c7ceab02SAnatolij Gustschin b = mxcmci_readw(host, MMC_REG_RES_FIFO); 499d96be879SSascha Hauer cmd->resp[i] = a << 16 | b; 500d96be879SSascha Hauer } 501d96be879SSascha Hauer } else { 502c7ceab02SAnatolij Gustschin a = mxcmci_readw(host, MMC_REG_RES_FIFO); 503c7ceab02SAnatolij Gustschin b = mxcmci_readw(host, MMC_REG_RES_FIFO); 504c7ceab02SAnatolij Gustschin c = mxcmci_readw(host, MMC_REG_RES_FIFO); 505d96be879SSascha Hauer cmd->resp[0] = a << 24 | b << 8 | c >> 8; 506d96be879SSascha Hauer } 507d96be879SSascha Hauer } 508d96be879SSascha Hauer } 509d96be879SSascha Hauer 510d96be879SSascha Hauer static int mxcmci_poll_status(struct mxcmci_host *host, u32 mask) 511d96be879SSascha Hauer { 512d96be879SSascha Hauer u32 stat; 513d96be879SSascha Hauer unsigned long timeout = jiffies + HZ; 514d96be879SSascha Hauer 515d96be879SSascha Hauer do { 516c7ceab02SAnatolij Gustschin stat = mxcmci_readl(host, MMC_REG_STATUS); 517d96be879SSascha Hauer if (stat & STATUS_ERR_MASK) 518d96be879SSascha Hauer return stat; 51918489fa2SMartin Fuzzey if (time_after(jiffies, timeout)) { 52018489fa2SMartin Fuzzey mxcmci_softreset(host); 52118489fa2SMartin Fuzzey mxcmci_set_clk_rate(host, host->clock); 522d96be879SSascha Hauer return STATUS_TIME_OUT_READ; 52318489fa2SMartin Fuzzey } 524d96be879SSascha Hauer if (stat & mask) 525d96be879SSascha Hauer return 0; 526d96be879SSascha Hauer cpu_relax(); 527d96be879SSascha Hauer } while (1); 528d96be879SSascha Hauer } 529d96be879SSascha Hauer 530d96be879SSascha Hauer static int mxcmci_pull(struct mxcmci_host *host, void *_buf, int bytes) 531d96be879SSascha Hauer { 532d96be879SSascha Hauer unsigned int stat; 533d96be879SSascha Hauer u32 *buf = _buf; 534d96be879SSascha Hauer 535d96be879SSascha Hauer while (bytes > 3) { 536d96be879SSascha Hauer stat = mxcmci_poll_status(host, 537d96be879SSascha Hauer STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 538d96be879SSascha Hauer if (stat) 539d96be879SSascha Hauer return stat; 540c7ceab02SAnatolij Gustschin *buf++ = cpu_to_le32(mxcmci_readl(host, MMC_REG_BUFFER_ACCESS)); 541d96be879SSascha Hauer bytes -= 4; 542d96be879SSascha Hauer } 543d96be879SSascha Hauer 544d96be879SSascha Hauer if (bytes) { 545d96be879SSascha Hauer u8 *b = (u8 *)buf; 546d96be879SSascha Hauer u32 tmp; 547d96be879SSascha Hauer 548d96be879SSascha Hauer stat = mxcmci_poll_status(host, 549d96be879SSascha Hauer STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 550d96be879SSascha Hauer if (stat) 551d96be879SSascha Hauer return stat; 552c7ceab02SAnatolij Gustschin tmp = cpu_to_le32(mxcmci_readl(host, MMC_REG_BUFFER_ACCESS)); 553d96be879SSascha Hauer memcpy(b, &tmp, bytes); 554d96be879SSascha Hauer } 555d96be879SSascha Hauer 556d96be879SSascha Hauer return 0; 557d96be879SSascha Hauer } 558d96be879SSascha Hauer 559d96be879SSascha Hauer static int mxcmci_push(struct mxcmci_host *host, void *_buf, int bytes) 560d96be879SSascha Hauer { 561d96be879SSascha Hauer unsigned int stat; 562d96be879SSascha Hauer u32 *buf = _buf; 563d96be879SSascha Hauer 564d96be879SSascha Hauer while (bytes > 3) { 565d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 566d96be879SSascha Hauer if (stat) 567d96be879SSascha Hauer return stat; 568c7ceab02SAnatolij Gustschin mxcmci_writel(host, cpu_to_le32(*buf++), MMC_REG_BUFFER_ACCESS); 569d96be879SSascha Hauer bytes -= 4; 570d96be879SSascha Hauer } 571d96be879SSascha Hauer 572d96be879SSascha Hauer if (bytes) { 573d96be879SSascha Hauer u8 *b = (u8 *)buf; 574d96be879SSascha Hauer u32 tmp; 575d96be879SSascha Hauer 576d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 577d96be879SSascha Hauer if (stat) 578d96be879SSascha Hauer return stat; 579d96be879SSascha Hauer 580d96be879SSascha Hauer memcpy(&tmp, b, bytes); 581c7ceab02SAnatolij Gustschin mxcmci_writel(host, cpu_to_le32(tmp), MMC_REG_BUFFER_ACCESS); 582d96be879SSascha Hauer } 583d96be879SSascha Hauer 5846d916416SFabio Estevam return mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 585d96be879SSascha Hauer } 586d96be879SSascha Hauer 587d96be879SSascha Hauer static int mxcmci_transfer_data(struct mxcmci_host *host) 588d96be879SSascha Hauer { 589d96be879SSascha Hauer struct mmc_data *data = host->req->data; 590d96be879SSascha Hauer struct scatterlist *sg; 591d96be879SSascha Hauer int stat, i; 592d96be879SSascha Hauer 593d96be879SSascha Hauer host->data = data; 594d96be879SSascha Hauer host->datasize = 0; 595d96be879SSascha Hauer 596d96be879SSascha Hauer if (data->flags & MMC_DATA_READ) { 597d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 5982b77158fSAlexander Shiyan stat = mxcmci_pull(host, sg_virt(sg), sg->length); 599d96be879SSascha Hauer if (stat) 600d96be879SSascha Hauer return stat; 601d96be879SSascha Hauer host->datasize += sg->length; 602d96be879SSascha Hauer } 603d96be879SSascha Hauer } else { 604d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 6052b77158fSAlexander Shiyan stat = mxcmci_push(host, sg_virt(sg), sg->length); 606d96be879SSascha Hauer if (stat) 607d96be879SSascha Hauer return stat; 608d96be879SSascha Hauer host->datasize += sg->length; 609d96be879SSascha Hauer } 610d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_WRITE_OP_DONE); 611d96be879SSascha Hauer if (stat) 612d96be879SSascha Hauer return stat; 613d96be879SSascha Hauer } 614d96be879SSascha Hauer return 0; 615d96be879SSascha Hauer } 616d96be879SSascha Hauer 617d96be879SSascha Hauer static void mxcmci_datawork(struct work_struct *work) 618d96be879SSascha Hauer { 619d96be879SSascha Hauer struct mxcmci_host *host = container_of(work, struct mxcmci_host, 620d96be879SSascha Hauer datawork); 621d96be879SSascha Hauer int datastat = mxcmci_transfer_data(host); 6224a31f2efSDaniel Mack 623c7ceab02SAnatolij Gustschin mxcmci_writel(host, STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE, 624c7ceab02SAnatolij Gustschin MMC_REG_STATUS); 625d96be879SSascha Hauer mxcmci_finish_data(host, datastat); 626d96be879SSascha Hauer 627d96be879SSascha Hauer if (host->req->stop) { 628d96be879SSascha Hauer if (mxcmci_start_cmd(host, host->req->stop, 0)) { 629d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 630d96be879SSascha Hauer return; 631d96be879SSascha Hauer } 632d96be879SSascha Hauer } else { 633d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 634d96be879SSascha Hauer } 635d96be879SSascha Hauer } 636d96be879SSascha Hauer 637d96be879SSascha Hauer static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat) 638d96be879SSascha Hauer { 63970aa6109SAnatolij Gustschin struct mmc_request *req; 640d96be879SSascha Hauer int data_error; 64170aa6109SAnatolij Gustschin unsigned long flags; 642d96be879SSascha Hauer 64370aa6109SAnatolij Gustschin spin_lock_irqsave(&host->lock, flags); 64470aa6109SAnatolij Gustschin 64570aa6109SAnatolij Gustschin if (!host->data) { 64670aa6109SAnatolij Gustschin spin_unlock_irqrestore(&host->lock, flags); 647d96be879SSascha Hauer return; 64870aa6109SAnatolij Gustschin } 64970aa6109SAnatolij Gustschin 65070aa6109SAnatolij Gustschin if (!host->req) { 65170aa6109SAnatolij Gustschin spin_unlock_irqrestore(&host->lock, flags); 65270aa6109SAnatolij Gustschin return; 65370aa6109SAnatolij Gustschin } 65470aa6109SAnatolij Gustschin 65570aa6109SAnatolij Gustschin req = host->req; 65670aa6109SAnatolij Gustschin if (!req->stop) 65770aa6109SAnatolij Gustschin host->req = NULL; /* we will handle finish req below */ 658d96be879SSascha Hauer 659d96be879SSascha Hauer data_error = mxcmci_finish_data(host, stat); 660d96be879SSascha Hauer 66170aa6109SAnatolij Gustschin spin_unlock_irqrestore(&host->lock, flags); 66270aa6109SAnatolij Gustschin 66309954ea9SShawn Lin if (data_error) 66409954ea9SShawn Lin return; 66509954ea9SShawn Lin 666d96be879SSascha Hauer mxcmci_read_response(host, stat); 667d96be879SSascha Hauer host->cmd = NULL; 668d96be879SSascha Hauer 66970aa6109SAnatolij Gustschin if (req->stop) { 67070aa6109SAnatolij Gustschin if (mxcmci_start_cmd(host, req->stop, 0)) { 67170aa6109SAnatolij Gustschin mxcmci_finish_request(host, req); 672d96be879SSascha Hauer return; 673d96be879SSascha Hauer } 674d96be879SSascha Hauer } else { 67570aa6109SAnatolij Gustschin mxcmci_finish_request(host, req); 676d96be879SSascha Hauer } 677d96be879SSascha Hauer } 678d96be879SSascha Hauer 679d96be879SSascha Hauer static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat) 680d96be879SSascha Hauer { 681d96be879SSascha Hauer mxcmci_read_response(host, stat); 682d96be879SSascha Hauer host->cmd = NULL; 683d96be879SSascha Hauer 684d96be879SSascha Hauer if (!host->data && host->req) { 685d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 686d96be879SSascha Hauer return; 687d96be879SSascha Hauer } 688d96be879SSascha Hauer 689d96be879SSascha Hauer /* For the DMA case the DMA engine handles the data transfer 690fd589a8fSAnand Gadiyar * automatically. For non DMA we have to do it ourselves. 691d96be879SSascha Hauer * Don't do it in interrupt context though. 692d96be879SSascha Hauer */ 693d96be879SSascha Hauer if (!mxcmci_use_dma(host) && host->data) 694d96be879SSascha Hauer schedule_work(&host->datawork); 695d96be879SSascha Hauer 696d96be879SSascha Hauer } 697d96be879SSascha Hauer 698d96be879SSascha Hauer static irqreturn_t mxcmci_irq(int irq, void *devid) 699d96be879SSascha Hauer { 700d96be879SSascha Hauer struct mxcmci_host *host = devid; 701f441b993SDaniel Mack bool sdio_irq; 702d96be879SSascha Hauer u32 stat; 703d96be879SSascha Hauer 704c7ceab02SAnatolij Gustschin stat = mxcmci_readl(host, MMC_REG_STATUS); 705c7ceab02SAnatolij Gustschin mxcmci_writel(host, 706c7ceab02SAnatolij Gustschin stat & ~(STATUS_SDIO_INT_ACTIVE | STATUS_DATA_TRANS_DONE | 707c7ceab02SAnatolij Gustschin STATUS_WRITE_OP_DONE), 708c7ceab02SAnatolij Gustschin MMC_REG_STATUS); 709d96be879SSascha Hauer 710d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat); 711d96be879SSascha Hauer 7125a941898Sjun qian spin_lock(&host->lock); 713f441b993SDaniel Mack sdio_irq = (stat & STATUS_SDIO_INT_ACTIVE) && host->use_sdio; 7145a941898Sjun qian spin_unlock(&host->lock); 715f441b993SDaniel Mack 716adfa5703SMatteo Facchinetti if (mxcmci_use_dma(host) && (stat & (STATUS_WRITE_OP_DONE))) 717adfa5703SMatteo Facchinetti mxcmci_writel(host, STATUS_WRITE_OP_DONE, MMC_REG_STATUS); 7184a31f2efSDaniel Mack 719f441b993SDaniel Mack if (sdio_irq) { 720c7ceab02SAnatolij Gustschin mxcmci_writel(host, STATUS_SDIO_INT_ACTIVE, MMC_REG_STATUS); 721f441b993SDaniel Mack mmc_signal_sdio_irq(host->mmc); 722f441b993SDaniel Mack } 723f441b993SDaniel Mack 724d96be879SSascha Hauer if (stat & STATUS_END_CMD_RESP) 725d96be879SSascha Hauer mxcmci_cmd_done(host, stat); 726f441b993SDaniel Mack 727adfa5703SMatteo Facchinetti if (mxcmci_use_dma(host) && (stat & STATUS_WRITE_OP_DONE)) { 728f6ad0a48SJavier Martin del_timer(&host->watchdog); 729d96be879SSascha Hauer mxcmci_data_done(host, stat); 730f6ad0a48SJavier Martin } 731f53fbde4SSascha Hauer 73216b3bf8cSEric Bénard if (host->default_irq_mask && 73316b3bf8cSEric Bénard (stat & (STATUS_CARD_INSERTION | STATUS_CARD_REMOVAL))) 73416b3bf8cSEric Bénard mmc_detect_change(host->mmc, msecs_to_jiffies(200)); 735f53fbde4SSascha Hauer 736d96be879SSascha Hauer return IRQ_HANDLED; 737d96be879SSascha Hauer } 738d96be879SSascha Hauer 739d96be879SSascha Hauer static void mxcmci_request(struct mmc_host *mmc, struct mmc_request *req) 740d96be879SSascha Hauer { 741d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 742d96be879SSascha Hauer unsigned int cmdat = host->cmdat; 743656217d2SMartin Fuzzey int error; 744d96be879SSascha Hauer 745d96be879SSascha Hauer WARN_ON(host->req != NULL); 746d96be879SSascha Hauer 747d96be879SSascha Hauer host->req = req; 748d96be879SSascha Hauer host->cmdat &= ~CMD_DAT_CONT_INIT; 749f53fbde4SSascha Hauer 750f53fbde4SSascha Hauer if (host->dma) 751d96be879SSascha Hauer host->do_dma = 1; 752f53fbde4SSascha Hauer 753d96be879SSascha Hauer if (req->data) { 754656217d2SMartin Fuzzey error = mxcmci_setup_data(host, req->data); 755656217d2SMartin Fuzzey if (error) { 756656217d2SMartin Fuzzey req->cmd->error = error; 757656217d2SMartin Fuzzey goto out; 758656217d2SMartin Fuzzey } 759656217d2SMartin Fuzzey 760d96be879SSascha Hauer 761d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_DATA_ENABLE; 762d96be879SSascha Hauer 763d96be879SSascha Hauer if (req->data->flags & MMC_DATA_WRITE) 764d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_WRITE; 765d96be879SSascha Hauer } 766d96be879SSascha Hauer 767656217d2SMartin Fuzzey error = mxcmci_start_cmd(host, req->cmd, cmdat); 768f53fbde4SSascha Hauer 769656217d2SMartin Fuzzey out: 770656217d2SMartin Fuzzey if (error) 771d96be879SSascha Hauer mxcmci_finish_request(host, req); 772d96be879SSascha Hauer } 773d96be879SSascha Hauer 774d96be879SSascha Hauer static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios) 775d96be879SSascha Hauer { 776d96be879SSascha Hauer unsigned int divider; 777d96be879SSascha Hauer int prescaler = 0; 778529aa29eSSascha Hauer unsigned int clk_in = clk_get_rate(host->clk_per); 779d96be879SSascha Hauer 780d96be879SSascha Hauer while (prescaler <= 0x800) { 781d96be879SSascha Hauer for (divider = 1; divider <= 0xF; divider++) { 782d96be879SSascha Hauer int x; 783d96be879SSascha Hauer 784d96be879SSascha Hauer x = (clk_in / (divider + 1)); 785d96be879SSascha Hauer 786d96be879SSascha Hauer if (prescaler) 787d96be879SSascha Hauer x /= (prescaler * 2); 788d96be879SSascha Hauer 789d96be879SSascha Hauer if (x <= clk_ios) 790d96be879SSascha Hauer break; 791d96be879SSascha Hauer } 792d96be879SSascha Hauer if (divider < 0x10) 793d96be879SSascha Hauer break; 794d96be879SSascha Hauer 795d96be879SSascha Hauer if (prescaler == 0) 796d96be879SSascha Hauer prescaler = 1; 797d96be879SSascha Hauer else 798d96be879SSascha Hauer prescaler <<= 1; 799d96be879SSascha Hauer } 800d96be879SSascha Hauer 801c7ceab02SAnatolij Gustschin mxcmci_writew(host, (prescaler << 4) | divider, MMC_REG_CLK_RATE); 802d96be879SSascha Hauer 803d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "scaler: %d divider: %d in: %d out: %d\n", 804d96be879SSascha Hauer prescaler, divider, clk_in, clk_ios); 805d96be879SSascha Hauer } 806d96be879SSascha Hauer 807f53fbde4SSascha Hauer static int mxcmci_setup_dma(struct mmc_host *mmc) 808f53fbde4SSascha Hauer { 809f53fbde4SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 810f53fbde4SSascha Hauer struct dma_slave_config *config = &host->dma_slave_config; 811f53fbde4SSascha Hauer 81201e4f958SAlexander Shiyan config->dst_addr = host->phys_base + MMC_REG_BUFFER_ACCESS; 81301e4f958SAlexander Shiyan config->src_addr = host->phys_base + MMC_REG_BUFFER_ACCESS; 814f53fbde4SSascha Hauer config->dst_addr_width = 4; 815f53fbde4SSascha Hauer config->src_addr_width = 4; 816f53fbde4SSascha Hauer config->dst_maxburst = host->burstlen; 817f53fbde4SSascha Hauer config->src_maxburst = host->burstlen; 818258aea76SViresh Kumar config->device_fc = false; 819f53fbde4SSascha Hauer 820f53fbde4SSascha Hauer return dmaengine_slave_config(host->dma, config); 821f53fbde4SSascha Hauer } 822f53fbde4SSascha Hauer 823d96be879SSascha Hauer static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 824d96be879SSascha Hauer { 825d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 826f53fbde4SSascha Hauer int burstlen, ret; 827f53fbde4SSascha Hauer 828d96be879SSascha Hauer /* 8296584cb88SSascha Hauer * use burstlen of 64 (16 words) in 4 bit mode (--> reg value 0) 8306584cb88SSascha Hauer * use burstlen of 16 (4 words) in 1 bit mode (--> reg value 16) 831d96be879SSascha Hauer */ 832d96be879SSascha Hauer if (ios->bus_width == MMC_BUS_WIDTH_4) 833f53fbde4SSascha Hauer burstlen = 16; 8346584cb88SSascha Hauer else 8356584cb88SSascha Hauer burstlen = 4; 836d96be879SSascha Hauer 837f53fbde4SSascha Hauer if (mxcmci_use_dma(host) && burstlen != host->burstlen) { 838f53fbde4SSascha Hauer host->burstlen = burstlen; 839f53fbde4SSascha Hauer ret = mxcmci_setup_dma(mmc); 840f53fbde4SSascha Hauer if (ret) { 841f53fbde4SSascha Hauer dev_err(mmc_dev(host->mmc), 842f53fbde4SSascha Hauer "failed to config DMA channel. Falling back to PIO\n"); 843f53fbde4SSascha Hauer dma_release_channel(host->dma); 844f53fbde4SSascha Hauer host->do_dma = 0; 845e58f516fSSascha Hauer host->dma = NULL; 846f53fbde4SSascha Hauer } 847f53fbde4SSascha Hauer } 848f53fbde4SSascha Hauer 849d96be879SSascha Hauer if (ios->bus_width == MMC_BUS_WIDTH_4) 850d96be879SSascha Hauer host->cmdat |= CMD_DAT_CONT_BUS_WIDTH_4; 851d96be879SSascha Hauer else 852d96be879SSascha Hauer host->cmdat &= ~CMD_DAT_CONT_BUS_WIDTH_4; 853d96be879SSascha Hauer 854d96be879SSascha Hauer if (host->power_mode != ios->power_mode) { 855d96be879SSascha Hauer host->power_mode = ios->power_mode; 856bc3c1771SAlexander Shiyan mxcmci_set_power(host, ios->vdd); 85774b66954SAlberto Panizzo 858d96be879SSascha Hauer if (ios->power_mode == MMC_POWER_ON) 859d96be879SSascha Hauer host->cmdat |= CMD_DAT_CONT_INIT; 860d96be879SSascha Hauer } 861d96be879SSascha Hauer 862d96be879SSascha Hauer if (ios->clock) { 863d96be879SSascha Hauer mxcmci_set_clk_rate(host, ios->clock); 864c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_START_CLK, MMC_REG_STR_STP_CLK); 865d96be879SSascha Hauer } else { 866c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_STOP_CLK, MMC_REG_STR_STP_CLK); 867d96be879SSascha Hauer } 868d96be879SSascha Hauer 869d96be879SSascha Hauer host->clock = ios->clock; 870d96be879SSascha Hauer } 871d96be879SSascha Hauer 872d96be879SSascha Hauer static irqreturn_t mxcmci_detect_irq(int irq, void *data) 873d96be879SSascha Hauer { 874d96be879SSascha Hauer struct mmc_host *mmc = data; 875d96be879SSascha Hauer 876d96be879SSascha Hauer dev_dbg(mmc_dev(mmc), "%s\n", __func__); 877d96be879SSascha Hauer 878d96be879SSascha Hauer mmc_detect_change(mmc, msecs_to_jiffies(250)); 879d96be879SSascha Hauer return IRQ_HANDLED; 880d96be879SSascha Hauer } 881d96be879SSascha Hauer 882d96be879SSascha Hauer static int mxcmci_get_ro(struct mmc_host *mmc) 883d96be879SSascha Hauer { 884d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 885d96be879SSascha Hauer 886d96be879SSascha Hauer if (host->pdata && host->pdata->get_ro) 887d96be879SSascha Hauer return !!host->pdata->get_ro(mmc_dev(mmc)); 888d96be879SSascha Hauer /* 889bcf53524SAnatolij Gustschin * If board doesn't support read only detection (no mmc_gpio 890bcf53524SAnatolij Gustschin * context or gpio is invalid), then let the mmc core decide 891bcf53524SAnatolij Gustschin * what to do. 892d96be879SSascha Hauer */ 893bcf53524SAnatolij Gustschin return mmc_gpio_get_ro(mmc); 894d96be879SSascha Hauer } 895d96be879SSascha Hauer 896f441b993SDaniel Mack static void mxcmci_enable_sdio_irq(struct mmc_host *mmc, int enable) 897f441b993SDaniel Mack { 898f441b993SDaniel Mack struct mxcmci_host *host = mmc_priv(mmc); 899f441b993SDaniel Mack unsigned long flags; 900f441b993SDaniel Mack u32 int_cntr; 901f441b993SDaniel Mack 902f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 903f441b993SDaniel Mack host->use_sdio = enable; 904c7ceab02SAnatolij Gustschin int_cntr = mxcmci_readl(host, MMC_REG_INT_CNTR); 905f441b993SDaniel Mack 906f441b993SDaniel Mack if (enable) 907f441b993SDaniel Mack int_cntr |= INT_SDIO_IRQ_EN; 908f441b993SDaniel Mack else 909f441b993SDaniel Mack int_cntr &= ~INT_SDIO_IRQ_EN; 910f441b993SDaniel Mack 911c7ceab02SAnatolij Gustschin mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 912f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 913f441b993SDaniel Mack } 914d96be879SSascha Hauer 9153fcb027dSDaniel Mack static void mxcmci_init_card(struct mmc_host *host, struct mmc_card *card) 9163fcb027dSDaniel Mack { 9177f917a8dSShawn Guo struct mxcmci_host *mxcmci = mmc_priv(host); 9187f917a8dSShawn Guo 9193fcb027dSDaniel Mack /* 9203fcb027dSDaniel Mack * MX3 SoCs have a silicon bug which corrupts CRC calculation of 9213fcb027dSDaniel Mack * multi-block transfers when connected SDIO peripheral doesn't 9223fcb027dSDaniel Mack * drive the BUSY line as required by the specs. 9233fcb027dSDaniel Mack * One way to prevent this is to only allow 1-bit transfers. 9243fcb027dSDaniel Mack */ 9253fcb027dSDaniel Mack 9267f917a8dSShawn Guo if (is_imx31_mmc(mxcmci) && card->type == MMC_TYPE_SDIO) 9273fcb027dSDaniel Mack host->caps &= ~MMC_CAP_4_BIT_DATA; 9283fcb027dSDaniel Mack else 9293fcb027dSDaniel Mack host->caps |= MMC_CAP_4_BIT_DATA; 9303fcb027dSDaniel Mack } 9313fcb027dSDaniel Mack 932f53fbde4SSascha Hauer static bool filter(struct dma_chan *chan, void *param) 933f53fbde4SSascha Hauer { 934f53fbde4SSascha Hauer struct mxcmci_host *host = param; 935f53fbde4SSascha Hauer 936f53fbde4SSascha Hauer if (!imx_dma_is_general_purpose(chan)) 937f53fbde4SSascha Hauer return false; 938f53fbde4SSascha Hauer 939f53fbde4SSascha Hauer chan->private = &host->dma_data; 940f53fbde4SSascha Hauer 941f53fbde4SSascha Hauer return true; 942f53fbde4SSascha Hauer } 943f53fbde4SSascha Hauer 9442ee4f620SKees Cook static void mxcmci_watchdog(struct timer_list *t) 945f6ad0a48SJavier Martin { 9462ee4f620SKees Cook struct mxcmci_host *host = from_timer(host, t, watchdog); 947f6ad0a48SJavier Martin struct mmc_request *req = host->req; 948c7ceab02SAnatolij Gustschin unsigned int stat = mxcmci_readl(host, MMC_REG_STATUS); 949f6ad0a48SJavier Martin 950f6ad0a48SJavier Martin if (host->dma_dir == DMA_FROM_DEVICE) { 951f6ad0a48SJavier Martin dmaengine_terminate_all(host->dma); 952f6ad0a48SJavier Martin dev_err(mmc_dev(host->mmc), 953f6ad0a48SJavier Martin "%s: read time out (status = 0x%08x)\n", 954f6ad0a48SJavier Martin __func__, stat); 955f6ad0a48SJavier Martin } else { 956f6ad0a48SJavier Martin dev_err(mmc_dev(host->mmc), 957f6ad0a48SJavier Martin "%s: write time out (status = 0x%08x)\n", 958f6ad0a48SJavier Martin __func__, stat); 959f6ad0a48SJavier Martin mxcmci_softreset(host); 960f6ad0a48SJavier Martin } 961f6ad0a48SJavier Martin 962f6ad0a48SJavier Martin /* Mark transfer as erroneus and inform the upper layers */ 963f6ad0a48SJavier Martin 96470aa6109SAnatolij Gustschin if (host->data) 965f6ad0a48SJavier Martin host->data->error = -ETIMEDOUT; 966f6ad0a48SJavier Martin host->req = NULL; 967f6ad0a48SJavier Martin host->cmd = NULL; 968f6ad0a48SJavier Martin host->data = NULL; 969f6ad0a48SJavier Martin mmc_request_done(host->mmc, req); 970f6ad0a48SJavier Martin } 971f6ad0a48SJavier Martin 972d96be879SSascha Hauer static const struct mmc_host_ops mxcmci_ops = { 973d96be879SSascha Hauer .request = mxcmci_request, 974d96be879SSascha Hauer .set_ios = mxcmci_set_ios, 975d96be879SSascha Hauer .get_ro = mxcmci_get_ro, 976f441b993SDaniel Mack .enable_sdio_irq = mxcmci_enable_sdio_irq, 9773fcb027dSDaniel Mack .init_card = mxcmci_init_card, 978d96be879SSascha Hauer }; 979d96be879SSascha Hauer 980d96be879SSascha Hauer static int mxcmci_probe(struct platform_device *pdev) 981d96be879SSascha Hauer { 982d96be879SSascha Hauer struct mmc_host *mmc; 98301e4f958SAlexander Shiyan struct mxcmci_host *host; 98401e4f958SAlexander Shiyan struct resource *res; 985d96be879SSascha Hauer int ret = 0, irq; 9867ff747c4SMarkus Pargmann bool dat3_card_detect = false; 987f53fbde4SSascha Hauer dma_cap_mask_t mask; 9887ff747c4SMarkus Pargmann struct imxmmc_platform_data *pdata = pdev->dev.platform_data; 989d96be879SSascha Hauer 990c7ceab02SAnatolij Gustschin pr_info("i.MX/MPC512x SDHC driver\n"); 991d96be879SSascha Hauer 99201e4f958SAlexander Shiyan res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 993d96be879SSascha Hauer irq = platform_get_irq(pdev, 0); 9949a7957d0SStephen Boyd if (irq < 0) 995f216c124SGustavo A. R. Silva return irq; 996d96be879SSascha Hauer 99701e4f958SAlexander Shiyan mmc = mmc_alloc_host(sizeof(*host), &pdev->dev); 99801e4f958SAlexander Shiyan if (!mmc) 99901e4f958SAlexander Shiyan return -ENOMEM; 1000d96be879SSascha Hauer 100101e4f958SAlexander Shiyan host = mmc_priv(mmc); 100201e4f958SAlexander Shiyan 100301e4f958SAlexander Shiyan host->base = devm_ioremap_resource(&pdev->dev, res); 100401e4f958SAlexander Shiyan if (IS_ERR(host->base)) { 100501e4f958SAlexander Shiyan ret = PTR_ERR(host->base); 100601e4f958SAlexander Shiyan goto out_free; 1007d96be879SSascha Hauer } 1008d96be879SSascha Hauer 100901e4f958SAlexander Shiyan host->phys_base = res->start; 101001e4f958SAlexander Shiyan 1011b8857696SSimon Baatz ret = mmc_of_parse(mmc); 1012b8857696SSimon Baatz if (ret) 1013b8857696SSimon Baatz goto out_free; 1014d96be879SSascha Hauer mmc->ops = &mxcmci_ops; 10157ff747c4SMarkus Pargmann 10167ff747c4SMarkus Pargmann /* For devicetree parsing, the bus width is read from devicetree */ 10177ff747c4SMarkus Pargmann if (pdata) 1018f441b993SDaniel Mack mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ; 10197ff747c4SMarkus Pargmann else 10207ff747c4SMarkus Pargmann mmc->caps |= MMC_CAP_SDIO_IRQ; 1021d96be879SSascha Hauer 1022d96be879SSascha Hauer /* MMC core transfer sizes tunable parameters */ 1023d96be879SSascha Hauer mmc->max_blk_size = 2048; 1024d96be879SSascha Hauer mmc->max_blk_count = 65535; 1025d96be879SSascha Hauer mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count; 1026d759c374SVladimir Zapolskiy mmc->max_seg_size = mmc->max_req_size; 1027d96be879SSascha Hauer 10288223e885SFabio Estevam host->devtype = (enum mxcmci_type)of_device_get_match_data(&pdev->dev); 1029e48fc15aSAnatolij Gustschin 1030e48fc15aSAnatolij Gustschin /* adjust max_segs after devtype detection */ 1031e48fc15aSAnatolij Gustschin if (!is_mpc512x_mmc(host)) 1032e48fc15aSAnatolij Gustschin mmc->max_segs = 64; 1033e48fc15aSAnatolij Gustschin 10347ff747c4SMarkus Pargmann host->mmc = mmc; 10357ff747c4SMarkus Pargmann host->pdata = pdata; 1036f441b993SDaniel Mack spin_lock_init(&host->lock); 1037d96be879SSascha Hauer 10387ff747c4SMarkus Pargmann if (pdata) 10397ff747c4SMarkus Pargmann dat3_card_detect = pdata->dat3_card_detect; 1040860951c5SJaehoon Chung else if (mmc_card_is_removable(mmc) 10417ff747c4SMarkus Pargmann && !of_property_read_bool(pdev->dev.of_node, "cd-gpios")) 10427ff747c4SMarkus Pargmann dat3_card_detect = true; 10437ff747c4SMarkus Pargmann 1044bc3c1771SAlexander Shiyan ret = mmc_regulator_get_supply(mmc); 1045337d7c8aSWolfram Sang if (ret) 1046bc3c1771SAlexander Shiyan goto out_free; 104718a09806SMatteo Facchinetti 104818a09806SMatteo Facchinetti if (!mmc->ocr_avail) { 104918a09806SMatteo Facchinetti if (pdata && pdata->ocr_avail) 105018a09806SMatteo Facchinetti mmc->ocr_avail = pdata->ocr_avail; 105118a09806SMatteo Facchinetti else 105218a09806SMatteo Facchinetti mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34; 1053bc3c1771SAlexander Shiyan } 1054d96be879SSascha Hauer 10557ff747c4SMarkus Pargmann if (dat3_card_detect) 105616b3bf8cSEric Bénard host->default_irq_mask = 105716b3bf8cSEric Bénard INT_CARD_INSERTION_EN | INT_CARD_REMOVAL_EN; 105816b3bf8cSEric Bénard else 105916b3bf8cSEric Bénard host->default_irq_mask = 0; 106016b3bf8cSEric Bénard 1061529aa29eSSascha Hauer host->clk_ipg = devm_clk_get(&pdev->dev, "ipg"); 1062529aa29eSSascha Hauer if (IS_ERR(host->clk_ipg)) { 1063529aa29eSSascha Hauer ret = PTR_ERR(host->clk_ipg); 106401e4f958SAlexander Shiyan goto out_free; 1065d96be879SSascha Hauer } 1066529aa29eSSascha Hauer 1067529aa29eSSascha Hauer host->clk_per = devm_clk_get(&pdev->dev, "per"); 1068529aa29eSSascha Hauer if (IS_ERR(host->clk_per)) { 1069529aa29eSSascha Hauer ret = PTR_ERR(host->clk_per); 107001e4f958SAlexander Shiyan goto out_free; 1071529aa29eSSascha Hauer } 1072529aa29eSSascha Hauer 1073a2bc74cfSArvind Yadav ret = clk_prepare_enable(host->clk_per); 1074a2bc74cfSArvind Yadav if (ret) 1075a2bc74cfSArvind Yadav goto out_free; 1076a2bc74cfSArvind Yadav 1077a2bc74cfSArvind Yadav ret = clk_prepare_enable(host->clk_ipg); 1078a2bc74cfSArvind Yadav if (ret) 1079a2bc74cfSArvind Yadav goto out_clk_per_put; 1080d96be879SSascha Hauer 1081d96be879SSascha Hauer mxcmci_softreset(host); 1082d96be879SSascha Hauer 1083c7ceab02SAnatolij Gustschin host->rev_no = mxcmci_readw(host, MMC_REG_REV_NO); 1084d96be879SSascha Hauer if (host->rev_no != 0x400) { 1085d96be879SSascha Hauer ret = -ENODEV; 1086d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "wrong rev.no. 0x%08x. aborting.\n", 1087d96be879SSascha Hauer host->rev_no); 1088d96be879SSascha Hauer goto out_clk_put; 1089d96be879SSascha Hauer } 1090d96be879SSascha Hauer 1091529aa29eSSascha Hauer mmc->f_min = clk_get_rate(host->clk_per) >> 16; 1092529aa29eSSascha Hauer mmc->f_max = clk_get_rate(host->clk_per) >> 1; 1093d96be879SSascha Hauer 1094d96be879SSascha Hauer /* recommended in data sheet */ 1095c7ceab02SAnatolij Gustschin mxcmci_writew(host, 0x2db4, MMC_REG_READ_TO); 1096d96be879SSascha Hauer 1097c7ceab02SAnatolij Gustschin mxcmci_writel(host, host->default_irq_mask, MMC_REG_INT_CNTR); 1098d96be879SSascha Hauer 10997ff747c4SMarkus Pargmann if (!host->pdata) { 1100c3b2a021SPeter Ujfalusi host->dma = dma_request_chan(&pdev->dev, "rx-tx"); 1101c3b2a021SPeter Ujfalusi if (IS_ERR(host->dma)) { 1102c3b2a021SPeter Ujfalusi if (PTR_ERR(host->dma) == -EPROBE_DEFER) { 1103c3b2a021SPeter Ujfalusi ret = -EPROBE_DEFER; 1104c3b2a021SPeter Ujfalusi goto out_clk_put; 1105c3b2a021SPeter Ujfalusi } 1106c3b2a021SPeter Ujfalusi 1107c3b2a021SPeter Ujfalusi /* Ignore errors to fall back to PIO mode */ 1108c3b2a021SPeter Ujfalusi host->dma = NULL; 1109c3b2a021SPeter Ujfalusi } 11107ff747c4SMarkus Pargmann } else { 111101e4f958SAlexander Shiyan res = platform_get_resource(pdev, IORESOURCE_DMA, 0); 111201e4f958SAlexander Shiyan if (res) { 111301e4f958SAlexander Shiyan host->dmareq = res->start; 1114f53fbde4SSascha Hauer host->dma_data.peripheral_type = IMX_DMATYPE_SDHC; 1115f53fbde4SSascha Hauer host->dma_data.priority = DMA_PRIO_LOW; 1116f53fbde4SSascha Hauer host->dma_data.dma_request = host->dmareq; 1117f53fbde4SSascha Hauer dma_cap_zero(mask); 1118f53fbde4SSascha Hauer dma_cap_set(DMA_SLAVE, mask); 1119f53fbde4SSascha Hauer host->dma = dma_request_channel(mask, filter, host); 11207ff747c4SMarkus Pargmann } 11217ff747c4SMarkus Pargmann } 1122f53fbde4SSascha Hauer if (host->dma) 1123f53fbde4SSascha Hauer mmc->max_seg_size = dma_get_max_seg_size( 1124f53fbde4SSascha Hauer host->dma->device->dev); 11257ff747c4SMarkus Pargmann else 1126f53fbde4SSascha Hauer dev_info(mmc_dev(host->mmc), "dma not available. Using PIO\n"); 1127f53fbde4SSascha Hauer 1128d96be879SSascha Hauer INIT_WORK(&host->datawork, mxcmci_datawork); 1129d96be879SSascha Hauer 113001e4f958SAlexander Shiyan ret = devm_request_irq(&pdev->dev, irq, mxcmci_irq, 0, 113101e4f958SAlexander Shiyan dev_name(&pdev->dev), host); 1132d96be879SSascha Hauer if (ret) 1133d96be879SSascha Hauer goto out_free_dma; 1134d96be879SSascha Hauer 1135d96be879SSascha Hauer platform_set_drvdata(pdev, mmc); 1136d96be879SSascha Hauer 1137d96be879SSascha Hauer if (host->pdata && host->pdata->init) { 1138d96be879SSascha Hauer ret = host->pdata->init(&pdev->dev, mxcmci_detect_irq, 1139d96be879SSascha Hauer host->mmc); 1140d96be879SSascha Hauer if (ret) 114101e4f958SAlexander Shiyan goto out_free_dma; 1142d96be879SSascha Hauer } 1143d96be879SSascha Hauer 11442ee4f620SKees Cook timer_setup(&host->watchdog, mxcmci_watchdog, 0); 1145f6ad0a48SJavier Martin 1146abd4190fSAlexander Shiyan mmc_add_host(mmc); 1147abd4190fSAlexander Shiyan 1148d96be879SSascha Hauer return 0; 1149d96be879SSascha Hauer 1150d96be879SSascha Hauer out_free_dma: 1151f53fbde4SSascha Hauer if (host->dma) 1152f53fbde4SSascha Hauer dma_release_channel(host->dma); 115301e4f958SAlexander Shiyan 1154d96be879SSascha Hauer out_clk_put: 1155529aa29eSSascha Hauer clk_disable_unprepare(host->clk_ipg); 1156a2bc74cfSArvind Yadav out_clk_per_put: 1157a2bc74cfSArvind Yadav clk_disable_unprepare(host->clk_per); 115801e4f958SAlexander Shiyan 1159d96be879SSascha Hauer out_free: 1160d96be879SSascha Hauer mmc_free_host(mmc); 116101e4f958SAlexander Shiyan 1162d96be879SSascha Hauer return ret; 1163d96be879SSascha Hauer } 1164d96be879SSascha Hauer 1165d96be879SSascha Hauer static int mxcmci_remove(struct platform_device *pdev) 1166d96be879SSascha Hauer { 1167d96be879SSascha Hauer struct mmc_host *mmc = platform_get_drvdata(pdev); 1168d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 1169d96be879SSascha Hauer 1170d96be879SSascha Hauer mmc_remove_host(mmc); 1171d96be879SSascha Hauer 1172d96be879SSascha Hauer if (host->pdata && host->pdata->exit) 1173d96be879SSascha Hauer host->pdata->exit(&pdev->dev, mmc); 1174d96be879SSascha Hauer 1175f53fbde4SSascha Hauer if (host->dma) 1176f53fbde4SSascha Hauer dma_release_channel(host->dma); 1177f53fbde4SSascha Hauer 1178529aa29eSSascha Hauer clk_disable_unprepare(host->clk_per); 1179529aa29eSSascha Hauer clk_disable_unprepare(host->clk_ipg); 1180d96be879SSascha Hauer 1181d96be879SSascha Hauer mmc_free_host(mmc); 1182d96be879SSascha Hauer 1183d96be879SSascha Hauer return 0; 1184d96be879SSascha Hauer } 1185d96be879SSascha Hauer 1186d8edfc4eSUlf Hansson static int mxcmci_suspend(struct device *dev) 1187d96be879SSascha Hauer { 1188a7d403cfSEric Bénard struct mmc_host *mmc = dev_get_drvdata(dev); 1189a7d403cfSEric Bénard struct mxcmci_host *host = mmc_priv(mmc); 1190d96be879SSascha Hauer 1191529aa29eSSascha Hauer clk_disable_unprepare(host->clk_per); 1192529aa29eSSascha Hauer clk_disable_unprepare(host->clk_ipg); 1193bd190f90SUlf Hansson return 0; 1194d96be879SSascha Hauer } 1195d96be879SSascha Hauer 1196d8edfc4eSUlf Hansson static int mxcmci_resume(struct device *dev) 1197d96be879SSascha Hauer { 1198a7d403cfSEric Bénard struct mmc_host *mmc = dev_get_drvdata(dev); 1199a7d403cfSEric Bénard struct mxcmci_host *host = mmc_priv(mmc); 1200a2bc74cfSArvind Yadav int ret; 1201d96be879SSascha Hauer 1202a2bc74cfSArvind Yadav ret = clk_prepare_enable(host->clk_per); 1203a2bc74cfSArvind Yadav if (ret) 1204a2bc74cfSArvind Yadav return ret; 1205a2bc74cfSArvind Yadav 1206a2bc74cfSArvind Yadav ret = clk_prepare_enable(host->clk_ipg); 1207a2bc74cfSArvind Yadav if (ret) 1208a2bc74cfSArvind Yadav clk_disable_unprepare(host->clk_per); 1209a2bc74cfSArvind Yadav 1210a2bc74cfSArvind Yadav return ret; 1211d96be879SSascha Hauer } 1212a7d403cfSEric Bénard 1213*2cdbd92cSPaul Cercueil DEFINE_SIMPLE_DEV_PM_OPS(mxcmci_pm_ops, mxcmci_suspend, mxcmci_resume); 1214d96be879SSascha Hauer 1215d96be879SSascha Hauer static struct platform_driver mxcmci_driver = { 1216d96be879SSascha Hauer .probe = mxcmci_probe, 1217d96be879SSascha Hauer .remove = mxcmci_remove, 1218d96be879SSascha Hauer .driver = { 1219d96be879SSascha Hauer .name = DRIVER_NAME, 122021b2cec6SDouglas Anderson .probe_type = PROBE_PREFER_ASYNCHRONOUS, 1221*2cdbd92cSPaul Cercueil .pm = pm_sleep_ptr(&mxcmci_pm_ops), 12227ff747c4SMarkus Pargmann .of_match_table = mxcmci_of_match, 1223d96be879SSascha Hauer } 1224d96be879SSascha Hauer }; 1225d96be879SSascha Hauer 1226d1f81a64SAxel Lin module_platform_driver(mxcmci_driver); 1227d96be879SSascha Hauer 1228d96be879SSascha Hauer MODULE_DESCRIPTION("i.MX Multimedia Card Interface Driver"); 1229d96be879SSascha Hauer MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 1230d96be879SSascha Hauer MODULE_LICENSE("GPL"); 12316eb30adfSFabio Estevam MODULE_ALIAS("platform:mxc-mmc"); 1232