1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
114struct 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
143static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios);
144
145static inline int mxcmci_use_dma(struct mxcmci_host *host)
146{
147 return host->do_dma;
148}
149
150static void mxcmci_softreset(struct mxcmci_host *host)
151{
152 int i;
153
154
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
165static 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
221 return 0;
222}
223
224static 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:
232 case MMC_RSP_R1B:
233 cmdat |= CMD_DAT_CONT_RESPONSE_48BIT_CRC;
234 break;
235 case MMC_RSP_R2:
236 cmdat |= CMD_DAT_CONT_RESPONSE_136BIT;
237 break;
238 case MMC_RSP_R3:
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
264static 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
276static 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)
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
316static 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
349static 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
369static 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
398static 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
430static 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
462static 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
480static 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
503
504static 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
515
516
517
518 if (!mxcmci_use_dma(host) && host->data)
519 schedule_work(&host->datawork);
520
521}
522
523static 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
543static 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);
571out:
572 if (error)
573 mxcmci_finish_request(host, req);
574}
575
576static 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
609static 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
616
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
648static 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
658static 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
666
667
668 return -ENOSYS;
669}
670
671
672static 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
678static int mxcmci_probe(struct platform_device *pdev)
679{
680 struct mmc_host *mmc;
681 struct mxcmci_host *host = NULL;
682 struct resource *r;
683 int ret = 0, irq;
684
685 printk(KERN_INFO "i.MX SDHC driver\n");
686
687 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
688 irq = platform_get_irq(pdev, 0);
689 if (!r || irq < 0)
690 return -EINVAL;
691
692 r = request_mem_region(r->start, resource_size(r), 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
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
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
798out_free_irq:
799 free_irq(host->irq, host);
800out_free_dma:
801#ifdef HAS_DMA
802 imx_dma_free(host->dma);
803#endif
804out_clk_put:
805 clk_disable(host->clk);
806 clk_put(host->clk);
807out_iounmap:
808 iounmap(host->base);
809out_free:
810 mmc_free_host(mmc);
811out_release_mem:
812 release_mem_region(host->res->start, resource_size(host->res));
813 return ret;
814}
815
816static 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
845static 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
856static 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
873
874static 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
885static int __init mxcmci_init(void)
886{
887 return platform_driver_register(&mxcmci_driver);
888}
889
890static void __exit mxcmci_exit(void)
891{
892 platform_driver_unregister(&mxcmci_driver);
893}
894
895module_init(mxcmci_init);
896module_exit(mxcmci_exit);
897
898MODULE_DESCRIPTION("i.MX Multimedia Card Interface Driver");
899MODULE_AUTHOR("Sascha Hauer, Pengutronix");
900MODULE_LICENSE("GPL");
901MODULE_ALIAS("platform:imx-mmc");
902
