1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/drivers/mmc/host/mxcmmc.c - Freescale i.MX MMCI driver 4 * 5 * This is a driver for the SDHC controller found in Freescale MX2/MX3 6 * SoCs. It is basically the same hardware as found on MX1 (imxmmc.c). 7 * Unlike the hardware found on MX1, this hardware just works and does 8 * not need all the quirks found in imxmmc.c, hence the separate driver. 9 * 10 * Copyright (C) 2008 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de> 11 * Copyright (C) 2006 Pavel Pisa, PiKRON <ppisa@pikron.com> 12 * 13 * derived from pxamci.c by Russell King 14 */ 15 16 #include <linux/module.h> 17 #include <linux/init.h> 18 #include <linux/ioport.h> 19 #include <linux/platform_device.h> 20 #include <linux/highmem.h> 21 #include <linux/interrupt.h> 22 #include <linux/irq.h> 23 #include <linux/blkdev.h> 24 #include <linux/dma-mapping.h> 25 #include <linux/mmc/host.h> 26 #include <linux/mmc/card.h> 27 #include <linux/delay.h> 28 #include <linux/clk.h> 29 #include <linux/io.h> 30 #include <linux/regulator/consumer.h> 31 #include <linux/dmaengine.h> 32 #include <linux/types.h> 33 #include <linux/of.h> 34 #include <linux/of_device.h> 35 #include <linux/of_dma.h> 36 #include <linux/mmc/slot-gpio.h> 37 38 #include <asm/dma.h> 39 #include <asm/irq.h> 40 #include <linux/platform_data/mmc-mxcmmc.h> 41 42 #include <linux/dma/imx-dma.h> 43 44 #define DRIVER_NAME "mxc-mmc" 45 #define MXCMCI_TIMEOUT_MS 10000 46 47 #define MMC_REG_STR_STP_CLK 0x00 48 #define MMC_REG_STATUS 0x04 49 #define MMC_REG_CLK_RATE 0x08 50 #define MMC_REG_CMD_DAT_CONT 0x0C 51 #define MMC_REG_RES_TO 0x10 52 #define MMC_REG_READ_TO 0x14 53 #define MMC_REG_BLK_LEN 0x18 54 #define MMC_REG_NOB 0x1C 55 #define MMC_REG_REV_NO 0x20 56 #define MMC_REG_INT_CNTR 0x24 57 #define MMC_REG_CMD 0x28 58 #define MMC_REG_ARG 0x2C 59 #define MMC_REG_RES_FIFO 0x34 60 #define MMC_REG_BUFFER_ACCESS 0x38 61 62 #define STR_STP_CLK_RESET (1 << 3) 63 #define STR_STP_CLK_START_CLK (1 << 1) 64 #define STR_STP_CLK_STOP_CLK (1 << 0) 65 66 #define STATUS_CARD_INSERTION (1 << 31) 67 #define STATUS_CARD_REMOVAL (1 << 30) 68 #define STATUS_YBUF_EMPTY (1 << 29) 69 #define STATUS_XBUF_EMPTY (1 << 28) 70 #define STATUS_YBUF_FULL (1 << 27) 71 #define STATUS_XBUF_FULL (1 << 26) 72 #define STATUS_BUF_UND_RUN (1 << 25) 73 #define STATUS_BUF_OVFL (1 << 24) 74 #define STATUS_SDIO_INT_ACTIVE (1 << 14) 75 #define STATUS_END_CMD_RESP (1 << 13) 76 #define STATUS_WRITE_OP_DONE (1 << 12) 77 #define STATUS_DATA_TRANS_DONE (1 << 11) 78 #define STATUS_READ_OP_DONE (1 << 11) 79 #define STATUS_WR_CRC_ERROR_CODE_MASK (3 << 10) 80 #define STATUS_CARD_BUS_CLK_RUN (1 << 8) 81 #define STATUS_BUF_READ_RDY (1 << 7) 82 #define STATUS_BUF_WRITE_RDY (1 << 6) 83 #define STATUS_RESP_CRC_ERR (1 << 5) 84 #define STATUS_CRC_READ_ERR (1 << 3) 85 #define STATUS_CRC_WRITE_ERR (1 << 2) 86 #define STATUS_TIME_OUT_RESP (1 << 1) 87 #define STATUS_TIME_OUT_READ (1 << 0) 88 #define STATUS_ERR_MASK 0x2f 89 90 #define CMD_DAT_CONT_CMD_RESP_LONG_OFF (1 << 12) 91 #define CMD_DAT_CONT_STOP_READWAIT (1 << 11) 92 #define CMD_DAT_CONT_START_READWAIT (1 << 10) 93 #define CMD_DAT_CONT_BUS_WIDTH_4 (2 << 8) 94 #define CMD_DAT_CONT_INIT (1 << 7) 95 #define CMD_DAT_CONT_WRITE (1 << 4) 96 #define CMD_DAT_CONT_DATA_ENABLE (1 << 3) 97 #define CMD_DAT_CONT_RESPONSE_48BIT_CRC (1 << 0) 98 #define CMD_DAT_CONT_RESPONSE_136BIT (2 << 0) 99 #define CMD_DAT_CONT_RESPONSE_48BIT (3 << 0) 100 101 #define INT_SDIO_INT_WKP_EN (1 << 18) 102 #define INT_CARD_INSERTION_WKP_EN (1 << 17) 103 #define INT_CARD_REMOVAL_WKP_EN (1 << 16) 104 #define INT_CARD_INSERTION_EN (1 << 15) 105 #define INT_CARD_REMOVAL_EN (1 << 14) 106 #define INT_SDIO_IRQ_EN (1 << 13) 107 #define INT_DAT0_EN (1 << 12) 108 #define INT_BUF_READ_EN (1 << 4) 109 #define INT_BUF_WRITE_EN (1 << 3) 110 #define INT_END_CMD_RES_EN (1 << 2) 111 #define INT_WRITE_OP_DONE_EN (1 << 1) 112 #define INT_READ_OP_EN (1 << 0) 113 114 enum mxcmci_type { 115 IMX21_MMC, 116 IMX31_MMC, 117 MPC512X_MMC, 118 }; 119 120 struct mxcmci_host { 121 struct mmc_host *mmc; 122 void __iomem *base; 123 dma_addr_t phys_base; 124 int detect_irq; 125 struct dma_chan *dma; 126 struct dma_async_tx_descriptor *desc; 127 int do_dma; 128 int default_irq_mask; 129 int use_sdio; 130 unsigned int power_mode; 131 struct imxmmc_platform_data *pdata; 132 133 struct mmc_request *req; 134 struct mmc_command *cmd; 135 struct mmc_data *data; 136 137 unsigned int datasize; 138 unsigned int dma_dir; 139 140 u16 rev_no; 141 unsigned int cmdat; 142 143 struct clk *clk_ipg; 144 struct clk *clk_per; 145 146 int clock; 147 148 struct work_struct datawork; 149 spinlock_t lock; 150 151 int burstlen; 152 int dmareq; 153 struct dma_slave_config dma_slave_config; 154 struct imx_dma_data dma_data; 155 156 struct timer_list watchdog; 157 enum mxcmci_type devtype; 158 }; 159 160 static const struct of_device_id mxcmci_of_match[] = { 161 { 162 .compatible = "fsl,imx21-mmc", 163 .data = (void *) IMX21_MMC, 164 }, { 165 .compatible = "fsl,imx31-mmc", 166 .data = (void *) IMX31_MMC, 167 }, { 168 .compatible = "fsl,mpc5121-sdhc", 169 .data = (void *) MPC512X_MMC, 170 }, { 171 /* sentinel */ 172 } 173 }; 174 MODULE_DEVICE_TABLE(of, mxcmci_of_match); 175 176 static inline int is_imx31_mmc(struct mxcmci_host *host) 177 { 178 return host->devtype == IMX31_MMC; 179 } 180 181 static inline int is_mpc512x_mmc(struct mxcmci_host *host) 182 { 183 return host->devtype == MPC512X_MMC; 184 } 185 186 static inline u32 mxcmci_readl(struct mxcmci_host *host, int reg) 187 { 188 if (IS_ENABLED(CONFIG_PPC_MPC512x)) 189 return ioread32be(host->base + reg); 190 else 191 return readl(host->base + reg); 192 } 193 194 static inline void mxcmci_writel(struct mxcmci_host *host, u32 val, int reg) 195 { 196 if (IS_ENABLED(CONFIG_PPC_MPC512x)) 197 iowrite32be(val, host->base + reg); 198 else 199 writel(val, host->base + reg); 200 } 201 202 static inline u16 mxcmci_readw(struct mxcmci_host *host, int reg) 203 { 204 if (IS_ENABLED(CONFIG_PPC_MPC512x)) 205 return ioread32be(host->base + reg); 206 else 207 return readw(host->base + reg); 208 } 209 210 static inline void mxcmci_writew(struct mxcmci_host *host, u16 val, int reg) 211 { 212 if (IS_ENABLED(CONFIG_PPC_MPC512x)) 213 iowrite32be(val, host->base + reg); 214 else 215 writew(val, host->base + reg); 216 } 217 218 static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios); 219 220 static void mxcmci_set_power(struct mxcmci_host *host, unsigned int vdd) 221 { 222 if (!IS_ERR(host->mmc->supply.vmmc)) { 223 if (host->power_mode == MMC_POWER_UP) 224 mmc_regulator_set_ocr(host->mmc, 225 host->mmc->supply.vmmc, vdd); 226 else if (host->power_mode == MMC_POWER_OFF) 227 mmc_regulator_set_ocr(host->mmc, 228 host->mmc->supply.vmmc, 0); 229 } 230 231 if (host->pdata && host->pdata->setpower) 232 host->pdata->setpower(mmc_dev(host->mmc), vdd); 233 } 234 235 static inline int mxcmci_use_dma(struct mxcmci_host *host) 236 { 237 return host->do_dma; 238 } 239 240 static void mxcmci_softreset(struct mxcmci_host *host) 241 { 242 int i; 243 244 dev_dbg(mmc_dev(host->mmc), "mxcmci_softreset\n"); 245 246 /* reset sequence */ 247 mxcmci_writew(host, STR_STP_CLK_RESET, MMC_REG_STR_STP_CLK); 248 mxcmci_writew(host, STR_STP_CLK_RESET | STR_STP_CLK_START_CLK, 249 MMC_REG_STR_STP_CLK); 250 251 for (i = 0; i < 8; i++) 252 mxcmci_writew(host, STR_STP_CLK_START_CLK, MMC_REG_STR_STP_CLK); 253 254 mxcmci_writew(host, 0xff, MMC_REG_RES_TO); 255 } 256 257 #if IS_ENABLED(CONFIG_PPC_MPC512x) 258 static inline void buffer_swap32(u32 *buf, int len) 259 { 260 int i; 261 262 for (i = 0; i < ((len + 3) / 4); i++) { 263 *buf = swab32(*buf); 264 buf++; 265 } 266 } 267 268 static void mxcmci_swap_buffers(struct mmc_data *data) 269 { 270 struct scatterlist *sg; 271 int i; 272 273 for_each_sg(data->sg, sg, data->sg_len, i) 274 buffer_swap32(sg_virt(sg), sg->length); 275 } 276 #else 277 static inline void mxcmci_swap_buffers(struct mmc_data *data) {} 278 #endif 279 280 static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data) 281 { 282 unsigned int nob = data->blocks; 283 unsigned int blksz = data->blksz; 284 unsigned int datasize = nob * blksz; 285 struct scatterlist *sg; 286 enum dma_transfer_direction slave_dirn; 287 int i, nents; 288 289 host->data = data; 290 data->bytes_xfered = 0; 291 292 mxcmci_writew(host, nob, MMC_REG_NOB); 293 mxcmci_writew(host, blksz, MMC_REG_BLK_LEN); 294 host->datasize = datasize; 295 296 if (!mxcmci_use_dma(host)) 297 return 0; 298 299 for_each_sg(data->sg, sg, data->sg_len, i) { 300 if (sg->offset & 3 || sg->length & 3 || sg->length < 512) { 301 host->do_dma = 0; 302 return 0; 303 } 304 } 305 306 if (data->flags & MMC_DATA_READ) { 307 host->dma_dir = DMA_FROM_DEVICE; 308 slave_dirn = DMA_DEV_TO_MEM; 309 } else { 310 host->dma_dir = DMA_TO_DEVICE; 311 slave_dirn = DMA_MEM_TO_DEV; 312 313 mxcmci_swap_buffers(data); 314 } 315 316 nents = dma_map_sg(host->dma->device->dev, data->sg, 317 data->sg_len, host->dma_dir); 318 if (nents != data->sg_len) 319 return -EINVAL; 320 321 host->desc = dmaengine_prep_slave_sg(host->dma, 322 data->sg, data->sg_len, slave_dirn, 323 DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 324 325 if (!host->desc) { 326 dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len, 327 host->dma_dir); 328 host->do_dma = 0; 329 return 0; /* Fall back to PIO */ 330 } 331 wmb(); 332 333 dmaengine_submit(host->desc); 334 dma_async_issue_pending(host->dma); 335 336 mod_timer(&host->watchdog, jiffies + msecs_to_jiffies(MXCMCI_TIMEOUT_MS)); 337 338 return 0; 339 } 340 341 static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat); 342 static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat); 343 344 static void mxcmci_dma_callback(void *data) 345 { 346 struct mxcmci_host *host = data; 347 u32 stat; 348 349 del_timer(&host->watchdog); 350 351 stat = mxcmci_readl(host, MMC_REG_STATUS); 352 353 dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat); 354 355 mxcmci_data_done(host, stat); 356 } 357 358 static int mxcmci_start_cmd(struct mxcmci_host *host, struct mmc_command *cmd, 359 unsigned int cmdat) 360 { 361 u32 int_cntr = host->default_irq_mask; 362 unsigned long flags; 363 364 WARN_ON(host->cmd != NULL); 365 host->cmd = cmd; 366 367 switch (mmc_resp_type(cmd)) { 368 case MMC_RSP_R1: /* short CRC, OPCODE */ 369 case MMC_RSP_R1B:/* short CRC, OPCODE, BUSY */ 370 cmdat |= CMD_DAT_CONT_RESPONSE_48BIT_CRC; 371 break; 372 case MMC_RSP_R2: /* long 136 bit + CRC */ 373 cmdat |= CMD_DAT_CONT_RESPONSE_136BIT; 374 break; 375 case MMC_RSP_R3: /* short */ 376 cmdat |= CMD_DAT_CONT_RESPONSE_48BIT; 377 break; 378 case MMC_RSP_NONE: 379 break; 380 default: 381 dev_err(mmc_dev(host->mmc), "unhandled response type 0x%x\n", 382 mmc_resp_type(cmd)); 383 cmd->error = -EINVAL; 384 return -EINVAL; 385 } 386 387 int_cntr = INT_END_CMD_RES_EN; 388 389 if (mxcmci_use_dma(host)) { 390 if (host->dma_dir == DMA_FROM_DEVICE) { 391 host->desc->callback = mxcmci_dma_callback; 392 host->desc->callback_param = host; 393 } else { 394 int_cntr |= INT_WRITE_OP_DONE_EN; 395 } 396 } 397 398 spin_lock_irqsave(&host->lock, flags); 399 if (host->use_sdio) 400 int_cntr |= INT_SDIO_IRQ_EN; 401 mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 402 spin_unlock_irqrestore(&host->lock, flags); 403 404 mxcmci_writew(host, cmd->opcode, MMC_REG_CMD); 405 mxcmci_writel(host, cmd->arg, MMC_REG_ARG); 406 mxcmci_writew(host, cmdat, MMC_REG_CMD_DAT_CONT); 407 408 return 0; 409 } 410 411 static void mxcmci_finish_request(struct mxcmci_host *host, 412 struct mmc_request *req) 413 { 414 u32 int_cntr = host->default_irq_mask; 415 unsigned long flags; 416 417 spin_lock_irqsave(&host->lock, flags); 418 if (host->use_sdio) 419 int_cntr |= INT_SDIO_IRQ_EN; 420 mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 421 spin_unlock_irqrestore(&host->lock, flags); 422 423 host->req = NULL; 424 host->cmd = NULL; 425 host->data = NULL; 426 427 mmc_request_done(host->mmc, req); 428 } 429 430 static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat) 431 { 432 struct mmc_data *data = host->data; 433 int data_error; 434 435 if (mxcmci_use_dma(host)) { 436 dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len, 437 host->dma_dir); 438 mxcmci_swap_buffers(data); 439 } 440 441 if (stat & STATUS_ERR_MASK) { 442 dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n", 443 stat); 444 if (stat & STATUS_CRC_READ_ERR) { 445 dev_err(mmc_dev(host->mmc), "%s: -EILSEQ\n", __func__); 446 data->error = -EILSEQ; 447 } else if (stat & STATUS_CRC_WRITE_ERR) { 448 u32 err_code = (stat >> 9) & 0x3; 449 if (err_code == 2) { /* No CRC response */ 450 dev_err(mmc_dev(host->mmc), 451 "%s: No CRC -ETIMEDOUT\n", __func__); 452 data->error = -ETIMEDOUT; 453 } else { 454 dev_err(mmc_dev(host->mmc), 455 "%s: -EILSEQ\n", __func__); 456 data->error = -EILSEQ; 457 } 458 } else if (stat & STATUS_TIME_OUT_READ) { 459 dev_err(mmc_dev(host->mmc), 460 "%s: read -ETIMEDOUT\n", __func__); 461 data->error = -ETIMEDOUT; 462 } else { 463 dev_err(mmc_dev(host->mmc), "%s: -EIO\n", __func__); 464 data->error = -EIO; 465 } 466 } else { 467 data->bytes_xfered = host->datasize; 468 } 469 470 data_error = data->error; 471 472 host->data = NULL; 473 474 return data_error; 475 } 476 477 static void mxcmci_read_response(struct mxcmci_host *host, unsigned int stat) 478 { 479 struct mmc_command *cmd = host->cmd; 480 int i; 481 u32 a, b, c; 482 483 if (!cmd) 484 return; 485 486 if (stat & STATUS_TIME_OUT_RESP) { 487 dev_dbg(mmc_dev(host->mmc), "CMD TIMEOUT\n"); 488 cmd->error = -ETIMEDOUT; 489 } else if (stat & STATUS_RESP_CRC_ERR && cmd->flags & MMC_RSP_CRC) { 490 dev_dbg(mmc_dev(host->mmc), "cmd crc error\n"); 491 cmd->error = -EILSEQ; 492 } 493 494 if (cmd->flags & MMC_RSP_PRESENT) { 495 if (cmd->flags & MMC_RSP_136) { 496 for (i = 0; i < 4; i++) { 497 a = mxcmci_readw(host, MMC_REG_RES_FIFO); 498 b = mxcmci_readw(host, MMC_REG_RES_FIFO); 499 cmd->resp[i] = a << 16 | b; 500 } 501 } else { 502 a = mxcmci_readw(host, MMC_REG_RES_FIFO); 503 b = mxcmci_readw(host, MMC_REG_RES_FIFO); 504 c = mxcmci_readw(host, MMC_REG_RES_FIFO); 505 cmd->resp[0] = a << 24 | b << 8 | c >> 8; 506 } 507 } 508 } 509 510 static int mxcmci_poll_status(struct mxcmci_host *host, u32 mask) 511 { 512 u32 stat; 513 unsigned long timeout = jiffies + HZ; 514 515 do { 516 stat = mxcmci_readl(host, MMC_REG_STATUS); 517 if (stat & STATUS_ERR_MASK) 518 return stat; 519 if (time_after(jiffies, timeout)) { 520 mxcmci_softreset(host); 521 mxcmci_set_clk_rate(host, host->clock); 522 return STATUS_TIME_OUT_READ; 523 } 524 if (stat & mask) 525 return 0; 526 cpu_relax(); 527 } while (1); 528 } 529 530 static int mxcmci_pull(struct mxcmci_host *host, void *_buf, int bytes) 531 { 532 unsigned int stat; 533 u32 *buf = _buf; 534 535 while (bytes > 3) { 536 stat = mxcmci_poll_status(host, 537 STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 538 if (stat) 539 return stat; 540 *buf++ = cpu_to_le32(mxcmci_readl(host, MMC_REG_BUFFER_ACCESS)); 541 bytes -= 4; 542 } 543 544 if (bytes) { 545 u8 *b = (u8 *)buf; 546 u32 tmp; 547 548 stat = mxcmci_poll_status(host, 549 STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 550 if (stat) 551 return stat; 552 tmp = cpu_to_le32(mxcmci_readl(host, MMC_REG_BUFFER_ACCESS)); 553 memcpy(b, &tmp, bytes); 554 } 555 556 return 0; 557 } 558 559 static int mxcmci_push(struct mxcmci_host *host, void *_buf, int bytes) 560 { 561 unsigned int stat; 562 u32 *buf = _buf; 563 564 while (bytes > 3) { 565 stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 566 if (stat) 567 return stat; 568 mxcmci_writel(host, cpu_to_le32(*buf++), MMC_REG_BUFFER_ACCESS); 569 bytes -= 4; 570 } 571 572 if (bytes) { 573 u8 *b = (u8 *)buf; 574 u32 tmp; 575 576 stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 577 if (stat) 578 return stat; 579 580 memcpy(&tmp, b, bytes); 581 mxcmci_writel(host, cpu_to_le32(tmp), MMC_REG_BUFFER_ACCESS); 582 } 583 584 return mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 585 } 586 587 static int mxcmci_transfer_data(struct mxcmci_host *host) 588 { 589 struct mmc_data *data = host->req->data; 590 struct scatterlist *sg; 591 int stat, i; 592 593 host->data = data; 594 host->datasize = 0; 595 596 if (data->flags & MMC_DATA_READ) { 597 for_each_sg(data->sg, sg, data->sg_len, i) { 598 stat = mxcmci_pull(host, sg_virt(sg), sg->length); 599 if (stat) 600 return stat; 601 host->datasize += sg->length; 602 } 603 } else { 604 for_each_sg(data->sg, sg, data->sg_len, i) { 605 stat = mxcmci_push(host, sg_virt(sg), sg->length); 606 if (stat) 607 return stat; 608 host->datasize += sg->length; 609 } 610 stat = mxcmci_poll_status(host, STATUS_WRITE_OP_DONE); 611 if (stat) 612 return stat; 613 } 614 return 0; 615 } 616 617 static void mxcmci_datawork(struct work_struct *work) 618 { 619 struct mxcmci_host *host = container_of(work, struct mxcmci_host, 620 datawork); 621 int datastat = mxcmci_transfer_data(host); 622 623 mxcmci_writel(host, STATUS_READ_OP_DONE | STATUS_WRITE_OP_DONE, 624 MMC_REG_STATUS); 625 mxcmci_finish_data(host, datastat); 626 627 if (host->req->stop) { 628 if (mxcmci_start_cmd(host, host->req->stop, 0)) { 629 mxcmci_finish_request(host, host->req); 630 return; 631 } 632 } else { 633 mxcmci_finish_request(host, host->req); 634 } 635 } 636 637 static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat) 638 { 639 struct mmc_request *req; 640 int data_error; 641 unsigned long flags; 642 643 spin_lock_irqsave(&host->lock, flags); 644 645 if (!host->data) { 646 spin_unlock_irqrestore(&host->lock, flags); 647 return; 648 } 649 650 if (!host->req) { 651 spin_unlock_irqrestore(&host->lock, flags); 652 return; 653 } 654 655 req = host->req; 656 if (!req->stop) 657 host->req = NULL; /* we will handle finish req below */ 658 659 data_error = mxcmci_finish_data(host, stat); 660 661 spin_unlock_irqrestore(&host->lock, flags); 662 663 if (data_error) 664 return; 665 666 mxcmci_read_response(host, stat); 667 host->cmd = NULL; 668 669 if (req->stop) { 670 if (mxcmci_start_cmd(host, req->stop, 0)) { 671 mxcmci_finish_request(host, req); 672 return; 673 } 674 } else { 675 mxcmci_finish_request(host, req); 676 } 677 } 678 679 static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat) 680 { 681 mxcmci_read_response(host, stat); 682 host->cmd = NULL; 683 684 if (!host->data && host->req) { 685 mxcmci_finish_request(host, host->req); 686 return; 687 } 688 689 /* For the DMA case the DMA engine handles the data transfer 690 * automatically. For non DMA we have to do it ourselves. 691 * Don't do it in interrupt context though. 692 */ 693 if (!mxcmci_use_dma(host) && host->data) 694 schedule_work(&host->datawork); 695 696 } 697 698 static irqreturn_t mxcmci_irq(int irq, void *devid) 699 { 700 struct mxcmci_host *host = devid; 701 bool sdio_irq; 702 u32 stat; 703 704 stat = mxcmci_readl(host, MMC_REG_STATUS); 705 mxcmci_writel(host, 706 stat & ~(STATUS_SDIO_INT_ACTIVE | STATUS_DATA_TRANS_DONE | 707 STATUS_WRITE_OP_DONE), 708 MMC_REG_STATUS); 709 710 dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat); 711 712 spin_lock(&host->lock); 713 sdio_irq = (stat & STATUS_SDIO_INT_ACTIVE) && host->use_sdio; 714 spin_unlock(&host->lock); 715 716 if (mxcmci_use_dma(host) && (stat & (STATUS_WRITE_OP_DONE))) 717 mxcmci_writel(host, STATUS_WRITE_OP_DONE, MMC_REG_STATUS); 718 719 if (sdio_irq) { 720 mxcmci_writel(host, STATUS_SDIO_INT_ACTIVE, MMC_REG_STATUS); 721 mmc_signal_sdio_irq(host->mmc); 722 } 723 724 if (stat & STATUS_END_CMD_RESP) 725 mxcmci_cmd_done(host, stat); 726 727 if (mxcmci_use_dma(host) && (stat & STATUS_WRITE_OP_DONE)) { 728 del_timer(&host->watchdog); 729 mxcmci_data_done(host, stat); 730 } 731 732 if (host->default_irq_mask && 733 (stat & (STATUS_CARD_INSERTION | STATUS_CARD_REMOVAL))) 734 mmc_detect_change(host->mmc, msecs_to_jiffies(200)); 735 736 return IRQ_HANDLED; 737 } 738 739 static void mxcmci_request(struct mmc_host *mmc, struct mmc_request *req) 740 { 741 struct mxcmci_host *host = mmc_priv(mmc); 742 unsigned int cmdat = host->cmdat; 743 int error; 744 745 WARN_ON(host->req != NULL); 746 747 host->req = req; 748 host->cmdat &= ~CMD_DAT_CONT_INIT; 749 750 if (host->dma) 751 host->do_dma = 1; 752 753 if (req->data) { 754 error = mxcmci_setup_data(host, req->data); 755 if (error) { 756 req->cmd->error = error; 757 goto out; 758 } 759 760 761 cmdat |= CMD_DAT_CONT_DATA_ENABLE; 762 763 if (req->data->flags & MMC_DATA_WRITE) 764 cmdat |= CMD_DAT_CONT_WRITE; 765 } 766 767 error = mxcmci_start_cmd(host, req->cmd, cmdat); 768 769 out: 770 if (error) 771 mxcmci_finish_request(host, req); 772 } 773 774 static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios) 775 { 776 unsigned int divider; 777 int prescaler = 0; 778 unsigned int clk_in = clk_get_rate(host->clk_per); 779 780 while (prescaler <= 0x800) { 781 for (divider = 1; divider <= 0xF; divider++) { 782 int x; 783 784 x = (clk_in / (divider + 1)); 785 786 if (prescaler) 787 x /= (prescaler * 2); 788 789 if (x <= clk_ios) 790 break; 791 } 792 if (divider < 0x10) 793 break; 794 795 if (prescaler == 0) 796 prescaler = 1; 797 else 798 prescaler <<= 1; 799 } 800 801 mxcmci_writew(host, (prescaler << 4) | divider, MMC_REG_CLK_RATE); 802 803 dev_dbg(mmc_dev(host->mmc), "scaler: %d divider: %d in: %d out: %d\n", 804 prescaler, divider, clk_in, clk_ios); 805 } 806 807 static int mxcmci_setup_dma(struct mmc_host *mmc) 808 { 809 struct mxcmci_host *host = mmc_priv(mmc); 810 struct dma_slave_config *config = &host->dma_slave_config; 811 812 config->dst_addr = host->phys_base + MMC_REG_BUFFER_ACCESS; 813 config->src_addr = host->phys_base + MMC_REG_BUFFER_ACCESS; 814 config->dst_addr_width = 4; 815 config->src_addr_width = 4; 816 config->dst_maxburst = host->burstlen; 817 config->src_maxburst = host->burstlen; 818 config->device_fc = false; 819 820 return dmaengine_slave_config(host->dma, config); 821 } 822 823 static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 824 { 825 struct mxcmci_host *host = mmc_priv(mmc); 826 int burstlen, ret; 827 828 /* 829 * use burstlen of 64 (16 words) in 4 bit mode (--> reg value 0) 830 * use burstlen of 16 (4 words) in 1 bit mode (--> reg value 16) 831 */ 832 if (ios->bus_width == MMC_BUS_WIDTH_4) 833 burstlen = 16; 834 else 835 burstlen = 4; 836 837 if (mxcmci_use_dma(host) && burstlen != host->burstlen) { 838 host->burstlen = burstlen; 839 ret = mxcmci_setup_dma(mmc); 840 if (ret) { 841 dev_err(mmc_dev(host->mmc), 842 "failed to config DMA channel. Falling back to PIO\n"); 843 dma_release_channel(host->dma); 844 host->do_dma = 0; 845 host->dma = NULL; 846 } 847 } 848 849 if (ios->bus_width == MMC_BUS_WIDTH_4) 850 host->cmdat |= CMD_DAT_CONT_BUS_WIDTH_4; 851 else 852 host->cmdat &= ~CMD_DAT_CONT_BUS_WIDTH_4; 853 854 if (host->power_mode != ios->power_mode) { 855 host->power_mode = ios->power_mode; 856 mxcmci_set_power(host, ios->vdd); 857 858 if (ios->power_mode == MMC_POWER_ON) 859 host->cmdat |= CMD_DAT_CONT_INIT; 860 } 861 862 if (ios->clock) { 863 mxcmci_set_clk_rate(host, ios->clock); 864 mxcmci_writew(host, STR_STP_CLK_START_CLK, MMC_REG_STR_STP_CLK); 865 } else { 866 mxcmci_writew(host, STR_STP_CLK_STOP_CLK, MMC_REG_STR_STP_CLK); 867 } 868 869 host->clock = ios->clock; 870 } 871 872 static irqreturn_t mxcmci_detect_irq(int irq, void *data) 873 { 874 struct mmc_host *mmc = data; 875 876 dev_dbg(mmc_dev(mmc), "%s\n", __func__); 877 878 mmc_detect_change(mmc, msecs_to_jiffies(250)); 879 return IRQ_HANDLED; 880 } 881 882 static int mxcmci_get_ro(struct mmc_host *mmc) 883 { 884 struct mxcmci_host *host = mmc_priv(mmc); 885 886 if (host->pdata && host->pdata->get_ro) 887 return !!host->pdata->get_ro(mmc_dev(mmc)); 888 /* 889 * If board doesn't support read only detection (no mmc_gpio 890 * context or gpio is invalid), then let the mmc core decide 891 * what to do. 892 */ 893 return mmc_gpio_get_ro(mmc); 894 } 895 896 static void mxcmci_enable_sdio_irq(struct mmc_host *mmc, int enable) 897 { 898 struct mxcmci_host *host = mmc_priv(mmc); 899 unsigned long flags; 900 u32 int_cntr; 901 902 spin_lock_irqsave(&host->lock, flags); 903 host->use_sdio = enable; 904 int_cntr = mxcmci_readl(host, MMC_REG_INT_CNTR); 905 906 if (enable) 907 int_cntr |= INT_SDIO_IRQ_EN; 908 else 909 int_cntr &= ~INT_SDIO_IRQ_EN; 910 911 mxcmci_writel(host, int_cntr, MMC_REG_INT_CNTR); 912 spin_unlock_irqrestore(&host->lock, flags); 913 } 914 915 static void mxcmci_init_card(struct mmc_host *host, struct mmc_card *card) 916 { 917 struct mxcmci_host *mxcmci = mmc_priv(host); 918 919 /* 920 * MX3 SoCs have a silicon bug which corrupts CRC calculation of 921 * multi-block transfers when connected SDIO peripheral doesn't 922 * drive the BUSY line as required by the specs. 923 * One way to prevent this is to only allow 1-bit transfers. 924 */ 925 926 if (is_imx31_mmc(mxcmci) && mmc_card_sdio(card)) 927 host->caps &= ~MMC_CAP_4_BIT_DATA; 928 else 929 host->caps |= MMC_CAP_4_BIT_DATA; 930 } 931 932 static bool filter(struct dma_chan *chan, void *param) 933 { 934 struct mxcmci_host *host = param; 935 936 if (!imx_dma_is_general_purpose(chan)) 937 return false; 938 939 chan->private = &host->dma_data; 940 941 return true; 942 } 943 944 static void mxcmci_watchdog(struct timer_list *t) 945 { 946 struct mxcmci_host *host = from_timer(host, t, watchdog); 947 struct mmc_request *req = host->req; 948 unsigned int stat = mxcmci_readl(host, MMC_REG_STATUS); 949 950 if (host->dma_dir == DMA_FROM_DEVICE) { 951 dmaengine_terminate_all(host->dma); 952 dev_err(mmc_dev(host->mmc), 953 "%s: read time out (status = 0x%08x)\n", 954 __func__, stat); 955 } else { 956 dev_err(mmc_dev(host->mmc), 957 "%s: write time out (status = 0x%08x)\n", 958 __func__, stat); 959 mxcmci_softreset(host); 960 } 961 962 /* Mark transfer as erroneus and inform the upper layers */ 963 964 if (host->data) 965 host->data->error = -ETIMEDOUT; 966 host->req = NULL; 967 host->cmd = NULL; 968 host->data = NULL; 969 mmc_request_done(host->mmc, req); 970 } 971 972 static const struct mmc_host_ops mxcmci_ops = { 973 .request = mxcmci_request, 974 .set_ios = mxcmci_set_ios, 975 .get_ro = mxcmci_get_ro, 976 .enable_sdio_irq = mxcmci_enable_sdio_irq, 977 .init_card = mxcmci_init_card, 978 }; 979 980 static int mxcmci_probe(struct platform_device *pdev) 981 { 982 struct mmc_host *mmc; 983 struct mxcmci_host *host; 984 struct resource *res; 985 int ret = 0, irq; 986 bool dat3_card_detect = false; 987 dma_cap_mask_t mask; 988 struct imxmmc_platform_data *pdata = pdev->dev.platform_data; 989 990 pr_info("i.MX/MPC512x SDHC driver\n"); 991 992 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 993 irq = platform_get_irq(pdev, 0); 994 if (irq < 0) 995 return irq; 996 997 mmc = mmc_alloc_host(sizeof(*host), &pdev->dev); 998 if (!mmc) 999 return -ENOMEM; 1000 1001 host = mmc_priv(mmc); 1002 1003 host->base = devm_ioremap_resource(&pdev->dev, res); 1004 if (IS_ERR(host->base)) { 1005 ret = PTR_ERR(host->base); 1006 goto out_free; 1007 } 1008 1009 host->phys_base = res->start; 1010 1011 ret = mmc_of_parse(mmc); 1012 if (ret) 1013 goto out_free; 1014 mmc->ops = &mxcmci_ops; 1015 1016 /* For devicetree parsing, the bus width is read from devicetree */ 1017 if (pdata) 1018 mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ; 1019 else 1020 mmc->caps |= MMC_CAP_SDIO_IRQ; 1021 1022 /* MMC core transfer sizes tunable parameters */ 1023 mmc->max_blk_size = 2048; 1024 mmc->max_blk_count = 65535; 1025 mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count; 1026 mmc->max_seg_size = mmc->max_req_size; 1027 1028 host->devtype = (uintptr_t)of_device_get_match_data(&pdev->dev); 1029 1030 /* adjust max_segs after devtype detection */ 1031 if (!is_mpc512x_mmc(host)) 1032 mmc->max_segs = 64; 1033 1034 host->mmc = mmc; 1035 host->pdata = pdata; 1036 spin_lock_init(&host->lock); 1037 1038 if (pdata) 1039 dat3_card_detect = pdata->dat3_card_detect; 1040 else if (mmc_card_is_removable(mmc) 1041 && !of_property_read_bool(pdev->dev.of_node, "cd-gpios")) 1042 dat3_card_detect = true; 1043 1044 ret = mmc_regulator_get_supply(mmc); 1045 if (ret) 1046 goto out_free; 1047 1048 if (!mmc->ocr_avail) { 1049 if (pdata && pdata->ocr_avail) 1050 mmc->ocr_avail = pdata->ocr_avail; 1051 else 1052 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34; 1053 } 1054 1055 if (dat3_card_detect) 1056 host->default_irq_mask = 1057 INT_CARD_INSERTION_EN | INT_CARD_REMOVAL_EN; 1058 else 1059 host->default_irq_mask = 0; 1060 1061 host->clk_ipg = devm_clk_get(&pdev->dev, "ipg"); 1062 if (IS_ERR(host->clk_ipg)) { 1063 ret = PTR_ERR(host->clk_ipg); 1064 goto out_free; 1065 } 1066 1067 host->clk_per = devm_clk_get(&pdev->dev, "per"); 1068 if (IS_ERR(host->clk_per)) { 1069 ret = PTR_ERR(host->clk_per); 1070 goto out_free; 1071 } 1072 1073 ret = clk_prepare_enable(host->clk_per); 1074 if (ret) 1075 goto out_free; 1076 1077 ret = clk_prepare_enable(host->clk_ipg); 1078 if (ret) 1079 goto out_clk_per_put; 1080 1081 mxcmci_softreset(host); 1082 1083 host->rev_no = mxcmci_readw(host, MMC_REG_REV_NO); 1084 if (host->rev_no != 0x400) { 1085 ret = -ENODEV; 1086 dev_err(mmc_dev(host->mmc), "wrong rev.no. 0x%08x. aborting.\n", 1087 host->rev_no); 1088 goto out_clk_put; 1089 } 1090 1091 mmc->f_min = clk_get_rate(host->clk_per) >> 16; 1092 mmc->f_max = clk_get_rate(host->clk_per) >> 1; 1093 1094 /* recommended in data sheet */ 1095 mxcmci_writew(host, 0x2db4, MMC_REG_READ_TO); 1096 1097 mxcmci_writel(host, host->default_irq_mask, MMC_REG_INT_CNTR); 1098 1099 if (!host->pdata) { 1100 host->dma = dma_request_chan(&pdev->dev, "rx-tx"); 1101 if (IS_ERR(host->dma)) { 1102 if (PTR_ERR(host->dma) == -EPROBE_DEFER) { 1103 ret = -EPROBE_DEFER; 1104 goto out_clk_put; 1105 } 1106 1107 /* Ignore errors to fall back to PIO mode */ 1108 host->dma = NULL; 1109 } 1110 } else { 1111 res = platform_get_resource(pdev, IORESOURCE_DMA, 0); 1112 if (res) { 1113 host->dmareq = res->start; 1114 host->dma_data.peripheral_type = IMX_DMATYPE_SDHC; 1115 host->dma_data.priority = DMA_PRIO_LOW; 1116 host->dma_data.dma_request = host->dmareq; 1117 dma_cap_zero(mask); 1118 dma_cap_set(DMA_SLAVE, mask); 1119 host->dma = dma_request_channel(mask, filter, host); 1120 } 1121 } 1122 if (host->dma) 1123 mmc->max_seg_size = dma_get_max_seg_size( 1124 host->dma->device->dev); 1125 else 1126 dev_info(mmc_dev(host->mmc), "dma not available. Using PIO\n"); 1127 1128 INIT_WORK(&host->datawork, mxcmci_datawork); 1129 1130 ret = devm_request_irq(&pdev->dev, irq, mxcmci_irq, 0, 1131 dev_name(&pdev->dev), host); 1132 if (ret) 1133 goto out_free_dma; 1134 1135 platform_set_drvdata(pdev, mmc); 1136 1137 if (host->pdata && host->pdata->init) { 1138 ret = host->pdata->init(&pdev->dev, mxcmci_detect_irq, 1139 host->mmc); 1140 if (ret) 1141 goto out_free_dma; 1142 } 1143 1144 timer_setup(&host->watchdog, mxcmci_watchdog, 0); 1145 1146 ret = mmc_add_host(mmc); 1147 if (ret) 1148 goto out_free_dma; 1149 1150 return 0; 1151 1152 out_free_dma: 1153 if (host->dma) 1154 dma_release_channel(host->dma); 1155 1156 out_clk_put: 1157 clk_disable_unprepare(host->clk_ipg); 1158 out_clk_per_put: 1159 clk_disable_unprepare(host->clk_per); 1160 1161 out_free: 1162 mmc_free_host(mmc); 1163 1164 return ret; 1165 } 1166 1167 static int mxcmci_remove(struct platform_device *pdev) 1168 { 1169 struct mmc_host *mmc = platform_get_drvdata(pdev); 1170 struct mxcmci_host *host = mmc_priv(mmc); 1171 1172 mmc_remove_host(mmc); 1173 1174 if (host->pdata && host->pdata->exit) 1175 host->pdata->exit(&pdev->dev, mmc); 1176 1177 if (host->dma) 1178 dma_release_channel(host->dma); 1179 1180 clk_disable_unprepare(host->clk_per); 1181 clk_disable_unprepare(host->clk_ipg); 1182 1183 mmc_free_host(mmc); 1184 1185 return 0; 1186 } 1187 1188 static int mxcmci_suspend(struct device *dev) 1189 { 1190 struct mmc_host *mmc = dev_get_drvdata(dev); 1191 struct mxcmci_host *host = mmc_priv(mmc); 1192 1193 clk_disable_unprepare(host->clk_per); 1194 clk_disable_unprepare(host->clk_ipg); 1195 return 0; 1196 } 1197 1198 static int mxcmci_resume(struct device *dev) 1199 { 1200 struct mmc_host *mmc = dev_get_drvdata(dev); 1201 struct mxcmci_host *host = mmc_priv(mmc); 1202 int ret; 1203 1204 ret = clk_prepare_enable(host->clk_per); 1205 if (ret) 1206 return ret; 1207 1208 ret = clk_prepare_enable(host->clk_ipg); 1209 if (ret) 1210 clk_disable_unprepare(host->clk_per); 1211 1212 return ret; 1213 } 1214 1215 static DEFINE_SIMPLE_DEV_PM_OPS(mxcmci_pm_ops, mxcmci_suspend, mxcmci_resume); 1216 1217 static struct platform_driver mxcmci_driver = { 1218 .probe = mxcmci_probe, 1219 .remove = mxcmci_remove, 1220 .driver = { 1221 .name = DRIVER_NAME, 1222 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 1223 .pm = pm_sleep_ptr(&mxcmci_pm_ops), 1224 .of_match_table = mxcmci_of_match, 1225 } 1226 }; 1227 1228 module_platform_driver(mxcmci_driver); 1229 1230 MODULE_DESCRIPTION("i.MX Multimedia Card Interface Driver"); 1231 MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 1232 MODULE_LICENSE("GPL"); 1233 MODULE_ALIAS("platform:mxc-mmc"); 1234