2 * linux/drivers/mmc/host/pxa.c - PXA MMCI driver
4 * Copyright (C) 2003 Russell King, All Rights Reserved.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * This hardware is really sick:
11 * - No way to clear interrupts.
12 * - Have to turn off the clock whenever we touch the device.
13 * - Doesn't tell you how many data blocks were transferred.
16 * 1 and 3 byte data transfers not supported
17 * max block length up to 1023
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/ioport.h>
22 #include <linux/platform_device.h>
23 #include <linux/delay.h>
24 #include <linux/interrupt.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/clk.h>
27 #include <linux/err.h>
28 #include <linux/mmc/host.h>
32 #include <asm/sizes.h>
34 #include <asm/arch/pxa-regs.h>
35 #include <asm/arch/mmc.h>
39 #define DRIVER_NAME "pxa2xx-mci"
42 #define CLKRT_OFF (~0)
50 unsigned long clkrate
;
56 unsigned int power_mode
;
57 struct pxamci_platform_data
*pdata
;
59 struct mmc_request
*mrq
;
60 struct mmc_command
*cmd
;
61 struct mmc_data
*data
;
64 struct pxa_dma_desc
*sg_cpu
;
68 unsigned int dma_drcmrrx
;
69 unsigned int dma_drcmrtx
;
72 static void pxamci_stop_clock(struct pxamci_host
*host
)
74 if (readl(host
->base
+ MMC_STAT
) & STAT_CLK_EN
) {
75 unsigned long timeout
= 10000;
78 writel(STOP_CLOCK
, host
->base
+ MMC_STRPCL
);
81 v
= readl(host
->base
+ MMC_STAT
);
82 if (!(v
& STAT_CLK_EN
))
88 dev_err(mmc_dev(host
->mmc
), "unable to stop clock\n");
92 static void pxamci_enable_irq(struct pxamci_host
*host
, unsigned int mask
)
96 spin_lock_irqsave(&host
->lock
, flags
);
98 writel(host
->imask
, host
->base
+ MMC_I_MASK
);
99 spin_unlock_irqrestore(&host
->lock
, flags
);
102 static void pxamci_disable_irq(struct pxamci_host
*host
, unsigned int mask
)
106 spin_lock_irqsave(&host
->lock
, flags
);
108 writel(host
->imask
, host
->base
+ MMC_I_MASK
);
109 spin_unlock_irqrestore(&host
->lock
, flags
);
112 static void pxamci_setup_data(struct pxamci_host
*host
, struct mmc_data
*data
)
114 unsigned int nob
= data
->blocks
;
115 unsigned long long clks
;
116 unsigned int timeout
;
123 if (data
->flags
& MMC_DATA_STREAM
)
126 writel(nob
, host
->base
+ MMC_NOB
);
127 writel(data
->blksz
, host
->base
+ MMC_BLKLEN
);
129 clks
= (unsigned long long)data
->timeout_ns
* host
->clkrate
;
130 do_div(clks
, 1000000000UL);
131 timeout
= (unsigned int)clks
+ (data
->timeout_clks
<< host
->clkrt
);
132 writel((timeout
+ 255) / 256, host
->base
+ MMC_RDTO
);
134 if (data
->flags
& MMC_DATA_READ
) {
135 host
->dma_dir
= DMA_FROM_DEVICE
;
136 dcmd
= DCMD_INCTRGADDR
| DCMD_FLOWTRG
;
137 DRCMR(host
->dma_drcmrtx
) = 0;
138 DRCMR(host
->dma_drcmrrx
) = host
->dma
| DRCMR_MAPVLD
;
140 host
->dma_dir
= DMA_TO_DEVICE
;
141 dcmd
= DCMD_INCSRCADDR
| DCMD_FLOWSRC
;
142 DRCMR(host
->dma_drcmrrx
) = 0;
143 DRCMR(host
->dma_drcmrtx
) = host
->dma
| DRCMR_MAPVLD
;
146 dcmd
|= DCMD_BURST32
| DCMD_WIDTH1
;
148 host
->dma_len
= dma_map_sg(mmc_dev(host
->mmc
), data
->sg
, data
->sg_len
,
151 for (i
= 0; i
< host
->dma_len
; i
++) {
152 unsigned int length
= sg_dma_len(&data
->sg
[i
]);
153 host
->sg_cpu
[i
].dcmd
= dcmd
| length
;
154 if (length
& 31 && !(data
->flags
& MMC_DATA_READ
))
155 host
->sg_cpu
[i
].dcmd
|= DCMD_ENDIRQEN
;
156 /* Not aligned to 8-byte boundary? */
157 if (sg_dma_address(&data
->sg
[i
]) & 0x7)
159 if (data
->flags
& MMC_DATA_READ
) {
160 host
->sg_cpu
[i
].dsadr
= host
->res
->start
+ MMC_RXFIFO
;
161 host
->sg_cpu
[i
].dtadr
= sg_dma_address(&data
->sg
[i
]);
163 host
->sg_cpu
[i
].dsadr
= sg_dma_address(&data
->sg
[i
]);
164 host
->sg_cpu
[i
].dtadr
= host
->res
->start
+ MMC_TXFIFO
;
166 host
->sg_cpu
[i
].ddadr
= host
->sg_dma
+ (i
+ 1) *
167 sizeof(struct pxa_dma_desc
);
169 host
->sg_cpu
[host
->dma_len
- 1].ddadr
= DDADR_STOP
;
173 * The PXA27x DMA controller encounters overhead when working with
174 * unaligned (to 8-byte boundaries) data, so switch on byte alignment
175 * mode only if we have unaligned data.
178 DALGN
|= (1 << host
->dma
);
180 DALGN
&= (1 << host
->dma
);
181 DDADR(host
->dma
) = host
->sg_dma
;
182 DCSR(host
->dma
) = DCSR_RUN
;
185 static void pxamci_start_cmd(struct pxamci_host
*host
, struct mmc_command
*cmd
, unsigned int cmdat
)
187 WARN_ON(host
->cmd
!= NULL
);
190 if (cmd
->flags
& MMC_RSP_BUSY
)
193 #define RSP_TYPE(x) ((x) & ~(MMC_RSP_BUSY|MMC_RSP_OPCODE))
194 switch (RSP_TYPE(mmc_resp_type(cmd
))) {
195 case RSP_TYPE(MMC_RSP_R1
): /* r1, r1b, r6, r7 */
196 cmdat
|= CMDAT_RESP_SHORT
;
198 case RSP_TYPE(MMC_RSP_R3
):
199 cmdat
|= CMDAT_RESP_R3
;
201 case RSP_TYPE(MMC_RSP_R2
):
202 cmdat
|= CMDAT_RESP_R2
;
208 writel(cmd
->opcode
, host
->base
+ MMC_CMD
);
209 writel(cmd
->arg
>> 16, host
->base
+ MMC_ARGH
);
210 writel(cmd
->arg
& 0xffff, host
->base
+ MMC_ARGL
);
211 writel(cmdat
, host
->base
+ MMC_CMDAT
);
212 writel(host
->clkrt
, host
->base
+ MMC_CLKRT
);
214 writel(START_CLOCK
, host
->base
+ MMC_STRPCL
);
216 pxamci_enable_irq(host
, END_CMD_RES
);
219 static void pxamci_finish_request(struct pxamci_host
*host
, struct mmc_request
*mrq
)
224 mmc_request_done(host
->mmc
, mrq
);
227 static int pxamci_cmd_done(struct pxamci_host
*host
, unsigned int stat
)
229 struct mmc_command
*cmd
= host
->cmd
;
239 * Did I mention this is Sick. We always need to
240 * discard the upper 8 bits of the first 16-bit word.
242 v
= readl(host
->base
+ MMC_RES
) & 0xffff;
243 for (i
= 0; i
< 4; i
++) {
244 u32 w1
= readl(host
->base
+ MMC_RES
) & 0xffff;
245 u32 w2
= readl(host
->base
+ MMC_RES
) & 0xffff;
246 cmd
->resp
[i
] = v
<< 24 | w1
<< 8 | w2
>> 8;
250 if (stat
& STAT_TIME_OUT_RESPONSE
) {
251 cmd
->error
= -ETIMEDOUT
;
252 } else if (stat
& STAT_RES_CRC_ERR
&& cmd
->flags
& MMC_RSP_CRC
) {
255 * workaround for erratum #42:
256 * Intel PXA27x Family Processor Specification Update Rev 001
257 * A bogus CRC error can appear if the msb of a 136 bit
260 if (cmd
->flags
& MMC_RSP_136
&& cmd
->resp
[0] & 0x80000000) {
261 pr_debug("ignoring CRC from command %d - *risky*\n", cmd
->opcode
);
264 cmd
->error
= -EILSEQ
;
267 pxamci_disable_irq(host
, END_CMD_RES
);
268 if (host
->data
&& !cmd
->error
) {
269 pxamci_enable_irq(host
, DATA_TRAN_DONE
);
271 pxamci_finish_request(host
, host
->mrq
);
277 static int pxamci_data_done(struct pxamci_host
*host
, unsigned int stat
)
279 struct mmc_data
*data
= host
->data
;
285 dma_unmap_sg(mmc_dev(host
->mmc
), data
->sg
, host
->dma_len
,
288 if (stat
& STAT_READ_TIME_OUT
)
289 data
->error
= -ETIMEDOUT
;
290 else if (stat
& (STAT_CRC_READ_ERROR
|STAT_CRC_WRITE_ERROR
))
291 data
->error
= -EILSEQ
;
294 * There appears to be a hardware design bug here. There seems to
295 * be no way to find out how much data was transferred to the card.
296 * This means that if there was an error on any block, we mark all
297 * data blocks as being in error.
300 data
->bytes_xfered
= data
->blocks
* data
->blksz
;
302 data
->bytes_xfered
= 0;
304 pxamci_disable_irq(host
, DATA_TRAN_DONE
);
307 if (host
->mrq
->stop
) {
308 pxamci_stop_clock(host
);
309 pxamci_start_cmd(host
, host
->mrq
->stop
, host
->cmdat
);
311 pxamci_finish_request(host
, host
->mrq
);
317 static irqreturn_t
pxamci_irq(int irq
, void *devid
)
319 struct pxamci_host
*host
= devid
;
323 ireg
= readl(host
->base
+ MMC_I_REG
) & ~readl(host
->base
+ MMC_I_MASK
);
326 unsigned stat
= readl(host
->base
+ MMC_STAT
);
328 pr_debug("PXAMCI: irq %08x stat %08x\n", ireg
, stat
);
330 if (ireg
& END_CMD_RES
)
331 handled
|= pxamci_cmd_done(host
, stat
);
332 if (ireg
& DATA_TRAN_DONE
)
333 handled
|= pxamci_data_done(host
, stat
);
334 if (ireg
& SDIO_INT
) {
335 mmc_signal_sdio_irq(host
->mmc
);
340 return IRQ_RETVAL(handled
);
343 static void pxamci_request(struct mmc_host
*mmc
, struct mmc_request
*mrq
)
345 struct pxamci_host
*host
= mmc_priv(mmc
);
348 WARN_ON(host
->mrq
!= NULL
);
352 pxamci_stop_clock(host
);
355 host
->cmdat
&= ~CMDAT_INIT
;
358 pxamci_setup_data(host
, mrq
->data
);
360 cmdat
&= ~CMDAT_BUSY
;
361 cmdat
|= CMDAT_DATAEN
| CMDAT_DMAEN
;
362 if (mrq
->data
->flags
& MMC_DATA_WRITE
)
363 cmdat
|= CMDAT_WRITE
;
365 if (mrq
->data
->flags
& MMC_DATA_STREAM
)
366 cmdat
|= CMDAT_STREAM
;
369 pxamci_start_cmd(host
, mrq
->cmd
, cmdat
);
372 static int pxamci_get_ro(struct mmc_host
*mmc
)
374 struct pxamci_host
*host
= mmc_priv(mmc
);
376 if (host
->pdata
&& host
->pdata
->get_ro
)
377 return host
->pdata
->get_ro(mmc_dev(mmc
));
378 /* Host doesn't support read only detection so assume writeable */
382 static void pxamci_set_ios(struct mmc_host
*mmc
, struct mmc_ios
*ios
)
384 struct pxamci_host
*host
= mmc_priv(mmc
);
387 unsigned long rate
= host
->clkrate
;
388 unsigned int clk
= rate
/ ios
->clock
;
390 if (host
->clkrt
== CLKRT_OFF
)
391 clk_enable(host
->clk
);
393 if (ios
->clock
== 26000000) {
394 /* to support 26MHz on pxa300/pxa310 */
397 /* to handle (19.5MHz, 26MHz) */
402 * clk might result in a lower divisor than we
403 * desire. check for that condition and adjust
406 if (rate
/ clk
> ios
->clock
)
408 host
->clkrt
= fls(clk
) - 1;
412 * we write clkrt on the next command
415 pxamci_stop_clock(host
);
416 if (host
->clkrt
!= CLKRT_OFF
) {
417 host
->clkrt
= CLKRT_OFF
;
418 clk_disable(host
->clk
);
422 if (host
->power_mode
!= ios
->power_mode
) {
423 host
->power_mode
= ios
->power_mode
;
425 if (host
->pdata
&& host
->pdata
->setpower
)
426 host
->pdata
->setpower(mmc_dev(mmc
), ios
->vdd
);
428 if (ios
->power_mode
== MMC_POWER_ON
)
429 host
->cmdat
|= CMDAT_INIT
;
432 if (ios
->bus_width
== MMC_BUS_WIDTH_4
)
433 host
->cmdat
|= CMDAT_SD_4DAT
;
435 host
->cmdat
&= ~CMDAT_SD_4DAT
;
437 pr_debug("PXAMCI: clkrt = %x cmdat = %x\n",
438 host
->clkrt
, host
->cmdat
);
441 static void pxamci_enable_sdio_irq(struct mmc_host
*host
, int enable
)
443 struct pxamci_host
*pxa_host
= mmc_priv(host
);
446 pxamci_enable_irq(pxa_host
, SDIO_INT
);
448 pxamci_disable_irq(pxa_host
, SDIO_INT
);
451 static const struct mmc_host_ops pxamci_ops
= {
452 .request
= pxamci_request
,
453 .get_ro
= pxamci_get_ro
,
454 .set_ios
= pxamci_set_ios
,
455 .enable_sdio_irq
= pxamci_enable_sdio_irq
,
458 static void pxamci_dma_irq(int dma
, void *devid
)
460 struct pxamci_host
*host
= devid
;
461 int dcsr
= DCSR(dma
);
462 DCSR(dma
) = dcsr
& ~DCSR_STOPIRQEN
;
464 if (dcsr
& DCSR_ENDINTR
) {
465 writel(BUF_PART_FULL
, host
->base
+ MMC_PRTBUF
);
467 printk(KERN_ERR
"%s: DMA error on channel %d (DCSR=%#x)\n",
468 mmc_hostname(host
->mmc
), dma
, dcsr
);
469 host
->data
->error
= -EIO
;
470 pxamci_data_done(host
, 0);
474 static irqreturn_t
pxamci_detect_irq(int irq
, void *devid
)
476 struct pxamci_host
*host
= mmc_priv(devid
);
478 mmc_detect_change(devid
, host
->pdata
->detect_delay
);
482 static int pxamci_probe(struct platform_device
*pdev
)
484 struct mmc_host
*mmc
;
485 struct pxamci_host
*host
= NULL
;
486 struct resource
*r
, *dmarx
, *dmatx
;
489 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
490 irq
= platform_get_irq(pdev
, 0);
494 r
= request_mem_region(r
->start
, SZ_4K
, DRIVER_NAME
);
498 mmc
= mmc_alloc_host(sizeof(struct pxamci_host
), &pdev
->dev
);
504 mmc
->ops
= &pxamci_ops
;
507 * We can do SG-DMA, but we don't because we never know how much
508 * data we successfully wrote to the card.
510 mmc
->max_phys_segs
= NR_SG
;
513 * Our hardware DMA can handle a maximum of one page per SG entry.
515 mmc
->max_seg_size
= PAGE_SIZE
;
518 * Block length register is only 10 bits before PXA27x.
520 mmc
->max_blk_size
= (cpu_is_pxa21x() || cpu_is_pxa25x()) ? 1023 : 2048;
523 * Block count register is 16 bits.
525 mmc
->max_blk_count
= 65535;
527 host
= mmc_priv(mmc
);
530 host
->pdata
= pdev
->dev
.platform_data
;
531 host
->clkrt
= CLKRT_OFF
;
533 host
->clk
= clk_get(&pdev
->dev
, "MMCCLK");
534 if (IS_ERR(host
->clk
)) {
535 ret
= PTR_ERR(host
->clk
);
540 host
->clkrate
= clk_get_rate(host
->clk
);
543 * Calculate minimum clock rate, rounding up.
545 mmc
->f_min
= (host
->clkrate
+ 63) / 64;
546 mmc
->f_max
= (cpu_is_pxa300() || cpu_is_pxa310()) ? 26000000
549 mmc
->ocr_avail
= host
->pdata
?
550 host
->pdata
->ocr_mask
:
551 MMC_VDD_32_33
|MMC_VDD_33_34
;
554 if (!cpu_is_pxa21x() && !cpu_is_pxa25x()) {
555 mmc
->caps
|= MMC_CAP_4_BIT_DATA
| MMC_CAP_SDIO_IRQ
;
556 host
->cmdat
|= CMDAT_SDIO_INT_EN
;
557 if (cpu_is_pxa300() || cpu_is_pxa310())
558 mmc
->caps
|= MMC_CAP_MMC_HIGHSPEED
|
559 MMC_CAP_SD_HIGHSPEED
;
562 host
->sg_cpu
= dma_alloc_coherent(&pdev
->dev
, PAGE_SIZE
, &host
->sg_dma
, GFP_KERNEL
);
568 spin_lock_init(&host
->lock
);
571 host
->imask
= MMC_I_MASK_ALL
;
573 host
->base
= ioremap(r
->start
, SZ_4K
);
580 * Ensure that the host controller is shut down, and setup
583 pxamci_stop_clock(host
);
584 writel(0, host
->base
+ MMC_SPI
);
585 writel(64, host
->base
+ MMC_RESTO
);
586 writel(host
->imask
, host
->base
+ MMC_I_MASK
);
588 host
->dma
= pxa_request_dma(DRIVER_NAME
, DMA_PRIO_LOW
,
589 pxamci_dma_irq
, host
);
595 ret
= request_irq(host
->irq
, pxamci_irq
, 0, DRIVER_NAME
, host
);
599 platform_set_drvdata(pdev
, mmc
);
601 dmarx
= platform_get_resource(pdev
, IORESOURCE_DMA
, 0);
606 host
->dma_drcmrrx
= dmarx
->start
;
608 dmatx
= platform_get_resource(pdev
, IORESOURCE_DMA
, 1);
613 host
->dma_drcmrtx
= dmatx
->start
;
615 if (host
->pdata
&& host
->pdata
->init
)
616 host
->pdata
->init(&pdev
->dev
, pxamci_detect_irq
, mmc
);
625 pxa_free_dma(host
->dma
);
629 dma_free_coherent(&pdev
->dev
, PAGE_SIZE
, host
->sg_cpu
, host
->sg_dma
);
639 static int pxamci_remove(struct platform_device
*pdev
)
641 struct mmc_host
*mmc
= platform_get_drvdata(pdev
);
643 platform_set_drvdata(pdev
, NULL
);
646 struct pxamci_host
*host
= mmc_priv(mmc
);
648 if (host
->pdata
&& host
->pdata
->exit
)
649 host
->pdata
->exit(&pdev
->dev
, mmc
);
651 mmc_remove_host(mmc
);
653 pxamci_stop_clock(host
);
654 writel(TXFIFO_WR_REQ
|RXFIFO_RD_REQ
|CLK_IS_OFF
|STOP_CMD
|
655 END_CMD_RES
|PRG_DONE
|DATA_TRAN_DONE
,
656 host
->base
+ MMC_I_MASK
);
658 DRCMR(host
->dma_drcmrrx
) = 0;
659 DRCMR(host
->dma_drcmrtx
) = 0;
661 free_irq(host
->irq
, host
);
662 pxa_free_dma(host
->dma
);
664 dma_free_coherent(&pdev
->dev
, PAGE_SIZE
, host
->sg_cpu
, host
->sg_dma
);
668 release_resource(host
->res
);
676 static int pxamci_suspend(struct platform_device
*dev
, pm_message_t state
)
678 struct mmc_host
*mmc
= platform_get_drvdata(dev
);
682 ret
= mmc_suspend_host(mmc
, state
);
687 static int pxamci_resume(struct platform_device
*dev
)
689 struct mmc_host
*mmc
= platform_get_drvdata(dev
);
693 ret
= mmc_resume_host(mmc
);
698 #define pxamci_suspend NULL
699 #define pxamci_resume NULL
702 static struct platform_driver pxamci_driver
= {
703 .probe
= pxamci_probe
,
704 .remove
= pxamci_remove
,
705 .suspend
= pxamci_suspend
,
706 .resume
= pxamci_resume
,
709 .owner
= THIS_MODULE
,
713 static int __init
pxamci_init(void)
715 return platform_driver_register(&pxamci_driver
);
718 static void __exit
pxamci_exit(void)
720 platform_driver_unregister(&pxamci_driver
);
723 module_init(pxamci_init
);
724 module_exit(pxamci_exit
);
726 MODULE_DESCRIPTION("PXA Multimedia Card Interface Driver");
727 MODULE_LICENSE("GPL");
728 MODULE_ALIAS("platform:pxa2xx-mci");