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 7d96be879SSascha Hauer * not need all the quirks found in imxmmc.c, hence the seperate 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> 34d96be879SSascha Hauer 35d96be879SSascha Hauer #include <asm/dma.h> 36d96be879SSascha Hauer #include <asm/irq.h> 37d96be879SSascha Hauer #include <asm/sizes.h> 38d96be879SSascha Hauer #include <mach/mmc.h> 39d96be879SSascha Hauer 40d96be879SSascha Hauer #ifdef CONFIG_ARCH_MX2 41d96be879SSascha Hauer #include <mach/dma-mx1-mx2.h> 42d96be879SSascha Hauer #define HAS_DMA 43d96be879SSascha Hauer #endif 44d96be879SSascha Hauer 459563b1dbSSascha Hauer #define DRIVER_NAME "mxc-mmc" 46d96be879SSascha Hauer 47d96be879SSascha Hauer #define MMC_REG_STR_STP_CLK 0x00 48d96be879SSascha Hauer #define MMC_REG_STATUS 0x04 49d96be879SSascha Hauer #define MMC_REG_CLK_RATE 0x08 50d96be879SSascha Hauer #define MMC_REG_CMD_DAT_CONT 0x0C 51d96be879SSascha Hauer #define MMC_REG_RES_TO 0x10 52d96be879SSascha Hauer #define MMC_REG_READ_TO 0x14 53d96be879SSascha Hauer #define MMC_REG_BLK_LEN 0x18 54d96be879SSascha Hauer #define MMC_REG_NOB 0x1C 55d96be879SSascha Hauer #define MMC_REG_REV_NO 0x20 56d96be879SSascha Hauer #define MMC_REG_INT_CNTR 0x24 57d96be879SSascha Hauer #define MMC_REG_CMD 0x28 58d96be879SSascha Hauer #define MMC_REG_ARG 0x2C 59d96be879SSascha Hauer #define MMC_REG_RES_FIFO 0x34 60d96be879SSascha Hauer #define MMC_REG_BUFFER_ACCESS 0x38 61d96be879SSascha Hauer 62d96be879SSascha Hauer #define STR_STP_CLK_RESET (1 << 3) 63d96be879SSascha Hauer #define STR_STP_CLK_START_CLK (1 << 1) 64d96be879SSascha Hauer #define STR_STP_CLK_STOP_CLK (1 << 0) 65d96be879SSascha Hauer 66d96be879SSascha Hauer #define STATUS_CARD_INSERTION (1 << 31) 67d96be879SSascha Hauer #define STATUS_CARD_REMOVAL (1 << 30) 68d96be879SSascha Hauer #define STATUS_YBUF_EMPTY (1 << 29) 69d96be879SSascha Hauer #define STATUS_XBUF_EMPTY (1 << 28) 70d96be879SSascha Hauer #define STATUS_YBUF_FULL (1 << 27) 71d96be879SSascha Hauer #define STATUS_XBUF_FULL (1 << 26) 72d96be879SSascha Hauer #define STATUS_BUF_UND_RUN (1 << 25) 73d96be879SSascha Hauer #define STATUS_BUF_OVFL (1 << 24) 74d96be879SSascha Hauer #define STATUS_SDIO_INT_ACTIVE (1 << 14) 75d96be879SSascha Hauer #define STATUS_END_CMD_RESP (1 << 13) 76d96be879SSascha Hauer #define STATUS_WRITE_OP_DONE (1 << 12) 77d96be879SSascha Hauer #define STATUS_DATA_TRANS_DONE (1 << 11) 78d96be879SSascha Hauer #define STATUS_READ_OP_DONE (1 << 11) 79d96be879SSascha Hauer #define STATUS_WR_CRC_ERROR_CODE_MASK (3 << 10) 80d96be879SSascha Hauer #define STATUS_CARD_BUS_CLK_RUN (1 << 8) 81d96be879SSascha Hauer #define STATUS_BUF_READ_RDY (1 << 7) 82d96be879SSascha Hauer #define STATUS_BUF_WRITE_RDY (1 << 6) 83d96be879SSascha Hauer #define STATUS_RESP_CRC_ERR (1 << 5) 84d96be879SSascha Hauer #define STATUS_CRC_READ_ERR (1 << 3) 85d96be879SSascha Hauer #define STATUS_CRC_WRITE_ERR (1 << 2) 86d96be879SSascha Hauer #define STATUS_TIME_OUT_RESP (1 << 1) 87d96be879SSascha Hauer #define STATUS_TIME_OUT_READ (1 << 0) 88d96be879SSascha Hauer #define STATUS_ERR_MASK 0x2f 89d96be879SSascha Hauer 90d96be879SSascha Hauer #define CMD_DAT_CONT_CMD_RESP_LONG_OFF (1 << 12) 91d96be879SSascha Hauer #define CMD_DAT_CONT_STOP_READWAIT (1 << 11) 92d96be879SSascha Hauer #define CMD_DAT_CONT_START_READWAIT (1 << 10) 93d96be879SSascha Hauer #define CMD_DAT_CONT_BUS_WIDTH_4 (2 << 8) 94d96be879SSascha Hauer #define CMD_DAT_CONT_INIT (1 << 7) 95d96be879SSascha Hauer #define CMD_DAT_CONT_WRITE (1 << 4) 96d96be879SSascha Hauer #define CMD_DAT_CONT_DATA_ENABLE (1 << 3) 97d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_48BIT_CRC (1 << 0) 98d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_136BIT (2 << 0) 99d96be879SSascha Hauer #define CMD_DAT_CONT_RESPONSE_48BIT (3 << 0) 100d96be879SSascha Hauer 101d96be879SSascha Hauer #define INT_SDIO_INT_WKP_EN (1 << 18) 102d96be879SSascha Hauer #define INT_CARD_INSERTION_WKP_EN (1 << 17) 103d96be879SSascha Hauer #define INT_CARD_REMOVAL_WKP_EN (1 << 16) 104d96be879SSascha Hauer #define INT_CARD_INSERTION_EN (1 << 15) 105d96be879SSascha Hauer #define INT_CARD_REMOVAL_EN (1 << 14) 106d96be879SSascha Hauer #define INT_SDIO_IRQ_EN (1 << 13) 107d96be879SSascha Hauer #define INT_DAT0_EN (1 << 12) 108d96be879SSascha Hauer #define INT_BUF_READ_EN (1 << 4) 109d96be879SSascha Hauer #define INT_BUF_WRITE_EN (1 << 3) 110d96be879SSascha Hauer #define INT_END_CMD_RES_EN (1 << 2) 111d96be879SSascha Hauer #define INT_WRITE_OP_DONE_EN (1 << 1) 112d96be879SSascha Hauer #define INT_READ_OP_EN (1 << 0) 113d96be879SSascha Hauer 114d96be879SSascha Hauer struct mxcmci_host { 115d96be879SSascha Hauer struct mmc_host *mmc; 116d96be879SSascha Hauer struct resource *res; 117d96be879SSascha Hauer void __iomem *base; 118d96be879SSascha Hauer int irq; 119d96be879SSascha Hauer int detect_irq; 120d96be879SSascha Hauer int dma; 121d96be879SSascha Hauer int do_dma; 122d96be879SSascha Hauer unsigned int power_mode; 123d96be879SSascha Hauer struct imxmmc_platform_data *pdata; 124d96be879SSascha Hauer 125d96be879SSascha Hauer struct mmc_request *req; 126d96be879SSascha Hauer struct mmc_command *cmd; 127d96be879SSascha Hauer struct mmc_data *data; 128d96be879SSascha Hauer 129d96be879SSascha Hauer unsigned int dma_nents; 130d96be879SSascha Hauer unsigned int datasize; 131d96be879SSascha Hauer unsigned int dma_dir; 132d96be879SSascha Hauer 133d96be879SSascha Hauer u16 rev_no; 134d96be879SSascha Hauer unsigned int cmdat; 135d96be879SSascha Hauer 136d96be879SSascha Hauer struct clk *clk; 137d96be879SSascha Hauer 138d96be879SSascha Hauer int clock; 139d96be879SSascha Hauer 140d96be879SSascha Hauer struct work_struct datawork; 141d96be879SSascha Hauer }; 142d96be879SSascha Hauer 14318489fa2SMartin Fuzzey static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios); 14418489fa2SMartin Fuzzey 145d96be879SSascha Hauer static inline int mxcmci_use_dma(struct mxcmci_host *host) 146d96be879SSascha Hauer { 147d96be879SSascha Hauer return host->do_dma; 148d96be879SSascha Hauer } 149d96be879SSascha Hauer 150d96be879SSascha Hauer static void mxcmci_softreset(struct mxcmci_host *host) 151d96be879SSascha Hauer { 152d96be879SSascha Hauer int i; 153d96be879SSascha Hauer 154d96be879SSascha Hauer /* reset sequence */ 155d96be879SSascha Hauer writew(STR_STP_CLK_RESET, host->base + MMC_REG_STR_STP_CLK); 156d96be879SSascha Hauer writew(STR_STP_CLK_RESET | STR_STP_CLK_START_CLK, 157d96be879SSascha Hauer host->base + MMC_REG_STR_STP_CLK); 158d96be879SSascha Hauer 159d96be879SSascha Hauer for (i = 0; i < 8; i++) 160d96be879SSascha Hauer writew(STR_STP_CLK_START_CLK, host->base + MMC_REG_STR_STP_CLK); 161d96be879SSascha Hauer 162d96be879SSascha Hauer writew(0xff, host->base + MMC_REG_RES_TO); 163d96be879SSascha Hauer } 164d96be879SSascha Hauer 165656217d2SMartin Fuzzey static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data) 166d96be879SSascha Hauer { 167d96be879SSascha Hauer unsigned int nob = data->blocks; 168d96be879SSascha Hauer unsigned int blksz = data->blksz; 169d96be879SSascha Hauer unsigned int datasize = nob * blksz; 170d96be879SSascha Hauer #ifdef HAS_DMA 171d96be879SSascha Hauer struct scatterlist *sg; 172d96be879SSascha Hauer int i; 173656217d2SMartin Fuzzey int ret; 174d96be879SSascha Hauer #endif 175d96be879SSascha Hauer if (data->flags & MMC_DATA_STREAM) 176d96be879SSascha Hauer nob = 0xffff; 177d96be879SSascha Hauer 178d96be879SSascha Hauer host->data = data; 179d96be879SSascha Hauer data->bytes_xfered = 0; 180d96be879SSascha Hauer 181d96be879SSascha Hauer writew(nob, host->base + MMC_REG_NOB); 182d96be879SSascha Hauer writew(blksz, host->base + MMC_REG_BLK_LEN); 183d96be879SSascha Hauer host->datasize = datasize; 184d96be879SSascha Hauer 185d96be879SSascha Hauer #ifdef HAS_DMA 186d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 187d96be879SSascha Hauer if (sg->offset & 3 || sg->length & 3) { 188d96be879SSascha Hauer host->do_dma = 0; 189656217d2SMartin Fuzzey return 0; 190d96be879SSascha Hauer } 191d96be879SSascha Hauer } 192d96be879SSascha Hauer 193d96be879SSascha Hauer if (data->flags & MMC_DATA_READ) { 194d96be879SSascha Hauer host->dma_dir = DMA_FROM_DEVICE; 195d96be879SSascha Hauer host->dma_nents = dma_map_sg(mmc_dev(host->mmc), data->sg, 196d96be879SSascha Hauer data->sg_len, host->dma_dir); 197d96be879SSascha Hauer 198656217d2SMartin Fuzzey ret = imx_dma_setup_sg(host->dma, data->sg, host->dma_nents, 199656217d2SMartin Fuzzey datasize, 200d96be879SSascha Hauer host->res->start + MMC_REG_BUFFER_ACCESS, 201d96be879SSascha Hauer DMA_MODE_READ); 202d96be879SSascha Hauer } else { 203d96be879SSascha Hauer host->dma_dir = DMA_TO_DEVICE; 204d96be879SSascha Hauer host->dma_nents = dma_map_sg(mmc_dev(host->mmc), data->sg, 205d96be879SSascha Hauer data->sg_len, host->dma_dir); 206d96be879SSascha Hauer 207656217d2SMartin Fuzzey ret = imx_dma_setup_sg(host->dma, data->sg, host->dma_nents, 208656217d2SMartin Fuzzey datasize, 209d96be879SSascha Hauer host->res->start + MMC_REG_BUFFER_ACCESS, 210d96be879SSascha Hauer DMA_MODE_WRITE); 211d96be879SSascha Hauer } 212d96be879SSascha Hauer 213656217d2SMartin Fuzzey if (ret) { 214656217d2SMartin Fuzzey dev_err(mmc_dev(host->mmc), "failed to setup DMA : %d\n", ret); 215656217d2SMartin Fuzzey return ret; 216656217d2SMartin Fuzzey } 217d96be879SSascha Hauer wmb(); 218d96be879SSascha Hauer 219d96be879SSascha Hauer imx_dma_enable(host->dma); 220d96be879SSascha Hauer #endif /* HAS_DMA */ 221656217d2SMartin Fuzzey return 0; 222d96be879SSascha Hauer } 223d96be879SSascha Hauer 224d96be879SSascha Hauer static int mxcmci_start_cmd(struct mxcmci_host *host, struct mmc_command *cmd, 225d96be879SSascha Hauer unsigned int cmdat) 226d96be879SSascha Hauer { 227d96be879SSascha Hauer WARN_ON(host->cmd != NULL); 228d96be879SSascha Hauer host->cmd = cmd; 229d96be879SSascha Hauer 230d96be879SSascha Hauer switch (mmc_resp_type(cmd)) { 231d96be879SSascha Hauer case MMC_RSP_R1: /* short CRC, OPCODE */ 232d96be879SSascha Hauer case MMC_RSP_R1B:/* short CRC, OPCODE, BUSY */ 233d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_48BIT_CRC; 234d96be879SSascha Hauer break; 235d96be879SSascha Hauer case MMC_RSP_R2: /* long 136 bit + CRC */ 236d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_136BIT; 237d96be879SSascha Hauer break; 238d96be879SSascha Hauer case MMC_RSP_R3: /* short */ 239d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_RESPONSE_48BIT; 240d96be879SSascha Hauer break; 241d96be879SSascha Hauer case MMC_RSP_NONE: 242d96be879SSascha Hauer break; 243d96be879SSascha Hauer default: 244d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "unhandled response type 0x%x\n", 245d96be879SSascha Hauer mmc_resp_type(cmd)); 246d96be879SSascha Hauer cmd->error = -EINVAL; 247d96be879SSascha Hauer return -EINVAL; 248d96be879SSascha Hauer } 249d96be879SSascha Hauer 250d96be879SSascha Hauer if (mxcmci_use_dma(host)) 251d96be879SSascha Hauer writel(INT_READ_OP_EN | INT_WRITE_OP_DONE_EN | 252d96be879SSascha Hauer INT_END_CMD_RES_EN, 253d96be879SSascha Hauer host->base + MMC_REG_INT_CNTR); 254d96be879SSascha Hauer else 255d96be879SSascha Hauer writel(INT_END_CMD_RES_EN, host->base + MMC_REG_INT_CNTR); 256d96be879SSascha Hauer 257d96be879SSascha Hauer writew(cmd->opcode, host->base + MMC_REG_CMD); 258d96be879SSascha Hauer writel(cmd->arg, host->base + MMC_REG_ARG); 259d96be879SSascha Hauer writew(cmdat, host->base + MMC_REG_CMD_DAT_CONT); 260d96be879SSascha Hauer 261d96be879SSascha Hauer return 0; 262d96be879SSascha Hauer } 263d96be879SSascha Hauer 264d96be879SSascha Hauer static void mxcmci_finish_request(struct mxcmci_host *host, 265d96be879SSascha Hauer struct mmc_request *req) 266d96be879SSascha Hauer { 267d96be879SSascha Hauer writel(0, host->base + MMC_REG_INT_CNTR); 268d96be879SSascha Hauer 269d96be879SSascha Hauer host->req = NULL; 270d96be879SSascha Hauer host->cmd = NULL; 271d96be879SSascha Hauer host->data = NULL; 272d96be879SSascha Hauer 273d96be879SSascha Hauer mmc_request_done(host->mmc, req); 274d96be879SSascha Hauer } 275d96be879SSascha Hauer 276d96be879SSascha Hauer static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat) 277d96be879SSascha Hauer { 278d96be879SSascha Hauer struct mmc_data *data = host->data; 279d96be879SSascha Hauer int data_error; 280d96be879SSascha Hauer 281d96be879SSascha Hauer #ifdef HAS_DMA 282d96be879SSascha Hauer if (mxcmci_use_dma(host)) { 283d96be879SSascha Hauer imx_dma_disable(host->dma); 284d96be879SSascha Hauer dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->dma_nents, 285d96be879SSascha Hauer host->dma_dir); 286d96be879SSascha Hauer } 287d96be879SSascha Hauer #endif 288d96be879SSascha Hauer 289d96be879SSascha Hauer if (stat & STATUS_ERR_MASK) { 290d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n", 291d96be879SSascha Hauer stat); 292d96be879SSascha Hauer if (stat & STATUS_CRC_READ_ERR) { 293d96be879SSascha Hauer data->error = -EILSEQ; 294d96be879SSascha Hauer } else if (stat & STATUS_CRC_WRITE_ERR) { 295d96be879SSascha Hauer u32 err_code = (stat >> 9) & 0x3; 296d96be879SSascha Hauer if (err_code == 2) /* No CRC response */ 297d96be879SSascha Hauer data->error = -ETIMEDOUT; 298d96be879SSascha Hauer else 299d96be879SSascha Hauer data->error = -EILSEQ; 300d96be879SSascha Hauer } else if (stat & STATUS_TIME_OUT_READ) { 301d96be879SSascha Hauer data->error = -ETIMEDOUT; 302d96be879SSascha Hauer } else { 303d96be879SSascha Hauer data->error = -EIO; 304d96be879SSascha Hauer } 305d96be879SSascha Hauer } else { 306d96be879SSascha Hauer data->bytes_xfered = host->datasize; 307d96be879SSascha Hauer } 308d96be879SSascha Hauer 309d96be879SSascha Hauer data_error = data->error; 310d96be879SSascha Hauer 311d96be879SSascha Hauer host->data = NULL; 312d96be879SSascha Hauer 313d96be879SSascha Hauer return data_error; 314d96be879SSascha Hauer } 315d96be879SSascha Hauer 316d96be879SSascha Hauer static void mxcmci_read_response(struct mxcmci_host *host, unsigned int stat) 317d96be879SSascha Hauer { 318d96be879SSascha Hauer struct mmc_command *cmd = host->cmd; 319d96be879SSascha Hauer int i; 320d96be879SSascha Hauer u32 a, b, c; 321d96be879SSascha Hauer 322d96be879SSascha Hauer if (!cmd) 323d96be879SSascha Hauer return; 324d96be879SSascha Hauer 325d96be879SSascha Hauer if (stat & STATUS_TIME_OUT_RESP) { 326d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "CMD TIMEOUT\n"); 327d96be879SSascha Hauer cmd->error = -ETIMEDOUT; 328d96be879SSascha Hauer } else if (stat & STATUS_RESP_CRC_ERR && cmd->flags & MMC_RSP_CRC) { 329d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "cmd crc error\n"); 330d96be879SSascha Hauer cmd->error = -EILSEQ; 331d96be879SSascha Hauer } 332d96be879SSascha Hauer 333d96be879SSascha Hauer if (cmd->flags & MMC_RSP_PRESENT) { 334d96be879SSascha Hauer if (cmd->flags & MMC_RSP_136) { 335d96be879SSascha Hauer for (i = 0; i < 4; i++) { 336d96be879SSascha Hauer a = readw(host->base + MMC_REG_RES_FIFO); 337d96be879SSascha Hauer b = readw(host->base + MMC_REG_RES_FIFO); 338d96be879SSascha Hauer cmd->resp[i] = a << 16 | b; 339d96be879SSascha Hauer } 340d96be879SSascha Hauer } else { 341d96be879SSascha Hauer a = readw(host->base + MMC_REG_RES_FIFO); 342d96be879SSascha Hauer b = readw(host->base + MMC_REG_RES_FIFO); 343d96be879SSascha Hauer c = readw(host->base + MMC_REG_RES_FIFO); 344d96be879SSascha Hauer cmd->resp[0] = a << 24 | b << 8 | c >> 8; 345d96be879SSascha Hauer } 346d96be879SSascha Hauer } 347d96be879SSascha Hauer } 348d96be879SSascha Hauer 349d96be879SSascha Hauer static int mxcmci_poll_status(struct mxcmci_host *host, u32 mask) 350d96be879SSascha Hauer { 351d96be879SSascha Hauer u32 stat; 352d96be879SSascha Hauer unsigned long timeout = jiffies + HZ; 353d96be879SSascha Hauer 354d96be879SSascha Hauer do { 355d96be879SSascha Hauer stat = readl(host->base + MMC_REG_STATUS); 356d96be879SSascha Hauer if (stat & STATUS_ERR_MASK) 357d96be879SSascha Hauer return stat; 35818489fa2SMartin Fuzzey if (time_after(jiffies, timeout)) { 35918489fa2SMartin Fuzzey mxcmci_softreset(host); 36018489fa2SMartin Fuzzey mxcmci_set_clk_rate(host, host->clock); 361d96be879SSascha Hauer return STATUS_TIME_OUT_READ; 36218489fa2SMartin Fuzzey } 363d96be879SSascha Hauer if (stat & mask) 364d96be879SSascha Hauer return 0; 365d96be879SSascha Hauer cpu_relax(); 366d96be879SSascha Hauer } while (1); 367d96be879SSascha Hauer } 368d96be879SSascha Hauer 369d96be879SSascha Hauer static int mxcmci_pull(struct mxcmci_host *host, void *_buf, int bytes) 370d96be879SSascha Hauer { 371d96be879SSascha Hauer unsigned int stat; 372d96be879SSascha Hauer u32 *buf = _buf; 373d96be879SSascha Hauer 374d96be879SSascha Hauer while (bytes > 3) { 375d96be879SSascha Hauer stat = mxcmci_poll_status(host, 376d96be879SSascha Hauer STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 377d96be879SSascha Hauer if (stat) 378d96be879SSascha Hauer return stat; 379d96be879SSascha Hauer *buf++ = readl(host->base + MMC_REG_BUFFER_ACCESS); 380d96be879SSascha Hauer bytes -= 4; 381d96be879SSascha Hauer } 382d96be879SSascha Hauer 383d96be879SSascha Hauer if (bytes) { 384d96be879SSascha Hauer u8 *b = (u8 *)buf; 385d96be879SSascha Hauer u32 tmp; 386d96be879SSascha Hauer 387d96be879SSascha Hauer stat = mxcmci_poll_status(host, 388d96be879SSascha Hauer STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 389d96be879SSascha Hauer if (stat) 390d96be879SSascha Hauer return stat; 391d96be879SSascha Hauer tmp = readl(host->base + MMC_REG_BUFFER_ACCESS); 392d96be879SSascha Hauer memcpy(b, &tmp, bytes); 393d96be879SSascha Hauer } 394d96be879SSascha Hauer 395d96be879SSascha Hauer return 0; 396d96be879SSascha Hauer } 397d96be879SSascha Hauer 398d96be879SSascha Hauer static int mxcmci_push(struct mxcmci_host *host, void *_buf, int bytes) 399d96be879SSascha Hauer { 400d96be879SSascha Hauer unsigned int stat; 401d96be879SSascha Hauer u32 *buf = _buf; 402d96be879SSascha Hauer 403d96be879SSascha Hauer while (bytes > 3) { 404d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 405d96be879SSascha Hauer if (stat) 406d96be879SSascha Hauer return stat; 407d96be879SSascha Hauer writel(*buf++, host->base + MMC_REG_BUFFER_ACCESS); 408d96be879SSascha Hauer bytes -= 4; 409d96be879SSascha Hauer } 410d96be879SSascha Hauer 411d96be879SSascha Hauer if (bytes) { 412d96be879SSascha Hauer u8 *b = (u8 *)buf; 413d96be879SSascha Hauer u32 tmp; 414d96be879SSascha Hauer 415d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 416d96be879SSascha Hauer if (stat) 417d96be879SSascha Hauer return stat; 418d96be879SSascha Hauer 419d96be879SSascha Hauer memcpy(&tmp, b, bytes); 420d96be879SSascha Hauer writel(tmp, host->base + MMC_REG_BUFFER_ACCESS); 421d96be879SSascha Hauer } 422d96be879SSascha Hauer 423d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 424d96be879SSascha Hauer if (stat) 425d96be879SSascha Hauer return stat; 426d96be879SSascha Hauer 427d96be879SSascha Hauer return 0; 428d96be879SSascha Hauer } 429d96be879SSascha Hauer 430d96be879SSascha Hauer static int mxcmci_transfer_data(struct mxcmci_host *host) 431d96be879SSascha Hauer { 432d96be879SSascha Hauer struct mmc_data *data = host->req->data; 433d96be879SSascha Hauer struct scatterlist *sg; 434d96be879SSascha Hauer int stat, i; 435d96be879SSascha Hauer 436d96be879SSascha Hauer host->datasize = 0; 437d96be879SSascha Hauer 438d96be879SSascha Hauer host->data = data; 439d96be879SSascha Hauer host->datasize = 0; 440d96be879SSascha Hauer 441d96be879SSascha Hauer if (data->flags & MMC_DATA_READ) { 442d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 443d96be879SSascha Hauer stat = mxcmci_pull(host, sg_virt(sg), sg->length); 444d96be879SSascha Hauer if (stat) 445d96be879SSascha Hauer return stat; 446d96be879SSascha Hauer host->datasize += sg->length; 447d96be879SSascha Hauer } 448d96be879SSascha Hauer } else { 449d96be879SSascha Hauer for_each_sg(data->sg, sg, data->sg_len, i) { 450d96be879SSascha Hauer stat = mxcmci_push(host, sg_virt(sg), sg->length); 451d96be879SSascha Hauer if (stat) 452d96be879SSascha Hauer return stat; 453d96be879SSascha Hauer host->datasize += sg->length; 454d96be879SSascha Hauer } 455d96be879SSascha Hauer stat = mxcmci_poll_status(host, STATUS_WRITE_OP_DONE); 456d96be879SSascha Hauer if (stat) 457d96be879SSascha Hauer return stat; 458d96be879SSascha Hauer } 459d96be879SSascha Hauer return 0; 460d96be879SSascha Hauer } 461d96be879SSascha Hauer 462d96be879SSascha Hauer static void mxcmci_datawork(struct work_struct *work) 463d96be879SSascha Hauer { 464d96be879SSascha Hauer struct mxcmci_host *host = container_of(work, struct mxcmci_host, 465d96be879SSascha Hauer datawork); 466d96be879SSascha Hauer int datastat = mxcmci_transfer_data(host); 467d96be879SSascha Hauer mxcmci_finish_data(host, datastat); 468d96be879SSascha Hauer 469d96be879SSascha Hauer if (host->req->stop) { 470d96be879SSascha Hauer if (mxcmci_start_cmd(host, host->req->stop, 0)) { 471d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 472d96be879SSascha Hauer return; 473d96be879SSascha Hauer } 474d96be879SSascha Hauer } else { 475d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 476d96be879SSascha Hauer } 477d96be879SSascha Hauer } 478d96be879SSascha Hauer 479d96be879SSascha Hauer #ifdef HAS_DMA 480d96be879SSascha Hauer static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat) 481d96be879SSascha Hauer { 482d96be879SSascha Hauer struct mmc_data *data = host->data; 483d96be879SSascha Hauer int data_error; 484d96be879SSascha Hauer 485d96be879SSascha Hauer if (!data) 486d96be879SSascha Hauer return; 487d96be879SSascha Hauer 488d96be879SSascha Hauer data_error = mxcmci_finish_data(host, stat); 489d96be879SSascha Hauer 490d96be879SSascha Hauer mxcmci_read_response(host, stat); 491d96be879SSascha Hauer host->cmd = NULL; 492d96be879SSascha Hauer 493d96be879SSascha Hauer if (host->req->stop) { 494d96be879SSascha Hauer if (mxcmci_start_cmd(host, host->req->stop, 0)) { 495d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 496d96be879SSascha Hauer return; 497d96be879SSascha Hauer } 498d96be879SSascha Hauer } else { 499d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 500d96be879SSascha Hauer } 501d96be879SSascha Hauer } 502d96be879SSascha Hauer #endif /* HAS_DMA */ 503d96be879SSascha Hauer 504d96be879SSascha Hauer static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat) 505d96be879SSascha Hauer { 506d96be879SSascha Hauer mxcmci_read_response(host, stat); 507d96be879SSascha Hauer host->cmd = NULL; 508d96be879SSascha Hauer 509d96be879SSascha Hauer if (!host->data && host->req) { 510d96be879SSascha Hauer mxcmci_finish_request(host, host->req); 511d96be879SSascha Hauer return; 512d96be879SSascha Hauer } 513d96be879SSascha Hauer 514d96be879SSascha Hauer /* For the DMA case the DMA engine handles the data transfer 515fd589a8fSAnand Gadiyar * automatically. For non DMA we have to do it ourselves. 516d96be879SSascha Hauer * Don't do it in interrupt context though. 517d96be879SSascha Hauer */ 518d96be879SSascha Hauer if (!mxcmci_use_dma(host) && host->data) 519d96be879SSascha Hauer schedule_work(&host->datawork); 520d96be879SSascha Hauer 521d96be879SSascha Hauer } 522d96be879SSascha Hauer 523d96be879SSascha Hauer static irqreturn_t mxcmci_irq(int irq, void *devid) 524d96be879SSascha Hauer { 525d96be879SSascha Hauer struct mxcmci_host *host = devid; 526d96be879SSascha Hauer u32 stat; 527d96be879SSascha Hauer 528d96be879SSascha Hauer stat = readl(host->base + MMC_REG_STATUS); 529d96be879SSascha Hauer writel(stat, host->base + MMC_REG_STATUS); 530d96be879SSascha Hauer 531d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat); 532d96be879SSascha Hauer 533d96be879SSascha Hauer if (stat & STATUS_END_CMD_RESP) 534d96be879SSascha Hauer mxcmci_cmd_done(host, stat); 535d96be879SSascha Hauer #ifdef HAS_DMA 536d96be879SSascha Hauer if (mxcmci_use_dma(host) && 537d96be879SSascha Hauer (stat & (STATUS_DATA_TRANS_DONE | STATUS_WRITE_OP_DONE))) 538d96be879SSascha Hauer mxcmci_data_done(host, stat); 539d96be879SSascha Hauer #endif 540d96be879SSascha Hauer return IRQ_HANDLED; 541d96be879SSascha Hauer } 542d96be879SSascha Hauer 543d96be879SSascha Hauer static void mxcmci_request(struct mmc_host *mmc, struct mmc_request *req) 544d96be879SSascha Hauer { 545d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 546d96be879SSascha Hauer unsigned int cmdat = host->cmdat; 547656217d2SMartin Fuzzey int error; 548d96be879SSascha Hauer 549d96be879SSascha Hauer WARN_ON(host->req != NULL); 550d96be879SSascha Hauer 551d96be879SSascha Hauer host->req = req; 552d96be879SSascha Hauer host->cmdat &= ~CMD_DAT_CONT_INIT; 553d96be879SSascha Hauer #ifdef HAS_DMA 554d96be879SSascha Hauer host->do_dma = 1; 555d96be879SSascha Hauer #endif 556d96be879SSascha Hauer if (req->data) { 557656217d2SMartin Fuzzey error = mxcmci_setup_data(host, req->data); 558656217d2SMartin Fuzzey if (error) { 559656217d2SMartin Fuzzey req->cmd->error = error; 560656217d2SMartin Fuzzey goto out; 561656217d2SMartin Fuzzey } 562656217d2SMartin Fuzzey 563d96be879SSascha Hauer 564d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_DATA_ENABLE; 565d96be879SSascha Hauer 566d96be879SSascha Hauer if (req->data->flags & MMC_DATA_WRITE) 567d96be879SSascha Hauer cmdat |= CMD_DAT_CONT_WRITE; 568d96be879SSascha Hauer } 569d96be879SSascha Hauer 570656217d2SMartin Fuzzey error = mxcmci_start_cmd(host, req->cmd, cmdat); 571656217d2SMartin Fuzzey out: 572656217d2SMartin Fuzzey if (error) 573d96be879SSascha Hauer mxcmci_finish_request(host, req); 574d96be879SSascha Hauer } 575d96be879SSascha Hauer 576d96be879SSascha Hauer static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios) 577d96be879SSascha Hauer { 578d96be879SSascha Hauer unsigned int divider; 579d96be879SSascha Hauer int prescaler = 0; 580d96be879SSascha Hauer unsigned int clk_in = clk_get_rate(host->clk); 581d96be879SSascha Hauer 582d96be879SSascha Hauer while (prescaler <= 0x800) { 583d96be879SSascha Hauer for (divider = 1; divider <= 0xF; divider++) { 584d96be879SSascha Hauer int x; 585d96be879SSascha Hauer 586d96be879SSascha Hauer x = (clk_in / (divider + 1)); 587d96be879SSascha Hauer 588d96be879SSascha Hauer if (prescaler) 589d96be879SSascha Hauer x /= (prescaler * 2); 590d96be879SSascha Hauer 591d96be879SSascha Hauer if (x <= clk_ios) 592d96be879SSascha Hauer break; 593d96be879SSascha Hauer } 594d96be879SSascha Hauer if (divider < 0x10) 595d96be879SSascha Hauer break; 596d96be879SSascha Hauer 597d96be879SSascha Hauer if (prescaler == 0) 598d96be879SSascha Hauer prescaler = 1; 599d96be879SSascha Hauer else 600d96be879SSascha Hauer prescaler <<= 1; 601d96be879SSascha Hauer } 602d96be879SSascha Hauer 603d96be879SSascha Hauer writew((prescaler << 4) | divider, host->base + MMC_REG_CLK_RATE); 604d96be879SSascha Hauer 605d96be879SSascha Hauer dev_dbg(mmc_dev(host->mmc), "scaler: %d divider: %d in: %d out: %d\n", 606d96be879SSascha Hauer prescaler, divider, clk_in, clk_ios); 607d96be879SSascha Hauer } 608d96be879SSascha Hauer 609d96be879SSascha Hauer static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 610d96be879SSascha Hauer { 611d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 612d96be879SSascha Hauer #ifdef HAS_DMA 613d96be879SSascha Hauer unsigned int blen; 614d96be879SSascha Hauer /* 615d96be879SSascha Hauer * use burstlen of 64 in 4 bit mode (--> reg value 0) 616d96be879SSascha Hauer * use burstlen of 16 in 1 bit mode (--> reg value 16) 617d96be879SSascha Hauer */ 618d96be879SSascha Hauer if (ios->bus_width == MMC_BUS_WIDTH_4) 619d96be879SSascha Hauer blen = 0; 620d96be879SSascha Hauer else 621d96be879SSascha Hauer blen = 16; 622d96be879SSascha Hauer 623d96be879SSascha Hauer imx_dma_config_burstlen(host->dma, blen); 624d96be879SSascha Hauer #endif 625d96be879SSascha Hauer if (ios->bus_width == MMC_BUS_WIDTH_4) 626d96be879SSascha Hauer host->cmdat |= CMD_DAT_CONT_BUS_WIDTH_4; 627d96be879SSascha Hauer else 628d96be879SSascha Hauer host->cmdat &= ~CMD_DAT_CONT_BUS_WIDTH_4; 629d96be879SSascha Hauer 630d96be879SSascha Hauer if (host->power_mode != ios->power_mode) { 631d96be879SSascha Hauer if (host->pdata && host->pdata->setpower) 632d96be879SSascha Hauer host->pdata->setpower(mmc_dev(mmc), ios->vdd); 633d96be879SSascha Hauer host->power_mode = ios->power_mode; 634d96be879SSascha Hauer if (ios->power_mode == MMC_POWER_ON) 635d96be879SSascha Hauer host->cmdat |= CMD_DAT_CONT_INIT; 636d96be879SSascha Hauer } 637d96be879SSascha Hauer 638d96be879SSascha Hauer if (ios->clock) { 639d96be879SSascha Hauer mxcmci_set_clk_rate(host, ios->clock); 640d96be879SSascha Hauer writew(STR_STP_CLK_START_CLK, host->base + MMC_REG_STR_STP_CLK); 641d96be879SSascha Hauer } else { 642d96be879SSascha Hauer writew(STR_STP_CLK_STOP_CLK, host->base + MMC_REG_STR_STP_CLK); 643d96be879SSascha Hauer } 644d96be879SSascha Hauer 645d96be879SSascha Hauer host->clock = ios->clock; 646d96be879SSascha Hauer } 647d96be879SSascha Hauer 648d96be879SSascha Hauer static irqreturn_t mxcmci_detect_irq(int irq, void *data) 649d96be879SSascha Hauer { 650d96be879SSascha Hauer struct mmc_host *mmc = data; 651d96be879SSascha Hauer 652d96be879SSascha Hauer dev_dbg(mmc_dev(mmc), "%s\n", __func__); 653d96be879SSascha Hauer 654d96be879SSascha Hauer mmc_detect_change(mmc, msecs_to_jiffies(250)); 655d96be879SSascha Hauer return IRQ_HANDLED; 656d96be879SSascha Hauer } 657d96be879SSascha Hauer 658d96be879SSascha Hauer static int mxcmci_get_ro(struct mmc_host *mmc) 659d96be879SSascha Hauer { 660d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 661d96be879SSascha Hauer 662d96be879SSascha Hauer if (host->pdata && host->pdata->get_ro) 663d96be879SSascha Hauer return !!host->pdata->get_ro(mmc_dev(mmc)); 664d96be879SSascha Hauer /* 665d96be879SSascha Hauer * Board doesn't support read only detection; let the mmc core 666d96be879SSascha Hauer * decide what to do. 667d96be879SSascha Hauer */ 668d96be879SSascha Hauer return -ENOSYS; 669d96be879SSascha Hauer } 670d96be879SSascha Hauer 671d96be879SSascha Hauer 672d96be879SSascha Hauer static const struct mmc_host_ops mxcmci_ops = { 673d96be879SSascha Hauer .request = mxcmci_request, 674d96be879SSascha Hauer .set_ios = mxcmci_set_ios, 675d96be879SSascha Hauer .get_ro = mxcmci_get_ro, 676d96be879SSascha Hauer }; 677d96be879SSascha Hauer 678d96be879SSascha Hauer static int mxcmci_probe(struct platform_device *pdev) 679d96be879SSascha Hauer { 680d96be879SSascha Hauer struct mmc_host *mmc; 681d96be879SSascha Hauer struct mxcmci_host *host = NULL; 682c0521bafSUwe Kleine-König struct resource *iores, *r; 683d96be879SSascha Hauer int ret = 0, irq; 684d96be879SSascha Hauer 685d96be879SSascha Hauer printk(KERN_INFO "i.MX SDHC driver\n"); 686d96be879SSascha Hauer 687c0521bafSUwe Kleine-König iores = platform_get_resource(pdev, IORESOURCE_MEM, 0); 688d96be879SSascha Hauer irq = platform_get_irq(pdev, 0); 689c0521bafSUwe Kleine-König if (!iores || irq < 0) 690d96be879SSascha Hauer return -EINVAL; 691d96be879SSascha Hauer 692c0521bafSUwe Kleine-König r = request_mem_region(iores->start, resource_size(iores), pdev->name); 693d96be879SSascha Hauer if (!r) 694d96be879SSascha Hauer return -EBUSY; 695d96be879SSascha Hauer 696d96be879SSascha Hauer mmc = mmc_alloc_host(sizeof(struct mxcmci_host), &pdev->dev); 697d96be879SSascha Hauer if (!mmc) { 698d96be879SSascha Hauer ret = -ENOMEM; 699d96be879SSascha Hauer goto out_release_mem; 700d96be879SSascha Hauer } 701d96be879SSascha Hauer 702d96be879SSascha Hauer mmc->ops = &mxcmci_ops; 703d96be879SSascha Hauer mmc->caps = MMC_CAP_4_BIT_DATA; 704d96be879SSascha Hauer 705d96be879SSascha Hauer /* MMC core transfer sizes tunable parameters */ 706d96be879SSascha Hauer mmc->max_hw_segs = 64; 707d96be879SSascha Hauer mmc->max_phys_segs = 64; 708d96be879SSascha Hauer mmc->max_blk_size = 2048; 709d96be879SSascha Hauer mmc->max_blk_count = 65535; 710d96be879SSascha Hauer mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count; 711d759c374SVladimir Zapolskiy mmc->max_seg_size = mmc->max_req_size; 712d96be879SSascha Hauer 713d96be879SSascha Hauer host = mmc_priv(mmc); 714d96be879SSascha Hauer host->base = ioremap(r->start, resource_size(r)); 715d96be879SSascha Hauer if (!host->base) { 716d96be879SSascha Hauer ret = -ENOMEM; 717d96be879SSascha Hauer goto out_free; 718d96be879SSascha Hauer } 719d96be879SSascha Hauer 720d96be879SSascha Hauer host->mmc = mmc; 721d96be879SSascha Hauer host->pdata = pdev->dev.platform_data; 722d96be879SSascha Hauer 723d96be879SSascha Hauer if (host->pdata && host->pdata->ocr_avail) 724d96be879SSascha Hauer mmc->ocr_avail = host->pdata->ocr_avail; 725d96be879SSascha Hauer else 726d96be879SSascha Hauer mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34; 727d96be879SSascha Hauer 728d96be879SSascha Hauer host->res = r; 729d96be879SSascha Hauer host->irq = irq; 730d96be879SSascha Hauer 73106277b5cSSascha Hauer host->clk = clk_get(&pdev->dev, NULL); 732d96be879SSascha Hauer if (IS_ERR(host->clk)) { 733d96be879SSascha Hauer ret = PTR_ERR(host->clk); 734d96be879SSascha Hauer goto out_iounmap; 735d96be879SSascha Hauer } 736d96be879SSascha Hauer clk_enable(host->clk); 737d96be879SSascha Hauer 738d96be879SSascha Hauer mxcmci_softreset(host); 739d96be879SSascha Hauer 740d96be879SSascha Hauer host->rev_no = readw(host->base + MMC_REG_REV_NO); 741d96be879SSascha Hauer if (host->rev_no != 0x400) { 742d96be879SSascha Hauer ret = -ENODEV; 743d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "wrong rev.no. 0x%08x. aborting.\n", 744d96be879SSascha Hauer host->rev_no); 745d96be879SSascha Hauer goto out_clk_put; 746d96be879SSascha Hauer } 747d96be879SSascha Hauer 748c499b067SSascha Hauer mmc->f_min = clk_get_rate(host->clk) >> 16; 749d96be879SSascha Hauer mmc->f_max = clk_get_rate(host->clk) >> 1; 750d96be879SSascha Hauer 751d96be879SSascha Hauer /* recommended in data sheet */ 752d96be879SSascha Hauer writew(0x2db4, host->base + MMC_REG_READ_TO); 753d96be879SSascha Hauer 754d96be879SSascha Hauer writel(0, host->base + MMC_REG_INT_CNTR); 755d96be879SSascha Hauer 756d96be879SSascha Hauer #ifdef HAS_DMA 757d96be879SSascha Hauer host->dma = imx_dma_request_by_prio(DRIVER_NAME, DMA_PRIO_LOW); 758d96be879SSascha Hauer if (host->dma < 0) { 759d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "imx_dma_request_by_prio failed\n"); 760d96be879SSascha Hauer ret = -EBUSY; 761d96be879SSascha Hauer goto out_clk_put; 762d96be879SSascha Hauer } 763d96be879SSascha Hauer 764d96be879SSascha Hauer r = platform_get_resource(pdev, IORESOURCE_DMA, 0); 765d96be879SSascha Hauer if (!r) { 766d96be879SSascha Hauer ret = -EINVAL; 767d96be879SSascha Hauer goto out_free_dma; 768d96be879SSascha Hauer } 769d96be879SSascha Hauer 770d96be879SSascha Hauer ret = imx_dma_config_channel(host->dma, 771d96be879SSascha Hauer IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_FIFO, 772d96be879SSascha Hauer IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR, 773d96be879SSascha Hauer r->start, 0); 774d96be879SSascha Hauer if (ret) { 775d96be879SSascha Hauer dev_err(mmc_dev(host->mmc), "failed to config DMA channel\n"); 776d96be879SSascha Hauer goto out_free_dma; 777d96be879SSascha Hauer } 778d96be879SSascha Hauer #endif 779d96be879SSascha Hauer INIT_WORK(&host->datawork, mxcmci_datawork); 780d96be879SSascha Hauer 781d96be879SSascha Hauer ret = request_irq(host->irq, mxcmci_irq, 0, DRIVER_NAME, host); 782d96be879SSascha Hauer if (ret) 783d96be879SSascha Hauer goto out_free_dma; 784d96be879SSascha Hauer 785d96be879SSascha Hauer platform_set_drvdata(pdev, mmc); 786d96be879SSascha Hauer 787d96be879SSascha Hauer if (host->pdata && host->pdata->init) { 788d96be879SSascha Hauer ret = host->pdata->init(&pdev->dev, mxcmci_detect_irq, 789d96be879SSascha Hauer host->mmc); 790d96be879SSascha Hauer if (ret) 791d96be879SSascha Hauer goto out_free_irq; 792d96be879SSascha Hauer } 793d96be879SSascha Hauer 794d96be879SSascha Hauer mmc_add_host(mmc); 795d96be879SSascha Hauer 796d96be879SSascha Hauer return 0; 797d96be879SSascha Hauer 798d96be879SSascha Hauer out_free_irq: 799d96be879SSascha Hauer free_irq(host->irq, host); 800d96be879SSascha Hauer out_free_dma: 801d96be879SSascha Hauer #ifdef HAS_DMA 802d96be879SSascha Hauer imx_dma_free(host->dma); 803d96be879SSascha Hauer #endif 804d96be879SSascha Hauer out_clk_put: 805d96be879SSascha Hauer clk_disable(host->clk); 806d96be879SSascha Hauer clk_put(host->clk); 807d96be879SSascha Hauer out_iounmap: 808d96be879SSascha Hauer iounmap(host->base); 809d96be879SSascha Hauer out_free: 810d96be879SSascha Hauer mmc_free_host(mmc); 811d96be879SSascha Hauer out_release_mem: 812c0521bafSUwe Kleine-König release_mem_region(iores->start, resource_size(iores)); 813d96be879SSascha Hauer return ret; 814d96be879SSascha Hauer } 815d96be879SSascha Hauer 816d96be879SSascha Hauer static int mxcmci_remove(struct platform_device *pdev) 817d96be879SSascha Hauer { 818d96be879SSascha Hauer struct mmc_host *mmc = platform_get_drvdata(pdev); 819d96be879SSascha Hauer struct mxcmci_host *host = mmc_priv(mmc); 820d96be879SSascha Hauer 821d96be879SSascha Hauer platform_set_drvdata(pdev, NULL); 822d96be879SSascha Hauer 823d96be879SSascha Hauer mmc_remove_host(mmc); 824d96be879SSascha Hauer 825d96be879SSascha Hauer if (host->pdata && host->pdata->exit) 826d96be879SSascha Hauer host->pdata->exit(&pdev->dev, mmc); 827d96be879SSascha Hauer 828d96be879SSascha Hauer free_irq(host->irq, host); 829d96be879SSascha Hauer iounmap(host->base); 830d96be879SSascha Hauer #ifdef HAS_DMA 831d96be879SSascha Hauer imx_dma_free(host->dma); 832d96be879SSascha Hauer #endif 833d96be879SSascha Hauer clk_disable(host->clk); 834d96be879SSascha Hauer clk_put(host->clk); 835d96be879SSascha Hauer 836d96be879SSascha Hauer release_mem_region(host->res->start, resource_size(host->res)); 837d96be879SSascha Hauer release_resource(host->res); 838d96be879SSascha Hauer 839d96be879SSascha Hauer mmc_free_host(mmc); 840d96be879SSascha Hauer 841d96be879SSascha Hauer return 0; 842d96be879SSascha Hauer } 843d96be879SSascha Hauer 844d96be879SSascha Hauer #ifdef CONFIG_PM 845d96be879SSascha Hauer static int mxcmci_suspend(struct platform_device *dev, pm_message_t state) 846d96be879SSascha Hauer { 847d96be879SSascha Hauer struct mmc_host *mmc = platform_get_drvdata(dev); 848d96be879SSascha Hauer int ret = 0; 849d96be879SSascha Hauer 850d96be879SSascha Hauer if (mmc) 851d96be879SSascha Hauer ret = mmc_suspend_host(mmc, state); 852d96be879SSascha Hauer 853d96be879SSascha Hauer return ret; 854d96be879SSascha Hauer } 855d96be879SSascha Hauer 856d96be879SSascha Hauer static int mxcmci_resume(struct platform_device *dev) 857d96be879SSascha Hauer { 858d96be879SSascha Hauer struct mmc_host *mmc = platform_get_drvdata(dev); 859d96be879SSascha Hauer struct mxcmci_host *host; 860d96be879SSascha Hauer int ret = 0; 861d96be879SSascha Hauer 862d96be879SSascha Hauer if (mmc) { 863d96be879SSascha Hauer host = mmc_priv(mmc); 864d96be879SSascha Hauer ret = mmc_resume_host(mmc); 865d96be879SSascha Hauer } 866d96be879SSascha Hauer 867d96be879SSascha Hauer return ret; 868d96be879SSascha Hauer } 869d96be879SSascha Hauer #else 870d96be879SSascha Hauer #define mxcmci_suspend NULL 871d96be879SSascha Hauer #define mxcmci_resume NULL 872d96be879SSascha Hauer #endif /* CONFIG_PM */ 873d96be879SSascha Hauer 874d96be879SSascha Hauer static struct platform_driver mxcmci_driver = { 875d96be879SSascha Hauer .probe = mxcmci_probe, 876d96be879SSascha Hauer .remove = mxcmci_remove, 877d96be879SSascha Hauer .suspend = mxcmci_suspend, 878d96be879SSascha Hauer .resume = mxcmci_resume, 879d96be879SSascha Hauer .driver = { 880d96be879SSascha Hauer .name = DRIVER_NAME, 881d96be879SSascha Hauer .owner = THIS_MODULE, 882d96be879SSascha Hauer } 883d96be879SSascha Hauer }; 884d96be879SSascha Hauer 885d96be879SSascha Hauer static int __init mxcmci_init(void) 886d96be879SSascha Hauer { 887d96be879SSascha Hauer return platform_driver_register(&mxcmci_driver); 888d96be879SSascha Hauer } 889d96be879SSascha Hauer 890d96be879SSascha Hauer static void __exit mxcmci_exit(void) 891d96be879SSascha Hauer { 892d96be879SSascha Hauer platform_driver_unregister(&mxcmci_driver); 893d96be879SSascha Hauer } 894d96be879SSascha Hauer 895d96be879SSascha Hauer module_init(mxcmci_init); 896d96be879SSascha Hauer module_exit(mxcmci_exit); 897d96be879SSascha Hauer 898d96be879SSascha Hauer MODULE_DESCRIPTION("i.MX Multimedia Card Interface Driver"); 899d96be879SSascha Hauer MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 900d96be879SSascha Hauer MODULE_LICENSE("GPL"); 901d96be879SSascha Hauer MODULE_ALIAS("platform:imx-mmc"); 902