2 * linux/drivers/mmc/imxmmc.c - Motorola i.MX MMCI driver
4 * Copyright (C) 2004 Sascha Hauer, Pengutronix <sascha@saschahauer.de>
5 * Copyright (C) 2006 Pavel Pisa, PiKRON <ppisa@pikron.com>
7 * derived from pxamci.c by Russell King
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 * 2005-04-17 Pavel Pisa <pisa@cmp.felk.cvut.cz>
14 * Changed to conform redesigned i.MX scatter gather DMA interface
16 * 2005-11-04 Pavel Pisa <pisa@cmp.felk.cvut.cz>
17 * Updated for 2.6.14 kernel
19 * 2005-12-13 Jay Monkman <jtm@smoothsmoothie.com>
20 * Found and corrected problems in the write path
22 * 2005-12-30 Pavel Pisa <pisa@cmp.felk.cvut.cz>
23 * The event handling rewritten right way in softirq.
24 * Added many ugly hacks and delays to overcome SDHC
29 #ifdef CONFIG_MMC_DEBUG
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/ioport.h>
38 #include <linux/platform_device.h>
39 #include <linux/interrupt.h>
40 #include <linux/blkdev.h>
41 #include <linux/dma-mapping.h>
42 #include <linux/mmc/host.h>
43 #include <linux/mmc/card.h>
44 #include <linux/mmc/protocol.h>
45 #include <linux/delay.h>
50 #include <asm/sizes.h>
51 #include <asm/arch/mmc.h>
52 #include <asm/arch/imx-dma.h>
56 #define DRIVER_NAME "imx-mmc"
58 #define IMXMCI_INT_MASK_DEFAULT (INT_MASK_BUF_READY | INT_MASK_DATA_TRAN | \
59 INT_MASK_WRITE_OP_DONE | INT_MASK_END_CMD_RES | \
60 INT_MASK_AUTO_CARD_DETECT | INT_MASK_DAT0_EN | INT_MASK_SDIO)
70 volatile unsigned int imask
;
71 unsigned int power_mode
;
73 struct imxmmc_platform_data
*pdata
;
75 struct mmc_request
*req
;
76 struct mmc_command
*cmd
;
77 struct mmc_data
*data
;
79 struct timer_list timer
;
80 struct tasklet_struct tasklet
;
81 unsigned int status_reg
;
82 unsigned long pending_events
;
83 /* Next to fields are there for CPU driven transfers to overcome SDHC deficiencies */
85 unsigned int data_cnt
;
86 atomic_t stuck_timeout
;
88 unsigned int dma_nents
;
89 unsigned int dma_size
;
93 unsigned char actual_bus_width
;
98 #define IMXMCI_PEND_IRQ_b 0
99 #define IMXMCI_PEND_DMA_END_b 1
100 #define IMXMCI_PEND_DMA_ERR_b 2
101 #define IMXMCI_PEND_WAIT_RESP_b 3
102 #define IMXMCI_PEND_DMA_DATA_b 4
103 #define IMXMCI_PEND_CPU_DATA_b 5
104 #define IMXMCI_PEND_CARD_XCHG_b 6
105 #define IMXMCI_PEND_SET_INIT_b 7
106 #define IMXMCI_PEND_STARTED_b 8
108 #define IMXMCI_PEND_IRQ_m (1 << IMXMCI_PEND_IRQ_b)
109 #define IMXMCI_PEND_DMA_END_m (1 << IMXMCI_PEND_DMA_END_b)
110 #define IMXMCI_PEND_DMA_ERR_m (1 << IMXMCI_PEND_DMA_ERR_b)
111 #define IMXMCI_PEND_WAIT_RESP_m (1 << IMXMCI_PEND_WAIT_RESP_b)
112 #define IMXMCI_PEND_DMA_DATA_m (1 << IMXMCI_PEND_DMA_DATA_b)
113 #define IMXMCI_PEND_CPU_DATA_m (1 << IMXMCI_PEND_CPU_DATA_b)
114 #define IMXMCI_PEND_CARD_XCHG_m (1 << IMXMCI_PEND_CARD_XCHG_b)
115 #define IMXMCI_PEND_SET_INIT_m (1 << IMXMCI_PEND_SET_INIT_b)
116 #define IMXMCI_PEND_STARTED_m (1 << IMXMCI_PEND_STARTED_b)
118 static void imxmci_stop_clock(struct imxmci_host
*host
)
121 MMC_STR_STP_CLK
&= ~STR_STP_CLK_START_CLK
;
124 MMC_STR_STP_CLK
|= STR_STP_CLK_STOP_CLK
;
126 if(!(MMC_STATUS
& STATUS_CARD_BUS_CLK_RUN
)) {
127 /* Check twice before cut */
128 if(!(MMC_STATUS
& STATUS_CARD_BUS_CLK_RUN
))
134 dev_dbg(mmc_dev(host
->mmc
), "imxmci_stop_clock blocked, no luck\n");
137 static int imxmci_start_clock(struct imxmci_host
*host
)
139 unsigned int trials
= 0;
140 unsigned int delay_limit
= 128;
143 MMC_STR_STP_CLK
&= ~STR_STP_CLK_STOP_CLK
;
145 clear_bit(IMXMCI_PEND_STARTED_b
, &host
->pending_events
);
148 * Command start of the clock, this usually succeeds in less
149 * then 6 delay loops, but during card detection (low clockrate)
150 * it takes up to 5000 delay loops and sometimes fails for the first time
152 MMC_STR_STP_CLK
|= STR_STP_CLK_START_CLK
;
155 unsigned int delay
= delay_limit
;
158 if(MMC_STATUS
& STATUS_CARD_BUS_CLK_RUN
)
159 /* Check twice before cut */
160 if(MMC_STATUS
& STATUS_CARD_BUS_CLK_RUN
)
163 if(test_bit(IMXMCI_PEND_STARTED_b
, &host
->pending_events
))
167 local_irq_save(flags
);
169 * Ensure, that request is not doubled under all possible circumstances.
170 * It is possible, that cock running state is missed, because some other
171 * IRQ or schedule delays this function execution and the clocks has
172 * been already stopped by other means (response processing, SDHC HW)
174 if(!test_bit(IMXMCI_PEND_STARTED_b
, &host
->pending_events
))
175 MMC_STR_STP_CLK
|= STR_STP_CLK_START_CLK
;
176 local_irq_restore(flags
);
178 } while(++trials
<256);
180 dev_err(mmc_dev(host
->mmc
), "imxmci_start_clock blocked, no luck\n");
185 static void imxmci_softreset(void)
188 MMC_STR_STP_CLK
= 0x8;
189 MMC_STR_STP_CLK
= 0xD;
190 MMC_STR_STP_CLK
= 0x5;
191 MMC_STR_STP_CLK
= 0x5;
192 MMC_STR_STP_CLK
= 0x5;
193 MMC_STR_STP_CLK
= 0x5;
194 MMC_STR_STP_CLK
= 0x5;
195 MMC_STR_STP_CLK
= 0x5;
196 MMC_STR_STP_CLK
= 0x5;
197 MMC_STR_STP_CLK
= 0x5;
204 static int imxmci_busy_wait_for_status(struct imxmci_host
*host
,
205 unsigned int *pstat
, unsigned int stat_mask
,
206 int timeout
, const char *where
)
209 while(!(*pstat
& stat_mask
)) {
211 if(loops
>= timeout
) {
212 dev_dbg(mmc_dev(host
->mmc
), "busy wait timeout in %s, STATUS = 0x%x (0x%x)\n",
213 where
, *pstat
, stat_mask
);
217 *pstat
|= MMC_STATUS
;
222 /* The busy-wait is expected there for clock <8MHz due to SDHC hardware flaws */
223 if(!(stat_mask
& STATUS_END_CMD_RESP
) || (host
->mmc
->ios
.clock
>=8000000))
224 dev_info(mmc_dev(host
->mmc
), "busy wait for %d usec in %s, STATUS = 0x%x (0x%x)\n",
225 loops
, where
, *pstat
, stat_mask
);
229 static void imxmci_setup_data(struct imxmci_host
*host
, struct mmc_data
*data
)
231 unsigned int nob
= data
->blocks
;
232 unsigned int blksz
= data
->blksz
;
233 unsigned int datasz
= nob
* blksz
;
236 if (data
->flags
& MMC_DATA_STREAM
)
240 data
->bytes_xfered
= 0;
246 * DMA cannot be used for small block sizes, we have to use CPU driven transfers otherwise.
247 * We are in big troubles for non-512 byte transfers according to note in the paragraph
248 * 20.6.7 of User Manual anyway, but we need to be able to transfer SCR at least.
249 * The situation is even more complex in reality. The SDHC in not able to handle wll
250 * partial FIFO fills and reads. The length has to be rounded up to burst size multiple.
251 * This is required for SCR read at least.
254 host
->dma_size
= datasz
;
255 if (data
->flags
& MMC_DATA_READ
) {
256 host
->dma_dir
= DMA_FROM_DEVICE
;
258 /* Hack to enable read SCR */
262 host
->dma_dir
= DMA_TO_DEVICE
;
265 /* Convert back to virtual address */
266 host
->data_ptr
= (u16
*)(page_address(data
->sg
->page
) + data
->sg
->offset
);
269 clear_bit(IMXMCI_PEND_DMA_DATA_b
, &host
->pending_events
);
270 set_bit(IMXMCI_PEND_CPU_DATA_b
, &host
->pending_events
);
275 if (data
->flags
& MMC_DATA_READ
) {
276 host
->dma_dir
= DMA_FROM_DEVICE
;
277 host
->dma_nents
= dma_map_sg(mmc_dev(host
->mmc
), data
->sg
,
278 data
->sg_len
, host
->dma_dir
);
280 imx_dma_setup_sg(host
->dma
, data
->sg
, data
->sg_len
, datasz
,
281 host
->res
->start
+ MMC_BUFFER_ACCESS_OFS
, DMA_MODE_READ
);
283 /*imx_dma_setup_mem2dev_ccr(host->dma, DMA_MODE_READ, IMX_DMA_WIDTH_16, CCR_REN);*/
284 CCR(host
->dma
) = CCR_DMOD_LINEAR
| CCR_DSIZ_32
| CCR_SMOD_FIFO
| CCR_SSIZ_16
| CCR_REN
;
286 host
->dma_dir
= DMA_TO_DEVICE
;
288 host
->dma_nents
= dma_map_sg(mmc_dev(host
->mmc
), data
->sg
,
289 data
->sg_len
, host
->dma_dir
);
291 imx_dma_setup_sg(host
->dma
, data
->sg
, data
->sg_len
, datasz
,
292 host
->res
->start
+ MMC_BUFFER_ACCESS_OFS
, DMA_MODE_WRITE
);
294 /*imx_dma_setup_mem2dev_ccr(host->dma, DMA_MODE_WRITE, IMX_DMA_WIDTH_16, CCR_REN);*/
295 CCR(host
->dma
) = CCR_SMOD_LINEAR
| CCR_SSIZ_32
| CCR_DMOD_FIFO
| CCR_DSIZ_16
| CCR_REN
;
298 #if 1 /* This code is there only for consistency checking and can be disabled in future */
300 for(i
=0; i
<host
->dma_nents
; i
++)
301 host
->dma_size
+=data
->sg
[i
].length
;
303 if (datasz
> host
->dma_size
) {
304 dev_err(mmc_dev(host
->mmc
), "imxmci_setup_data datasz 0x%x > 0x%x dm_size\n",
305 datasz
, host
->dma_size
);
309 host
->dma_size
= datasz
;
313 if(host
->actual_bus_width
== MMC_BUS_WIDTH_4
)
314 BLR(host
->dma
) = 0; /* burst 64 byte read / 64 bytes write */
316 BLR(host
->dma
) = 16; /* burst 16 byte read / 16 bytes write */
318 RSSR(host
->dma
) = DMA_REQ_SDHC
;
320 set_bit(IMXMCI_PEND_DMA_DATA_b
, &host
->pending_events
);
321 clear_bit(IMXMCI_PEND_CPU_DATA_b
, &host
->pending_events
);
323 /* start DMA engine for read, write is delayed after initial response */
324 if (host
->dma_dir
== DMA_FROM_DEVICE
) {
325 imx_dma_enable(host
->dma
);
329 static void imxmci_start_cmd(struct imxmci_host
*host
, struct mmc_command
*cmd
, unsigned int cmdat
)
334 WARN_ON(host
->cmd
!= NULL
);
337 /* Ensure, that clock are stopped else command programming and start fails */
338 imxmci_stop_clock(host
);
340 if (cmd
->flags
& MMC_RSP_BUSY
)
341 cmdat
|= CMD_DAT_CONT_BUSY
;
343 switch (mmc_resp_type(cmd
)) {
344 case MMC_RSP_R1
: /* short CRC, OPCODE */
345 case MMC_RSP_R1B
:/* short CRC, OPCODE, BUSY */
346 cmdat
|= CMD_DAT_CONT_RESPONSE_FORMAT_R1
;
348 case MMC_RSP_R2
: /* long 136 bit + CRC */
349 cmdat
|= CMD_DAT_CONT_RESPONSE_FORMAT_R2
;
351 case MMC_RSP_R3
: /* short */
352 cmdat
|= CMD_DAT_CONT_RESPONSE_FORMAT_R3
;
358 if ( test_and_clear_bit(IMXMCI_PEND_SET_INIT_b
, &host
->pending_events
) )
359 cmdat
|= CMD_DAT_CONT_INIT
; /* This command needs init */
361 if ( host
->actual_bus_width
== MMC_BUS_WIDTH_4
)
362 cmdat
|= CMD_DAT_CONT_BUS_WIDTH_4
;
364 MMC_CMD
= cmd
->opcode
;
365 MMC_ARGH
= cmd
->arg
>> 16;
366 MMC_ARGL
= cmd
->arg
& 0xffff;
367 MMC_CMD_DAT_CONT
= cmdat
;
369 atomic_set(&host
->stuck_timeout
, 0);
370 set_bit(IMXMCI_PEND_WAIT_RESP_b
, &host
->pending_events
);
373 imask
= IMXMCI_INT_MASK_DEFAULT
;
374 imask
&= ~INT_MASK_END_CMD_RES
;
375 if ( cmdat
& CMD_DAT_CONT_DATA_ENABLE
) {
376 /*imask &= ~INT_MASK_BUF_READY;*/
377 imask
&= ~INT_MASK_DATA_TRAN
;
378 if ( cmdat
& CMD_DAT_CONT_WRITE
)
379 imask
&= ~INT_MASK_WRITE_OP_DONE
;
380 if(test_bit(IMXMCI_PEND_CPU_DATA_b
, &host
->pending_events
))
381 imask
&= ~INT_MASK_BUF_READY
;
384 spin_lock_irqsave(&host
->lock
, flags
);
386 MMC_INT_MASK
= host
->imask
;
387 spin_unlock_irqrestore(&host
->lock
, flags
);
389 dev_dbg(mmc_dev(host
->mmc
), "CMD%02d (0x%02x) mask set to 0x%04x\n",
390 cmd
->opcode
, cmd
->opcode
, imask
);
392 imxmci_start_clock(host
);
395 static void imxmci_finish_request(struct imxmci_host
*host
, struct mmc_request
*req
)
399 spin_lock_irqsave(&host
->lock
, flags
);
401 host
->pending_events
&= ~(IMXMCI_PEND_WAIT_RESP_m
| IMXMCI_PEND_DMA_END_m
|
402 IMXMCI_PEND_DMA_DATA_m
| IMXMCI_PEND_CPU_DATA_m
);
404 host
->imask
= IMXMCI_INT_MASK_DEFAULT
;
405 MMC_INT_MASK
= host
->imask
;
407 spin_unlock_irqrestore(&host
->lock
, flags
);
410 host
->prev_cmd_code
= req
->cmd
->opcode
;
415 mmc_request_done(host
->mmc
, req
);
418 static int imxmci_finish_data(struct imxmci_host
*host
, unsigned int stat
)
420 struct mmc_data
*data
= host
->data
;
423 if(test_and_clear_bit(IMXMCI_PEND_DMA_DATA_b
, &host
->pending_events
)){
424 imx_dma_disable(host
->dma
);
425 dma_unmap_sg(mmc_dev(host
->mmc
), data
->sg
, host
->dma_nents
,
429 if ( stat
& STATUS_ERR_MASK
) {
430 dev_dbg(mmc_dev(host
->mmc
), "request failed. status: 0x%08x\n",stat
);
431 if(stat
& (STATUS_CRC_READ_ERR
| STATUS_CRC_WRITE_ERR
))
432 data
->error
= MMC_ERR_BADCRC
;
433 else if(stat
& STATUS_TIME_OUT_READ
)
434 data
->error
= MMC_ERR_TIMEOUT
;
436 data
->error
= MMC_ERR_FAILED
;
438 data
->bytes_xfered
= host
->dma_size
;
441 data_error
= data
->error
;
448 static int imxmci_cmd_done(struct imxmci_host
*host
, unsigned int stat
)
450 struct mmc_command
*cmd
= host
->cmd
;
453 struct mmc_data
*data
= host
->data
;
460 if (stat
& STATUS_TIME_OUT_RESP
) {
461 dev_dbg(mmc_dev(host
->mmc
), "CMD TIMEOUT\n");
462 cmd
->error
= MMC_ERR_TIMEOUT
;
463 } else if (stat
& STATUS_RESP_CRC_ERR
&& cmd
->flags
& MMC_RSP_CRC
) {
464 dev_dbg(mmc_dev(host
->mmc
), "cmd crc error\n");
465 cmd
->error
= MMC_ERR_BADCRC
;
468 if(cmd
->flags
& MMC_RSP_PRESENT
) {
469 if(cmd
->flags
& MMC_RSP_136
) {
470 for (i
= 0; i
< 4; i
++) {
471 u32 a
= MMC_RES_FIFO
& 0xffff;
472 u32 b
= MMC_RES_FIFO
& 0xffff;
473 cmd
->resp
[i
] = a
<<16 | b
;
476 a
= MMC_RES_FIFO
& 0xffff;
477 b
= MMC_RES_FIFO
& 0xffff;
478 c
= MMC_RES_FIFO
& 0xffff;
479 cmd
->resp
[0] = a
<<24 | b
<<8 | c
>>8;
483 dev_dbg(mmc_dev(host
->mmc
), "RESP 0x%08x, 0x%08x, 0x%08x, 0x%08x, error %d\n",
484 cmd
->resp
[0], cmd
->resp
[1], cmd
->resp
[2], cmd
->resp
[3], cmd
->error
);
486 if (data
&& (cmd
->error
== MMC_ERR_NONE
) && !(stat
& STATUS_ERR_MASK
)) {
487 if (host
->req
->data
->flags
& MMC_DATA_WRITE
) {
489 /* Wait for FIFO to be empty before starting DMA write */
492 if(imxmci_busy_wait_for_status(host
, &stat
,
494 40, "imxmci_cmd_done DMA WR") < 0) {
495 cmd
->error
= MMC_ERR_FIFO
;
496 imxmci_finish_data(host
, stat
);
498 imxmci_finish_request(host
, host
->req
);
499 dev_warn(mmc_dev(host
->mmc
), "STATUS = 0x%04x\n",
504 if(test_bit(IMXMCI_PEND_DMA_DATA_b
, &host
->pending_events
)) {
505 imx_dma_enable(host
->dma
);
509 struct mmc_request
*req
;
510 imxmci_stop_clock(host
);
514 imxmci_finish_data(host
, stat
);
517 imxmci_finish_request(host
, req
);
519 dev_warn(mmc_dev(host
->mmc
), "imxmci_cmd_done: no request to finish\n");
526 static int imxmci_data_done(struct imxmci_host
*host
, unsigned int stat
)
528 struct mmc_data
*data
= host
->data
;
534 data_error
= imxmci_finish_data(host
, stat
);
536 if (host
->req
->stop
) {
537 imxmci_stop_clock(host
);
538 imxmci_start_cmd(host
, host
->req
->stop
, 0);
540 struct mmc_request
*req
;
543 imxmci_finish_request(host
, req
);
545 dev_warn(mmc_dev(host
->mmc
), "imxmci_data_done: no request to finish\n");
552 static int imxmci_cpu_driven_data(struct imxmci_host
*host
, unsigned int *pstat
)
557 unsigned int stat
= *pstat
;
559 if(host
->actual_bus_width
!= MMC_BUS_WIDTH_4
)
564 /* This is unfortunately required */
565 dev_dbg(mmc_dev(host
->mmc
), "imxmci_cpu_driven_data running STATUS = 0x%x\n",
568 udelay(20); /* required for clocks < 8MHz*/
570 if(host
->dma_dir
== DMA_FROM_DEVICE
) {
571 imxmci_busy_wait_for_status(host
, &stat
,
572 STATUS_APPL_BUFF_FF
| STATUS_DATA_TRANS_DONE
|
573 STATUS_TIME_OUT_READ
,
574 50, "imxmci_cpu_driven_data read");
576 while((stat
& (STATUS_APPL_BUFF_FF
| STATUS_DATA_TRANS_DONE
)) &&
577 !(stat
& STATUS_TIME_OUT_READ
) &&
578 (host
->data_cnt
< 512)) {
580 udelay(20); /* required for clocks < 8MHz*/
582 for(i
= burst_len
; i
>=2 ; i
-=2) {
584 data
= MMC_BUFFER_ACCESS
;
585 udelay(10); /* required for clocks < 8MHz*/
586 if(host
->data_cnt
+2 <= host
->dma_size
) {
587 *(host
->data_ptr
++) = data
;
589 if(host
->data_cnt
< host
->dma_size
)
590 *(u8
*)(host
->data_ptr
) = data
;
597 dev_dbg(mmc_dev(host
->mmc
), "imxmci_cpu_driven_data read %d burst %d STATUS = 0x%x\n",
598 host
->data_cnt
, burst_len
, stat
);
601 if((stat
& STATUS_DATA_TRANS_DONE
) && (host
->data_cnt
>= 512))
604 if(host
->dma_size
& 0x1ff)
605 stat
&= ~STATUS_CRC_READ_ERR
;
607 if(stat
& STATUS_TIME_OUT_READ
) {
608 dev_dbg(mmc_dev(host
->mmc
), "imxmci_cpu_driven_data read timeout STATUS = 0x%x\n",
614 imxmci_busy_wait_for_status(host
, &stat
,
616 20, "imxmci_cpu_driven_data write");
618 while((stat
& STATUS_APPL_BUFF_FE
) &&
619 (host
->data_cnt
< host
->dma_size
)) {
620 if(burst_len
>= host
->dma_size
- host
->data_cnt
) {
621 burst_len
= host
->dma_size
- host
->data_cnt
;
622 host
->data_cnt
= host
->dma_size
;
625 host
->data_cnt
+= burst_len
;
628 for(i
= burst_len
; i
>0 ; i
-=2)
629 MMC_BUFFER_ACCESS
= *(host
->data_ptr
++);
633 dev_dbg(mmc_dev(host
->mmc
), "imxmci_cpu_driven_data write burst %d STATUS = 0x%x\n",
643 static void imxmci_dma_irq(int dma
, void *devid
)
645 struct imxmci_host
*host
= devid
;
646 uint32_t stat
= MMC_STATUS
;
648 atomic_set(&host
->stuck_timeout
, 0);
649 host
->status_reg
= stat
;
650 set_bit(IMXMCI_PEND_DMA_END_b
, &host
->pending_events
);
651 tasklet_schedule(&host
->tasklet
);
654 static irqreturn_t
imxmci_irq(int irq
, void *devid
)
656 struct imxmci_host
*host
= devid
;
657 uint32_t stat
= MMC_STATUS
;
660 MMC_INT_MASK
= host
->imask
| INT_MASK_SDIO
| INT_MASK_AUTO_CARD_DETECT
;
662 atomic_set(&host
->stuck_timeout
, 0);
663 host
->status_reg
= stat
;
664 set_bit(IMXMCI_PEND_IRQ_b
, &host
->pending_events
);
665 set_bit(IMXMCI_PEND_STARTED_b
, &host
->pending_events
);
666 tasklet_schedule(&host
->tasklet
);
668 return IRQ_RETVAL(handled
);;
671 static void imxmci_tasklet_fnc(unsigned long data
)
673 struct imxmci_host
*host
= (struct imxmci_host
*)data
;
675 unsigned int data_dir_mask
= 0; /* STATUS_WR_CRC_ERROR_CODE_MASK */
678 if(atomic_read(&host
->stuck_timeout
) > 4) {
682 host
->status_reg
= stat
;
683 if (test_bit(IMXMCI_PEND_WAIT_RESP_b
, &host
->pending_events
))
684 if (test_bit(IMXMCI_PEND_DMA_DATA_b
, &host
->pending_events
))
689 if (test_bit(IMXMCI_PEND_DMA_DATA_b
, &host
->pending_events
))
690 if(test_bit(IMXMCI_PEND_DMA_END_b
, &host
->pending_events
))
697 dev_err(mmc_dev(host
->mmc
), "%s TIMEOUT, hardware stucked STATUS = 0x%04x IMASK = 0x%04x\n",
698 what
, stat
, MMC_INT_MASK
);
699 dev_err(mmc_dev(host
->mmc
), "CMD_DAT_CONT = 0x%04x, MMC_BLK_LEN = 0x%04x, MMC_NOB = 0x%04x, DMA_CCR = 0x%08x\n",
700 MMC_CMD_DAT_CONT
, MMC_BLK_LEN
, MMC_NOB
, CCR(host
->dma
));
701 dev_err(mmc_dev(host
->mmc
), "CMD%d, prevCMD%d, bus %d-bit, dma_size = 0x%x\n",
702 host
->cmd
?host
->cmd
->opcode
:0, host
->prev_cmd_code
, 1<<host
->actual_bus_width
, host
->dma_size
);
705 if(!host
->present
|| timeout
)
706 host
->status_reg
= STATUS_TIME_OUT_RESP
| STATUS_TIME_OUT_READ
|
707 STATUS_CRC_READ_ERR
| STATUS_CRC_WRITE_ERR
;
709 if(test_bit(IMXMCI_PEND_IRQ_b
, &host
->pending_events
) || timeout
) {
710 clear_bit(IMXMCI_PEND_IRQ_b
, &host
->pending_events
);
714 * This is not required in theory, but there is chance to miss some flag
715 * which clears automatically by mask write, FreeScale original code keeps
716 * stat from IRQ time so do I
718 stat
|= host
->status_reg
;
720 if(test_bit(IMXMCI_PEND_CPU_DATA_b
, &host
->pending_events
))
721 stat
&= ~STATUS_CRC_READ_ERR
;
723 if(test_bit(IMXMCI_PEND_WAIT_RESP_b
, &host
->pending_events
)) {
724 imxmci_busy_wait_for_status(host
, &stat
,
725 STATUS_END_CMD_RESP
| STATUS_ERR_MASK
,
726 20, "imxmci_tasklet_fnc resp (ERRATUM #4)");
729 if(stat
& (STATUS_END_CMD_RESP
| STATUS_ERR_MASK
)) {
730 if(test_and_clear_bit(IMXMCI_PEND_WAIT_RESP_b
, &host
->pending_events
))
731 imxmci_cmd_done(host
, stat
);
732 if(host
->data
&& (stat
& STATUS_ERR_MASK
))
733 imxmci_data_done(host
, stat
);
736 if(test_bit(IMXMCI_PEND_CPU_DATA_b
, &host
->pending_events
)) {
738 if(imxmci_cpu_driven_data(host
, &stat
)){
739 if(test_and_clear_bit(IMXMCI_PEND_WAIT_RESP_b
, &host
->pending_events
))
740 imxmci_cmd_done(host
, stat
);
741 atomic_clear_mask(IMXMCI_PEND_IRQ_m
|IMXMCI_PEND_CPU_DATA_m
,
742 &host
->pending_events
);
743 imxmci_data_done(host
, stat
);
748 if(test_bit(IMXMCI_PEND_DMA_END_b
, &host
->pending_events
) &&
749 !test_bit(IMXMCI_PEND_WAIT_RESP_b
, &host
->pending_events
)) {
753 stat
|= host
->status_reg
;
755 if(host
->dma_dir
== DMA_TO_DEVICE
) {
756 data_dir_mask
= STATUS_WRITE_OP_DONE
;
758 data_dir_mask
= STATUS_DATA_TRANS_DONE
;
761 if(stat
& data_dir_mask
) {
762 clear_bit(IMXMCI_PEND_DMA_END_b
, &host
->pending_events
);
763 imxmci_data_done(host
, stat
);
767 if(test_and_clear_bit(IMXMCI_PEND_CARD_XCHG_b
, &host
->pending_events
)) {
770 imxmci_cmd_done(host
, STATUS_TIME_OUT_RESP
);
773 imxmci_data_done(host
, STATUS_TIME_OUT_READ
|
774 STATUS_CRC_READ_ERR
| STATUS_CRC_WRITE_ERR
);
777 imxmci_finish_request(host
, host
->req
);
779 mmc_detect_change(host
->mmc
, msecs_to_jiffies(100));
784 static void imxmci_request(struct mmc_host
*mmc
, struct mmc_request
*req
)
786 struct imxmci_host
*host
= mmc_priv(mmc
);
789 WARN_ON(host
->req
!= NULL
);
796 imxmci_setup_data(host
, req
->data
);
798 cmdat
|= CMD_DAT_CONT_DATA_ENABLE
;
800 if (req
->data
->flags
& MMC_DATA_WRITE
)
801 cmdat
|= CMD_DAT_CONT_WRITE
;
803 if (req
->data
->flags
& MMC_DATA_STREAM
) {
804 cmdat
|= CMD_DAT_CONT_STREAM_BLOCK
;
808 imxmci_start_cmd(host
, req
->cmd
, cmdat
);
811 #define CLK_RATE 19200000
813 static void imxmci_set_ios(struct mmc_host
*mmc
, struct mmc_ios
*ios
)
815 struct imxmci_host
*host
= mmc_priv(mmc
);
818 if( ios
->bus_width
==MMC_BUS_WIDTH_4
) {
819 host
->actual_bus_width
= MMC_BUS_WIDTH_4
;
820 imx_gpio_mode(PB11_PF_SD_DAT3
);
822 host
->actual_bus_width
= MMC_BUS_WIDTH_1
;
823 imx_gpio_mode(GPIO_PORTB
| GPIO_IN
| GPIO_PUEN
| 11);
826 if ( host
->power_mode
!= ios
->power_mode
) {
827 switch (ios
->power_mode
) {
831 set_bit(IMXMCI_PEND_SET_INIT_b
, &host
->pending_events
);
836 host
->power_mode
= ios
->power_mode
;
842 /* The prescaler is 5 for PERCLK2 equal to 96MHz
843 * then 96MHz / 5 = 19.2 MHz
845 clk
=imx_get_perclk2();
846 prescaler
=(clk
+(CLK_RATE
*7)/8)/CLK_RATE
;
849 case 1: prescaler
= 0;
851 case 2: prescaler
= 1;
853 case 3: prescaler
= 2;
855 case 4: prescaler
= 4;
858 case 5: prescaler
= 5;
862 dev_dbg(mmc_dev(host
->mmc
), "PERCLK2 %d MHz -> prescaler %d\n",
865 for(clk
=0; clk
<8; clk
++) {
867 x
= CLK_RATE
/ (1<<clk
);
872 MMC_STR_STP_CLK
|= STR_STP_CLK_ENABLE
; /* enable controller */
874 imxmci_stop_clock(host
);
875 MMC_CLK_RATE
= (prescaler
<<3) | clk
;
877 * Under my understanding, clock should not be started there, because it would
878 * initiate SDHC sequencer and send last or random command into card
880 /*imxmci_start_clock(host);*/
882 dev_dbg(mmc_dev(host
->mmc
), "MMC_CLK_RATE: 0x%08x\n", MMC_CLK_RATE
);
884 imxmci_stop_clock(host
);
888 static const struct mmc_host_ops imxmci_ops
= {
889 .request
= imxmci_request
,
890 .set_ios
= imxmci_set_ios
,
893 static struct resource
*platform_device_resource(struct platform_device
*dev
, unsigned int mask
, int nr
)
897 for (i
= 0; i
< dev
->num_resources
; i
++)
898 if (dev
->resource
[i
].flags
== mask
&& nr
-- == 0)
899 return &dev
->resource
[i
];
903 static int platform_device_irq(struct platform_device
*dev
, int nr
)
907 for (i
= 0; i
< dev
->num_resources
; i
++)
908 if (dev
->resource
[i
].flags
== IORESOURCE_IRQ
&& nr
-- == 0)
909 return dev
->resource
[i
].start
;
913 static void imxmci_check_status(unsigned long data
)
915 struct imxmci_host
*host
= (struct imxmci_host
*)data
;
917 if( host
->pdata
->card_present() != host
->present
) {
919 dev_info(mmc_dev(host
->mmc
), "card %s\n",
920 host
->present
? "inserted" : "removed");
922 set_bit(IMXMCI_PEND_CARD_XCHG_b
, &host
->pending_events
);
923 tasklet_schedule(&host
->tasklet
);
926 if(test_bit(IMXMCI_PEND_WAIT_RESP_b
, &host
->pending_events
) ||
927 test_bit(IMXMCI_PEND_DMA_DATA_b
, &host
->pending_events
)) {
928 atomic_inc(&host
->stuck_timeout
);
929 if(atomic_read(&host
->stuck_timeout
) > 4)
930 tasklet_schedule(&host
->tasklet
);
932 atomic_set(&host
->stuck_timeout
, 0);
936 mod_timer(&host
->timer
, jiffies
+ (HZ
>>1));
939 static int imxmci_probe(struct platform_device
*pdev
)
941 struct mmc_host
*mmc
;
942 struct imxmci_host
*host
= NULL
;
946 printk(KERN_INFO
"i.MX mmc driver\n");
948 r
= platform_device_resource(pdev
, IORESOURCE_MEM
, 0);
949 irq
= platform_device_irq(pdev
, 0);
950 if (!r
|| irq
== NO_IRQ
)
953 r
= request_mem_region(r
->start
, 0x100, "IMXMCI");
957 mmc
= mmc_alloc_host(sizeof(struct imxmci_host
), &pdev
->dev
);
963 mmc
->ops
= &imxmci_ops
;
965 mmc
->f_max
= CLK_RATE
/2;
966 mmc
->ocr_avail
= MMC_VDD_32_33
;
967 mmc
->caps
= MMC_CAP_4_BIT_DATA
| MMC_CAP_BYTEBLOCK
;
969 /* MMC core transfer sizes tunable parameters */
970 mmc
->max_hw_segs
= 64;
971 mmc
->max_phys_segs
= 64;
972 mmc
->max_seg_size
= 64*512; /* default PAGE_CACHE_SIZE */
973 mmc
->max_req_size
= 64*512; /* default PAGE_CACHE_SIZE */
974 mmc
->max_blk_size
= 2048;
975 mmc
->max_blk_count
= 65535;
977 host
= mmc_priv(mmc
);
979 host
->dma_allocated
= 0;
980 host
->pdata
= pdev
->dev
.platform_data
;
982 spin_lock_init(&host
->lock
);
986 imx_gpio_mode(PB8_PF_SD_DAT0
);
987 imx_gpio_mode(PB9_PF_SD_DAT1
);
988 imx_gpio_mode(PB10_PF_SD_DAT2
);
989 /* Configured as GPIO with pull-up to ensure right MCC card mode */
990 /* Switched to PB11_PF_SD_DAT3 if 4 bit bus is configured */
991 imx_gpio_mode(GPIO_PORTB
| GPIO_IN
| GPIO_PUEN
| 11);
992 /* imx_gpio_mode(PB11_PF_SD_DAT3); */
993 imx_gpio_mode(PB12_PF_SD_CLK
);
994 imx_gpio_mode(PB13_PF_SD_CMD
);
998 if ( MMC_REV_NO
!= 0x390 ) {
999 dev_err(mmc_dev(host
->mmc
), "wrong rev.no. 0x%08x. aborting.\n",
1004 MMC_READ_TO
= 0x2db4; /* recommended in data sheet */
1006 host
->imask
= IMXMCI_INT_MASK_DEFAULT
;
1007 MMC_INT_MASK
= host
->imask
;
1010 if(imx_dma_request_by_prio(&host
->dma
, DRIVER_NAME
, DMA_PRIO_LOW
)<0){
1011 dev_err(mmc_dev(host
->mmc
), "imx_dma_request_by_prio failed\n");
1015 host
->dma_allocated
=1;
1016 imx_dma_setup_handlers(host
->dma
, imxmci_dma_irq
, NULL
, host
);
1018 tasklet_init(&host
->tasklet
, imxmci_tasklet_fnc
, (unsigned long)host
);
1020 host
->pending_events
=0;
1022 ret
= request_irq(host
->irq
, imxmci_irq
, 0, DRIVER_NAME
, host
);
1026 host
->present
= host
->pdata
->card_present();
1027 init_timer(&host
->timer
);
1028 host
->timer
.data
= (unsigned long)host
;
1029 host
->timer
.function
= imxmci_check_status
;
1030 add_timer(&host
->timer
);
1031 mod_timer(&host
->timer
, jiffies
+ (HZ
>>1));
1033 platform_set_drvdata(pdev
, mmc
);
1041 if(host
->dma_allocated
){
1042 imx_dma_free(host
->dma
);
1043 host
->dma_allocated
=0;
1048 release_resource(r
);
1052 static int imxmci_remove(struct platform_device
*pdev
)
1054 struct mmc_host
*mmc
= platform_get_drvdata(pdev
);
1056 platform_set_drvdata(pdev
, NULL
);
1059 struct imxmci_host
*host
= mmc_priv(mmc
);
1061 tasklet_disable(&host
->tasklet
);
1063 del_timer_sync(&host
->timer
);
1064 mmc_remove_host(mmc
);
1066 free_irq(host
->irq
, host
);
1067 if(host
->dma_allocated
){
1068 imx_dma_free(host
->dma
);
1069 host
->dma_allocated
=0;
1072 tasklet_kill(&host
->tasklet
);
1074 release_resource(host
->res
);
1082 static int imxmci_suspend(struct platform_device
*dev
, pm_message_t state
)
1084 struct mmc_host
*mmc
= platform_get_drvdata(dev
);
1088 ret
= mmc_suspend_host(mmc
, state
);
1093 static int imxmci_resume(struct platform_device
*dev
)
1095 struct mmc_host
*mmc
= platform_get_drvdata(dev
);
1096 struct imxmci_host
*host
;
1100 host
= mmc_priv(mmc
);
1102 set_bit(IMXMCI_PEND_SET_INIT_b
, &host
->pending_events
);
1103 ret
= mmc_resume_host(mmc
);
1109 #define imxmci_suspend NULL
1110 #define imxmci_resume NULL
1111 #endif /* CONFIG_PM */
1113 static struct platform_driver imxmci_driver
= {
1114 .probe
= imxmci_probe
,
1115 .remove
= imxmci_remove
,
1116 .suspend
= imxmci_suspend
,
1117 .resume
= imxmci_resume
,
1119 .name
= DRIVER_NAME
,
1123 static int __init
imxmci_init(void)
1125 return platform_driver_register(&imxmci_driver
);
1128 static void __exit
imxmci_exit(void)
1130 platform_driver_unregister(&imxmci_driver
);
1133 module_init(imxmci_init
);
1134 module_exit(imxmci_exit
);
1136 MODULE_DESCRIPTION("i.MX Multimedia Card Interface Driver");
1137 MODULE_AUTHOR("Sascha Hauer, Pengutronix");
1138 MODULE_LICENSE("GPL");