1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright 2007, Google Inc.
4 * Copyright 2012, Intel Inc.
6 * based on omap.c driver, which was
7 * Copyright (C) 2004 Nokia Corporation
8 * Written by Tuukka Tikkanen and Juha Yrjölä <juha.yrjola@nokia.com>
9 * Misc hacks here and there by Tony Lindgren <tony@atomide.com>
10 * Other hacks (DMA, SD, etc) by David Brownell
13 #include <linux/module.h>
14 #include <linux/platform_device.h>
15 #include <linux/major.h>
17 #include <linux/types.h>
18 #include <linux/pci.h>
19 #include <linux/interrupt.h>
21 #include <linux/kernel.h>
23 #include <linux/errno.h>
24 #include <linux/hdreg.h>
25 #include <linux/kdev_t.h>
26 #include <linux/blkdev.h>
27 #include <linux/mutex.h>
28 #include <linux/scatterlist.h>
29 #include <linux/mmc/mmc.h>
30 #include <linux/mmc/sdio.h>
31 #include <linux/mmc/host.h>
32 #include <linux/mmc/card.h>
34 #include <linux/moduleparam.h>
35 #include <linux/init.h>
36 #include <linux/ioport.h>
37 #include <linux/dma-mapping.h>
38 #include <linux/delay.h>
39 #include <linux/spinlock.h>
40 #include <linux/timer.h>
41 #include <linux/clk.h>
46 #include <asm/types.h>
47 #include <linux/uaccess.h>
49 #define DRIVER_NAME "goldfish_mmc"
51 #define BUFFER_SIZE 16384
53 #define GOLDFISH_MMC_READ(host, addr) (readl(host->reg_base + addr))
54 #define GOLDFISH_MMC_WRITE(host, addr, x) (writel(x, host->reg_base + addr))
58 MMC_INT_STATUS
= 0x00,
59 /* set this to enable IRQ */
60 MMC_INT_ENABLE
= 0x04,
61 /* set this to specify buffer address */
62 MMC_SET_BUFFER
= 0x08,
64 /* MMC command number */
70 /* MMC response (or R2 bits 0 - 31) */
73 /* MMC R2 response bits 32 - 63 */
76 /* MMC R2 response bits 64 - 95 */
79 /* MMC R2 response bits 96 - 127 */
82 MMC_BLOCK_LENGTH
= 0x24,
83 MMC_BLOCK_COUNT
= 0x28,
88 /* MMC_INT_STATUS bits */
90 MMC_STAT_END_OF_CMD
= 1U << 0,
91 MMC_STAT_END_OF_DATA
= 1U << 1,
92 MMC_STAT_STATE_CHANGE
= 1U << 2,
93 MMC_STAT_CMD_TIMEOUT
= 1U << 3,
96 MMC_STATE_INSERTED
= 1U << 0,
97 MMC_STATE_READ_ONLY
= 1U << 1,
103 #define OMAP_MMC_CMDTYPE_BC 0
104 #define OMAP_MMC_CMDTYPE_BCR 1
105 #define OMAP_MMC_CMDTYPE_AC 2
106 #define OMAP_MMC_CMDTYPE_ADTC 3
109 struct goldfish_mmc_host
{
110 struct mmc_request
*mrq
;
111 struct mmc_command
*cmd
;
112 struct mmc_data
*data
;
113 struct mmc_host
*mmc
;
115 unsigned char id
; /* 16xx chips have 2 MMC blocks */
117 unsigned int phys_base
;
119 unsigned char bus_mode
;
120 unsigned char hw_bus_mode
;
124 unsigned dma_in_use
:1;
126 void __iomem
*reg_base
;
130 goldfish_mmc_cover_is_open(struct goldfish_mmc_host
*host
)
136 goldfish_mmc_show_cover_switch(struct device
*dev
,
137 struct device_attribute
*attr
, char *buf
)
139 struct goldfish_mmc_host
*host
= dev_get_drvdata(dev
);
141 return sprintf(buf
, "%s\n", goldfish_mmc_cover_is_open(host
) ? "open" :
145 static DEVICE_ATTR(cover_switch
, S_IRUGO
, goldfish_mmc_show_cover_switch
, NULL
);
148 goldfish_mmc_start_command(struct goldfish_mmc_host
*host
, struct mmc_command
*cmd
)
159 /* Our hardware needs to know exact type */
160 switch (mmc_resp_type(cmd
)) {
165 /* resp 1, 1b, 6, 7 */
175 dev_err(mmc_dev(host
->mmc
),
176 "Invalid response type: %04x\n", mmc_resp_type(cmd
));
180 if (mmc_cmd_type(cmd
) == MMC_CMD_ADTC
)
181 cmdtype
= OMAP_MMC_CMDTYPE_ADTC
;
182 else if (mmc_cmd_type(cmd
) == MMC_CMD_BC
)
183 cmdtype
= OMAP_MMC_CMDTYPE_BC
;
184 else if (mmc_cmd_type(cmd
) == MMC_CMD_BCR
)
185 cmdtype
= OMAP_MMC_CMDTYPE_BCR
;
187 cmdtype
= OMAP_MMC_CMDTYPE_AC
;
189 cmdreg
= cmd
->opcode
| (resptype
<< 8) | (cmdtype
<< 12);
191 if (host
->bus_mode
== MMC_BUSMODE_OPENDRAIN
)
194 if (cmd
->flags
& MMC_RSP_BUSY
)
197 if (host
->data
&& !(host
->data
->flags
& MMC_DATA_WRITE
))
200 GOLDFISH_MMC_WRITE(host
, MMC_ARG
, cmd
->arg
);
201 GOLDFISH_MMC_WRITE(host
, MMC_CMD
, cmdreg
);
204 static void goldfish_mmc_xfer_done(struct goldfish_mmc_host
*host
,
205 struct mmc_data
*data
)
207 if (host
->dma_in_use
) {
208 enum dma_data_direction dma_data_dir
;
210 dma_data_dir
= mmc_get_dma_dir(data
);
212 if (dma_data_dir
== DMA_FROM_DEVICE
) {
214 * We don't really have DMA, so we need
215 * to copy from our platform driver buffer
217 sg_copy_from_buffer(data
->sg
, 1, host
->virt_base
,
220 host
->data
->bytes_xfered
+= data
->sg
->length
;
221 dma_unmap_sg(mmc_dev(host
->mmc
), data
->sg
, host
->sg_len
,
229 * NOTE: MMC layer will sometimes poll-wait CMD13 next, issuing
230 * dozens of requests until the card finishes writing data.
231 * It'd be cheaper to just wait till an EOFB interrupt arrives...
236 mmc_request_done(host
->mmc
, data
->mrq
);
240 goldfish_mmc_start_command(host
, data
->stop
);
243 static void goldfish_mmc_end_of_data(struct goldfish_mmc_host
*host
,
244 struct mmc_data
*data
)
246 if (!host
->dma_in_use
) {
247 goldfish_mmc_xfer_done(host
, data
);
251 goldfish_mmc_xfer_done(host
, data
);
254 static void goldfish_mmc_cmd_done(struct goldfish_mmc_host
*host
,
255 struct mmc_command
*cmd
)
258 if (cmd
->flags
& MMC_RSP_PRESENT
) {
259 if (cmd
->flags
& MMC_RSP_136
) {
260 /* response type 2 */
262 GOLDFISH_MMC_READ(host
, MMC_RESP_0
);
264 GOLDFISH_MMC_READ(host
, MMC_RESP_1
);
266 GOLDFISH_MMC_READ(host
, MMC_RESP_2
);
268 GOLDFISH_MMC_READ(host
, MMC_RESP_3
);
270 /* response types 1, 1b, 3, 4, 5, 6 */
272 GOLDFISH_MMC_READ(host
, MMC_RESP_0
);
276 if (host
->data
== NULL
|| cmd
->error
) {
278 mmc_request_done(host
->mmc
, cmd
->mrq
);
282 static irqreturn_t
goldfish_mmc_irq(int irq
, void *dev_id
)
284 struct goldfish_mmc_host
*host
= (struct goldfish_mmc_host
*)dev_id
;
287 int end_transfer
= 0;
288 int state_changed
= 0;
291 while ((status
= GOLDFISH_MMC_READ(host
, MMC_INT_STATUS
)) != 0) {
292 GOLDFISH_MMC_WRITE(host
, MMC_INT_STATUS
, status
);
294 if (status
& MMC_STAT_END_OF_CMD
)
297 if (status
& MMC_STAT_END_OF_DATA
)
300 if (status
& MMC_STAT_STATE_CHANGE
)
303 if (status
& MMC_STAT_CMD_TIMEOUT
) {
310 struct mmc_request
*mrq
= host
->mrq
;
311 mrq
->cmd
->error
= -ETIMEDOUT
;
313 mmc_request_done(host
->mmc
, mrq
);
317 goldfish_mmc_cmd_done(host
, host
->cmd
);
321 goldfish_mmc_end_of_data(host
, host
->data
);
322 } else if (host
->data
!= NULL
) {
324 * WORKAROUND -- after porting this driver from 2.6 to 3.4,
325 * during device initialization, cases where host->data is
326 * non-null but end_transfer is false would occur. Doing
327 * nothing in such cases results in no further interrupts,
328 * and initialization failure.
329 * TODO -- find the real cause.
332 goldfish_mmc_end_of_data(host
, host
->data
);
336 u32 state
= GOLDFISH_MMC_READ(host
, MMC_STATE
);
337 pr_info("%s: Card detect now %d\n", __func__
,
338 (state
& MMC_STATE_INSERTED
));
339 mmc_detect_change(host
->mmc
, 0);
342 if (!end_command
&& !end_transfer
&& !state_changed
&& !cmd_timeout
) {
343 status
= GOLDFISH_MMC_READ(host
, MMC_INT_STATUS
);
344 dev_info(mmc_dev(host
->mmc
),"spurious irq 0x%04x\n", status
);
346 GOLDFISH_MMC_WRITE(host
, MMC_INT_STATUS
, status
);
347 GOLDFISH_MMC_WRITE(host
, MMC_INT_ENABLE
, 0);
354 static void goldfish_mmc_prepare_data(struct goldfish_mmc_host
*host
,
355 struct mmc_request
*req
)
357 struct mmc_data
*data
= req
->data
;
360 enum dma_data_direction dma_data_dir
;
364 GOLDFISH_MMC_WRITE(host
, MMC_BLOCK_LENGTH
, 0);
365 GOLDFISH_MMC_WRITE(host
, MMC_BLOCK_COUNT
, 0);
366 host
->dma_in_use
= 0;
370 block_size
= data
->blksz
;
372 GOLDFISH_MMC_WRITE(host
, MMC_BLOCK_COUNT
, data
->blocks
- 1);
373 GOLDFISH_MMC_WRITE(host
, MMC_BLOCK_LENGTH
, block_size
- 1);
376 * Cope with calling layer confusion; it issues "single
377 * block" writes using multi-block scatterlists.
379 sg_len
= (data
->blocks
== 1) ? 1 : data
->sg_len
;
381 dma_data_dir
= mmc_get_dma_dir(data
);
383 host
->sg_len
= dma_map_sg(mmc_dev(host
->mmc
), data
->sg
,
384 sg_len
, dma_data_dir
);
386 host
->dma_in_use
= 1;
388 if (dma_data_dir
== DMA_TO_DEVICE
) {
390 * We don't really have DMA, so we need to copy to our
391 * platform driver buffer
393 sg_copy_to_buffer(data
->sg
, 1, host
->virt_base
,
398 static void goldfish_mmc_request(struct mmc_host
*mmc
, struct mmc_request
*req
)
400 struct goldfish_mmc_host
*host
= mmc_priv(mmc
);
402 WARN_ON(host
->mrq
!= NULL
);
405 goldfish_mmc_prepare_data(host
, req
);
406 goldfish_mmc_start_command(host
, req
->cmd
);
409 * This is to avoid accidentally being detected as an SDIO card
410 * in mmc_attach_sdio().
412 if (req
->cmd
->opcode
== SD_IO_SEND_OP_COND
&&
413 req
->cmd
->flags
== (MMC_RSP_SPI_R4
| MMC_RSP_R4
| MMC_CMD_BCR
))
414 req
->cmd
->error
= -EINVAL
;
417 static void goldfish_mmc_set_ios(struct mmc_host
*mmc
, struct mmc_ios
*ios
)
419 struct goldfish_mmc_host
*host
= mmc_priv(mmc
);
421 host
->bus_mode
= ios
->bus_mode
;
422 host
->hw_bus_mode
= host
->bus_mode
;
425 static int goldfish_mmc_get_ro(struct mmc_host
*mmc
)
428 struct goldfish_mmc_host
*host
= mmc_priv(mmc
);
430 state
= GOLDFISH_MMC_READ(host
, MMC_STATE
);
431 return ((state
& MMC_STATE_READ_ONLY
) != 0);
434 static const struct mmc_host_ops goldfish_mmc_ops
= {
435 .request
= goldfish_mmc_request
,
436 .set_ios
= goldfish_mmc_set_ios
,
437 .get_ro
= goldfish_mmc_get_ro
,
440 static int goldfish_mmc_probe(struct platform_device
*pdev
)
442 struct mmc_host
*mmc
;
443 struct goldfish_mmc_host
*host
= NULL
;
444 struct resource
*res
;
449 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
450 irq
= platform_get_irq(pdev
, 0);
451 if (res
== NULL
|| irq
< 0)
454 mmc
= mmc_alloc_host(sizeof(struct goldfish_mmc_host
), &pdev
->dev
);
457 goto err_alloc_host_failed
;
460 host
= mmc_priv(mmc
);
463 pr_err("mmc: Mapping %lX to %lX\n", (long)res
->start
, (long)res
->end
);
464 host
->reg_base
= ioremap(res
->start
, resource_size(res
));
465 if (host
->reg_base
== NULL
) {
469 host
->virt_base
= dma_alloc_coherent(&pdev
->dev
, BUFFER_SIZE
,
470 &buf_addr
, GFP_KERNEL
);
472 if (host
->virt_base
== 0) {
474 goto dma_alloc_failed
;
476 host
->phys_base
= buf_addr
;
481 mmc
->ops
= &goldfish_mmc_ops
;
483 mmc
->f_max
= 24000000;
484 mmc
->ocr_avail
= MMC_VDD_32_33
| MMC_VDD_33_34
;
485 mmc
->caps
= MMC_CAP_4_BIT_DATA
;
487 /* Use scatterlist DMA to reduce per-transfer costs.
488 * NOTE max_seg_size assumption that small blocks aren't
489 * normally used (except e.g. for reading SD registers).
492 mmc
->max_blk_size
= 2048; /* MMC_BLOCK_LENGTH is 11 bits (+1) */
493 mmc
->max_blk_count
= 2048; /* MMC_BLOCK_COUNT is 11 bits (+1) */
494 mmc
->max_req_size
= BUFFER_SIZE
;
495 mmc
->max_seg_size
= mmc
->max_req_size
;
497 ret
= request_irq(host
->irq
, goldfish_mmc_irq
, 0, DRIVER_NAME
, host
);
499 dev_err(&pdev
->dev
, "Failed IRQ Adding goldfish MMC\n");
500 goto err_request_irq_failed
;
503 host
->dev
= &pdev
->dev
;
504 platform_set_drvdata(pdev
, host
);
506 ret
= device_create_file(&pdev
->dev
, &dev_attr_cover_switch
);
508 dev_warn(mmc_dev(host
->mmc
),
509 "Unable to create sysfs attributes\n");
511 GOLDFISH_MMC_WRITE(host
, MMC_SET_BUFFER
, host
->phys_base
);
512 GOLDFISH_MMC_WRITE(host
, MMC_INT_ENABLE
,
513 MMC_STAT_END_OF_CMD
| MMC_STAT_END_OF_DATA
|
514 MMC_STAT_STATE_CHANGE
| MMC_STAT_CMD_TIMEOUT
);
519 err_request_irq_failed
:
520 dma_free_coherent(&pdev
->dev
, BUFFER_SIZE
, host
->virt_base
,
523 iounmap(host
->reg_base
);
525 mmc_free_host(host
->mmc
);
526 err_alloc_host_failed
:
530 static int goldfish_mmc_remove(struct platform_device
*pdev
)
532 struct goldfish_mmc_host
*host
= platform_get_drvdata(pdev
);
534 BUG_ON(host
== NULL
);
536 mmc_remove_host(host
->mmc
);
537 free_irq(host
->irq
, host
);
538 dma_free_coherent(&pdev
->dev
, BUFFER_SIZE
, host
->virt_base
, host
->phys_base
);
539 iounmap(host
->reg_base
);
540 mmc_free_host(host
->mmc
);
544 static struct platform_driver goldfish_mmc_driver
= {
545 .probe
= goldfish_mmc_probe
,
546 .remove
= goldfish_mmc_remove
,
552 module_platform_driver(goldfish_mmc_driver
);
553 MODULE_LICENSE("GPL v2");