1d96be879SSascha Hauer /* 2d96be879SSascha Hauer * linux/drivers/mmc/host/mxcmmc.c - Freescale i.MX MMCI driver 3d96be879SSascha Hauer * 4d96be879SSascha Hauer * This is a driver for the SDHC controller found in Freescale MX2/MX3 5d96be879SSascha Hauer * SoCs. It is basically the same hardware as found on MX1 (imxmmc.c). 6d96be879SSascha Hauer * Unlike the hardware found on MX1, this hardware just works and does 73ad2f3fbSDaniel Mack * not need all the quirks found in imxmmc.c, hence the separate driver. 8d96be879SSascha Hauer * 9d96be879SSascha Hauer * Copyright (C) 2008 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de> 10d96be879SSascha Hauer * Copyright (C) 2006 Pavel Pisa, PiKRON <ppisa@pikron.com> 11d96be879SSascha Hauer * 12d96be879SSascha Hauer * derived from pxamci.c by Russell King 13d96be879SSascha Hauer * 14d96be879SSascha Hauer * This program is free software; you can redistribute it and/or modify 15d96be879SSascha Hauer * it under the terms of the GNU General Public License version 2 as 16d96be879SSascha Hauer * published by the Free Software Foundation. 17d96be879SSascha Hauer * 18d96be879SSascha Hauer */ 19d96be879SSascha Hauer 20d96be879SSascha Hauer #include <linux/module.h> 21d96be879SSascha Hauer #include <linux/init.h> 22d96be879SSascha Hauer #include <linux/ioport.h> 23d96be879SSascha Hauer #include <linux/platform_device.h> 24d96be879SSascha Hauer #include <linux/interrupt.h> 25d96be879SSascha Hauer #include <linux/irq.h> 26d96be879SSascha Hauer #include <linux/blkdev.h> 27d96be879SSascha Hauer #include <linux/dma-mapping.h> 28d96be879SSascha Hauer #include <linux/mmc/host.h> 29d96be879SSascha Hauer #include <linux/mmc/card.h> 30d96be879SSascha Hauer #include <linux/delay.h> 31d96be879SSascha Hauer #include <linux/clk.h> 32d96be879SSascha Hauer #include <linux/io.h> 33d96be879SSascha Hauer #include <linux/gpio.h> 3474b66954SAlberto Panizzo #include <linux/regulator/consumer.h> 35f53fbde4SSascha Hauer #include <linux/dmaengine.h> 36258aea76SViresh Kumar #include <linux/types.h> 377ff747c4SMarkus Pargmann #include <linux/of.h> 387ff747c4SMarkus Pargmann #include <linux/of_device.h> 397ff747c4SMarkus Pargmann #include <linux/of_dma.h> 407ff747c4SMarkus Pargmann #include <linux/of_gpio.h> 41bcf53524SAnatolij Gustschin #include <linux/mmc/slot-gpio.h> 42d96be879SSascha Hauer 43d96be879SSascha Hauer #include <asm/dma.h> 44d96be879SSascha Hauer #include <asm/irq.h> 4582906b13SArnd Bergmann #include <linux/platform_data/mmc-mxcmmc.h> 46d96be879SSascha Hauer 4782906b13SArnd Bergmann #include <linux/platform_data/dma-imx.h> 48d96be879SSascha Hauer 499563b1dbSSascha Hauer #define DRIVER_NAME "mxc-mmc" 50f6ad0a48SJavier Martin #define MXCMCI_TIMEOUT_MS 10000 51d96be879SSascha Hauer 52d96be879SSascha Hauer #define MMC_REG_STR_STP_CLK 0x00 53d96be879SSascha Hauer #define MMC_REG_STATUS 0x04 54d96be879SSascha Hauer #define MMC_REG_CLK_RATE 0x08 55d96be879SSascha Hauer #define MMC_REG_CMD_DAT_CONT 0x0C 56d96be879SSascha Hauer #define MMC_REG_RES_TO 0x10 57d96be879SSascha Hauer #define MMC_REG_READ_TO 0x14 58d96be879SSascha Hauer #define MMC_REG_BLK_LEN 0x18 59d96be879SSascha Hauer #define MMC_REG_NOB 0x1C 60d96be879SSascha Hauer #define MMC_REG_REV_NO 0x20 61d96be879SSascha Hauer #define MMC_REG_INT_CNTR 0x24 62d96be879SSascha Hauer #define MMC_REG_CMD 0x28 63d96be879SSascha Hauer #define MMC_REG_ARG 0x2C 64d96be879SSascha Hauer #define MMC_REG_RES_FIFO 0x34 65d96be879SSascha Hauer #define MMC_REG_BUFFER_ACCESS 0x38 66d96be879SSascha Hauer 67d96be879SSascha Hauer #define STR_STP_CLK_RESET (1 << 3) 68d96be879SSascha Hauer #define STR_STP_CLK_START_CLK (1 << 1) 69d96be879SSascha Hauer #define STR_STP_CLK_STOP_CLK (1 << 0) 70d96be879SSascha Hauer 71d96be879SSascha Hauer #define STATUS_CARD_INSERTION (1 << 31) 72d96be879SSascha Hauer #define STATUS_CARD_REMOVAL (1 << 30) 73d96be879SSascha Hauer #define STATUS_YBUF_EMPTY (1 << 29) 74d96be879SSascha Hauer #define STATUS_XBUF_EMPTY (1 << 28) 75d96be879SSascha Hauer #define STATUS_YBUF_FULL (1 << 27) 76d96be879SSascha Hauer #define STATUS_XBUF_FULL (1 << 26) 77d96be879SSascha Hauer #define STATUS_BUF_UND_RUN (1 << 25) 78d96be879SSascha Hauer #define STATUS_BUF_OVFL (1 << 24) 79d96be879SSascha Hauer #define STATUS_SDIO_INT_ACTIVE (1 << 14) 80d96be879SSascha Hauer #define STATUS_END_CMD_RESP (1 << 13) 81d96be879SSascha Hauer #define STATUS_WRITE_OP_DONE (1 << 12) 82d96be879SSascha Hauer #define STATUS_DATA_TRANS_DONE (1 << 11) 83d96be879SSascha Hauer #define STATUS_READ_OP_DONE (1 << 11) 84d96be879SSascha Hauer #define STATUS_WR_CRC_ERROR_CODE_MASK (3 << 10) 85d96be879SSascha Hauer #define STATUS_CARD_BUS_CLK_RUN (1 << 8) 86d96be879SSascha Hauer #define STATUS_BUF_READ_RDY (1 << 7) 87d96be879SSascha Hauer #define STATUS_BUF_WRITE_RDY (1 << 6) 88d96be879SSascha Hauer #define STATUS_RESP_CRC_ERR (1 << 5) 89d96be879SSascha Hauer #define STATUS_CRC_READ_ERR (1 << 3) 90d96be879SSascha Hauer #define STATUS_CRC_WRITE_ERR (1 << 2) 91d96be879SSascha Hauer #define STATUS_TIME_OUT_RESP (1 << 1) 92d96be879SSascha Hauer #define STATUS_TIME_OUT_READ (1 << 0) 93d96be879SSascha Hauer #define STATUS_ERR_MASK 0x2f 94d96be879SSascha Hauer 95d96be879SSascha Hauer #define CMD_DAT_CONT_CMD_RESP_LONG_OFF (1 << 12) 96d96be879SSascha Hauer #define CMD_DAT_CONT_STOP_READWAIT (1 << 11) 97d96be879SSascha Hauer #define CMD_DAT_CONT_START_READWAIT (1 << 10) 98d96be879SSascha Hauer #define CMD_DAT_CONT_BUS_WIDTH_4 (2 << 8) 99d96be879SSascha Hauer #define CMD_DAT_CONT_INIT (1 << 7) 100d96be879SSascha Hauer #define CMD_DAT_CONT_WRITE (1 << 4) 101d96be879SSascha Hauer #define CMD_DAT_CONT_DATA_ENABLE (1 << 3) 102d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_48BIT_CRC (1 << 0) 103d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_136BIT (2 << 0) 104d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_48BIT (3 << 0) 105d96be879SSascha Hauer 106d96be879SSascha Hauer #define INT_SDIO_INT_WKP_EN (1 << 18) 107d96be879SSascha Hauer #define INT_CARD_INSERTION_WKP_EN (1 << 17) 108d96be879SSascha Hauer #define INT_CARD_REMOVAL_WKP_EN (1 << 16) 109d96be879SSascha Hauer #define INT_CARD_INSERTION_EN (1 << 15) 110d96be879SSascha Hauer #define INT_CARD_REMOVAL_EN (1 << 14) 111d96be879SSascha Hauer #define INT_SDIO_IRQ_EN (1 << 13) 112d96be879SSascha Hauer #define INT_DAT0_EN (1 << 12) 113d96be879SSascha Hauer #define INT_BUF_READ_EN (1 << 4) 114d96be879SSascha Hauer #define INT_BUF_WRITE_EN (1 << 3) 115d96be879SSascha Hauer #define INT_END_CMD_RES_EN (1 << 2) 116d96be879SSascha Hauer #define INT_WRITE_OP_DONE_EN (1 << 1) 117d96be879SSascha Hauer #define INT_READ_OP_EN (1 << 0) 118d96be879SSascha Hauer 1197f917a8dSShawn Guo enum mxcmci_type { 1207f917a8dSShawn Guo IMX21_MMC, 1217f917a8dSShawn Guo IMX31_MMC, 122c7ceab02SAnatolij Gustschin MPC512X_MMC, 1237f917a8dSShawn Guo }; 1247f917a8dSShawn Guo 125d96be879SSascha Hauer struct mxcmci_host { 126d96be879SSascha Hauer struct mmc_host *mmc; 127d96be879SSascha Hauer struct resource *res; 128d96be879SSascha Hauer void __iomem *base; 129d96be879SSascha Hauer int irq; 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 15774b66954SAlberto Panizzo struct regulator *vcc; 158f53fbde4SSascha Hauer 159f53fbde4SSascha Hauer int burstlen; 160f53fbde4SSascha Hauer int dmareq; 161f53fbde4SSascha Hauer struct dma_slave_config dma_slave_config; 162f53fbde4SSascha Hauer struct imx_dma_data dma_data; 163f6ad0a48SJavier Martin 164f6ad0a48SJavier Martin struct timer_list watchdog; 1657f917a8dSShawn Guo enum mxcmci_type devtype; 166d96be879SSascha Hauer }; 167d96be879SSascha Hauer 16842477053SAnatolij Gustschin static const struct platform_device_id mxcmci_devtype[] = { 1697f917a8dSShawn Guo { 1707f917a8dSShawn Guo .name = "imx21-mmc", 1717f917a8dSShawn Guo .driver_data = IMX21_MMC, 1727f917a8dSShawn Guo }, { 1737f917a8dSShawn Guo .name = "imx31-mmc", 1747f917a8dSShawn Guo .driver_data = IMX31_MMC, 1757f917a8dSShawn Guo }, { 176c7ceab02SAnatolij Gustschin .name = "mpc512x-sdhc", 177c7ceab02SAnatolij Gustschin .driver_data = MPC512X_MMC, 178c7ceab02SAnatolij Gustschin }, { 1797f917a8dSShawn Guo /* sentinel */ 1807f917a8dSShawn Guo } 1817f917a8dSShawn Guo }; 1827f917a8dSShawn Guo MODULE_DEVICE_TABLE(platform, mxcmci_devtype); 1837f917a8dSShawn Guo 1847ff747c4SMarkus Pargmann static const struct of_device_id mxcmci_of_match[] = { 1857ff747c4SMarkus Pargmann { 1867ff747c4SMarkus Pargmann .compatible = "fsl,imx21-mmc", 1877ff747c4SMarkus Pargmann .data = &mxcmci_devtype[IMX21_MMC], 1887ff747c4SMarkus Pargmann }, { 1897ff747c4SMarkus Pargmann .compatible = "fsl,imx31-mmc", 1907ff747c4SMarkus Pargmann .data = &mxcmci_devtype[IMX31_MMC], 1917ff747c4SMarkus Pargmann }, { 192c7ceab02SAnatolij Gustschin .compatible = "fsl,mpc5121-sdhc", 193c7ceab02SAnatolij Gustschin .data = &mxcmci_devtype[MPC512X_MMC], 194c7ceab02SAnatolij Gustschin }, { 1957ff747c4SMarkus Pargmann /* sentinel */ 1967ff747c4SMarkus Pargmann } 1977ff747c4SMarkus Pargmann }; 1987ff747c4SMarkus Pargmann MODULE_DEVICE_TABLE(of, mxcmci_of_match); 1997ff747c4SMarkus Pargmann 2007f917a8dSShawn Guo static inline int is_imx31_mmc(struct mxcmci_host *host) 2017f917a8dSShawn Guo { 2027f917a8dSShawn Guo return host->devtype == IMX31_MMC; 2037f917a8dSShawn Guo } 2047f917a8dSShawn Guo 205c7ceab02SAnatolij Gustschin static inline int is_mpc512x_mmc(struct mxcmci_host *host) 206c7ceab02SAnatolij Gustschin { 207c7ceab02SAnatolij Gustschin return host->devtype == MPC512X_MMC; 208c7ceab02SAnatolij Gustschin } 209c7ceab02SAnatolij Gustschin 210c7ceab02SAnatolij Gustschin static inline u32 mxcmci_readl(struct mxcmci_host *host, int reg) 211c7ceab02SAnatolij Gustschin { 212c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 213c7ceab02SAnatolij Gustschin return ioread32be(host->base + reg); 214c7ceab02SAnatolij Gustschin else 215c7ceab02SAnatolij Gustschin return readl(host->base + reg); 216c7ceab02SAnatolij Gustschin } 217c7ceab02SAnatolij Gustschin 218c7ceab02SAnatolij Gustschin static inline void mxcmci_writel(struct mxcmci_host *host, u32 val, int reg) 219c7ceab02SAnatolij Gustschin { 220c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 221c7ceab02SAnatolij Gustschin iowrite32be(val, host->base + reg); 222c7ceab02SAnatolij Gustschin else 223c7ceab02SAnatolij Gustschin writel(val, host->base + reg); 224c7ceab02SAnatolij Gustschin } 225c7ceab02SAnatolij Gustschin 226c7ceab02SAnatolij Gustschin static inline u16 mxcmci_readw(struct mxcmci_host *host, int reg) 227c7ceab02SAnatolij Gustschin { 228c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 229c7ceab02SAnatolij Gustschin return ioread32be(host->base + reg); 230c7ceab02SAnatolij Gustschin else 231c7ceab02SAnatolij Gustschin return readw(host->base + reg); 232c7ceab02SAnatolij Gustschin } 233c7ceab02SAnatolij Gustschin 234c7ceab02SAnatolij Gustschin static inline void mxcmci_writew(struct mxcmci_host *host, u16 val, int reg) 235c7ceab02SAnatolij Gustschin { 236c7ceab02SAnatolij Gustschin if (IS_ENABLED(CONFIG_PPC_MPC512x)) 237c7ceab02SAnatolij Gustschin iowrite32be(val, host->base + reg); 238c7ceab02SAnatolij Gustschin else 239c7ceab02SAnatolij Gustschin writew(val, host->base + reg); 240c7ceab02SAnatolij Gustschin } 241c7ceab02SAnatolij Gustschin 24218489fa2SMartin Fuzzey static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios); 24318489fa2SMartin Fuzzey 24474b66954SAlberto Panizzo static inline void mxcmci_init_ocr(struct mxcmci_host *host) 24574b66954SAlberto Panizzo { 24674b66954SAlberto Panizzo host->vcc = regulator_get(mmc_dev(host->mmc), "vmmc"); 24774b66954SAlberto Panizzo 24874b66954SAlberto Panizzo if (IS_ERR(host->vcc)) { 24974b66954SAlberto Panizzo host->vcc = NULL; 25074b66954SAlberto Panizzo } else { 25174b66954SAlberto Panizzo host->mmc->ocr_avail = mmc_regulator_get_ocrmask(host->vcc); 25274b66954SAlberto Panizzo if (host->pdata && host->pdata->ocr_avail) 25374b66954SAlberto Panizzo dev_warn(mmc_dev(host->mmc), 25474b66954SAlberto Panizzo "pdata->ocr_avail will not be used\n"); 25574b66954SAlberto Panizzo } 256d078d242SAlberto Panizzo 25774b66954SAlberto Panizzo if (host->vcc == NULL) { 25874b66954SAlberto Panizzo /* fall-back to platform data */ 25974b66954SAlberto Panizzo if (host->pdata && host->pdata->ocr_avail) 26074b66954SAlberto Panizzo host->mmc->ocr_avail = host->pdata->ocr_avail; 26174b66954SAlberto Panizzo else 26274b66954SAlberto Panizzo host->mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34; 26374b66954SAlberto Panizzo } 26474b66954SAlberto Panizzo } 26574b66954SAlberto Panizzo 266d078d242SAlberto Panizzo static inline void mxcmci_set_power(struct mxcmci_host *host, 267d078d242SAlberto Panizzo unsigned char power_mode, 268d078d242SAlberto Panizzo unsigned int vdd) 26974b66954SAlberto Panizzo { 270d078d242SAlberto Panizzo if (host->vcc) { 271d078d242SAlberto Panizzo if (power_mode == MMC_POWER_UP) 272d078d242SAlberto Panizzo mmc_regulator_set_ocr(host->mmc, host->vcc, vdd); 273d078d242SAlberto Panizzo else if (power_mode == MMC_POWER_OFF) 274d078d242SAlberto Panizzo mmc_regulator_set_ocr(host->mmc, host->vcc, 0); 275d078d242SAlberto Panizzo } 276d078d242SAlberto Panizzo 27774b66954SAlberto Panizzo if (host->pdata && host->pdata->setpower) 27874b66954SAlberto Panizzo host->pdata->setpower(mmc_dev(host->mmc), vdd); 27974b66954SAlberto Panizzo } 28074b66954SAlberto Panizzo 281d96be879SSascha Hauer static inline int mxcmci_use_dma(struct mxcmci_host *host) 282d96be879SSascha Hauer { 283d96be879SSascha Hauer return host->do_dma; 284d96be879SSascha Hauer } 285d96be879SSascha Hauer 286d96be879SSascha Hauer static void mxcmci_softreset(struct mxcmci_host *host) 287d96be879SSascha Hauer { 288d96be879SSascha Hauer int i; 289d96be879SSascha Hauer 2904725f6f1SDaniel Mack dev_dbg(mmc_dev(host->mmc), "mxcmci_softreset\n"); 2914725f6f1SDaniel Mack 292d96be879SSascha Hauer /* reset sequence */ 293c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_RESET, MMC_REG_STR_STP_CLK); 294c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_RESET | STR_STP_CLK_START_CLK, 295c7ceab02SAnatolij Gustschin MMC_REG_STR_STP_CLK); 296d96be879SSascha Hauer 297d96be879SSascha Hauer for (i = 0; i < 8; i++) 298c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_START_CLK, MMC_REG_STR_STP_CLK); 299d96be879SSascha Hauer 300c7ceab02SAnatolij Gustschin mxcmci_writew(host, 0xff, MMC_REG_RES_TO); 301d96be879SSascha Hauer } 302f53fbde4SSascha Hauer static int mxcmci_setup_dma(struct mmc_host *mmc); 303d96be879SSascha Hauer 304e48fc15aSAnatolij Gustschin #if IS_ENABLED(CONFIG_PPC_MPC512x) 305e48fc15aSAnatolij Gustschin static inline void buffer_swap32(u32 *buf, int len) 306e48fc15aSAnatolij Gustschin { 307e48fc15aSAnatolij Gustschin int i; 308e48fc15aSAnatolij Gustschin 309e48fc15aSAnatolij Gustschin for (i = 0; i < ((len + 3) / 4); i++) { 310e48fc15aSAnatolij Gustschin st_le32(buf, *buf); 311e48fc15aSAnatolij Gustschin buf++; 312e48fc15aSAnatolij Gustschin } 313e48fc15aSAnatolij Gustschin } 314e48fc15aSAnatolij Gustschin 315e48fc15aSAnatolij Gustschin static void mxcmci_swap_buffers(struct mmc_data *data) 316e48fc15aSAnatolij Gustschin { 317e48fc15aSAnatolij Gustschin struct scatterlist *sg; 318e48fc15aSAnatolij Gustschin int i; 319e48fc15aSAnatolij Gustschin 320e48fc15aSAnatolij Gustschin for_each_sg(data->sg, sg, data->sg_len, i) 321e48fc15aSAnatolij Gustschin buffer_swap32(sg_virt(sg), sg->length); 322e48fc15aSAnatolij Gustschin } 323e48fc15aSAnatolij Gustschin #else 324e48fc15aSAnatolij Gustschin static inline void mxcmci_swap_buffers(struct mmc_data *data) {} 325e48fc15aSAnatolij Gustschin #endif 326e48fc15aSAnatolij Gustschin 327656217d2SMartin Fuzzey static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data) 328d96be879SSascha Hauer { 329d96be879SSascha Hauer unsigned int nob = data->blocks; 330d96be879SSascha Hauer unsigned int blksz = data->blksz; 331d96be879SSascha Hauer unsigned int datasize = nob * blksz; 332d96be879SSascha Hauer struct scatterlist *sg; 33305f5799cSVinod Koul enum dma_transfer_direction slave_dirn; 334f53fbde4SSascha Hauer int i, nents; 335f53fbde4SSascha Hauer 336d96be879SSascha Hauer if (data->flags & MMC_DATA_STREAM) 337d96be879SSascha Hauer nob = 0xffff; 338d96be879SSascha Hauer 339d96be879SSascha Hauer host->data = data; 340d96be879SSascha Hauer data->bytes_xfered = 0; 341d96be879SSascha Hauer 342c7ceab02SAnatolij Gustschin mxcmci_writew(host, nob, MMC_REG_NOB); 343c7ceab02SAnatolij Gustschin mxcmci_writew(host, blksz, MMC_REG_BLK_LEN); 344d96be879SSascha Hauer host->datasize = datasize; 345d96be879SSascha Hauer 346f53fbde4SSascha Hauer if (!mxcmci_use_dma(host)) 347f53fbde4SSascha Hauer return 0; 348f53fbde4SSascha Hauer 349d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 3502cb53552SJavier Martin if (sg->offset & 3 || sg->length & 3 || sg->length < 512) { 351d96be879SSascha Hauer host->do_dma = 0; 352656217d2SMartin Fuzzey return 0; 353d96be879SSascha Hauer } 354d96be879SSascha Hauer } 355d96be879SSascha Hauer 35605f5799cSVinod Koul if (data->flags & MMC_DATA_READ) { 357d96be879SSascha Hauer host->dma_dir = DMA_FROM_DEVICE; 35805f5799cSVinod Koul slave_dirn = DMA_DEV_TO_MEM; 35905f5799cSVinod Koul } else { 360d96be879SSascha Hauer host->dma_dir = DMA_TO_DEVICE; 36105f5799cSVinod Koul slave_dirn = DMA_MEM_TO_DEV; 362e48fc15aSAnatolij Gustschin 363e48fc15aSAnatolij Gustschin mxcmci_swap_buffers(data); 36405f5799cSVinod Koul } 365f53fbde4SSascha Hauer 366f53fbde4SSascha Hauer nents = dma_map_sg(host->dma->device->dev, data->sg, 367d96be879SSascha Hauer data->sg_len, host->dma_dir); 368f53fbde4SSascha Hauer if (nents != data->sg_len) 369f53fbde4SSascha Hauer return -EINVAL; 370d96be879SSascha Hauer 37116052827SAlexandre Bounine host->desc = dmaengine_prep_slave_sg(host->dma, 37205f5799cSVinod Koul data->sg, data->sg_len, slave_dirn, 373f53fbde4SSascha Hauer DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 374d96be879SSascha Hauer 375f53fbde4SSascha Hauer if (!host->desc) { 376f53fbde4SSascha Hauer dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len, 377f53fbde4SSascha Hauer host->dma_dir); 378f53fbde4SSascha Hauer host->do_dma = 0; 379f53fbde4SSascha Hauer return 0; /* Fall back to PIO */ 380656217d2SMartin Fuzzey } 381d96be879SSascha Hauer wmb(); 382d96be879SSascha Hauer 383f53fbde4SSascha Hauer dmaengine_submit(host->desc); 384439aa0efSSascha Hauer dma_async_issue_pending(host->dma); 385f53fbde4SSascha Hauer 386f6ad0a48SJavier Martin mod_timer(&host->watchdog, jiffies + msecs_to_jiffies(MXCMCI_TIMEOUT_MS)); 387f6ad0a48SJavier Martin 388656217d2SMartin Fuzzey return 0; 389d96be879SSascha Hauer } 390d96be879SSascha Hauer 391f6ad0a48SJavier Martin static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat); 392f6ad0a48SJavier Martin static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat); 393f6ad0a48SJavier Martin 394f6ad0a48SJavier Martin static void mxcmci_dma_callback(void *data) 395f6ad0a48SJavier Martin { 396f6ad0a48SJavier Martin struct mxcmci_host *host = data; 397f6ad0a48SJavier Martin u32 stat; 398f6ad0a48SJavier Martin 399f6ad0a48SJavier Martin del_timer(&host->watchdog); 400f6ad0a48SJavier Martin 401c7ceab02SAnatolij Gustschin stat = mxcmci_readl(host, MMC_REG_STATUS); 402c7ceab02SAnatolij Gustschin mxcmci_writel(host, stat & ~STATUS_DATA_TRANS_DONE, MMC_REG_STATUS); 403f6ad0a48SJavier Martin 404f6ad0a48SJavier Martin dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat); 405f6ad0a48SJavier Martin 406f6ad0a48SJavier Martin if (stat & STATUS_READ_OP_DONE) 407c7ceab02SAnatolij Gustschin mxcmci_writel(host, STATUS_READ_OP_DONE, MMC_REG_STATUS); 408f6ad0a48SJavier Martin 409f6ad0a48SJavier Martin mxcmci_data_done(host, stat); 410f6ad0a48SJavier Martin } 411f6ad0a48SJavier Martin 412d96be879SSascha Hauer static int mxcmci_start_cmd(struct mxcmci_host *host, struct mmc_command *cmd, 413d96be879SSascha Hauer unsigned int cmdat) 414d96be879SSascha Hauer { 41516b3bf8cSEric Bénard u32 int_cntr = host->default_irq_mask; 416f441b993SDaniel Mack unsigned long flags; 417f441b993SDaniel Mack 418d96be879SSascha Hauer WARN_ON(host->cmd != NULL); 419d96be879SSascha Hauer host->cmd = cmd; 420d96be879SSascha Hauer 421d96be879SSascha Hauer switch (mmc_resp_type(cmd)) { 422d96be879SSascha Hauer case MMC_RSP_R1: /* short CRC, OPCODE */ 423d96be879SSascha Hauer case MMC_RSP_R1B:/* short CRC, OPCODE, BUSY */ 424d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_48BIT_CRC; 425d96be879SSascha Hauer break; 426d96be879SSascha Hauer case MMC_RSP_R2: /* long 136 bit + CRC */ 427d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_136BIT; 428d96be879SSascha Hauer break; 429d96be879SSascha Hauer case MMC_RSP_R3: /* short */ 430d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_48BIT; 431d96be879SSascha Hauer break; 432d96be879SSascha Hauer case MMC_RSP_NONE: 433d96be879SSascha Hauer break; 434d96be879SSascha Hauer default: 435d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "unhandled response type 0x%x\n", 436d96be879SSascha Hauer mmc_resp_type(cmd)); 437d96be879SSascha Hauer cmd->error = -EINVAL; 438d96be879SSascha Hauer return -EINVAL; 439d96be879SSascha Hauer } 440d96be879SSascha Hauer 441f441b993SDaniel Mack int_cntr = INT_END_CMD_RES_EN; 442f441b993SDaniel Mack 443f6ad0a48SJavier Martin if (mxcmci_use_dma(host)) { 444f6ad0a48SJavier Martin if (host->dma_dir == DMA_FROM_DEVICE) { 445f6ad0a48SJavier Martin host->desc->callback = mxcmci_dma_callback; 446f6ad0a48SJavier Martin host->desc->callback_param = host; 447f6ad0a48SJavier Martin } else { 448f6ad0a48SJavier Martin int_cntr |= INT_WRITE_OP_DONE_EN; 449f6ad0a48SJavier Martin } 450f6ad0a48SJavier Martin } 451f441b993SDaniel Mack 452f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 453f441b993SDaniel Mack if (host->use_sdio) 454f441b993SDaniel Mack int_cntr |= INT_SDIO_IRQ_EN; 455c7ceab02SAnatolij Gustschin mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 456f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 457d96be879SSascha Hauer 458c7ceab02SAnatolij Gustschin mxcmci_writew(host, cmd->opcode, MMC_REG_CMD); 459c7ceab02SAnatolij Gustschin mxcmci_writel(host, cmd->arg, MMC_REG_ARG); 460c7ceab02SAnatolij Gustschin mxcmci_writew(host, cmdat, MMC_REG_CMD_DAT_CONT); 461d96be879SSascha Hauer 462d96be879SSascha Hauer return 0; 463d96be879SSascha Hauer } 464d96be879SSascha Hauer 465d96be879SSascha Hauer static void mxcmci_finish_request(struct mxcmci_host *host, 466d96be879SSascha Hauer struct mmc_request *req) 467d96be879SSascha Hauer { 46816b3bf8cSEric Bénard u32 int_cntr = host->default_irq_mask; 469f441b993SDaniel Mack unsigned long flags; 470f441b993SDaniel Mack 471f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 472f441b993SDaniel Mack if (host->use_sdio) 473f441b993SDaniel Mack int_cntr |= INT_SDIO_IRQ_EN; 474c7ceab02SAnatolij Gustschin mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 475f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 476d96be879SSascha Hauer 477d96be879SSascha Hauer host->req = NULL; 478d96be879SSascha Hauer host->cmd = NULL; 479d96be879SSascha Hauer host->data = NULL; 480d96be879SSascha Hauer 481d96be879SSascha Hauer mmc_request_done(host->mmc, req); 482d96be879SSascha Hauer } 483d96be879SSascha Hauer 484d96be879SSascha Hauer static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat) 485d96be879SSascha Hauer { 486d96be879SSascha Hauer struct mmc_data *data = host->data; 487d96be879SSascha Hauer int data_error; 488d96be879SSascha Hauer 489e48fc15aSAnatolij Gustschin if (mxcmci_use_dma(host)) { 490f53fbde4SSascha Hauer dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len, 491d96be879SSascha Hauer host->dma_dir); 492e48fc15aSAnatolij Gustschin mxcmci_swap_buffers(data); 493e48fc15aSAnatolij Gustschin } 494d96be879SSascha Hauer 495d96be879SSascha Hauer if (stat & STATUS_ERR_MASK) { 496d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n", 497d96be879SSascha Hauer stat); 498d96be879SSascha Hauer if (stat & STATUS_CRC_READ_ERR) { 4994725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), "%s: -EILSEQ\n", __func__); 500d96be879SSascha Hauer data->error = -EILSEQ; 501d96be879SSascha Hauer } else if (stat & STATUS_CRC_WRITE_ERR) { 502d96be879SSascha Hauer u32 err_code = (stat >> 9) & 0x3; 5034725f6f1SDaniel Mack if (err_code == 2) { /* No CRC response */ 5044725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), 5054725f6f1SDaniel Mack "%s: No CRC -ETIMEDOUT\n", __func__); 506d96be879SSascha Hauer data->error = -ETIMEDOUT; 507d96be879SSascha Hauer } else { 5084725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), 5094725f6f1SDaniel Mack "%s: -EILSEQ\n", __func__); 5104725f6f1SDaniel Mack data->error = -EILSEQ; 5114725f6f1SDaniel Mack } 5124725f6f1SDaniel Mack } else if (stat & STATUS_TIME_OUT_READ) { 5134725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), 5144725f6f1SDaniel Mack "%s: read -ETIMEDOUT\n", __func__); 5154725f6f1SDaniel Mack data->error = -ETIMEDOUT; 5164725f6f1SDaniel Mack } else { 5174725f6f1SDaniel Mack dev_err(mmc_dev(host->mmc), "%s: -EIO\n", __func__); 518d96be879SSascha Hauer data->error = -EIO; 519d96be879SSascha Hauer } 520d96be879SSascha Hauer } else { 521d96be879SSascha Hauer data->bytes_xfered = host->datasize; 522d96be879SSascha Hauer } 523d96be879SSascha Hauer 524d96be879SSascha Hauer data_error = data->error; 525d96be879SSascha Hauer 526d96be879SSascha Hauer host->data = NULL; 527d96be879SSascha Hauer 528d96be879SSascha Hauer return data_error; 529d96be879SSascha Hauer } 530d96be879SSascha Hauer 531d96be879SSascha Hauer static void mxcmci_read_response(struct mxcmci_host *host, unsigned int stat) 532d96be879SSascha Hauer { 533d96be879SSascha Hauer struct mmc_command *cmd = host->cmd; 534d96be879SSascha Hauer int i; 535d96be879SSascha Hauer u32 a, b, c; 536d96be879SSascha Hauer 537d96be879SSascha Hauer if (!cmd) 538d96be879SSascha Hauer return; 539d96be879SSascha Hauer 540d96be879SSascha Hauer if (stat & STATUS_TIME_OUT_RESP) { 541d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "CMD TIMEOUT\n"); 542d96be879SSascha Hauer cmd->error = -ETIMEDOUT; 543d96be879SSascha Hauer } else if (stat & STATUS_RESP_CRC_ERR && cmd->flags & MMC_RSP_CRC) { 544d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "cmd crc error\n"); 545d96be879SSascha Hauer cmd->error = -EILSEQ; 546d96be879SSascha Hauer } 547d96be879SSascha Hauer 548d96be879SSascha Hauer if (cmd->flags & MMC_RSP_PRESENT) { 549d96be879SSascha Hauer if (cmd->flags & MMC_RSP_136) { 550d96be879SSascha Hauer for (i = 0; i < 4; i++) { 551c7ceab02SAnatolij Gustschin a = mxcmci_readw(host, MMC_REG_RES_FIFO); 552c7ceab02SAnatolij Gustschin b = mxcmci_readw(host, MMC_REG_RES_FIFO); 553d96be879SSascha Hauer cmd->resp[i] = a << 16 | b; 554d96be879SSascha Hauer } 555d96be879SSascha Hauer } else { 556c7ceab02SAnatolij Gustschin a = mxcmci_readw(host, MMC_REG_RES_FIFO); 557c7ceab02SAnatolij Gustschin b = mxcmci_readw(host, MMC_REG_RES_FIFO); 558c7ceab02SAnatolij Gustschin c = mxcmci_readw(host, MMC_REG_RES_FIFO); 559d96be879SSascha Hauer cmd->resp[0] = a << 24 | b << 8 | c >> 8; 560d96be879SSascha Hauer } 561d96be879SSascha Hauer } 562d96be879SSascha Hauer } 563d96be879SSascha Hauer 564d96be879SSascha Hauer static int mxcmci_poll_status(struct mxcmci_host *host, u32 mask) 565d96be879SSascha Hauer { 566d96be879SSascha Hauer u32 stat; 567d96be879SSascha Hauer unsigned long timeout = jiffies + HZ; 568d96be879SSascha Hauer 569d96be879SSascha Hauer do { 570c7ceab02SAnatolij Gustschin stat = mxcmci_readl(host, MMC_REG_STATUS); 571d96be879SSascha Hauer if (stat & STATUS_ERR_MASK) 572d96be879SSascha Hauer return stat; 57318489fa2SMartin Fuzzey if (time_after(jiffies, timeout)) { 57418489fa2SMartin Fuzzey mxcmci_softreset(host); 57518489fa2SMartin Fuzzey mxcmci_set_clk_rate(host, host->clock); 576d96be879SSascha Hauer return STATUS_TIME_OUT_READ; 57718489fa2SMartin Fuzzey } 578d96be879SSascha Hauer if (stat & mask) 579d96be879SSascha Hauer return 0; 580d96be879SSascha Hauer cpu_relax(); 581d96be879SSascha Hauer } while (1); 582d96be879SSascha Hauer } 583d96be879SSascha Hauer 584d96be879SSascha Hauer static int mxcmci_pull(struct mxcmci_host *host, void *_buf, int bytes) 585d96be879SSascha Hauer { 586d96be879SSascha Hauer unsigned int stat; 587d96be879SSascha Hauer u32 *buf = _buf; 588d96be879SSascha Hauer 589d96be879SSascha Hauer while (bytes > 3) { 590d96be879SSascha Hauer stat = mxcmci_poll_status(host, 591d96be879SSascha Hauer STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 592d96be879SSascha Hauer if (stat) 593d96be879SSascha Hauer return stat; 594c7ceab02SAnatolij Gustschin *buf++ = cpu_to_le32(mxcmci_readl(host, MMC_REG_BUFFER_ACCESS)); 595d96be879SSascha Hauer bytes -= 4; 596d96be879SSascha Hauer } 597d96be879SSascha Hauer 598d96be879SSascha Hauer if (bytes) { 599d96be879SSascha Hauer u8 *b = (u8 *)buf; 600d96be879SSascha Hauer u32 tmp; 601d96be879SSascha Hauer 602d96be879SSascha Hauer stat = mxcmci_poll_status(host, 603d96be879SSascha Hauer STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 604d96be879SSascha Hauer if (stat) 605d96be879SSascha Hauer return stat; 606c7ceab02SAnatolij Gustschin tmp = cpu_to_le32(mxcmci_readl(host, MMC_REG_BUFFER_ACCESS)); 607d96be879SSascha Hauer memcpy(b, &tmp, bytes); 608d96be879SSascha Hauer } 609d96be879SSascha Hauer 610d96be879SSascha Hauer return 0; 611d96be879SSascha Hauer } 612d96be879SSascha Hauer 613d96be879SSascha Hauer static int mxcmci_push(struct mxcmci_host *host, void *_buf, int bytes) 614d96be879SSascha Hauer { 615d96be879SSascha Hauer unsigned int stat; 616d96be879SSascha Hauer u32 *buf = _buf; 617d96be879SSascha Hauer 618d96be879SSascha Hauer while (bytes > 3) { 619d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 620d96be879SSascha Hauer if (stat) 621d96be879SSascha Hauer return stat; 622c7ceab02SAnatolij Gustschin mxcmci_writel(host, cpu_to_le32(*buf++), MMC_REG_BUFFER_ACCESS); 623d96be879SSascha Hauer bytes -= 4; 624d96be879SSascha Hauer } 625d96be879SSascha Hauer 626d96be879SSascha Hauer if (bytes) { 627d96be879SSascha Hauer u8 *b = (u8 *)buf; 628d96be879SSascha Hauer u32 tmp; 629d96be879SSascha Hauer 630d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 631d96be879SSascha Hauer if (stat) 632d96be879SSascha Hauer return stat; 633d96be879SSascha Hauer 634d96be879SSascha Hauer memcpy(&tmp, b, bytes); 635c7ceab02SAnatolij Gustschin mxcmci_writel(host, cpu_to_le32(tmp), MMC_REG_BUFFER_ACCESS); 636d96be879SSascha Hauer } 637d96be879SSascha Hauer 638d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 639d96be879SSascha Hauer if (stat) 640d96be879SSascha Hauer return stat; 641d96be879SSascha Hauer 642d96be879SSascha Hauer return 0; 643d96be879SSascha Hauer } 644d96be879SSascha Hauer 645d96be879SSascha Hauer static int mxcmci_transfer_data(struct mxcmci_host *host) 646d96be879SSascha Hauer { 647d96be879SSascha Hauer struct mmc_data *data = host->req->data; 648d96be879SSascha Hauer struct scatterlist *sg; 649d96be879SSascha Hauer int stat, i; 650d96be879SSascha Hauer 651d96be879SSascha Hauer host->data = data; 652d96be879SSascha Hauer host->datasize = 0; 653d96be879SSascha Hauer 654d96be879SSascha Hauer if (data->flags & MMC_DATA_READ) { 655d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 656d96be879SSascha Hauer stat = mxcmci_pull(host, sg_virt(sg), sg->length); 657d96be879SSascha Hauer if (stat) 658d96be879SSascha Hauer return stat; 659d96be879SSascha Hauer host->datasize += sg->length; 660d96be879SSascha Hauer } 661d96be879SSascha Hauer } else { 662d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 663d96be879SSascha Hauer stat = mxcmci_push(host, sg_virt(sg), sg->length); 664d96be879SSascha Hauer if (stat) 665d96be879SSascha Hauer return stat; 666d96be879SSascha Hauer host->datasize += sg->length; 667d96be879SSascha Hauer } 668d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_WRITE_OP_DONE); 669d96be879SSascha Hauer if (stat) 670d96be879SSascha Hauer return stat; 671d96be879SSascha Hauer } 672d96be879SSascha Hauer return 0; 673d96be879SSascha Hauer } 674d96be879SSascha Hauer 675d96be879SSascha Hauer static void mxcmci_datawork(struct work_struct *work) 676d96be879SSascha Hauer { 677d96be879SSascha Hauer struct mxcmci_host *host = container_of(work, struct mxcmci_host, 678d96be879SSascha Hauer datawork); 679d96be879SSascha Hauer int datastat = mxcmci_transfer_data(host); 6804a31f2efSDaniel Mack 681c7ceab02SAnatolij Gustschin mxcmci_writel(host, STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE, 682c7ceab02SAnatolij Gustschin MMC_REG_STATUS); 683d96be879SSascha Hauer mxcmci_finish_data(host, datastat); 684d96be879SSascha Hauer 685d96be879SSascha Hauer if (host->req->stop) { 686d96be879SSascha Hauer if (mxcmci_start_cmd(host, host->req->stop, 0)) { 687d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 688d96be879SSascha Hauer return; 689d96be879SSascha Hauer } 690d96be879SSascha Hauer } else { 691d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 692d96be879SSascha Hauer } 693d96be879SSascha Hauer } 694d96be879SSascha Hauer 695d96be879SSascha Hauer static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat) 696d96be879SSascha Hauer { 69770aa6109SAnatolij Gustschin struct mmc_request *req; 698d96be879SSascha Hauer int data_error; 69970aa6109SAnatolij Gustschin unsigned long flags; 700d96be879SSascha Hauer 70170aa6109SAnatolij Gustschin spin_lock_irqsave(&host->lock, flags); 70270aa6109SAnatolij Gustschin 70370aa6109SAnatolij Gustschin if (!host->data) { 70470aa6109SAnatolij Gustschin spin_unlock_irqrestore(&host->lock, flags); 705d96be879SSascha Hauer return; 70670aa6109SAnatolij Gustschin } 70770aa6109SAnatolij Gustschin 70870aa6109SAnatolij Gustschin if (!host->req) { 70970aa6109SAnatolij Gustschin spin_unlock_irqrestore(&host->lock, flags); 71070aa6109SAnatolij Gustschin return; 71170aa6109SAnatolij Gustschin } 71270aa6109SAnatolij Gustschin 71370aa6109SAnatolij Gustschin req = host->req; 71470aa6109SAnatolij Gustschin if (!req->stop) 71570aa6109SAnatolij Gustschin host->req = NULL; /* we will handle finish req below */ 716d96be879SSascha Hauer 717d96be879SSascha Hauer data_error = mxcmci_finish_data(host, stat); 718d96be879SSascha Hauer 71970aa6109SAnatolij Gustschin spin_unlock_irqrestore(&host->lock, flags); 72070aa6109SAnatolij Gustschin 721d96be879SSascha Hauer mxcmci_read_response(host, stat); 722d96be879SSascha Hauer host->cmd = NULL; 723d96be879SSascha Hauer 72470aa6109SAnatolij Gustschin if (req->stop) { 72570aa6109SAnatolij Gustschin if (mxcmci_start_cmd(host, req->stop, 0)) { 72670aa6109SAnatolij Gustschin mxcmci_finish_request(host, req); 727d96be879SSascha Hauer return; 728d96be879SSascha Hauer } 729d96be879SSascha Hauer } else { 73070aa6109SAnatolij Gustschin mxcmci_finish_request(host, req); 731d96be879SSascha Hauer } 732d96be879SSascha Hauer } 733d96be879SSascha Hauer 734d96be879SSascha Hauer static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat) 735d96be879SSascha Hauer { 736d96be879SSascha Hauer mxcmci_read_response(host, stat); 737d96be879SSascha Hauer host->cmd = NULL; 738d96be879SSascha Hauer 739d96be879SSascha Hauer if (!host->data && host->req) { 740d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 741d96be879SSascha Hauer return; 742d96be879SSascha Hauer } 743d96be879SSascha Hauer 744d96be879SSascha Hauer /* For the DMA case the DMA engine handles the data transfer 745fd589a8fSAnand Gadiyar * automatically. For non DMA we have to do it ourselves. 746d96be879SSascha Hauer * Don't do it in interrupt context though. 747d96be879SSascha Hauer */ 748d96be879SSascha Hauer if (!mxcmci_use_dma(host) && host->data) 749d96be879SSascha Hauer schedule_work(&host->datawork); 750d96be879SSascha Hauer 751d96be879SSascha Hauer } 752d96be879SSascha Hauer 753d96be879SSascha Hauer static irqreturn_t mxcmci_irq(int irq, void *devid) 754d96be879SSascha Hauer { 755d96be879SSascha Hauer struct mxcmci_host *host = devid; 756f441b993SDaniel Mack unsigned long flags; 757f441b993SDaniel Mack bool sdio_irq; 758d96be879SSascha Hauer u32 stat; 759d96be879SSascha Hauer 760c7ceab02SAnatolij Gustschin stat = mxcmci_readl(host, MMC_REG_STATUS); 761c7ceab02SAnatolij Gustschin mxcmci_writel(host, 762c7ceab02SAnatolij Gustschin stat & ~(STATUS_SDIO_INT_ACTIVE | STATUS_DATA_TRANS_DONE | 763c7ceab02SAnatolij Gustschin STATUS_WRITE_OP_DONE), 764c7ceab02SAnatolij Gustschin MMC_REG_STATUS); 765d96be879SSascha Hauer 766d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat); 767d96be879SSascha Hauer 768f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 769f441b993SDaniel Mack sdio_irq = (stat & STATUS_SDIO_INT_ACTIVE) && host->use_sdio; 770f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 771f441b993SDaniel Mack 7724a31f2efSDaniel Mack if (mxcmci_use_dma(host) && 7734a31f2efSDaniel Mack (stat & (STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE))) 774c7ceab02SAnatolij Gustschin mxcmci_writel(host, STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE, 775c7ceab02SAnatolij Gustschin MMC_REG_STATUS); 7764a31f2efSDaniel Mack 777f441b993SDaniel Mack if (sdio_irq) { 778c7ceab02SAnatolij Gustschin mxcmci_writel(host, STATUS_SDIO_INT_ACTIVE, MMC_REG_STATUS); 779f441b993SDaniel Mack mmc_signal_sdio_irq(host->mmc); 780f441b993SDaniel Mack } 781f441b993SDaniel Mack 782d96be879SSascha Hauer if (stat & STATUS_END_CMD_RESP) 783d96be879SSascha Hauer mxcmci_cmd_done(host, stat); 784f441b993SDaniel Mack 785d96be879SSascha Hauer if (mxcmci_use_dma(host) && 786f6ad0a48SJavier Martin (stat & (STATUS_DATA_TRANS_DONE | STATUS_WRITE_OP_DONE))) { 787f6ad0a48SJavier Martin del_timer(&host->watchdog); 788d96be879SSascha Hauer mxcmci_data_done(host, stat); 789f6ad0a48SJavier Martin } 790f53fbde4SSascha Hauer 79116b3bf8cSEric Bénard if (host->default_irq_mask && 79216b3bf8cSEric Bénard (stat & (STATUS_CARD_INSERTION | STATUS_CARD_REMOVAL))) 79316b3bf8cSEric Bénard mmc_detect_change(host->mmc, msecs_to_jiffies(200)); 794f53fbde4SSascha Hauer 795d96be879SSascha Hauer return IRQ_HANDLED; 796d96be879SSascha Hauer } 797d96be879SSascha Hauer 798d96be879SSascha Hauer static void mxcmci_request(struct mmc_host *mmc, struct mmc_request *req) 799d96be879SSascha Hauer { 800d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 801d96be879SSascha Hauer unsigned int cmdat = host->cmdat; 802656217d2SMartin Fuzzey int error; 803d96be879SSascha Hauer 804d96be879SSascha Hauer WARN_ON(host->req != NULL); 805d96be879SSascha Hauer 806d96be879SSascha Hauer host->req = req; 807d96be879SSascha Hauer host->cmdat &= ~CMD_DAT_CONT_INIT; 808f53fbde4SSascha Hauer 809f53fbde4SSascha Hauer if (host->dma) 810d96be879SSascha Hauer host->do_dma = 1; 811f53fbde4SSascha Hauer 812d96be879SSascha Hauer if (req->data) { 813656217d2SMartin Fuzzey error = mxcmci_setup_data(host, req->data); 814656217d2SMartin Fuzzey if (error) { 815656217d2SMartin Fuzzey req->cmd->error = error; 816656217d2SMartin Fuzzey goto out; 817656217d2SMartin Fuzzey } 818656217d2SMartin Fuzzey 819d96be879SSascha Hauer 820d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_DATA_ENABLE; 821d96be879SSascha Hauer 822d96be879SSascha Hauer if (req->data->flags & MMC_DATA_WRITE) 823d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_WRITE; 824d96be879SSascha Hauer } 825d96be879SSascha Hauer 826656217d2SMartin Fuzzey error = mxcmci_start_cmd(host, req->cmd, cmdat); 827f53fbde4SSascha Hauer 828656217d2SMartin Fuzzey out: 829656217d2SMartin Fuzzey if (error) 830d96be879SSascha Hauer mxcmci_finish_request(host, req); 831d96be879SSascha Hauer } 832d96be879SSascha Hauer 833d96be879SSascha Hauer static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios) 834d96be879SSascha Hauer { 835d96be879SSascha Hauer unsigned int divider; 836d96be879SSascha Hauer int prescaler = 0; 837529aa29eSSascha Hauer unsigned int clk_in = clk_get_rate(host->clk_per); 838d96be879SSascha Hauer 839d96be879SSascha Hauer while (prescaler <= 0x800) { 840d96be879SSascha Hauer for (divider = 1; divider <= 0xF; divider++) { 841d96be879SSascha Hauer int x; 842d96be879SSascha Hauer 843d96be879SSascha Hauer x = (clk_in / (divider + 1)); 844d96be879SSascha Hauer 845d96be879SSascha Hauer if (prescaler) 846d96be879SSascha Hauer x /= (prescaler * 2); 847d96be879SSascha Hauer 848d96be879SSascha Hauer if (x <= clk_ios) 849d96be879SSascha Hauer break; 850d96be879SSascha Hauer } 851d96be879SSascha Hauer if (divider < 0x10) 852d96be879SSascha Hauer break; 853d96be879SSascha Hauer 854d96be879SSascha Hauer if (prescaler == 0) 855d96be879SSascha Hauer prescaler = 1; 856d96be879SSascha Hauer else 857d96be879SSascha Hauer prescaler <<= 1; 858d96be879SSascha Hauer } 859d96be879SSascha Hauer 860c7ceab02SAnatolij Gustschin mxcmci_writew(host, (prescaler << 4) | divider, MMC_REG_CLK_RATE); 861d96be879SSascha Hauer 862d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "scaler: %d divider: %d in: %d out: %d\n", 863d96be879SSascha Hauer prescaler, divider, clk_in, clk_ios); 864d96be879SSascha Hauer } 865d96be879SSascha Hauer 866f53fbde4SSascha Hauer static int mxcmci_setup_dma(struct mmc_host *mmc) 867f53fbde4SSascha Hauer { 868f53fbde4SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 869f53fbde4SSascha Hauer struct dma_slave_config *config = &host->dma_slave_config; 870f53fbde4SSascha Hauer 871f53fbde4SSascha Hauer config->dst_addr = host->res->start + MMC_REG_BUFFER_ACCESS; 872f53fbde4SSascha Hauer config->src_addr = host->res->start + MMC_REG_BUFFER_ACCESS; 873f53fbde4SSascha Hauer config->dst_addr_width = 4; 874f53fbde4SSascha Hauer config->src_addr_width = 4; 875f53fbde4SSascha Hauer config->dst_maxburst = host->burstlen; 876f53fbde4SSascha Hauer config->src_maxburst = host->burstlen; 877258aea76SViresh Kumar config->device_fc = false; 878f53fbde4SSascha Hauer 879f53fbde4SSascha Hauer return dmaengine_slave_config(host->dma, config); 880f53fbde4SSascha Hauer } 881f53fbde4SSascha Hauer 882d96be879SSascha Hauer static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 883d96be879SSascha Hauer { 884d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 885f53fbde4SSascha Hauer int burstlen, ret; 886f53fbde4SSascha Hauer 887d96be879SSascha Hauer /* 8886584cb88SSascha Hauer * use burstlen of 64 (16 words) in 4 bit mode (--> reg value 0) 8896584cb88SSascha Hauer * use burstlen of 16 (4 words) in 1 bit mode (--> reg value 16) 890d96be879SSascha Hauer */ 891d96be879SSascha Hauer if (ios->bus_width == MMC_BUS_WIDTH_4) 892f53fbde4SSascha Hauer burstlen = 16; 8936584cb88SSascha Hauer else 8946584cb88SSascha Hauer burstlen = 4; 895d96be879SSascha Hauer 896f53fbde4SSascha Hauer if (mxcmci_use_dma(host) && burstlen != host->burstlen) { 897f53fbde4SSascha Hauer host->burstlen = burstlen; 898f53fbde4SSascha Hauer ret = mxcmci_setup_dma(mmc); 899f53fbde4SSascha Hauer if (ret) { 900f53fbde4SSascha Hauer dev_err(mmc_dev(host->mmc), 901f53fbde4SSascha Hauer "failed to config DMA channel. Falling back to PIO\n"); 902f53fbde4SSascha Hauer dma_release_channel(host->dma); 903f53fbde4SSascha Hauer host->do_dma = 0; 904e58f516fSSascha Hauer host->dma = NULL; 905f53fbde4SSascha Hauer } 906f53fbde4SSascha Hauer } 907f53fbde4SSascha Hauer 908d96be879SSascha Hauer if (ios->bus_width == MMC_BUS_WIDTH_4) 909d96be879SSascha Hauer host->cmdat |= CMD_DAT_CONT_BUS_WIDTH_4; 910d96be879SSascha Hauer else 911d96be879SSascha Hauer host->cmdat &= ~CMD_DAT_CONT_BUS_WIDTH_4; 912d96be879SSascha Hauer 913d96be879SSascha Hauer if (host->power_mode != ios->power_mode) { 914d078d242SAlberto Panizzo mxcmci_set_power(host, ios->power_mode, ios->vdd); 915d96be879SSascha Hauer host->power_mode = ios->power_mode; 91674b66954SAlberto Panizzo 917d96be879SSascha Hauer if (ios->power_mode == MMC_POWER_ON) 918d96be879SSascha Hauer host->cmdat |= CMD_DAT_CONT_INIT; 919d96be879SSascha Hauer } 920d96be879SSascha Hauer 921d96be879SSascha Hauer if (ios->clock) { 922d96be879SSascha Hauer mxcmci_set_clk_rate(host, ios->clock); 923c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_START_CLK, MMC_REG_STR_STP_CLK); 924d96be879SSascha Hauer } else { 925c7ceab02SAnatolij Gustschin mxcmci_writew(host, STR_STP_CLK_STOP_CLK, MMC_REG_STR_STP_CLK); 926d96be879SSascha Hauer } 927d96be879SSascha Hauer 928d96be879SSascha Hauer host->clock = ios->clock; 929d96be879SSascha Hauer } 930d96be879SSascha Hauer 931d96be879SSascha Hauer static irqreturn_t mxcmci_detect_irq(int irq, void *data) 932d96be879SSascha Hauer { 933d96be879SSascha Hauer struct mmc_host *mmc = data; 934d96be879SSascha Hauer 935d96be879SSascha Hauer dev_dbg(mmc_dev(mmc), "%s\n", __func__); 936d96be879SSascha Hauer 937d96be879SSascha Hauer mmc_detect_change(mmc, msecs_to_jiffies(250)); 938d96be879SSascha Hauer return IRQ_HANDLED; 939d96be879SSascha Hauer } 940d96be879SSascha Hauer 941d96be879SSascha Hauer static int mxcmci_get_ro(struct mmc_host *mmc) 942d96be879SSascha Hauer { 943d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 944d96be879SSascha Hauer 945d96be879SSascha Hauer if (host->pdata && host->pdata->get_ro) 946d96be879SSascha Hauer return !!host->pdata->get_ro(mmc_dev(mmc)); 947d96be879SSascha Hauer /* 948bcf53524SAnatolij Gustschin * If board doesn't support read only detection (no mmc_gpio 949bcf53524SAnatolij Gustschin * context or gpio is invalid), then let the mmc core decide 950bcf53524SAnatolij Gustschin * what to do. 951d96be879SSascha Hauer */ 952bcf53524SAnatolij Gustschin return mmc_gpio_get_ro(mmc); 953d96be879SSascha Hauer } 954d96be879SSascha Hauer 955f441b993SDaniel Mack static void mxcmci_enable_sdio_irq(struct mmc_host *mmc, int enable) 956f441b993SDaniel Mack { 957f441b993SDaniel Mack struct mxcmci_host *host = mmc_priv(mmc); 958f441b993SDaniel Mack unsigned long flags; 959f441b993SDaniel Mack u32 int_cntr; 960f441b993SDaniel Mack 961f441b993SDaniel Mack spin_lock_irqsave(&host->lock, flags); 962f441b993SDaniel Mack host->use_sdio = enable; 963c7ceab02SAnatolij Gustschin int_cntr = mxcmci_readl(host, MMC_REG_INT_CNTR); 964f441b993SDaniel Mack 965f441b993SDaniel Mack if (enable) 966f441b993SDaniel Mack int_cntr |= INT_SDIO_IRQ_EN; 967f441b993SDaniel Mack else 968f441b993SDaniel Mack int_cntr &= ~INT_SDIO_IRQ_EN; 969f441b993SDaniel Mack 970c7ceab02SAnatolij Gustschin mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 971f441b993SDaniel Mack spin_unlock_irqrestore(&host->lock, flags); 972f441b993SDaniel Mack } 973d96be879SSascha Hauer 9743fcb027dSDaniel Mack static void mxcmci_init_card(struct mmc_host *host, struct mmc_card *card) 9753fcb027dSDaniel Mack { 9767f917a8dSShawn Guo struct mxcmci_host *mxcmci = mmc_priv(host); 9777f917a8dSShawn Guo 9783fcb027dSDaniel Mack /* 9793fcb027dSDaniel Mack * MX3 SoCs have a silicon bug which corrupts CRC calculation of 9803fcb027dSDaniel Mack * multi-block transfers when connected SDIO peripheral doesn't 9813fcb027dSDaniel Mack * drive the BUSY line as required by the specs. 9823fcb027dSDaniel Mack * One way to prevent this is to only allow 1-bit transfers. 9833fcb027dSDaniel Mack */ 9843fcb027dSDaniel Mack 9857f917a8dSShawn Guo if (is_imx31_mmc(mxcmci) && card->type == MMC_TYPE_SDIO) 9863fcb027dSDaniel Mack host->caps &= ~MMC_CAP_4_BIT_DATA; 9873fcb027dSDaniel Mack else 9883fcb027dSDaniel Mack host->caps |= MMC_CAP_4_BIT_DATA; 9893fcb027dSDaniel Mack } 9903fcb027dSDaniel Mack 991f53fbde4SSascha Hauer static bool filter(struct dma_chan *chan, void *param) 992f53fbde4SSascha Hauer { 993f53fbde4SSascha Hauer struct mxcmci_host *host = param; 994f53fbde4SSascha Hauer 995f53fbde4SSascha Hauer if (!imx_dma_is_general_purpose(chan)) 996f53fbde4SSascha Hauer return false; 997f53fbde4SSascha Hauer 998f53fbde4SSascha Hauer chan->private = &host->dma_data; 999f53fbde4SSascha Hauer 1000f53fbde4SSascha Hauer return true; 1001f53fbde4SSascha Hauer } 1002f53fbde4SSascha Hauer 1003f6ad0a48SJavier Martin static void mxcmci_watchdog(unsigned long data) 1004f6ad0a48SJavier Martin { 1005f6ad0a48SJavier Martin struct mmc_host *mmc = (struct mmc_host *)data; 1006f6ad0a48SJavier Martin struct mxcmci_host *host = mmc_priv(mmc); 1007f6ad0a48SJavier Martin struct mmc_request *req = host->req; 1008c7ceab02SAnatolij Gustschin unsigned int stat = mxcmci_readl(host, MMC_REG_STATUS); 1009f6ad0a48SJavier Martin 1010f6ad0a48SJavier Martin if (host->dma_dir == DMA_FROM_DEVICE) { 1011f6ad0a48SJavier Martin dmaengine_terminate_all(host->dma); 1012f6ad0a48SJavier Martin dev_err(mmc_dev(host->mmc), 1013f6ad0a48SJavier Martin "%s: read time out (status = 0x%08x)\n", 1014f6ad0a48SJavier Martin __func__, stat); 1015f6ad0a48SJavier Martin } else { 1016f6ad0a48SJavier Martin dev_err(mmc_dev(host->mmc), 1017f6ad0a48SJavier Martin "%s: write time out (status = 0x%08x)\n", 1018f6ad0a48SJavier Martin __func__, stat); 1019f6ad0a48SJavier Martin mxcmci_softreset(host); 1020f6ad0a48SJavier Martin } 1021f6ad0a48SJavier Martin 1022f6ad0a48SJavier Martin /* Mark transfer as erroneus and inform the upper layers */ 1023f6ad0a48SJavier Martin 102470aa6109SAnatolij Gustschin if (host->data) 1025f6ad0a48SJavier Martin host->data->error = -ETIMEDOUT; 1026f6ad0a48SJavier Martin host->req = NULL; 1027f6ad0a48SJavier Martin host->cmd = NULL; 1028f6ad0a48SJavier Martin host->data = NULL; 1029f6ad0a48SJavier Martin mmc_request_done(host->mmc, req); 1030f6ad0a48SJavier Martin } 1031f6ad0a48SJavier Martin 1032d96be879SSascha Hauer static const struct mmc_host_ops mxcmci_ops = { 1033d96be879SSascha Hauer .request = mxcmci_request, 1034d96be879SSascha Hauer .set_ios = mxcmci_set_ios, 1035d96be879SSascha Hauer .get_ro = mxcmci_get_ro, 1036f441b993SDaniel Mack .enable_sdio_irq = mxcmci_enable_sdio_irq, 10373fcb027dSDaniel Mack .init_card = mxcmci_init_card, 1038d96be879SSascha Hauer }; 1039d96be879SSascha Hauer 1040d96be879SSascha Hauer static int mxcmci_probe(struct platform_device *pdev) 1041d96be879SSascha Hauer { 1042d96be879SSascha Hauer struct mmc_host *mmc; 1043d96be879SSascha Hauer struct mxcmci_host *host = NULL; 1044c0521bafSUwe Kleine-König struct resource *iores, *r; 1045d96be879SSascha Hauer int ret = 0, irq; 10467ff747c4SMarkus Pargmann bool dat3_card_detect = false; 1047f53fbde4SSascha Hauer dma_cap_mask_t mask; 10487ff747c4SMarkus Pargmann const struct of_device_id *of_id; 10497ff747c4SMarkus Pargmann struct imxmmc_platform_data *pdata = pdev->dev.platform_data; 1050d96be879SSascha Hauer 1051c7ceab02SAnatolij Gustschin pr_info("i.MX/MPC512x SDHC driver\n"); 1052d96be879SSascha Hauer 10537ff747c4SMarkus Pargmann of_id = of_match_device(mxcmci_of_match, &pdev->dev); 10547ff747c4SMarkus Pargmann 1055c0521bafSUwe Kleine-König iores = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1056d96be879SSascha Hauer irq = platform_get_irq(pdev, 0); 1057c0521bafSUwe Kleine-König if (!iores || irq < 0) 1058d96be879SSascha Hauer return -EINVAL; 1059d96be879SSascha Hauer 1060c0521bafSUwe Kleine-König r = request_mem_region(iores->start, resource_size(iores), pdev->name); 1061d96be879SSascha Hauer if (!r) 1062d96be879SSascha Hauer return -EBUSY; 1063d96be879SSascha Hauer 1064d96be879SSascha Hauer mmc = mmc_alloc_host(sizeof(struct mxcmci_host), &pdev->dev); 1065d96be879SSascha Hauer if (!mmc) { 1066d96be879SSascha Hauer ret = -ENOMEM; 1067d96be879SSascha Hauer goto out_release_mem; 1068d96be879SSascha Hauer } 1069d96be879SSascha Hauer 1070b8857696SSimon Baatz ret = mmc_of_parse(mmc); 1071b8857696SSimon Baatz if (ret) 1072b8857696SSimon Baatz goto out_free; 1073d96be879SSascha Hauer mmc->ops = &mxcmci_ops; 10747ff747c4SMarkus Pargmann 10757ff747c4SMarkus Pargmann /* For devicetree parsing, the bus width is read from devicetree */ 10767ff747c4SMarkus Pargmann if (pdata) 1077f441b993SDaniel Mack mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ; 10787ff747c4SMarkus Pargmann else 10797ff747c4SMarkus Pargmann mmc->caps |= MMC_CAP_SDIO_IRQ; 1080d96be879SSascha Hauer 1081d96be879SSascha Hauer /* MMC core transfer sizes tunable parameters */ 1082d96be879SSascha Hauer mmc->max_blk_size = 2048; 1083d96be879SSascha Hauer mmc->max_blk_count = 65535; 1084d96be879SSascha Hauer mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count; 1085d759c374SVladimir Zapolskiy mmc->max_seg_size = mmc->max_req_size; 1086d96be879SSascha Hauer 1087d96be879SSascha Hauer host = mmc_priv(mmc); 1088d96be879SSascha Hauer host->base = ioremap(r->start, resource_size(r)); 1089d96be879SSascha Hauer if (!host->base) { 1090d96be879SSascha Hauer ret = -ENOMEM; 1091d96be879SSascha Hauer goto out_free; 1092d96be879SSascha Hauer } 1093d96be879SSascha Hauer 10947ff747c4SMarkus Pargmann if (of_id) { 10957ff747c4SMarkus Pargmann const struct platform_device_id *id_entry = of_id->data; 10967ff747c4SMarkus Pargmann host->devtype = id_entry->driver_data; 10977ff747c4SMarkus Pargmann } else { 10987f917a8dSShawn Guo host->devtype = pdev->id_entry->driver_data; 10997ff747c4SMarkus Pargmann } 1100e48fc15aSAnatolij Gustschin 1101e48fc15aSAnatolij Gustschin /* adjust max_segs after devtype detection */ 1102e48fc15aSAnatolij Gustschin if (!is_mpc512x_mmc(host)) 1103e48fc15aSAnatolij Gustschin mmc->max_segs = 64; 1104e48fc15aSAnatolij Gustschin 11057ff747c4SMarkus Pargmann host->mmc = mmc; 11067ff747c4SMarkus Pargmann host->pdata = pdata; 1107f441b993SDaniel Mack spin_lock_init(&host->lock); 1108d96be879SSascha Hauer 11097ff747c4SMarkus Pargmann if (pdata) 11107ff747c4SMarkus Pargmann dat3_card_detect = pdata->dat3_card_detect; 11117ff747c4SMarkus Pargmann else if (!(mmc->caps & MMC_CAP_NONREMOVABLE) 11127ff747c4SMarkus Pargmann && !of_property_read_bool(pdev->dev.of_node, "cd-gpios")) 11137ff747c4SMarkus Pargmann dat3_card_detect = true; 11147ff747c4SMarkus Pargmann 111574b66954SAlberto Panizzo mxcmci_init_ocr(host); 1116d96be879SSascha Hauer 11177ff747c4SMarkus Pargmann if (dat3_card_detect) 111816b3bf8cSEric Bénard host->default_irq_mask = 111916b3bf8cSEric Bénard INT_CARD_INSERTION_EN | INT_CARD_REMOVAL_EN; 112016b3bf8cSEric Bénard else 112116b3bf8cSEric Bénard host->default_irq_mask = 0; 112216b3bf8cSEric Bénard 1123d96be879SSascha Hauer host->res = r; 1124d96be879SSascha Hauer host->irq = irq; 1125d96be879SSascha Hauer 1126529aa29eSSascha Hauer host->clk_ipg = devm_clk_get(&pdev->dev, "ipg"); 1127529aa29eSSascha Hauer if (IS_ERR(host->clk_ipg)) { 1128529aa29eSSascha Hauer ret = PTR_ERR(host->clk_ipg); 1129d96be879SSascha Hauer goto out_iounmap; 1130d96be879SSascha Hauer } 1131529aa29eSSascha Hauer 1132529aa29eSSascha Hauer host->clk_per = devm_clk_get(&pdev->dev, "per"); 1133529aa29eSSascha Hauer if (IS_ERR(host->clk_per)) { 1134529aa29eSSascha Hauer ret = PTR_ERR(host->clk_per); 1135529aa29eSSascha Hauer goto out_iounmap; 1136529aa29eSSascha Hauer } 1137529aa29eSSascha Hauer 1138529aa29eSSascha Hauer clk_prepare_enable(host->clk_per); 1139529aa29eSSascha Hauer clk_prepare_enable(host->clk_ipg); 1140d96be879SSascha Hauer 1141d96be879SSascha Hauer mxcmci_softreset(host); 1142d96be879SSascha Hauer 1143c7ceab02SAnatolij Gustschin host->rev_no = mxcmci_readw(host, MMC_REG_REV_NO); 1144d96be879SSascha Hauer if (host->rev_no != 0x400) { 1145d96be879SSascha Hauer ret = -ENODEV; 1146d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "wrong rev.no. 0x%08x. aborting.\n", 1147d96be879SSascha Hauer host->rev_no); 1148d96be879SSascha Hauer goto out_clk_put; 1149d96be879SSascha Hauer } 1150d96be879SSascha Hauer 1151529aa29eSSascha Hauer mmc->f_min = clk_get_rate(host->clk_per) >> 16; 1152529aa29eSSascha Hauer mmc->f_max = clk_get_rate(host->clk_per) >> 1; 1153d96be879SSascha Hauer 1154d96be879SSascha Hauer /* recommended in data sheet */ 1155c7ceab02SAnatolij Gustschin mxcmci_writew(host, 0x2db4, MMC_REG_READ_TO); 1156d96be879SSascha Hauer 1157c7ceab02SAnatolij Gustschin mxcmci_writel(host, host->default_irq_mask, MMC_REG_INT_CNTR); 1158d96be879SSascha Hauer 11597ff747c4SMarkus Pargmann if (!host->pdata) { 11607ff747c4SMarkus Pargmann host->dma = dma_request_slave_channel(&pdev->dev, "rx-tx"); 11617ff747c4SMarkus Pargmann } else { 1162d96be879SSascha Hauer r = platform_get_resource(pdev, IORESOURCE_DMA, 0); 1163f53fbde4SSascha Hauer if (r) { 1164f53fbde4SSascha Hauer host->dmareq = r->start; 1165f53fbde4SSascha Hauer host->dma_data.peripheral_type = IMX_DMATYPE_SDHC; 1166f53fbde4SSascha Hauer host->dma_data.priority = DMA_PRIO_LOW; 1167f53fbde4SSascha Hauer host->dma_data.dma_request = host->dmareq; 1168f53fbde4SSascha Hauer dma_cap_zero(mask); 1169f53fbde4SSascha Hauer dma_cap_set(DMA_SLAVE, mask); 1170f53fbde4SSascha Hauer host->dma = dma_request_channel(mask, filter, host); 11717ff747c4SMarkus Pargmann } 11727ff747c4SMarkus Pargmann } 1173f53fbde4SSascha Hauer if (host->dma) 1174f53fbde4SSascha Hauer mmc->max_seg_size = dma_get_max_seg_size( 1175f53fbde4SSascha Hauer host->dma->device->dev); 11767ff747c4SMarkus Pargmann else 1177f53fbde4SSascha Hauer dev_info(mmc_dev(host->mmc), "dma not available. Using PIO\n"); 1178f53fbde4SSascha Hauer 1179d96be879SSascha Hauer INIT_WORK(&host->datawork, mxcmci_datawork); 1180d96be879SSascha Hauer 1181d96be879SSascha Hauer ret = request_irq(host->irq, mxcmci_irq, 0, DRIVER_NAME, host); 1182d96be879SSascha Hauer if (ret) 1183d96be879SSascha Hauer goto out_free_dma; 1184d96be879SSascha Hauer 1185d96be879SSascha Hauer platform_set_drvdata(pdev, mmc); 1186d96be879SSascha Hauer 1187d96be879SSascha Hauer if (host->pdata && host->pdata->init) { 1188d96be879SSascha Hauer ret = host->pdata->init(&pdev->dev, mxcmci_detect_irq, 1189d96be879SSascha Hauer host->mmc); 1190d96be879SSascha Hauer if (ret) 1191d96be879SSascha Hauer goto out_free_irq; 1192d96be879SSascha Hauer } 1193d96be879SSascha Hauer 1194f6ad0a48SJavier Martin init_timer(&host->watchdog); 1195f6ad0a48SJavier Martin host->watchdog.function = &mxcmci_watchdog; 1196f6ad0a48SJavier Martin host->watchdog.data = (unsigned long)mmc; 1197f6ad0a48SJavier Martin 1198abd4190fSAlexander Shiyan mmc_add_host(mmc); 1199abd4190fSAlexander Shiyan 1200d96be879SSascha Hauer return 0; 1201d96be879SSascha Hauer 1202d96be879SSascha Hauer out_free_irq: 1203d96be879SSascha Hauer free_irq(host->irq, host); 1204d96be879SSascha Hauer out_free_dma: 1205f53fbde4SSascha Hauer if (host->dma) 1206f53fbde4SSascha Hauer dma_release_channel(host->dma); 1207d96be879SSascha Hauer out_clk_put: 1208529aa29eSSascha Hauer clk_disable_unprepare(host->clk_per); 1209529aa29eSSascha Hauer clk_disable_unprepare(host->clk_ipg); 1210d96be879SSascha Hauer out_iounmap: 1211d96be879SSascha Hauer iounmap(host->base); 1212d96be879SSascha Hauer out_free: 1213d96be879SSascha Hauer mmc_free_host(mmc); 1214d96be879SSascha Hauer out_release_mem: 1215c0521bafSUwe Kleine-König release_mem_region(iores->start, resource_size(iores)); 1216d96be879SSascha Hauer return ret; 1217d96be879SSascha Hauer } 1218d96be879SSascha Hauer 1219d96be879SSascha Hauer static int mxcmci_remove(struct platform_device *pdev) 1220d96be879SSascha Hauer { 1221d96be879SSascha Hauer struct mmc_host *mmc = platform_get_drvdata(pdev); 1222d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 1223d96be879SSascha Hauer 1224d96be879SSascha Hauer mmc_remove_host(mmc); 1225d96be879SSascha Hauer 122674b66954SAlberto Panizzo if (host->vcc) 122774b66954SAlberto Panizzo regulator_put(host->vcc); 122874b66954SAlberto Panizzo 1229d96be879SSascha Hauer if (host->pdata && host->pdata->exit) 1230d96be879SSascha Hauer host->pdata->exit(&pdev->dev, mmc); 1231d96be879SSascha Hauer 1232d96be879SSascha Hauer free_irq(host->irq, host); 1233d96be879SSascha Hauer iounmap(host->base); 1234f53fbde4SSascha Hauer 1235f53fbde4SSascha Hauer if (host->dma) 1236f53fbde4SSascha Hauer dma_release_channel(host->dma); 1237f53fbde4SSascha Hauer 1238529aa29eSSascha Hauer clk_disable_unprepare(host->clk_per); 1239529aa29eSSascha Hauer clk_disable_unprepare(host->clk_ipg); 1240d96be879SSascha Hauer 1241d96be879SSascha Hauer release_mem_region(host->res->start, resource_size(host->res)); 1242d96be879SSascha Hauer 1243d96be879SSascha Hauer mmc_free_host(mmc); 1244d96be879SSascha Hauer 1245d96be879SSascha Hauer return 0; 1246d96be879SSascha Hauer } 1247d96be879SSascha Hauer 1248d96be879SSascha Hauer #ifdef CONFIG_PM 1249a7d403cfSEric Bénard static int mxcmci_suspend(struct device *dev) 1250d96be879SSascha Hauer { 1251a7d403cfSEric Bénard struct mmc_host *mmc = dev_get_drvdata(dev); 1252a7d403cfSEric Bénard struct mxcmci_host *host = mmc_priv(mmc); 1253d96be879SSascha Hauer 1254529aa29eSSascha Hauer clk_disable_unprepare(host->clk_per); 1255529aa29eSSascha Hauer clk_disable_unprepare(host->clk_ipg); 1256bd190f90SUlf Hansson return 0; 1257d96be879SSascha Hauer } 1258d96be879SSascha Hauer 1259a7d403cfSEric Bénard static int mxcmci_resume(struct device *dev) 1260d96be879SSascha Hauer { 1261a7d403cfSEric Bénard struct mmc_host *mmc = dev_get_drvdata(dev); 1262a7d403cfSEric Bénard struct mxcmci_host *host = mmc_priv(mmc); 1263d96be879SSascha Hauer 1264529aa29eSSascha Hauer clk_prepare_enable(host->clk_per); 1265529aa29eSSascha Hauer clk_prepare_enable(host->clk_ipg); 1266bd190f90SUlf Hansson return 0; 1267d96be879SSascha Hauer } 1268a7d403cfSEric Bénard 1269a7d403cfSEric Bénard static const struct dev_pm_ops mxcmci_pm_ops = { 1270a7d403cfSEric Bénard .suspend = mxcmci_suspend, 1271a7d403cfSEric Bénard .resume = mxcmci_resume, 1272a7d403cfSEric Bénard }; 1273a7d403cfSEric Bénard #endif 1274d96be879SSascha Hauer 1275d96be879SSascha Hauer static struct platform_driver mxcmci_driver = { 1276d96be879SSascha Hauer .probe = mxcmci_probe, 1277d96be879SSascha Hauer .remove = mxcmci_remove, 12787f917a8dSShawn Guo .id_table = mxcmci_devtype, 1279d96be879SSascha Hauer .driver = { 1280d96be879SSascha Hauer .name = DRIVER_NAME, 1281d96be879SSascha Hauer .owner = THIS_MODULE, 1282a7d403cfSEric Bénard #ifdef CONFIG_PM 1283a7d403cfSEric Bénard .pm = &mxcmci_pm_ops, 1284a7d403cfSEric Bénard #endif 12857ff747c4SMarkus Pargmann .of_match_table = mxcmci_of_match, 1286d96be879SSascha Hauer } 1287d96be879SSascha Hauer }; 1288d96be879SSascha Hauer 1289d1f81a64SAxel Lin module_platform_driver(mxcmci_driver); 1290d96be879SSascha Hauer 1291d96be879SSascha Hauer MODULE_DESCRIPTION("i.MX Multimedia Card Interface Driver"); 1292d96be879SSascha Hauer MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 1293d96be879SSascha Hauer MODULE_LICENSE("GPL"); 12946eb30adfSFabio Estevam MODULE_ALIAS("platform:mxc-mmc"); 1295