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> 24a639bb72SArnd Bergmann #include <linux/highmem.h> 25d96be879SSascha Hauer #include <linux/interrupt.h> 26d96be879SSascha Hauer #include <linux/irq.h> 27d96be879SSascha Hauer #include <linux/blkdev.h> 28d96be879SSascha Hauer #include <linux/dma-mapping.h> 29d96be879SSascha Hauer #include <linux/mmc/host.h> 30d96be879SSascha Hauer #include <linux/mmc/card.h> 31d96be879SSascha Hauer #include <linux/delay.h> 32d96be879SSascha Hauer #include <linux/clk.h> 33d96be879SSascha Hauer #include <linux/io.h> 34d96be879SSascha Hauer #include <linux/gpio.h> 3574b66954SAlberto Panizzo #include <linux/regulator/consumer.h> 36f53fbde4SSascha Hauer #include <linux/dmaengine.h> 37258aea76SViresh Kumar #include <linux/types.h> 387ff747c4SMarkus Pargmann #include <linux/of.h> 397ff747c4SMarkus Pargmann #include <linux/of_device.h> 407ff747c4SMarkus Pargmann #include <linux/of_dma.h> 417ff747c4SMarkus Pargmann #include <linux/of_gpio.h> 42bcf53524SAnatolij Gustschin #include <linux/mmc/slot-gpio.h> 43d96be879SSascha Hauer 44d96be879SSascha Hauer #include <asm/dma.h> 45d96be879SSascha Hauer #include <asm/irq.h> 4682906b13SArnd Bergmann #include <linux/platform_data/mmc-mxcmmc.h> 47d96be879SSascha Hauer 4882906b13SArnd Bergmann #include <linux/platform_data/dma-imx.h> 49d96be879SSascha Hauer 509563b1dbSSascha Hauer #define DRIVER_NAME "mxc-mmc" 51f6ad0a48SJavier Martin #define MXCMCI_TIMEOUT_MS 10000 52d96be879SSascha Hauer 53d96be879SSascha Hauer #define MMC_REG_STR_STP_CLK 0x00 54d96be879SSascha Hauer #define MMC_REG_STATUS 0x04 55d96be879SSascha Hauer #define MMC_REG_CLK_RATE 0x08 56d96be879SSascha Hauer #define MMC_REG_CMD_DAT_CONT 0x0C 57d96be879SSascha Hauer #define MMC_REG_RES_TO 0x10 58d96be879SSascha Hauer #define MMC_REG_READ_TO 0x14 59d96be879SSascha Hauer #define MMC_REG_BLK_LEN 0x18 60d96be879SSascha Hauer #define MMC_REG_NOB 0x1C 61d96be879SSascha Hauer #define MMC_REG_REV_NO 0x20 62d96be879SSascha Hauer #define MMC_REG_INT_CNTR 0x24 63d96be879SSascha Hauer #define MMC_REG_CMD 0x28 64d96be879SSascha Hauer #define MMC_REG_ARG 0x2C 65d96be879SSascha Hauer #define MMC_REG_RES_FIFO 0x34 66d96be879SSascha Hauer #define MMC_REG_BUFFER_ACCESS 0x38 67d96be879SSascha Hauer 68d96be879SSascha Hauer #define STR_STP_CLK_RESET (1 << 3) 69d96be879SSascha Hauer #define STR_STP_CLK_START_CLK (1 << 1) 70d96be879SSascha Hauer #define STR_STP_CLK_STOP_CLK (1 << 0) 71d96be879SSascha Hauer 72d96be879SSascha Hauer #define STATUS_CARD_INSERTION (1 << 31) 73d96be879SSascha Hauer #define STATUS_CARD_REMOVAL (1 << 30) 74d96be879SSascha Hauer #define STATUS_YBUF_EMPTY (1 << 29) 75d96be879SSascha Hauer #define STATUS_XBUF_EMPTY (1 << 28) 76d96be879SSascha Hauer #define STATUS_YBUF_FULL (1 << 27) 77d96be879SSascha Hauer #define STATUS_XBUF_FULL (1 << 26) 78d96be879SSascha Hauer #define STATUS_BUF_UND_RUN (1 << 25) 79d96be879SSascha Hauer #define STATUS_BUF_OVFL (1 << 24) 80d96be879SSascha Hauer #define STATUS_SDIO_INT_ACTIVE (1 << 14) 81d96be879SSascha Hauer #define STATUS_END_CMD_RESP (1 << 13) 82d96be879SSascha Hauer #define STATUS_WRITE_OP_DONE (1 << 12) 83d96be879SSascha Hauer #define STATUS_DATA_TRANS_DONE (1 << 11) 84d96be879SSascha Hauer #define STATUS_READ_OP_DONE (1 << 11) 85d96be879SSascha Hauer #define STATUS_WR_CRC_ERROR_CODE_MASK (3 << 10) 86d96be879SSascha Hauer #define STATUS_CARD_BUS_CLK_RUN (1 << 8) 87d96be879SSascha Hauer #define STATUS_BUF_READ_RDY (1 << 7) 88d96be879SSascha Hauer #define STATUS_BUF_WRITE_RDY (1 << 6) 89d96be879SSascha Hauer #define STATUS_RESP_CRC_ERR (1 << 5) 90d96be879SSascha Hauer #define STATUS_CRC_READ_ERR (1 << 3) 91d96be879SSascha Hauer #define STATUS_CRC_WRITE_ERR (1 << 2) 92d96be879SSascha Hauer #define STATUS_TIME_OUT_RESP (1 << 1) 93d96be879SSascha Hauer #define STATUS_TIME_OUT_READ (1 << 0) 94d96be879SSascha Hauer #define STATUS_ERR_MASK 0x2f 95d96be879SSascha Hauer 96d96be879SSascha Hauer #define CMD_DAT_CONT_CMD_RESP_LONG_OFF (1 << 12) 97d96be879SSascha Hauer #define CMD_DAT_CONT_STOP_READWAIT (1 << 11) 98d96be879SSascha Hauer #define CMD_DAT_CONT_START_READWAIT (1 << 10) 99d96be879SSascha Hauer #define CMD_DAT_CONT_BUS_WIDTH_4 (2 << 8) 100d96be879SSascha Hauer #define CMD_DAT_CONT_INIT (1 << 7) 101d96be879SSascha Hauer #define CMD_DAT_CONT_WRITE (1 << 4) 102d96be879SSascha Hauer #define CMD_DAT_CONT_DATA_ENABLE (1 << 3) 103d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_48BIT_CRC (1 << 0) 104d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_136BIT (2 << 0) 105d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_48BIT (3 << 0) 106d96be879SSascha Hauer 107d96be879SSascha Hauer #define INT_SDIO_INT_WKP_EN (1 << 18) 108d96be879SSascha Hauer #define INT_CARD_INSERTION_WKP_EN (1 << 17) 109d96be879SSascha Hauer #define INT_CARD_REMOVAL_WKP_EN (1 << 16) 110d96be879SSascha Hauer #define INT_CARD_INSERTION_EN (1 << 15) 111d96be879SSascha Hauer #define INT_CARD_REMOVAL_EN (1 << 14) 112d96be879SSascha Hauer #define INT_SDIO_IRQ_EN (1 << 13) 113d96be879SSascha Hauer #define INT_DAT0_EN (1 << 12) 114d96be879SSascha Hauer #define INT_BUF_READ_EN (1 << 4) 115d96be879SSascha Hauer #define INT_BUF_WRITE_EN (1 << 3) 116d96be879SSascha Hauer #define INT_END_CMD_RES_EN (1 << 2) 117d96be879SSascha Hauer #define INT_WRITE_OP_DONE_EN (1 << 1) 118d96be879SSascha Hauer #define INT_READ_OP_EN (1 << 0) 119d96be879SSascha Hauer 1207f917a8dSShawn Guo enum mxcmci_type { 1217f917a8dSShawn Guo IMX21_MMC, 1227f917a8dSShawn Guo IMX31_MMC, 123c7ceab02SAnatolij Gustschin MPC512X_MMC, 1247f917a8dSShawn Guo }; 1257f917a8dSShawn Guo 126d96be879SSascha Hauer struct mxcmci_host { 127d96be879SSascha Hauer struct mmc_host *mmc; 128d96be879SSascha Hauer void __iomem *base; 12901e4f958SAlexander Shiyan dma_addr_t phys_base; 130d96be879SSascha Hauer int detect_irq; 131f53fbde4SSascha Hauer struct dma_chan *dma; 132f53fbde4SSascha Hauer struct dma_async_tx_descriptor *desc; 133d96be879SSascha Hauer int do_dma; 13416b3bf8cSEric Bénard int default_irq_mask; 135f441b993SDaniel Mack int use_sdio; 136d96be879SSascha Hauer unsigned int power_mode; 137d96be879SSascha Hauer struct imxmmc_platform_data *pdata; 138d96be879SSascha Hauer 139d96be879SSascha Hauer struct mmc_request *req; 140d96be879SSascha Hauer struct mmc_command *cmd; 141d96be879SSascha Hauer struct mmc_data *data; 142d96be879SSascha Hauer 143d96be879SSascha Hauer unsigned int datasize; 144d96be879SSascha Hauer unsigned int dma_dir; 145d96be879SSascha Hauer 146d96be879SSascha Hauer u16 rev_no; 147d96be879SSascha Hauer unsigned int cmdat; 148d96be879SSascha Hauer 149529aa29eSSascha Hauer struct clk *clk_ipg; 150529aa29eSSascha Hauer struct clk *clk_per; 151d96be879SSascha Hauer 152d96be879SSascha Hauer int clock; 153d96be879SSascha Hauer 154d96be879SSascha Hauer struct work_struct datawork; 155f441b993SDaniel Mack spinlock_t lock; 15674b66954SAlberto Panizzo 157f53fbde4SSascha Hauer int burstlen; 158f53fbde4SSascha Hauer int dmareq; 159f53fbde4SSascha Hauer struct dma_slave_config dma_slave_config; 160f53fbde4SSascha Hauer struct imx_dma_data dma_data; 161f6ad0a48SJavier Martin 162f6ad0a48SJavier Martin struct timer_list watchdog; 1637f917a8dSShawn Guo enum mxcmci_type devtype; 164d96be879SSascha Hauer }; 165d96be879SSascha Hauer 16642477053SAnatolij Gustschin static const struct platform_device_id mxcmci_devtype[] = { 1677f917a8dSShawn Guo { 1687f917a8dSShawn Guo .name = "imx21-mmc", 1697f917a8dSShawn Guo .driver_data = IMX21_MMC, 1707f917a8dSShawn Guo }, { 1717f917a8dSShawn Guo .name = "imx31-mmc", 1727f917a8dSShawn Guo .driver_data = IMX31_MMC, 1737f917a8dSShawn Guo }, { 174c7ceab02SAnatolij Gustschin .name = "mpc512x-sdhc", 175c7ceab02SAnatolij Gustschin .driver_data = MPC512X_MMC, 176c7ceab02SAnatolij Gustschin }, { 1777f917a8dSShawn Guo /* sentinel */ 1787f917a8dSShawn Guo } 1797f917a8dSShawn Guo }; 1807f917a8dSShawn Guo MODULE_DEVICE_TABLE(platform, mxcmci_devtype); 1817f917a8dSShawn Guo 1827ff747c4SMarkus Pargmann static const struct of_device_id mxcmci_of_match[] = { 1837ff747c4SMarkus Pargmann { 1847ff747c4SMarkus Pargmann .compatible = "fsl,imx21-mmc", 1857ff747c4SMarkus Pargmann .data = &mxcmci_devtype[IMX21_MMC], 1867ff747c4SMarkus Pargmann }, { 1877ff747c4SMarkus Pargmann .compatible = "fsl,imx31-mmc", 1887ff747c4SMarkus Pargmann .data = &mxcmci_devtype[IMX31_MMC], 1897ff747c4SMarkus Pargmann }, { 190c7ceab02SAnatolij Gustschin .compatible = "fsl,mpc5121-sdhc", 191c7ceab02SAnatolij Gustschin .data = &mxcmci_devtype[MPC512X_MMC], 192c7ceab02SAnatolij Gustschin }, { 1937ff747c4SMarkus Pargmann /* sentinel */ 1947ff747c4SMarkus Pargmann } 1957ff747c4SMarkus Pargmann }; 1967ff747c4SMarkus Pargmann MODULE_DEVICE_TABLE(of, mxcmci_of_match); 1977ff747c4SMarkus Pargmann 1987f917a8dSShawn Guo static inline int is_imx31_mmc(struct mxcmci_host *host) 1997f917a8dSShawn Guo { 2007f917a8dSShawn Guo return host->devtype == IMX31_MMC; 2017f917a8dSShawn Guo } 2027f917a8dSShawn Guo 203c7ceab02SAnatolij Gustschin static inline int is_mpc512x_mmc(struct mxcmci_host *host) 204c7ceab02SAnatolij Gustschin { 205c7ceab02SAnatolij Gustschin return host->devtype == MPC512X_MMC; 206c7ceab02SAnatolij Gustschin } 207c7ceab02SAnatolij Gustschin 208c7ceab02SAnatolij Gustschin static inline u32 mxcmci_readl(struct mxcmci_host *host, int reg) 209c7ceab02SAnatolij Gustschin { 210c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 211c7ceab02SAnatolij Gustschin return ioread32be(host->base + reg); 212c7ceab02SAnatolij Gustschin else 213c7ceab02SAnatolij Gustschin return readl(host->base + reg); 214c7ceab02SAnatolij Gustschin } 215c7ceab02SAnatolij Gustschin 216c7ceab02SAnatolij Gustschin static inline void mxcmci_writel(struct mxcmci_host *host, u32 val, int reg) 217c7ceab02SAnatolij Gustschin { 218c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 219c7ceab02SAnatolij Gustschin iowrite32be(val, host->base + reg); 220c7ceab02SAnatolij Gustschin else 221c7ceab02SAnatolij Gustschin writel(val, host->base + reg); 222c7ceab02SAnatolij Gustschin } 223c7ceab02SAnatolij Gustschin 224c7ceab02SAnatolij Gustschin static inline u16 mxcmci_readw(struct mxcmci_host *host, int reg) 225c7ceab02SAnatolij Gustschin { 226c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 227c7ceab02SAnatolij Gustschin return ioread32be(host->base + reg); 228c7ceab02SAnatolij Gustschin else 229c7ceab02SAnatolij Gustschin return readw(host->base + reg); 230c7ceab02SAnatolij Gustschin } 231c7ceab02SAnatolij Gustschin 232c7ceab02SAnatolij Gustschin static inline void mxcmci_writew(struct mxcmci_host *host, u16 val, int reg) 233c7ceab02SAnatolij Gustschin { 234c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 235c7ceab02SAnatolij Gustschin iowrite32be(val, host->base + reg); 236c7ceab02SAnatolij Gustschin else 237c7ceab02SAnatolij Gustschin writew(val, host->base + reg); 238c7ceab02SAnatolij Gustschin } 239c7ceab02SAnatolij Gustschin 24018489fa2SMartin Fuzzey static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios); 24118489fa2SMartin Fuzzey 242bc3c1771SAlexander Shiyan static void mxcmci_set_power(struct mxcmci_host *host, unsigned int vdd) 24374b66954SAlberto Panizzo { 244bc3c1771SAlexander Shiyan if (!IS_ERR(host->mmc->supply.vmmc)) { 245bc3c1771SAlexander Shiyan if (host->power_mode == MMC_POWER_UP) 246bc3c1771SAlexander Shiyan mmc_regulator_set_ocr(host->mmc, 247bc3c1771SAlexander Shiyan host->mmc->supply.vmmc, vdd); 248bc3c1771SAlexander Shiyan else if (host->power_mode == MMC_POWER_OFF) 249bc3c1771SAlexander Shiyan mmc_regulator_set_ocr(host->mmc, 250bc3c1771SAlexander Shiyan host->mmc->supply.vmmc, 0); 251d078d242SAlberto Panizzo } 252d078d242SAlberto Panizzo 25374b66954SAlberto Panizzo if (host->pdata && host->pdata->setpower) 25474b66954SAlberto Panizzo host->pdata->setpower(mmc_dev(host->mmc), vdd); 25574b66954SAlberto Panizzo } 25674b66954SAlberto Panizzo 257d96be879SSascha Hauer static inline int mxcmci_use_dma(struct mxcmci_host *host) 258d96be879SSascha Hauer { 259d96be879SSascha Hauer return host->do_dma; 260d96be879SSascha Hauer } 261d96be879SSascha Hauer 262d96be879SSascha Hauer static void mxcmci_softreset(struct mxcmci_host *host) 263d96be879SSascha Hauer { 264d96be879SSascha Hauer int i; 265d96be879SSascha Hauer 2664725f6f1SDaniel Mack dev_dbg(mmc_dev(host->mmc), "mxcmci_softreset\n"); 2674725f6f1SDaniel Mack 268d96be879SSascha Hauer /* reset sequence */ 269c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_RESET, MMC_REG_STR_STP_CLK); 270c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_RESET | STR_STP_CLK_START_CLK, 271c7ceab02SAnatolij Gustschin MMC_REG_STR_STP_CLK); 272d96be879SSascha Hauer 273d96be879SSascha Hauer for (i = 0; i < 8; i++) 274c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_START_CLK, MMC_REG_STR_STP_CLK); 275d96be879SSascha Hauer 276c7ceab02SAnatolij Gustschin mxcmci_writew(host, 0xff, MMC_REG_RES_TO); 277d96be879SSascha Hauer } 278d96be879SSascha Hauer 279e48fc15aSAnatolij Gustschin #if IS_ENABLED(CONFIG_PPC_MPC512x) 280e48fc15aSAnatolij Gustschin static inline void buffer_swap32(u32 *buf, int len) 281e48fc15aSAnatolij Gustschin { 282e48fc15aSAnatolij Gustschin int i; 283e48fc15aSAnatolij Gustschin 284e48fc15aSAnatolij Gustschin for (i = 0; i < ((len + 3) / 4); i++) { 2857a8bf874SDavid Gibson *buf = swab32(*buf); 286e48fc15aSAnatolij Gustschin buf++; 287e48fc15aSAnatolij Gustschin } 288e48fc15aSAnatolij Gustschin } 289e48fc15aSAnatolij Gustschin 290e48fc15aSAnatolij Gustschin static void mxcmci_swap_buffers(struct mmc_data *data) 291e48fc15aSAnatolij Gustschin { 292e48fc15aSAnatolij Gustschin struct scatterlist *sg; 293e48fc15aSAnatolij Gustschin int i; 294e48fc15aSAnatolij Gustschin 295b189e758SChristoph Hellwig for_each_sg(data->sg, sg, data->sg_len, i) { 296b189e758SChristoph Hellwig void *buf = kmap_atomic(sg_page(sg) + sg->offset; 297b189e758SChristoph Hellwig buffer_swap32(buf, sg->length); 298b189e758SChristoph Hellwig kunmap_atomic(buf); 299e48fc15aSAnatolij Gustschin } 300e48fc15aSAnatolij Gustschin #else 301e48fc15aSAnatolij Gustschin static inline void mxcmci_swap_buffers(struct mmc_data *data) {} 302e48fc15aSAnatolij Gustschin #endif 303e48fc15aSAnatolij Gustschin 304656217d2SMartin Fuzzey static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data) 305d96be879SSascha Hauer { 306d96be879SSascha Hauer unsigned int nob = data->blocks; 307d96be879SSascha Hauer unsigned int blksz = data->blksz; 308d96be879SSascha Hauer unsigned int datasize = nob * blksz; 309d96be879SSascha Hauer struct scatterlist *sg; 31005f5799cSVinod Koul enum dma_transfer_direction slave_dirn; 311f53fbde4SSascha Hauer int i, nents; 312f53fbde4SSascha Hauer 313d96be879SSascha Hauer host->data = data; 314d96be879SSascha Hauer data->bytes_xfered = 0; 315d96be879SSascha Hauer 316c7ceab02SAnatolij Gustschin mxcmci_writew(host, nob, MMC_REG_NOB); 317c7ceab02SAnatolij Gustschin mxcmci_writew(host, blksz, MMC_REG_BLK_LEN); 318d96be879SSascha Hauer host->datasize = datasize; 319d96be879SSascha Hauer 320f53fbde4SSascha Hauer if (!mxcmci_use_dma(host)) 321f53fbde4SSascha Hauer return 0; 322f53fbde4SSascha Hauer 323d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 3242cb53552SJavier Martin if (sg->offset & 3 || sg->length & 3 || sg->length < 512) { 325d96be879SSascha Hauer host->do_dma = 0; 326656217d2SMartin Fuzzey return 0; 327d96be879SSascha Hauer } 328d96be879SSascha Hauer } 329d96be879SSascha Hauer 33005f5799cSVinod Koul if (data->flags & MMC_DATA_READ) { 331d96be879SSascha Hauer host->dma_dir = DMA_FROM_DEVICE; 33205f5799cSVinod Koul slave_dirn = DMA_DEV_TO_MEM; 33305f5799cSVinod Koul } else { 334d96be879SSascha Hauer host->dma_dir = DMA_TO_DEVICE; 33505f5799cSVinod Koul slave_dirn = DMA_MEM_TO_DEV; 336e48fc15aSAnatolij Gustschin 337e48fc15aSAnatolij Gustschin mxcmci_swap_buffers(data); 33805f5799cSVinod Koul } 339f53fbde4SSascha Hauer 340f53fbde4SSascha Hauer nents = dma_map_sg(host->dma->device->dev, data->sg, 341d96be879SSascha Hauer data->sg_len, host->dma_dir); 342f53fbde4SSascha Hauer if (nents != data->sg_len) 343f53fbde4SSascha Hauer return -EINVAL; 344d96be879SSascha Hauer 34516052827SAlexandre Bounine host->desc = dmaengine_prep_slave_sg(host->dma, 34605f5799cSVinod Koul data->sg, data->sg_len, slave_dirn, 347f53fbde4SSascha Hauer DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 348d96be879SSascha Hauer 349f53fbde4SSascha Hauer if (!host->desc) { 350f53fbde4SSascha Hauer dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len, 351f53fbde4SSascha Hauer host->dma_dir); 352f53fbde4SSascha Hauer host->do_dma = 0; 353f53fbde4SSascha Hauer return 0; /* Fall back to PIO */ 354656217d2SMartin Fuzzey } 355d96be879SSascha Hauer wmb(); 356d96be879SSascha Hauer 357f53fbde4SSascha Hauer dmaengine_submit(host->desc); 358439aa0efSSascha Hauer dma_async_issue_pending(host->dma); 359f53fbde4SSascha Hauer 360f6ad0a48SJavier Martin mod_timer(&host->watchdog, jiffies + msecs_to_jiffies(MXCMCI_TIMEOUT_MS)); 361f6ad0a48SJavier Martin 362656217d2SMartin Fuzzey return 0; 363d96be879SSascha Hauer } 364d96be879SSascha Hauer 365f6ad0a48SJavier Martin static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat); 366f6ad0a48SJavier Martin static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat); 367f6ad0a48SJavier Martin 368f6ad0a48SJavier Martin static void mxcmci_dma_callback(void *data) 369f6ad0a48SJavier Martin { 370f6ad0a48SJavier Martin struct mxcmci_host *host = data; 371f6ad0a48SJavier Martin u32 stat; 372f6ad0a48SJavier Martin 373f6ad0a48SJavier Martin del_timer(&host->watchdog); 374f6ad0a48SJavier Martin 375c7ceab02SAnatolij Gustschin stat = mxcmci_readl(host, MMC_REG_STATUS); 376f6ad0a48SJavier Martin 377f6ad0a48SJavier Martin dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat); 378f6ad0a48SJavier Martin 379f6ad0a48SJavier Martin mxcmci_data_done(host, stat); 380f6ad0a48SJavier Martin } 381f6ad0a48SJavier Martin 382d96be879SSascha Hauer static int mxcmci_start_cmd(struct mxcmci_host *host, struct mmc_command *cmd, 383d96be879SSascha Hauer unsigned int cmdat) 384d96be879SSascha Hauer { 38516b3bf8cSEric Bénard u32 int_cntr = host->default_irq_mask; 386f441b993SDaniel Mack unsigned long flags; 387f441b993SDaniel Mack 388d96be879SSascha Hauer WARN_ON(host->cmd != NULL); 389d96be879SSascha Hauer host->cmd = cmd; 390d96be879SSascha Hauer 391d96be879SSascha Hauer switch (mmc_resp_type(cmd)) { 392d96be879SSascha Hauer case MMC_RSP_R1: /* short CRC, OPCODE */ 393d96be879SSascha Hauer case MMC_RSP_R1B:/* short CRC, OPCODE, BUSY */ 394d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_48BIT_CRC; 395d96be879SSascha Hauer break; 396d96be879SSascha Hauer case MMC_RSP_R2: /* long 136 bit + CRC */ 397d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_136BIT; 398d96be879SSascha Hauer break; 399d96be879SSascha Hauer case MMC_RSP_R3: /* short */ 400d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_48BIT; 401d96be879SSascha Hauer break; 402d96be879SSascha Hauer case MMC_RSP_NONE: 403d96be879SSascha Hauer break; 404d96be879SSascha Hauer default: 405d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "unhandled response type 0x%x\n", 406d96be879SSascha Hauer mmc_resp_type(cmd)); 407d96be879SSascha Hauer cmd->error = -EINVAL; 408d96be879SSascha Hauer return -EINVAL; 409d96be879SSascha Hauer } 410d96be879SSascha Hauer 411f441b993SDaniel Mack int_cntr = INT_END_CMD_RES_EN; 412f441b993SDaniel Mack 413f6ad0a48SJavier Martin if (mxcmci_use_dma(host)) { 414f6ad0a48SJavier Martin if (host->dma_dir == DMA_FROM_DEVICE) { 415f6ad0a48SJavier Martin host->desc->callback = mxcmci_dma_callback; 416f6ad0a48SJavier Martin host->desc->callback_param = host; 417f6ad0a48SJavier Martin } else { 418f6ad0a48SJavier Martin int_cntr |= INT_WRITE_OP_DONE_EN; 419f6ad0a48SJavier Martin } 420f6ad0a48SJavier Martin } 421f441b993SDaniel Mack 422f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 423f441b993SDaniel Mack if (host->use_sdio) 424f441b993SDaniel Mack int_cntr |= INT_SDIO_IRQ_EN; 425c7ceab02SAnatolij Gustschin mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 426f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 427d96be879SSascha Hauer 428c7ceab02SAnatolij Gustschin mxcmci_writew(host, cmd->opcode, MMC_REG_CMD); 429c7ceab02SAnatolij Gustschin mxcmci_writel(host, cmd->arg, MMC_REG_ARG); 430c7ceab02SAnatolij Gustschin mxcmci_writew(host, cmdat, MMC_REG_CMD_DAT_CONT); 431d96be879SSascha Hauer 432d96be879SSascha Hauer return 0; 433d96be879SSascha Hauer } 434d96be879SSascha Hauer 435d96be879SSascha Hauer static void mxcmci_finish_request(struct mxcmci_host *host, 436d96be879SSascha Hauer struct mmc_request *req) 437d96be879SSascha Hauer { 43816b3bf8cSEric Bénard u32 int_cntr = host->default_irq_mask; 439f441b993SDaniel Mack unsigned long flags; 440f441b993SDaniel Mack 441f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 442f441b993SDaniel Mack if (host->use_sdio) 443f441b993SDaniel Mack int_cntr |= INT_SDIO_IRQ_EN; 444c7ceab02SAnatolij Gustschin mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 445f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 446d96be879SSascha Hauer 447d96be879SSascha Hauer host->req = NULL; 448d96be879SSascha Hauer host->cmd = NULL; 449d96be879SSascha Hauer host->data = NULL; 450d96be879SSascha Hauer 451d96be879SSascha Hauer mmc_request_done(host->mmc, req); 452d96be879SSascha Hauer } 453d96be879SSascha Hauer 454d96be879SSascha Hauer static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat) 455d96be879SSascha Hauer { 456d96be879SSascha Hauer struct mmc_data *data = host->data; 457d96be879SSascha Hauer int data_error; 458d96be879SSascha Hauer 459e48fc15aSAnatolij Gustschin if (mxcmci_use_dma(host)) { 460f53fbde4SSascha Hauer dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len, 461d96be879SSascha Hauer host->dma_dir); 462e48fc15aSAnatolij Gustschin mxcmci_swap_buffers(data); 463e48fc15aSAnatolij Gustschin } 464d96be879SSascha Hauer 465d96be879SSascha Hauer if (stat & STATUS_ERR_MASK) { 466d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n", 467d96be879SSascha Hauer stat); 468d96be879SSascha Hauer if (stat & STATUS_CRC_READ_ERR) { 4694725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), "%s: -EILSEQ\n", __func__); 470d96be879SSascha Hauer data->error = -EILSEQ; 471d96be879SSascha Hauer } else if (stat & STATUS_CRC_WRITE_ERR) { 472d96be879SSascha Hauer u32 err_code = (stat >> 9) & 0x3; 4734725f6f1SDaniel Mack if (err_code == 2) { /* No CRC response */ 4744725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), 4754725f6f1SDaniel Mack "%s: No CRC -ETIMEDOUT\n", __func__); 476d96be879SSascha Hauer data->error = -ETIMEDOUT; 477d96be879SSascha Hauer } else { 4784725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), 4794725f6f1SDaniel Mack "%s: -EILSEQ\n", __func__); 4804725f6f1SDaniel Mack data->error = -EILSEQ; 4814725f6f1SDaniel Mack } 4824725f6f1SDaniel Mack } else if (stat & STATUS_TIME_OUT_READ) { 4834725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), 4844725f6f1SDaniel Mack "%s: read -ETIMEDOUT\n", __func__); 4854725f6f1SDaniel Mack data->error = -ETIMEDOUT; 4864725f6f1SDaniel Mack } else { 4874725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), "%s: -EIO\n", __func__); 488d96be879SSascha Hauer data->error = -EIO; 489d96be879SSascha Hauer } 490d96be879SSascha Hauer } else { 491d96be879SSascha Hauer data->bytes_xfered = host->datasize; 492d96be879SSascha Hauer } 493d96be879SSascha Hauer 494d96be879SSascha Hauer data_error = data->error; 495d96be879SSascha Hauer 496d96be879SSascha Hauer host->data = NULL; 497d96be879SSascha Hauer 498d96be879SSascha Hauer return data_error; 499d96be879SSascha Hauer } 500d96be879SSascha Hauer 501d96be879SSascha Hauer static void mxcmci_read_response(struct mxcmci_host *host, unsigned int stat) 502d96be879SSascha Hauer { 503d96be879SSascha Hauer struct mmc_command *cmd = host->cmd; 504d96be879SSascha Hauer int i; 505d96be879SSascha Hauer u32 a, b, c; 506d96be879SSascha Hauer 507d96be879SSascha Hauer if (!cmd) 508d96be879SSascha Hauer return; 509d96be879SSascha Hauer 510d96be879SSascha Hauer if (stat & STATUS_TIME_OUT_RESP) { 511d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "CMD TIMEOUT\n"); 512d96be879SSascha Hauer cmd->error = -ETIMEDOUT; 513d96be879SSascha Hauer } else if (stat & STATUS_RESP_CRC_ERR && cmd->flags & MMC_RSP_CRC) { 514d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "cmd crc error\n"); 515d96be879SSascha Hauer cmd->error = -EILSEQ; 516d96be879SSascha Hauer } 517d96be879SSascha Hauer 518d96be879SSascha Hauer if (cmd->flags & MMC_RSP_PRESENT) { 519d96be879SSascha Hauer if (cmd->flags & MMC_RSP_136) { 520d96be879SSascha Hauer for (i = 0; i < 4; i++) { 521c7ceab02SAnatolij Gustschin a = mxcmci_readw(host, MMC_REG_RES_FIFO); 522c7ceab02SAnatolij Gustschin b = mxcmci_readw(host, MMC_REG_RES_FIFO); 523d96be879SSascha Hauer cmd->resp[i] = a << 16 | b; 524d96be879SSascha Hauer } 525d96be879SSascha Hauer } else { 526c7ceab02SAnatolij Gustschin a = mxcmci_readw(host, MMC_REG_RES_FIFO); 527c7ceab02SAnatolij Gustschin b = mxcmci_readw(host, MMC_REG_RES_FIFO); 528c7ceab02SAnatolij Gustschin c = mxcmci_readw(host, MMC_REG_RES_FIFO); 529d96be879SSascha Hauer cmd->resp[0] = a << 24 | b << 8 | c >> 8; 530d96be879SSascha Hauer } 531d96be879SSascha Hauer } 532d96be879SSascha Hauer } 533d96be879SSascha Hauer 534d96be879SSascha Hauer static int mxcmci_poll_status(struct mxcmci_host *host, u32 mask) 535d96be879SSascha Hauer { 536d96be879SSascha Hauer u32 stat; 537d96be879SSascha Hauer unsigned long timeout = jiffies + HZ; 538d96be879SSascha Hauer 539d96be879SSascha Hauer do { 540c7ceab02SAnatolij Gustschin stat = mxcmci_readl(host, MMC_REG_STATUS); 541d96be879SSascha Hauer if (stat & STATUS_ERR_MASK) 542d96be879SSascha Hauer return stat; 54318489fa2SMartin Fuzzey if (time_after(jiffies, timeout)) { 54418489fa2SMartin Fuzzey mxcmci_softreset(host); 54518489fa2SMartin Fuzzey mxcmci_set_clk_rate(host, host->clock); 546d96be879SSascha Hauer return STATUS_TIME_OUT_READ; 54718489fa2SMartin Fuzzey } 548d96be879SSascha Hauer if (stat & mask) 549d96be879SSascha Hauer return 0; 550d96be879SSascha Hauer cpu_relax(); 551d96be879SSascha Hauer } while (1); 552d96be879SSascha Hauer } 553d96be879SSascha Hauer 554d96be879SSascha Hauer static int mxcmci_pull(struct mxcmci_host *host, void *_buf, int bytes) 555d96be879SSascha Hauer { 556d96be879SSascha Hauer unsigned int stat; 557d96be879SSascha Hauer u32 *buf = _buf; 558d96be879SSascha Hauer 559d96be879SSascha Hauer while (bytes > 3) { 560d96be879SSascha Hauer stat = mxcmci_poll_status(host, 561d96be879SSascha Hauer STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 562d96be879SSascha Hauer if (stat) 563d96be879SSascha Hauer return stat; 564c7ceab02SAnatolij Gustschin *buf++ = cpu_to_le32(mxcmci_readl(host, MMC_REG_BUFFER_ACCESS)); 565d96be879SSascha Hauer bytes -= 4; 566d96be879SSascha Hauer } 567d96be879SSascha Hauer 568d96be879SSascha Hauer if (bytes) { 569d96be879SSascha Hauer u8 *b = (u8 *)buf; 570d96be879SSascha Hauer u32 tmp; 571d96be879SSascha Hauer 572d96be879SSascha Hauer stat = mxcmci_poll_status(host, 573d96be879SSascha Hauer STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 574d96be879SSascha Hauer if (stat) 575d96be879SSascha Hauer return stat; 576c7ceab02SAnatolij Gustschin tmp = cpu_to_le32(mxcmci_readl(host, MMC_REG_BUFFER_ACCESS)); 577d96be879SSascha Hauer memcpy(b, &tmp, bytes); 578d96be879SSascha Hauer } 579d96be879SSascha Hauer 580d96be879SSascha Hauer return 0; 581d96be879SSascha Hauer } 582d96be879SSascha Hauer 583d96be879SSascha Hauer static int mxcmci_push(struct mxcmci_host *host, void *_buf, int bytes) 584d96be879SSascha Hauer { 585d96be879SSascha Hauer unsigned int stat; 586d96be879SSascha Hauer u32 *buf = _buf; 587d96be879SSascha Hauer 588d96be879SSascha Hauer while (bytes > 3) { 589d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 590d96be879SSascha Hauer if (stat) 591d96be879SSascha Hauer return stat; 592c7ceab02SAnatolij Gustschin mxcmci_writel(host, cpu_to_le32(*buf++), MMC_REG_BUFFER_ACCESS); 593d96be879SSascha Hauer bytes -= 4; 594d96be879SSascha Hauer } 595d96be879SSascha Hauer 596d96be879SSascha Hauer if (bytes) { 597d96be879SSascha Hauer u8 *b = (u8 *)buf; 598d96be879SSascha Hauer u32 tmp; 599d96be879SSascha Hauer 600d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 601d96be879SSascha Hauer if (stat) 602d96be879SSascha Hauer return stat; 603d96be879SSascha Hauer 604d96be879SSascha Hauer memcpy(&tmp, b, bytes); 605c7ceab02SAnatolij Gustschin mxcmci_writel(host, cpu_to_le32(tmp), MMC_REG_BUFFER_ACCESS); 606d96be879SSascha Hauer } 607d96be879SSascha Hauer 6086d916416SFabio Estevam return mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 609d96be879SSascha Hauer } 610d96be879SSascha Hauer 611d96be879SSascha Hauer static int mxcmci_transfer_data(struct mxcmci_host *host) 612d96be879SSascha Hauer { 613d96be879SSascha Hauer struct mmc_data *data = host->req->data; 614d96be879SSascha Hauer struct scatterlist *sg; 615b189e758SChristoph Hellwig void *buf; 616d96be879SSascha Hauer int stat, i; 617d96be879SSascha Hauer 618d96be879SSascha Hauer host->data = data; 619d96be879SSascha Hauer host->datasize = 0; 620d96be879SSascha Hauer 621d96be879SSascha Hauer if (data->flags & MMC_DATA_READ) { 622d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 623b189e758SChristoph Hellwig buf = kmap_atomic(sg_page(sg) + sg->offset); 624b189e758SChristoph Hellwig stat = mxcmci_pull(host, buf, sg->length); 625b189e758SChristoph Hellwig kunmap(buf); 626d96be879SSascha Hauer if (stat) 627d96be879SSascha Hauer return stat; 628d96be879SSascha Hauer host->datasize += sg->length; 629d96be879SSascha Hauer } 630d96be879SSascha Hauer } else { 631d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 632b189e758SChristoph Hellwig buf = kmap_atomic(sg_page(sg) + sg->offset); 633b189e758SChristoph Hellwig stat = mxcmci_push(host, buf, sg->length); 634b189e758SChristoph Hellwig kunmap(buf); 635d96be879SSascha Hauer if (stat) 636d96be879SSascha Hauer return stat; 637d96be879SSascha Hauer host->datasize += sg->length; 638d96be879SSascha Hauer } 639d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_WRITE_OP_DONE); 640d96be879SSascha Hauer if (stat) 641d96be879SSascha Hauer return stat; 642d96be879SSascha Hauer } 643d96be879SSascha Hauer return 0; 644d96be879SSascha Hauer } 645d96be879SSascha Hauer 646d96be879SSascha Hauer static void mxcmci_datawork(struct work_struct *work) 647d96be879SSascha Hauer { 648d96be879SSascha Hauer struct mxcmci_host *host = container_of(work, struct mxcmci_host, 649d96be879SSascha Hauer datawork); 650d96be879SSascha Hauer int datastat = mxcmci_transfer_data(host); 6514a31f2efSDaniel Mack 652c7ceab02SAnatolij Gustschin mxcmci_writel(host, STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE, 653c7ceab02SAnatolij Gustschin MMC_REG_STATUS); 654d96be879SSascha Hauer mxcmci_finish_data(host, datastat); 655d96be879SSascha Hauer 656d96be879SSascha Hauer if (host->req->stop) { 657d96be879SSascha Hauer if (mxcmci_start_cmd(host, host->req->stop, 0)) { 658d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 659d96be879SSascha Hauer return; 660d96be879SSascha Hauer } 661d96be879SSascha Hauer } else { 662d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 663d96be879SSascha Hauer } 664d96be879SSascha Hauer } 665d96be879SSascha Hauer 666d96be879SSascha Hauer static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat) 667d96be879SSascha Hauer { 66870aa6109SAnatolij Gustschin struct mmc_request *req; 669d96be879SSascha Hauer int data_error; 67070aa6109SAnatolij Gustschin unsigned long flags; 671d96be879SSascha Hauer 67270aa6109SAnatolij Gustschin spin_lock_irqsave(&host->lock, flags); 67370aa6109SAnatolij Gustschin 67470aa6109SAnatolij Gustschin if (!host->data) { 67570aa6109SAnatolij Gustschin spin_unlock_irqrestore(&host->lock, flags); 676d96be879SSascha Hauer return; 67770aa6109SAnatolij Gustschin } 67870aa6109SAnatolij Gustschin 67970aa6109SAnatolij Gustschin if (!host->req) { 68070aa6109SAnatolij Gustschin spin_unlock_irqrestore(&host->lock, flags); 68170aa6109SAnatolij Gustschin return; 68270aa6109SAnatolij Gustschin } 68370aa6109SAnatolij Gustschin 68470aa6109SAnatolij Gustschin req = host->req; 68570aa6109SAnatolij Gustschin if (!req->stop) 68670aa6109SAnatolij Gustschin host->req = NULL; /* we will handle finish req below */ 687d96be879SSascha Hauer 688d96be879SSascha Hauer data_error = mxcmci_finish_data(host, stat); 689d96be879SSascha Hauer 69070aa6109SAnatolij Gustschin spin_unlock_irqrestore(&host->lock, flags); 69170aa6109SAnatolij Gustschin 69209954ea9SShawn Lin if (data_error) 69309954ea9SShawn Lin return; 69409954ea9SShawn Lin 695d96be879SSascha Hauer mxcmci_read_response(host, stat); 696d96be879SSascha Hauer host->cmd = NULL; 697d96be879SSascha Hauer 69870aa6109SAnatolij Gustschin if (req->stop) { 69970aa6109SAnatolij Gustschin if (mxcmci_start_cmd(host, req->stop, 0)) { 70070aa6109SAnatolij Gustschin mxcmci_finish_request(host, req); 701d96be879SSascha Hauer return; 702d96be879SSascha Hauer } 703d96be879SSascha Hauer } else { 70470aa6109SAnatolij Gustschin mxcmci_finish_request(host, req); 705d96be879SSascha Hauer } 706d96be879SSascha Hauer } 707d96be879SSascha Hauer 708d96be879SSascha Hauer static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat) 709d96be879SSascha Hauer { 710d96be879SSascha Hauer mxcmci_read_response(host, stat); 711d96be879SSascha Hauer host->cmd = NULL; 712d96be879SSascha Hauer 713d96be879SSascha Hauer if (!host->data && host->req) { 714d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 715d96be879SSascha Hauer return; 716d96be879SSascha Hauer } 717d96be879SSascha Hauer 718d96be879SSascha Hauer /* For the DMA case the DMA engine handles the data transfer 719fd589a8fSAnand Gadiyar * automatically. For non DMA we have to do it ourselves. 720d96be879SSascha Hauer * Don't do it in interrupt context though. 721d96be879SSascha Hauer */ 722d96be879SSascha Hauer if (!mxcmci_use_dma(host) && host->data) 723d96be879SSascha Hauer schedule_work(&host->datawork); 724d96be879SSascha Hauer 725d96be879SSascha Hauer } 726d96be879SSascha Hauer 727d96be879SSascha Hauer static irqreturn_t mxcmci_irq(int irq, void *devid) 728d96be879SSascha Hauer { 729d96be879SSascha Hauer struct mxcmci_host *host = devid; 730f441b993SDaniel Mack unsigned long flags; 731f441b993SDaniel Mack bool sdio_irq; 732d96be879SSascha Hauer u32 stat; 733d96be879SSascha Hauer 734c7ceab02SAnatolij Gustschin stat = mxcmci_readl(host, MMC_REG_STATUS); 735c7ceab02SAnatolij Gustschin mxcmci_writel(host, 736c7ceab02SAnatolij Gustschin stat & ~(STATUS_SDIO_INT_ACTIVE | STATUS_DATA_TRANS_DONE | 737c7ceab02SAnatolij Gustschin STATUS_WRITE_OP_DONE), 738c7ceab02SAnatolij Gustschin MMC_REG_STATUS); 739d96be879SSascha Hauer 740d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat); 741d96be879SSascha Hauer 742f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 743f441b993SDaniel Mack sdio_irq = (stat & STATUS_SDIO_INT_ACTIVE) && host->use_sdio; 744f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 745f441b993SDaniel Mack 746adfa5703SMatteo Facchinetti if (mxcmci_use_dma(host) && (stat & (STATUS_WRITE_OP_DONE))) 747adfa5703SMatteo Facchinetti mxcmci_writel(host, STATUS_WRITE_OP_DONE, MMC_REG_STATUS); 7484a31f2efSDaniel Mack 749f441b993SDaniel Mack if (sdio_irq) { 750c7ceab02SAnatolij Gustschin mxcmci_writel(host, STATUS_SDIO_INT_ACTIVE, MMC_REG_STATUS); 751f441b993SDaniel Mack mmc_signal_sdio_irq(host->mmc); 752f441b993SDaniel Mack } 753f441b993SDaniel Mack 754d96be879SSascha Hauer if (stat & STATUS_END_CMD_RESP) 755d96be879SSascha Hauer mxcmci_cmd_done(host, stat); 756f441b993SDaniel Mack 757adfa5703SMatteo Facchinetti if (mxcmci_use_dma(host) && (stat & STATUS_WRITE_OP_DONE)) { 758f6ad0a48SJavier Martin del_timer(&host->watchdog); 759d96be879SSascha Hauer mxcmci_data_done(host, stat); 760f6ad0a48SJavier Martin } 761f53fbde4SSascha Hauer 76216b3bf8cSEric Bénard if (host->default_irq_mask && 76316b3bf8cSEric Bénard (stat & (STATUS_CARD_INSERTION | STATUS_CARD_REMOVAL))) 76416b3bf8cSEric Bénard mmc_detect_change(host->mmc, msecs_to_jiffies(200)); 765f53fbde4SSascha Hauer 766d96be879SSascha Hauer return IRQ_HANDLED; 767d96be879SSascha Hauer } 768d96be879SSascha Hauer 769d96be879SSascha Hauer static void mxcmci_request(struct mmc_host *mmc, struct mmc_request *req) 770d96be879SSascha Hauer { 771d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 772d96be879SSascha Hauer unsigned int cmdat = host->cmdat; 773656217d2SMartin Fuzzey int error; 774d96be879SSascha Hauer 775d96be879SSascha Hauer WARN_ON(host->req != NULL); 776d96be879SSascha Hauer 777d96be879SSascha Hauer host->req = req; 778d96be879SSascha Hauer host->cmdat &= ~CMD_DAT_CONT_INIT; 779f53fbde4SSascha Hauer 780f53fbde4SSascha Hauer if (host->dma) 781d96be879SSascha Hauer host->do_dma = 1; 782f53fbde4SSascha Hauer 783d96be879SSascha Hauer if (req->data) { 784656217d2SMartin Fuzzey error = mxcmci_setup_data(host, req->data); 785656217d2SMartin Fuzzey if (error) { 786656217d2SMartin Fuzzey req->cmd->error = error; 787656217d2SMartin Fuzzey goto out; 788656217d2SMartin Fuzzey } 789656217d2SMartin Fuzzey 790d96be879SSascha Hauer 791d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_DATA_ENABLE; 792d96be879SSascha Hauer 793d96be879SSascha Hauer if (req->data->flags & MMC_DATA_WRITE) 794d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_WRITE; 795d96be879SSascha Hauer } 796d96be879SSascha Hauer 797656217d2SMartin Fuzzey error = mxcmci_start_cmd(host, req->cmd, cmdat); 798f53fbde4SSascha Hauer 799656217d2SMartin Fuzzey out: 800656217d2SMartin Fuzzey if (error) 801d96be879SSascha Hauer mxcmci_finish_request(host, req); 802d96be879SSascha Hauer } 803d96be879SSascha Hauer 804d96be879SSascha Hauer static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios) 805d96be879SSascha Hauer { 806d96be879SSascha Hauer unsigned int divider; 807d96be879SSascha Hauer int prescaler = 0; 808529aa29eSSascha Hauer unsigned int clk_in = clk_get_rate(host->clk_per); 809d96be879SSascha Hauer 810d96be879SSascha Hauer while (prescaler <= 0x800) { 811d96be879SSascha Hauer for (divider = 1; divider <= 0xF; divider++) { 812d96be879SSascha Hauer int x; 813d96be879SSascha Hauer 814d96be879SSascha Hauer x = (clk_in / (divider + 1)); 815d96be879SSascha Hauer 816d96be879SSascha Hauer if (prescaler) 817d96be879SSascha Hauer x /= (prescaler * 2); 818d96be879SSascha Hauer 819d96be879SSascha Hauer if (x <= clk_ios) 820d96be879SSascha Hauer break; 821d96be879SSascha Hauer } 822d96be879SSascha Hauer if (divider < 0x10) 823d96be879SSascha Hauer break; 824d96be879SSascha Hauer 825d96be879SSascha Hauer if (prescaler == 0) 826d96be879SSascha Hauer prescaler = 1; 827d96be879SSascha Hauer else 828d96be879SSascha Hauer prescaler <<= 1; 829d96be879SSascha Hauer } 830d96be879SSascha Hauer 831c7ceab02SAnatolij Gustschin mxcmci_writew(host, (prescaler << 4) | divider, MMC_REG_CLK_RATE); 832d96be879SSascha Hauer 833d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "scaler: %d divider: %d in: %d out: %d\n", 834d96be879SSascha Hauer prescaler, divider, clk_in, clk_ios); 835d96be879SSascha Hauer } 836d96be879SSascha Hauer 837f53fbde4SSascha Hauer static int mxcmci_setup_dma(struct mmc_host *mmc) 838f53fbde4SSascha Hauer { 839f53fbde4SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 840f53fbde4SSascha Hauer struct dma_slave_config *config = &host->dma_slave_config; 841f53fbde4SSascha Hauer 84201e4f958SAlexander Shiyan config->dst_addr = host->phys_base + MMC_REG_BUFFER_ACCESS; 84301e4f958SAlexander Shiyan config->src_addr = host->phys_base + MMC_REG_BUFFER_ACCESS; 844f53fbde4SSascha Hauer config->dst_addr_width = 4; 845f53fbde4SSascha Hauer config->src_addr_width = 4; 846f53fbde4SSascha Hauer config->dst_maxburst = host->burstlen; 847f53fbde4SSascha Hauer config->src_maxburst = host->burstlen; 848258aea76SViresh Kumar config->device_fc = false; 849f53fbde4SSascha Hauer 850f53fbde4SSascha Hauer return dmaengine_slave_config(host->dma, config); 851f53fbde4SSascha Hauer } 852f53fbde4SSascha Hauer 853d96be879SSascha Hauer static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 854d96be879SSascha Hauer { 855d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 856f53fbde4SSascha Hauer int burstlen, ret; 857f53fbde4SSascha Hauer 858d96be879SSascha Hauer /* 8596584cb88SSascha Hauer * use burstlen of 64 (16 words) in 4 bit mode (--> reg value 0) 8606584cb88SSascha Hauer * use burstlen of 16 (4 words) in 1 bit mode (--> reg value 16) 861d96be879SSascha Hauer */ 862d96be879SSascha Hauer if (ios->bus_width == MMC_BUS_WIDTH_4) 863f53fbde4SSascha Hauer burstlen = 16; 8646584cb88SSascha Hauer else 8656584cb88SSascha Hauer burstlen = 4; 866d96be879SSascha Hauer 867f53fbde4SSascha Hauer if (mxcmci_use_dma(host) && burstlen != host->burstlen) { 868f53fbde4SSascha Hauer host->burstlen = burstlen; 869f53fbde4SSascha Hauer ret = mxcmci_setup_dma(mmc); 870f53fbde4SSascha Hauer if (ret) { 871f53fbde4SSascha Hauer dev_err(mmc_dev(host->mmc), 872f53fbde4SSascha Hauer "failed to config DMA channel. Falling back to PIO\n"); 873f53fbde4SSascha Hauer dma_release_channel(host->dma); 874f53fbde4SSascha Hauer host->do_dma = 0; 875e58f516fSSascha Hauer host->dma = NULL; 876f53fbde4SSascha Hauer } 877f53fbde4SSascha Hauer } 878f53fbde4SSascha Hauer 879d96be879SSascha Hauer if (ios->bus_width == MMC_BUS_WIDTH_4) 880d96be879SSascha Hauer host->cmdat |= CMD_DAT_CONT_BUS_WIDTH_4; 881d96be879SSascha Hauer else 882d96be879SSascha Hauer host->cmdat &= ~CMD_DAT_CONT_BUS_WIDTH_4; 883d96be879SSascha Hauer 884d96be879SSascha Hauer if (host->power_mode != ios->power_mode) { 885d96be879SSascha Hauer host->power_mode = ios->power_mode; 886bc3c1771SAlexander Shiyan mxcmci_set_power(host, ios->vdd); 88774b66954SAlberto Panizzo 888d96be879SSascha Hauer if (ios->power_mode == MMC_POWER_ON) 889d96be879SSascha Hauer host->cmdat |= CMD_DAT_CONT_INIT; 890d96be879SSascha Hauer } 891d96be879SSascha Hauer 892d96be879SSascha Hauer if (ios->clock) { 893d96be879SSascha Hauer mxcmci_set_clk_rate(host, ios->clock); 894c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_START_CLK, MMC_REG_STR_STP_CLK); 895d96be879SSascha Hauer } else { 896c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_STOP_CLK, MMC_REG_STR_STP_CLK); 897d96be879SSascha Hauer } 898d96be879SSascha Hauer 899d96be879SSascha Hauer host->clock = ios->clock; 900d96be879SSascha Hauer } 901d96be879SSascha Hauer 902d96be879SSascha Hauer static irqreturn_t mxcmci_detect_irq(int irq, void *data) 903d96be879SSascha Hauer { 904d96be879SSascha Hauer struct mmc_host *mmc = data; 905d96be879SSascha Hauer 906d96be879SSascha Hauer dev_dbg(mmc_dev(mmc), "%s\n", __func__); 907d96be879SSascha Hauer 908d96be879SSascha Hauer mmc_detect_change(mmc, msecs_to_jiffies(250)); 909d96be879SSascha Hauer return IRQ_HANDLED; 910d96be879SSascha Hauer } 911d96be879SSascha Hauer 912d96be879SSascha Hauer static int mxcmci_get_ro(struct mmc_host *mmc) 913d96be879SSascha Hauer { 914d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 915d96be879SSascha Hauer 916d96be879SSascha Hauer if (host->pdata && host->pdata->get_ro) 917d96be879SSascha Hauer return !!host->pdata->get_ro(mmc_dev(mmc)); 918d96be879SSascha Hauer /* 919bcf53524SAnatolij Gustschin * If board doesn't support read only detection (no mmc_gpio 920bcf53524SAnatolij Gustschin * context or gpio is invalid), then let the mmc core decide 921bcf53524SAnatolij Gustschin * what to do. 922d96be879SSascha Hauer */ 923bcf53524SAnatolij Gustschin return mmc_gpio_get_ro(mmc); 924d96be879SSascha Hauer } 925d96be879SSascha Hauer 926f441b993SDaniel Mack static void mxcmci_enable_sdio_irq(struct mmc_host *mmc, int enable) 927f441b993SDaniel Mack { 928f441b993SDaniel Mack struct mxcmci_host *host = mmc_priv(mmc); 929f441b993SDaniel Mack unsigned long flags; 930f441b993SDaniel Mack u32 int_cntr; 931f441b993SDaniel Mack 932f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 933f441b993SDaniel Mack host->use_sdio = enable; 934c7ceab02SAnatolij Gustschin int_cntr = mxcmci_readl(host, MMC_REG_INT_CNTR); 935f441b993SDaniel Mack 936f441b993SDaniel Mack if (enable) 937f441b993SDaniel Mack int_cntr |= INT_SDIO_IRQ_EN; 938f441b993SDaniel Mack else 939f441b993SDaniel Mack int_cntr &= ~INT_SDIO_IRQ_EN; 940f441b993SDaniel Mack 941c7ceab02SAnatolij Gustschin mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 942f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 943f441b993SDaniel Mack } 944d96be879SSascha Hauer 9453fcb027dSDaniel Mack static void mxcmci_init_card(struct mmc_host *host, struct mmc_card *card) 9463fcb027dSDaniel Mack { 9477f917a8dSShawn Guo struct mxcmci_host *mxcmci = mmc_priv(host); 9487f917a8dSShawn Guo 9493fcb027dSDaniel Mack /* 9503fcb027dSDaniel Mack * MX3 SoCs have a silicon bug which corrupts CRC calculation of 9513fcb027dSDaniel Mack * multi-block transfers when connected SDIO peripheral doesn't 9523fcb027dSDaniel Mack * drive the BUSY line as required by the specs. 9533fcb027dSDaniel Mack * One way to prevent this is to only allow 1-bit transfers. 9543fcb027dSDaniel Mack */ 9553fcb027dSDaniel Mack 9567f917a8dSShawn Guo if (is_imx31_mmc(mxcmci) && card->type == MMC_TYPE_SDIO) 9573fcb027dSDaniel Mack host->caps &= ~MMC_CAP_4_BIT_DATA; 9583fcb027dSDaniel Mack else 9593fcb027dSDaniel Mack host->caps |= MMC_CAP_4_BIT_DATA; 9603fcb027dSDaniel Mack } 9613fcb027dSDaniel Mack 962f53fbde4SSascha Hauer static bool filter(struct dma_chan *chan, void *param) 963f53fbde4SSascha Hauer { 964f53fbde4SSascha Hauer struct mxcmci_host *host = param; 965f53fbde4SSascha Hauer 966f53fbde4SSascha Hauer if (!imx_dma_is_general_purpose(chan)) 967f53fbde4SSascha Hauer return false; 968f53fbde4SSascha Hauer 969f53fbde4SSascha Hauer chan->private = &host->dma_data; 970f53fbde4SSascha Hauer 971f53fbde4SSascha Hauer return true; 972f53fbde4SSascha Hauer } 973f53fbde4SSascha Hauer 9742ee4f620SKees Cook static void mxcmci_watchdog(struct timer_list *t) 975f6ad0a48SJavier Martin { 9762ee4f620SKees Cook struct mxcmci_host *host = from_timer(host, t, watchdog); 977f6ad0a48SJavier Martin struct mmc_request *req = host->req; 978c7ceab02SAnatolij Gustschin unsigned int stat = mxcmci_readl(host, MMC_REG_STATUS); 979f6ad0a48SJavier Martin 980f6ad0a48SJavier Martin if (host->dma_dir == DMA_FROM_DEVICE) { 981f6ad0a48SJavier Martin dmaengine_terminate_all(host->dma); 982f6ad0a48SJavier Martin dev_err(mmc_dev(host->mmc), 983f6ad0a48SJavier Martin "%s: read time out (status = 0x%08x)\n", 984f6ad0a48SJavier Martin __func__, stat); 985f6ad0a48SJavier Martin } else { 986f6ad0a48SJavier Martin dev_err(mmc_dev(host->mmc), 987f6ad0a48SJavier Martin "%s: write time out (status = 0x%08x)\n", 988f6ad0a48SJavier Martin __func__, stat); 989f6ad0a48SJavier Martin mxcmci_softreset(host); 990f6ad0a48SJavier Martin } 991f6ad0a48SJavier Martin 992f6ad0a48SJavier Martin /* Mark transfer as erroneus and inform the upper layers */ 993f6ad0a48SJavier Martin 99470aa6109SAnatolij Gustschin if (host->data) 995f6ad0a48SJavier Martin host->data->error = -ETIMEDOUT; 996f6ad0a48SJavier Martin host->req = NULL; 997f6ad0a48SJavier Martin host->cmd = NULL; 998f6ad0a48SJavier Martin host->data = NULL; 999f6ad0a48SJavier Martin mmc_request_done(host->mmc, req); 1000f6ad0a48SJavier Martin } 1001f6ad0a48SJavier Martin 1002d96be879SSascha Hauer static const struct mmc_host_ops mxcmci_ops = { 1003d96be879SSascha Hauer .request = mxcmci_request, 1004d96be879SSascha Hauer .set_ios = mxcmci_set_ios, 1005d96be879SSascha Hauer .get_ro = mxcmci_get_ro, 1006f441b993SDaniel Mack .enable_sdio_irq = mxcmci_enable_sdio_irq, 10073fcb027dSDaniel Mack .init_card = mxcmci_init_card, 1008d96be879SSascha Hauer }; 1009d96be879SSascha Hauer 1010d96be879SSascha Hauer static int mxcmci_probe(struct platform_device *pdev) 1011d96be879SSascha Hauer { 1012d96be879SSascha Hauer struct mmc_host *mmc; 101301e4f958SAlexander Shiyan struct mxcmci_host *host; 101401e4f958SAlexander Shiyan struct resource *res; 1015d96be879SSascha Hauer int ret = 0, irq; 10167ff747c4SMarkus Pargmann bool dat3_card_detect = false; 1017f53fbde4SSascha Hauer dma_cap_mask_t mask; 10187ff747c4SMarkus Pargmann const struct of_device_id *of_id; 10197ff747c4SMarkus Pargmann struct imxmmc_platform_data *pdata = pdev->dev.platform_data; 1020d96be879SSascha Hauer 1021c7ceab02SAnatolij Gustschin pr_info("i.MX/MPC512x SDHC driver\n"); 1022d96be879SSascha Hauer 10237ff747c4SMarkus Pargmann of_id = of_match_device(mxcmci_of_match, &pdev->dev); 10247ff747c4SMarkus Pargmann 102501e4f958SAlexander Shiyan res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1026d96be879SSascha Hauer irq = platform_get_irq(pdev, 0); 1027f216c124SGustavo A. R. Silva if (irq < 0) { 1028f216c124SGustavo A. R. Silva dev_err(&pdev->dev, "failed to get IRQ: %d\n", irq); 1029f216c124SGustavo A. R. Silva return irq; 1030f216c124SGustavo A. R. Silva } 1031d96be879SSascha Hauer 103201e4f958SAlexander Shiyan mmc = mmc_alloc_host(sizeof(*host), &pdev->dev); 103301e4f958SAlexander Shiyan if (!mmc) 103401e4f958SAlexander Shiyan return -ENOMEM; 1035d96be879SSascha Hauer 103601e4f958SAlexander Shiyan host = mmc_priv(mmc); 103701e4f958SAlexander Shiyan 103801e4f958SAlexander Shiyan host->base = devm_ioremap_resource(&pdev->dev, res); 103901e4f958SAlexander Shiyan if (IS_ERR(host->base)) { 104001e4f958SAlexander Shiyan ret = PTR_ERR(host->base); 104101e4f958SAlexander Shiyan goto out_free; 1042d96be879SSascha Hauer } 1043d96be879SSascha Hauer 104401e4f958SAlexander Shiyan host->phys_base = res->start; 104501e4f958SAlexander Shiyan 1046b8857696SSimon Baatz ret = mmc_of_parse(mmc); 1047b8857696SSimon Baatz if (ret) 1048b8857696SSimon Baatz goto out_free; 1049d96be879SSascha Hauer mmc->ops = &mxcmci_ops; 10507ff747c4SMarkus Pargmann 10517ff747c4SMarkus Pargmann /* For devicetree parsing, the bus width is read from devicetree */ 10527ff747c4SMarkus Pargmann if (pdata) 1053f441b993SDaniel Mack mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ; 10547ff747c4SMarkus Pargmann else 10557ff747c4SMarkus Pargmann mmc->caps |= MMC_CAP_SDIO_IRQ; 1056d96be879SSascha Hauer 1057d96be879SSascha Hauer /* MMC core transfer sizes tunable parameters */ 1058d96be879SSascha Hauer mmc->max_blk_size = 2048; 1059d96be879SSascha Hauer mmc->max_blk_count = 65535; 1060d96be879SSascha Hauer mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count; 1061d759c374SVladimir Zapolskiy mmc->max_seg_size = mmc->max_req_size; 1062d96be879SSascha Hauer 10637ff747c4SMarkus Pargmann if (of_id) { 10647ff747c4SMarkus Pargmann const struct platform_device_id *id_entry = of_id->data; 10657ff747c4SMarkus Pargmann host->devtype = id_entry->driver_data; 10667ff747c4SMarkus Pargmann } else { 10677f917a8dSShawn Guo host->devtype = pdev->id_entry->driver_data; 10687ff747c4SMarkus Pargmann } 1069e48fc15aSAnatolij Gustschin 1070e48fc15aSAnatolij Gustschin /* adjust max_segs after devtype detection */ 1071e48fc15aSAnatolij Gustschin if (!is_mpc512x_mmc(host)) 1072e48fc15aSAnatolij Gustschin mmc->max_segs = 64; 1073e48fc15aSAnatolij Gustschin 10747ff747c4SMarkus Pargmann host->mmc = mmc; 10757ff747c4SMarkus Pargmann host->pdata = pdata; 1076f441b993SDaniel Mack spin_lock_init(&host->lock); 1077d96be879SSascha Hauer 10787ff747c4SMarkus Pargmann if (pdata) 10797ff747c4SMarkus Pargmann dat3_card_detect = pdata->dat3_card_detect; 1080860951c5SJaehoon Chung else if (mmc_card_is_removable(mmc) 10817ff747c4SMarkus Pargmann && !of_property_read_bool(pdev->dev.of_node, "cd-gpios")) 10827ff747c4SMarkus Pargmann dat3_card_detect = true; 10837ff747c4SMarkus Pargmann 1084bc3c1771SAlexander Shiyan ret = mmc_regulator_get_supply(mmc); 1085337d7c8aSWolfram Sang if (ret) 1086bc3c1771SAlexander Shiyan goto out_free; 108718a09806SMatteo Facchinetti 108818a09806SMatteo Facchinetti if (!mmc->ocr_avail) { 108918a09806SMatteo Facchinetti if (pdata && pdata->ocr_avail) 109018a09806SMatteo Facchinetti mmc->ocr_avail = pdata->ocr_avail; 109118a09806SMatteo Facchinetti else 109218a09806SMatteo Facchinetti mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34; 1093bc3c1771SAlexander Shiyan } 1094d96be879SSascha Hauer 10957ff747c4SMarkus Pargmann if (dat3_card_detect) 109616b3bf8cSEric Bénard host->default_irq_mask = 109716b3bf8cSEric Bénard INT_CARD_INSERTION_EN | INT_CARD_REMOVAL_EN; 109816b3bf8cSEric Bénard else 109916b3bf8cSEric Bénard host->default_irq_mask = 0; 110016b3bf8cSEric Bénard 1101529aa29eSSascha Hauer host->clk_ipg = devm_clk_get(&pdev->dev, "ipg"); 1102529aa29eSSascha Hauer if (IS_ERR(host->clk_ipg)) { 1103529aa29eSSascha Hauer ret = PTR_ERR(host->clk_ipg); 110401e4f958SAlexander Shiyan goto out_free; 1105d96be879SSascha Hauer } 1106529aa29eSSascha Hauer 1107529aa29eSSascha Hauer host->clk_per = devm_clk_get(&pdev->dev, "per"); 1108529aa29eSSascha Hauer if (IS_ERR(host->clk_per)) { 1109529aa29eSSascha Hauer ret = PTR_ERR(host->clk_per); 111001e4f958SAlexander Shiyan goto out_free; 1111529aa29eSSascha Hauer } 1112529aa29eSSascha Hauer 1113a2bc74cfSArvind Yadav ret = clk_prepare_enable(host->clk_per); 1114a2bc74cfSArvind Yadav if (ret) 1115a2bc74cfSArvind Yadav goto out_free; 1116a2bc74cfSArvind Yadav 1117a2bc74cfSArvind Yadav ret = clk_prepare_enable(host->clk_ipg); 1118a2bc74cfSArvind Yadav if (ret) 1119a2bc74cfSArvind Yadav goto out_clk_per_put; 1120d96be879SSascha Hauer 1121d96be879SSascha Hauer mxcmci_softreset(host); 1122d96be879SSascha Hauer 1123c7ceab02SAnatolij Gustschin host->rev_no = mxcmci_readw(host, MMC_REG_REV_NO); 1124d96be879SSascha Hauer if (host->rev_no != 0x400) { 1125d96be879SSascha Hauer ret = -ENODEV; 1126d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "wrong rev.no. 0x%08x. aborting.\n", 1127d96be879SSascha Hauer host->rev_no); 1128d96be879SSascha Hauer goto out_clk_put; 1129d96be879SSascha Hauer } 1130d96be879SSascha Hauer 1131529aa29eSSascha Hauer mmc->f_min = clk_get_rate(host->clk_per) >> 16; 1132529aa29eSSascha Hauer mmc->f_max = clk_get_rate(host->clk_per) >> 1; 1133d96be879SSascha Hauer 1134d96be879SSascha Hauer /* recommended in data sheet */ 1135c7ceab02SAnatolij Gustschin mxcmci_writew(host, 0x2db4, MMC_REG_READ_TO); 1136d96be879SSascha Hauer 1137c7ceab02SAnatolij Gustschin mxcmci_writel(host, host->default_irq_mask, MMC_REG_INT_CNTR); 1138d96be879SSascha Hauer 11397ff747c4SMarkus Pargmann if (!host->pdata) { 11407ff747c4SMarkus Pargmann host->dma = dma_request_slave_channel(&pdev->dev, "rx-tx"); 11417ff747c4SMarkus Pargmann } else { 114201e4f958SAlexander Shiyan res = platform_get_resource(pdev, IORESOURCE_DMA, 0); 114301e4f958SAlexander Shiyan if (res) { 114401e4f958SAlexander Shiyan host->dmareq = res->start; 1145f53fbde4SSascha Hauer host->dma_data.peripheral_type = IMX_DMATYPE_SDHC; 1146f53fbde4SSascha Hauer host->dma_data.priority = DMA_PRIO_LOW; 1147f53fbde4SSascha Hauer host->dma_data.dma_request = host->dmareq; 1148f53fbde4SSascha Hauer dma_cap_zero(mask); 1149f53fbde4SSascha Hauer dma_cap_set(DMA_SLAVE, mask); 1150f53fbde4SSascha Hauer host->dma = dma_request_channel(mask, filter, host); 11517ff747c4SMarkus Pargmann } 11527ff747c4SMarkus Pargmann } 1153f53fbde4SSascha Hauer if (host->dma) 1154f53fbde4SSascha Hauer mmc->max_seg_size = dma_get_max_seg_size( 1155f53fbde4SSascha Hauer host->dma->device->dev); 11567ff747c4SMarkus Pargmann else 1157f53fbde4SSascha Hauer dev_info(mmc_dev(host->mmc), "dma not available. Using PIO\n"); 1158f53fbde4SSascha Hauer 1159d96be879SSascha Hauer INIT_WORK(&host->datawork, mxcmci_datawork); 1160d96be879SSascha Hauer 116101e4f958SAlexander Shiyan ret = devm_request_irq(&pdev->dev, irq, mxcmci_irq, 0, 116201e4f958SAlexander Shiyan dev_name(&pdev->dev), host); 1163d96be879SSascha Hauer if (ret) 1164d96be879SSascha Hauer goto out_free_dma; 1165d96be879SSascha Hauer 1166d96be879SSascha Hauer platform_set_drvdata(pdev, mmc); 1167d96be879SSascha Hauer 1168d96be879SSascha Hauer if (host->pdata && host->pdata->init) { 1169d96be879SSascha Hauer ret = host->pdata->init(&pdev->dev, mxcmci_detect_irq, 1170d96be879SSascha Hauer host->mmc); 1171d96be879SSascha Hauer if (ret) 117201e4f958SAlexander Shiyan goto out_free_dma; 1173d96be879SSascha Hauer } 1174d96be879SSascha Hauer 11752ee4f620SKees Cook timer_setup(&host->watchdog, mxcmci_watchdog, 0); 1176f6ad0a48SJavier Martin 1177abd4190fSAlexander Shiyan mmc_add_host(mmc); 1178abd4190fSAlexander Shiyan 1179d96be879SSascha Hauer return 0; 1180d96be879SSascha Hauer 1181d96be879SSascha Hauer out_free_dma: 1182f53fbde4SSascha Hauer if (host->dma) 1183f53fbde4SSascha Hauer dma_release_channel(host->dma); 118401e4f958SAlexander Shiyan 1185d96be879SSascha Hauer out_clk_put: 1186529aa29eSSascha Hauer clk_disable_unprepare(host->clk_ipg); 1187a2bc74cfSArvind Yadav out_clk_per_put: 1188a2bc74cfSArvind Yadav clk_disable_unprepare(host->clk_per); 118901e4f958SAlexander Shiyan 1190d96be879SSascha Hauer out_free: 1191d96be879SSascha Hauer mmc_free_host(mmc); 119201e4f958SAlexander Shiyan 1193d96be879SSascha Hauer return ret; 1194d96be879SSascha Hauer } 1195d96be879SSascha Hauer 1196d96be879SSascha Hauer static int mxcmci_remove(struct platform_device *pdev) 1197d96be879SSascha Hauer { 1198d96be879SSascha Hauer struct mmc_host *mmc = platform_get_drvdata(pdev); 1199d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 1200d96be879SSascha Hauer 1201d96be879SSascha Hauer mmc_remove_host(mmc); 1202d96be879SSascha Hauer 1203d96be879SSascha Hauer if (host->pdata && host->pdata->exit) 1204d96be879SSascha Hauer host->pdata->exit(&pdev->dev, mmc); 1205d96be879SSascha Hauer 1206f53fbde4SSascha Hauer if (host->dma) 1207f53fbde4SSascha Hauer dma_release_channel(host->dma); 1208f53fbde4SSascha Hauer 1209529aa29eSSascha Hauer clk_disable_unprepare(host->clk_per); 1210529aa29eSSascha Hauer clk_disable_unprepare(host->clk_ipg); 1211d96be879SSascha Hauer 1212d96be879SSascha Hauer mmc_free_host(mmc); 1213d96be879SSascha Hauer 1214d96be879SSascha Hauer return 0; 1215d96be879SSascha Hauer } 1216d96be879SSascha Hauer 1217d8edfc4eSUlf Hansson #ifdef CONFIG_PM_SLEEP 1218d8edfc4eSUlf Hansson static int mxcmci_suspend(struct device *dev) 1219d96be879SSascha Hauer { 1220a7d403cfSEric Bénard struct mmc_host *mmc = dev_get_drvdata(dev); 1221a7d403cfSEric Bénard struct mxcmci_host *host = mmc_priv(mmc); 1222d96be879SSascha Hauer 1223529aa29eSSascha Hauer clk_disable_unprepare(host->clk_per); 1224529aa29eSSascha Hauer clk_disable_unprepare(host->clk_ipg); 1225bd190f90SUlf Hansson return 0; 1226d96be879SSascha Hauer } 1227d96be879SSascha Hauer 1228d8edfc4eSUlf Hansson static int mxcmci_resume(struct device *dev) 1229d96be879SSascha Hauer { 1230a7d403cfSEric Bénard struct mmc_host *mmc = dev_get_drvdata(dev); 1231a7d403cfSEric Bénard struct mxcmci_host *host = mmc_priv(mmc); 1232a2bc74cfSArvind Yadav int ret; 1233d96be879SSascha Hauer 1234a2bc74cfSArvind Yadav ret = clk_prepare_enable(host->clk_per); 1235a2bc74cfSArvind Yadav if (ret) 1236a2bc74cfSArvind Yadav return ret; 1237a2bc74cfSArvind Yadav 1238a2bc74cfSArvind Yadav ret = clk_prepare_enable(host->clk_ipg); 1239a2bc74cfSArvind Yadav if (ret) 1240a2bc74cfSArvind Yadav clk_disable_unprepare(host->clk_per); 1241a2bc74cfSArvind Yadav 1242a2bc74cfSArvind Yadav return ret; 1243d96be879SSascha Hauer } 1244d8edfc4eSUlf Hansson #endif 1245a7d403cfSEric Bénard 1246384a81d5SAlexander Shiyan static SIMPLE_DEV_PM_OPS(mxcmci_pm_ops, mxcmci_suspend, mxcmci_resume); 1247d96be879SSascha Hauer 1248d96be879SSascha Hauer static struct platform_driver mxcmci_driver = { 1249d96be879SSascha Hauer .probe = mxcmci_probe, 1250d96be879SSascha Hauer .remove = mxcmci_remove, 12517f917a8dSShawn Guo .id_table = mxcmci_devtype, 1252d96be879SSascha Hauer .driver = { 1253d96be879SSascha Hauer .name = DRIVER_NAME, 1254a7d403cfSEric Bénard .pm = &mxcmci_pm_ops, 12557ff747c4SMarkus Pargmann .of_match_table = mxcmci_of_match, 1256d96be879SSascha Hauer } 1257d96be879SSascha Hauer }; 1258d96be879SSascha Hauer 1259d1f81a64SAxel Lin module_platform_driver(mxcmci_driver); 1260d96be879SSascha Hauer 1261d96be879SSascha Hauer MODULE_DESCRIPTION("i.MX Multimedia Card Interface Driver"); 1262d96be879SSascha Hauer MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 1263d96be879SSascha Hauer MODULE_LICENSE("GPL"); 12646eb30adfSFabio Estevam MODULE_ALIAS("platform:mxc-mmc"); 1265