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