2019-05-19 21:51:31 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2011-02-21 18:35:28 +08:00
|
|
|
/*
|
|
|
|
* Portions copyright (C) 2003 Russell King, PXA MMCI Driver
|
|
|
|
* Portions copyright (C) 2004-2005 Pierre Ossman, W83L51xD SD/MMC driver
|
|
|
|
*
|
|
|
|
* Copyright 2008 Embedded Alley Solutions, Inc.
|
|
|
|
* Copyright 2009-2011 Freescale Semiconductor, Inc.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/ioport.h>
|
2012-05-06 13:30:44 +08:00
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/of_device.h>
|
2011-02-21 18:35:28 +08:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/dmaengine.h>
|
2019-10-18 17:39:34 +08:00
|
|
|
#include <linux/dma/mxs-dma.h>
|
2011-02-21 18:35:28 +08:00
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/clk.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/mmc/host.h>
|
|
|
|
#include <linux/mmc/mmc.h>
|
|
|
|
#include <linux/mmc/sdio.h>
|
2013-12-05 21:34:50 +08:00
|
|
|
#include <linux/mmc/slot-gpio.h>
|
2011-02-21 18:35:28 +08:00
|
|
|
#include <linux/regulator/consumer.h>
|
2011-07-04 03:15:51 +08:00
|
|
|
#include <linux/module.h>
|
2012-05-05 19:40:09 +08:00
|
|
|
#include <linux/stmp_device.h>
|
2012-08-03 23:26:06 +08:00
|
|
|
#include <linux/spi/mxs-spi.h>
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
#define DRIVER_NAME "mxs-mmc"
|
|
|
|
|
|
|
|
#define MXS_MMC_IRQ_BITS (BM_SSP_CTRL1_SDIO_IRQ | \
|
|
|
|
BM_SSP_CTRL1_RESP_ERR_IRQ | \
|
|
|
|
BM_SSP_CTRL1_RESP_TIMEOUT_IRQ | \
|
|
|
|
BM_SSP_CTRL1_DATA_TIMEOUT_IRQ | \
|
|
|
|
BM_SSP_CTRL1_DATA_CRC_IRQ | \
|
|
|
|
BM_SSP_CTRL1_FIFO_UNDERRUN_IRQ | \
|
|
|
|
BM_SSP_CTRL1_RECV_TIMEOUT_IRQ | \
|
|
|
|
BM_SSP_CTRL1_FIFO_OVERRUN_IRQ)
|
|
|
|
|
2012-08-03 23:26:06 +08:00
|
|
|
/* card detect polling timeout */
|
|
|
|
#define MXS_MMC_DETECT_TIMEOUT (HZ/2)
|
2012-05-05 20:24:01 +08:00
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
struct mxs_mmc_host {
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp ssp;
|
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
struct mmc_host *mmc;
|
|
|
|
struct mmc_request *mrq;
|
|
|
|
struct mmc_command *cmd;
|
|
|
|
struct mmc_data *data;
|
|
|
|
|
|
|
|
unsigned char bus_width;
|
|
|
|
spinlock_t lock;
|
|
|
|
int sdio_irq_en;
|
2014-04-20 05:59:18 +08:00
|
|
|
bool broken_cd;
|
2011-02-21 18:35:28 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static int mxs_mmc_get_cd(struct mmc_host *mmc)
|
|
|
|
{
|
|
|
|
struct mxs_mmc_host *host = mmc_priv(mmc);
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2013-12-05 21:34:51 +08:00
|
|
|
int present, ret;
|
|
|
|
|
2014-04-20 05:59:18 +08:00
|
|
|
if (host->broken_cd)
|
|
|
|
return -ENOSYS;
|
|
|
|
|
2013-12-05 21:34:51 +08:00
|
|
|
ret = mmc_gpio_get_cd(mmc);
|
|
|
|
if (ret >= 0)
|
|
|
|
return ret;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
2014-06-10 22:57:02 +08:00
|
|
|
present = mmc->caps & MMC_CAP_NEEDS_POLL ||
|
|
|
|
!(readl(ssp->base + HW_SSP_STATUS(ssp)) &
|
2013-12-05 21:34:49 +08:00
|
|
|
BM_SSP_STATUS_CARD_DETECT);
|
|
|
|
|
|
|
|
if (mmc->caps2 & MMC_CAP2_CD_ACTIVE_HIGH)
|
|
|
|
present = !present;
|
|
|
|
|
|
|
|
return present;
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
2013-07-04 04:02:38 +08:00
|
|
|
static int mxs_mmc_reset(struct mxs_mmc_host *host)
|
2011-02-21 18:35:28 +08:00
|
|
|
{
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
u32 ctrl0, ctrl1;
|
2013-07-04 04:02:38 +08:00
|
|
|
int ret;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
2013-07-04 04:02:38 +08:00
|
|
|
ret = stmp_reset_block(ssp->base);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
ctrl0 = BM_SSP_CTRL0_IGNORE_CRC;
|
|
|
|
ctrl1 = BF_SSP(0x3, CTRL1_SSP_MODE) |
|
|
|
|
BF_SSP(0x7, CTRL1_WORD_LENGTH) |
|
|
|
|
BM_SSP_CTRL1_DMA_ENABLE |
|
|
|
|
BM_SSP_CTRL1_POLARITY |
|
|
|
|
BM_SSP_CTRL1_RECV_TIMEOUT_IRQ_EN |
|
|
|
|
BM_SSP_CTRL1_DATA_CRC_IRQ_EN |
|
|
|
|
BM_SSP_CTRL1_DATA_TIMEOUT_IRQ_EN |
|
|
|
|
BM_SSP_CTRL1_RESP_TIMEOUT_IRQ_EN |
|
|
|
|
BM_SSP_CTRL1_RESP_ERR_IRQ_EN;
|
|
|
|
|
|
|
|
writel(BF_SSP(0xffff, TIMING_TIMEOUT) |
|
|
|
|
BF_SSP(2, TIMING_CLOCK_DIVIDE) |
|
|
|
|
BF_SSP(0, TIMING_CLOCK_RATE),
|
2012-08-03 23:26:09 +08:00
|
|
|
ssp->base + HW_SSP_TIMING(ssp));
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
if (host->sdio_irq_en) {
|
|
|
|
ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
|
|
|
|
ctrl1 |= BM_SSP_CTRL1_SDIO_IRQ_EN;
|
|
|
|
}
|
|
|
|
|
2012-08-03 23:26:09 +08:00
|
|
|
writel(ctrl0, ssp->base + HW_SSP_CTRL0);
|
|
|
|
writel(ctrl1, ssp->base + HW_SSP_CTRL1(ssp));
|
2013-07-04 04:02:38 +08:00
|
|
|
return 0;
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mxs_mmc_start_cmd(struct mxs_mmc_host *host,
|
|
|
|
struct mmc_command *cmd);
|
|
|
|
|
|
|
|
static void mxs_mmc_request_done(struct mxs_mmc_host *host)
|
|
|
|
{
|
|
|
|
struct mmc_command *cmd = host->cmd;
|
|
|
|
struct mmc_data *data = host->data;
|
|
|
|
struct mmc_request *mrq = host->mrq;
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
if (mmc_resp_type(cmd) & MMC_RSP_PRESENT) {
|
|
|
|
if (mmc_resp_type(cmd) & MMC_RSP_136) {
|
2012-08-03 23:26:09 +08:00
|
|
|
cmd->resp[3] = readl(ssp->base + HW_SSP_SDRESP0(ssp));
|
|
|
|
cmd->resp[2] = readl(ssp->base + HW_SSP_SDRESP1(ssp));
|
|
|
|
cmd->resp[1] = readl(ssp->base + HW_SSP_SDRESP2(ssp));
|
|
|
|
cmd->resp[0] = readl(ssp->base + HW_SSP_SDRESP3(ssp));
|
2011-02-21 18:35:28 +08:00
|
|
|
} else {
|
2012-08-03 23:26:09 +08:00
|
|
|
cmd->resp[0] = readl(ssp->base + HW_SSP_SDRESP0(ssp));
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-15 01:29:18 +08:00
|
|
|
if (cmd == mrq->sbc) {
|
|
|
|
/* Finished CMD23, now send actual command. */
|
|
|
|
mxs_mmc_start_cmd(host, mrq->cmd);
|
|
|
|
return;
|
|
|
|
} else if (data) {
|
2011-02-21 18:35:28 +08:00
|
|
|
dma_unmap_sg(mmc_dev(host->mmc), data->sg,
|
2012-08-03 23:26:12 +08:00
|
|
|
data->sg_len, ssp->dma_dir);
|
2011-02-21 18:35:28 +08:00
|
|
|
/*
|
|
|
|
* If there was an error on any block, we mark all
|
|
|
|
* data blocks as being in error.
|
|
|
|
*/
|
|
|
|
if (!data->error)
|
|
|
|
data->bytes_xfered = data->blocks * data->blksz;
|
|
|
|
else
|
|
|
|
data->bytes_xfered = 0;
|
|
|
|
|
|
|
|
host->data = NULL;
|
2017-01-15 01:29:18 +08:00
|
|
|
if (data->stop && (data->error || !mrq->sbc)) {
|
2011-02-21 18:35:28 +08:00
|
|
|
mxs_mmc_start_cmd(host, mrq->stop);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
host->mrq = NULL;
|
|
|
|
mmc_request_done(host->mmc, mrq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mxs_mmc_dma_irq_callback(void *param)
|
|
|
|
{
|
|
|
|
struct mxs_mmc_host *host = param;
|
|
|
|
|
|
|
|
mxs_mmc_request_done(host);
|
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t mxs_mmc_irq_handler(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
struct mxs_mmc_host *host = dev_id;
|
|
|
|
struct mmc_command *cmd = host->cmd;
|
|
|
|
struct mmc_data *data = host->data;
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
u32 stat;
|
|
|
|
|
|
|
|
spin_lock(&host->lock);
|
|
|
|
|
2012-08-03 23:26:09 +08:00
|
|
|
stat = readl(ssp->base + HW_SSP_CTRL1(ssp));
|
2011-02-21 18:35:28 +08:00
|
|
|
writel(stat & MXS_MMC_IRQ_BITS,
|
2012-08-03 23:26:09 +08:00
|
|
|
ssp->base + HW_SSP_CTRL1(ssp) + STMP_OFFSET_REG_CLR);
|
2011-02-21 18:35:28 +08:00
|
|
|
|
2012-07-17 22:16:09 +08:00
|
|
|
spin_unlock(&host->lock);
|
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
if ((stat & BM_SSP_CTRL1_SDIO_IRQ) && (stat & BM_SSP_CTRL1_SDIO_IRQ_EN))
|
|
|
|
mmc_signal_sdio_irq(host->mmc);
|
|
|
|
|
|
|
|
if (stat & BM_SSP_CTRL1_RESP_TIMEOUT_IRQ)
|
|
|
|
cmd->error = -ETIMEDOUT;
|
|
|
|
else if (stat & BM_SSP_CTRL1_RESP_ERR_IRQ)
|
|
|
|
cmd->error = -EIO;
|
|
|
|
|
|
|
|
if (data) {
|
|
|
|
if (stat & (BM_SSP_CTRL1_DATA_TIMEOUT_IRQ |
|
|
|
|
BM_SSP_CTRL1_RECV_TIMEOUT_IRQ))
|
|
|
|
data->error = -ETIMEDOUT;
|
|
|
|
else if (stat & BM_SSP_CTRL1_DATA_CRC_IRQ)
|
|
|
|
data->error = -EILSEQ;
|
|
|
|
else if (stat & (BM_SSP_CTRL1_FIFO_UNDERRUN_IRQ |
|
|
|
|
BM_SSP_CTRL1_FIFO_OVERRUN_IRQ))
|
|
|
|
data->error = -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dma_async_tx_descriptor *mxs_mmc_prep_dma(
|
mxs-dma : rewrite the last parameter of mxs_dma_prep_slave_sg()
[1] Background :
The GPMI does ECC read page operation with a DMA chain consist of three DMA
Command Structures. The middle one of the chain is used to enable the BCH,
and read out the NAND page.
The WAIT4END(wait for command end) is a comunication signal between
the GPMI and MXS-DMA.
[2] The current DMA code sets the WAIT4END bit at the last one, such as:
+-----+ +-----+ +-----+
| cmd | ------------> | cmd | ------------------> | cmd |
+-----+ +-----+ +-----+
^
|
|
set WAIT4END here
This chain works fine in the mx23/mx28.
[3] But in the new GPMI version (used in MX50/MX60), the WAIT4END bit should
be set not only at the last DMA Command Structure,
but also at the middle one, such as:
+-----+ +-----+ +-----+
| cmd | ------------> | cmd | ------------------> | cmd |
+-----+ +-----+ +-----+
^ ^
| |
| |
set WAIT4END here too set WAIT4END here
If we do not set WAIT4END, the BCH maybe stalls in "ECC reading page" state.
In the next ECC write page operation, a DMA-timeout occurs.
This has been catched in the MX6Q board.
[4] In order to fix the bug, rewrite the last parameter of mxs_dma_prep_slave_sg(),
and use the dma_ctrl_flags:
---------------------------------------------------------
DMA_PREP_INTERRUPT : append a new DMA Command Structrue.
DMA_CTRL_ACK : set the WAIT4END bit for this DMA Command Structure.
---------------------------------------------------------
[5] changes to the relative drivers:
<1> For mxs-mmc driver, just use the new flags, do not change any logic.
<2> For gpmi-nand driver, and use the new flags to set the DMA
chain, especially for ecc read page.
Acked-by: Shawn Guo <shawn.guo@linaro.org>
Signed-off-by: Huang Shijie <b32955@freescale.com>
Acked-by: Vinod Koul <vinod.koul@linux.intel.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
2012-02-16 14:17:33 +08:00
|
|
|
struct mxs_mmc_host *host, unsigned long flags)
|
2011-02-21 18:35:28 +08:00
|
|
|
{
|
2012-08-03 23:26:12 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
struct dma_async_tx_descriptor *desc;
|
|
|
|
struct mmc_data *data = host->data;
|
|
|
|
struct scatterlist * sgl;
|
|
|
|
unsigned int sg_len;
|
|
|
|
|
|
|
|
if (data) {
|
|
|
|
/* data */
|
|
|
|
dma_map_sg(mmc_dev(host->mmc), data->sg,
|
2012-08-03 23:26:12 +08:00
|
|
|
data->sg_len, ssp->dma_dir);
|
2011-02-21 18:35:28 +08:00
|
|
|
sgl = data->sg;
|
|
|
|
sg_len = data->sg_len;
|
|
|
|
} else {
|
|
|
|
/* pio */
|
2012-08-03 23:26:12 +08:00
|
|
|
sgl = (struct scatterlist *) ssp->ssp_pio_words;
|
2011-02-21 18:35:28 +08:00
|
|
|
sg_len = SSP_PIO_NUM;
|
|
|
|
}
|
|
|
|
|
2012-08-03 23:26:12 +08:00
|
|
|
desc = dmaengine_prep_slave_sg(ssp->dmach,
|
|
|
|
sgl, sg_len, ssp->slave_dirn, flags);
|
2011-02-21 18:35:28 +08:00
|
|
|
if (desc) {
|
|
|
|
desc->callback = mxs_mmc_dma_irq_callback;
|
|
|
|
desc->callback_param = host;
|
|
|
|
} else {
|
|
|
|
if (data)
|
|
|
|
dma_unmap_sg(mmc_dev(host->mmc), data->sg,
|
2012-08-03 23:26:12 +08:00
|
|
|
data->sg_len, ssp->dma_dir);
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return desc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mxs_mmc_bc(struct mxs_mmc_host *host)
|
|
|
|
{
|
2012-08-03 23:26:12 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
struct mmc_command *cmd = host->cmd;
|
|
|
|
struct dma_async_tx_descriptor *desc;
|
|
|
|
u32 ctrl0, cmd0, cmd1;
|
|
|
|
|
|
|
|
ctrl0 = BM_SSP_CTRL0_ENABLE | BM_SSP_CTRL0_IGNORE_CRC;
|
|
|
|
cmd0 = BF_SSP(cmd->opcode, CMD0_CMD) | BM_SSP_CMD0_APPEND_8CYC;
|
|
|
|
cmd1 = cmd->arg;
|
|
|
|
|
|
|
|
if (host->sdio_irq_en) {
|
|
|
|
ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
|
|
|
|
cmd0 |= BM_SSP_CMD0_CONT_CLKING_EN | BM_SSP_CMD0_SLOW_CLKING_EN;
|
|
|
|
}
|
|
|
|
|
2012-08-03 23:26:12 +08:00
|
|
|
ssp->ssp_pio_words[0] = ctrl0;
|
|
|
|
ssp->ssp_pio_words[1] = cmd0;
|
|
|
|
ssp->ssp_pio_words[2] = cmd1;
|
|
|
|
ssp->dma_dir = DMA_NONE;
|
|
|
|
ssp->slave_dirn = DMA_TRANS_NONE;
|
2019-10-18 17:39:34 +08:00
|
|
|
desc = mxs_mmc_prep_dma(host, MXS_DMA_CTRL_WAIT4END);
|
2011-02-21 18:35:28 +08:00
|
|
|
if (!desc)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dmaengine_submit(desc);
|
2012-08-03 23:26:12 +08:00
|
|
|
dma_async_issue_pending(ssp->dmach);
|
2011-02-21 18:35:28 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
out:
|
|
|
|
dev_warn(mmc_dev(host->mmc),
|
|
|
|
"%s: failed to prep dma\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mxs_mmc_ac(struct mxs_mmc_host *host)
|
|
|
|
{
|
2012-08-03 23:26:12 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
struct mmc_command *cmd = host->cmd;
|
|
|
|
struct dma_async_tx_descriptor *desc;
|
|
|
|
u32 ignore_crc, get_resp, long_resp;
|
|
|
|
u32 ctrl0, cmd0, cmd1;
|
|
|
|
|
|
|
|
ignore_crc = (mmc_resp_type(cmd) & MMC_RSP_CRC) ?
|
|
|
|
0 : BM_SSP_CTRL0_IGNORE_CRC;
|
|
|
|
get_resp = (mmc_resp_type(cmd) & MMC_RSP_PRESENT) ?
|
|
|
|
BM_SSP_CTRL0_GET_RESP : 0;
|
|
|
|
long_resp = (mmc_resp_type(cmd) & MMC_RSP_136) ?
|
|
|
|
BM_SSP_CTRL0_LONG_RESP : 0;
|
|
|
|
|
|
|
|
ctrl0 = BM_SSP_CTRL0_ENABLE | ignore_crc | get_resp | long_resp;
|
|
|
|
cmd0 = BF_SSP(cmd->opcode, CMD0_CMD);
|
|
|
|
cmd1 = cmd->arg;
|
|
|
|
|
2017-01-06 03:24:04 +08:00
|
|
|
if (cmd->opcode == MMC_STOP_TRANSMISSION)
|
|
|
|
cmd0 |= BM_SSP_CMD0_APPEND_8CYC;
|
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
if (host->sdio_irq_en) {
|
|
|
|
ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
|
|
|
|
cmd0 |= BM_SSP_CMD0_CONT_CLKING_EN | BM_SSP_CMD0_SLOW_CLKING_EN;
|
|
|
|
}
|
|
|
|
|
2012-08-03 23:26:12 +08:00
|
|
|
ssp->ssp_pio_words[0] = ctrl0;
|
|
|
|
ssp->ssp_pio_words[1] = cmd0;
|
|
|
|
ssp->ssp_pio_words[2] = cmd1;
|
|
|
|
ssp->dma_dir = DMA_NONE;
|
|
|
|
ssp->slave_dirn = DMA_TRANS_NONE;
|
2019-10-18 17:39:34 +08:00
|
|
|
desc = mxs_mmc_prep_dma(host, MXS_DMA_CTRL_WAIT4END);
|
2011-02-21 18:35:28 +08:00
|
|
|
if (!desc)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dmaengine_submit(desc);
|
2012-08-03 23:26:12 +08:00
|
|
|
dma_async_issue_pending(ssp->dmach);
|
2011-02-21 18:35:28 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
out:
|
|
|
|
dev_warn(mmc_dev(host->mmc),
|
|
|
|
"%s: failed to prep dma\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned short mxs_ns_to_ssp_ticks(unsigned clock_rate, unsigned ns)
|
|
|
|
{
|
|
|
|
const unsigned int ssp_timeout_mul = 4096;
|
|
|
|
/*
|
|
|
|
* Calculate ticks in ms since ns are large numbers
|
|
|
|
* and might overflow
|
|
|
|
*/
|
|
|
|
const unsigned int clock_per_ms = clock_rate / 1000;
|
|
|
|
const unsigned int ms = ns / 1000;
|
|
|
|
const unsigned int ticks = ms * clock_per_ms;
|
|
|
|
const unsigned int ssp_ticks = ticks / ssp_timeout_mul;
|
|
|
|
|
|
|
|
WARN_ON(ssp_ticks == 0);
|
|
|
|
return ssp_ticks;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mxs_mmc_adtc(struct mxs_mmc_host *host)
|
|
|
|
{
|
|
|
|
struct mmc_command *cmd = host->cmd;
|
|
|
|
struct mmc_data *data = cmd->data;
|
|
|
|
struct dma_async_tx_descriptor *desc;
|
|
|
|
struct scatterlist *sgl = data->sg, *sg;
|
|
|
|
unsigned int sg_len = data->sg_len;
|
2013-01-08 08:42:35 +08:00
|
|
|
unsigned int i;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
unsigned short dma_data_dir, timeout;
|
2011-10-14 13:15:11 +08:00
|
|
|
enum dma_transfer_direction slave_dirn;
|
2011-02-21 18:35:28 +08:00
|
|
|
unsigned int data_size = 0, log2_blksz;
|
|
|
|
unsigned int blocks = data->blocks;
|
|
|
|
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
u32 ignore_crc, get_resp, long_resp, read;
|
|
|
|
u32 ctrl0, cmd0, cmd1, val;
|
|
|
|
|
|
|
|
ignore_crc = (mmc_resp_type(cmd) & MMC_RSP_CRC) ?
|
|
|
|
0 : BM_SSP_CTRL0_IGNORE_CRC;
|
|
|
|
get_resp = (mmc_resp_type(cmd) & MMC_RSP_PRESENT) ?
|
|
|
|
BM_SSP_CTRL0_GET_RESP : 0;
|
|
|
|
long_resp = (mmc_resp_type(cmd) & MMC_RSP_136) ?
|
|
|
|
BM_SSP_CTRL0_LONG_RESP : 0;
|
|
|
|
|
|
|
|
if (data->flags & MMC_DATA_WRITE) {
|
|
|
|
dma_data_dir = DMA_TO_DEVICE;
|
2011-10-14 13:15:11 +08:00
|
|
|
slave_dirn = DMA_MEM_TO_DEV;
|
2011-02-21 18:35:28 +08:00
|
|
|
read = 0;
|
|
|
|
} else {
|
|
|
|
dma_data_dir = DMA_FROM_DEVICE;
|
2011-10-14 13:15:11 +08:00
|
|
|
slave_dirn = DMA_DEV_TO_MEM;
|
2011-02-21 18:35:28 +08:00
|
|
|
read = BM_SSP_CTRL0_READ;
|
|
|
|
}
|
|
|
|
|
|
|
|
ctrl0 = BF_SSP(host->bus_width, CTRL0_BUS_WIDTH) |
|
|
|
|
ignore_crc | get_resp | long_resp |
|
|
|
|
BM_SSP_CTRL0_DATA_XFER | read |
|
|
|
|
BM_SSP_CTRL0_WAIT_FOR_IRQ |
|
|
|
|
BM_SSP_CTRL0_ENABLE;
|
|
|
|
|
|
|
|
cmd0 = BF_SSP(cmd->opcode, CMD0_CMD);
|
|
|
|
|
|
|
|
/* get logarithm to base 2 of block size for setting register */
|
|
|
|
log2_blksz = ilog2(data->blksz);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* take special care of the case that data size from data->sg
|
|
|
|
* is not equal to blocks x blksz
|
|
|
|
*/
|
|
|
|
for_each_sg(sgl, sg, sg_len, i)
|
|
|
|
data_size += sg->length;
|
|
|
|
|
|
|
|
if (data_size != data->blocks * data->blksz)
|
|
|
|
blocks = 1;
|
|
|
|
|
|
|
|
/* xfer count, block size and count need to be set differently */
|
2012-08-03 23:26:09 +08:00
|
|
|
if (ssp_is_old(ssp)) {
|
2011-02-21 18:35:28 +08:00
|
|
|
ctrl0 |= BF_SSP(data_size, CTRL0_XFER_COUNT);
|
|
|
|
cmd0 |= BF_SSP(log2_blksz, CMD0_BLOCK_SIZE) |
|
|
|
|
BF_SSP(blocks - 1, CMD0_BLOCK_COUNT);
|
|
|
|
} else {
|
2012-08-03 23:26:09 +08:00
|
|
|
writel(data_size, ssp->base + HW_SSP_XFER_SIZE);
|
2011-02-21 18:35:28 +08:00
|
|
|
writel(BF_SSP(log2_blksz, BLOCK_SIZE_BLOCK_SIZE) |
|
|
|
|
BF_SSP(blocks - 1, BLOCK_SIZE_BLOCK_COUNT),
|
2012-08-03 23:26:09 +08:00
|
|
|
ssp->base + HW_SSP_BLOCK_SIZE);
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
2017-01-06 03:24:04 +08:00
|
|
|
if (cmd->opcode == SD_IO_RW_EXTENDED)
|
2011-02-21 18:35:28 +08:00
|
|
|
cmd0 |= BM_SSP_CMD0_APPEND_8CYC;
|
|
|
|
|
|
|
|
cmd1 = cmd->arg;
|
|
|
|
|
|
|
|
if (host->sdio_irq_en) {
|
|
|
|
ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
|
|
|
|
cmd0 |= BM_SSP_CMD0_CONT_CLKING_EN | BM_SSP_CMD0_SLOW_CLKING_EN;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set the timeout count */
|
2012-08-03 23:26:09 +08:00
|
|
|
timeout = mxs_ns_to_ssp_ticks(ssp->clk_rate, data->timeout_ns);
|
|
|
|
val = readl(ssp->base + HW_SSP_TIMING(ssp));
|
2011-02-21 18:35:28 +08:00
|
|
|
val &= ~(BM_SSP_TIMING_TIMEOUT);
|
|
|
|
val |= BF_SSP(timeout, TIMING_TIMEOUT);
|
2012-08-03 23:26:09 +08:00
|
|
|
writel(val, ssp->base + HW_SSP_TIMING(ssp));
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
/* pio */
|
2012-08-03 23:26:12 +08:00
|
|
|
ssp->ssp_pio_words[0] = ctrl0;
|
|
|
|
ssp->ssp_pio_words[1] = cmd0;
|
|
|
|
ssp->ssp_pio_words[2] = cmd1;
|
|
|
|
ssp->dma_dir = DMA_NONE;
|
|
|
|
ssp->slave_dirn = DMA_TRANS_NONE;
|
2011-02-21 18:35:28 +08:00
|
|
|
desc = mxs_mmc_prep_dma(host, 0);
|
|
|
|
if (!desc)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* append data sg */
|
|
|
|
WARN_ON(host->data != NULL);
|
|
|
|
host->data = data;
|
2012-08-03 23:26:12 +08:00
|
|
|
ssp->dma_dir = dma_data_dir;
|
|
|
|
ssp->slave_dirn = slave_dirn;
|
2019-10-18 17:39:34 +08:00
|
|
|
desc = mxs_mmc_prep_dma(host, DMA_PREP_INTERRUPT | MXS_DMA_CTRL_WAIT4END);
|
2011-02-21 18:35:28 +08:00
|
|
|
if (!desc)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dmaengine_submit(desc);
|
2012-08-03 23:26:12 +08:00
|
|
|
dma_async_issue_pending(ssp->dmach);
|
2011-02-21 18:35:28 +08:00
|
|
|
return;
|
|
|
|
out:
|
|
|
|
dev_warn(mmc_dev(host->mmc),
|
|
|
|
"%s: failed to prep dma\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mxs_mmc_start_cmd(struct mxs_mmc_host *host,
|
|
|
|
struct mmc_command *cmd)
|
|
|
|
{
|
|
|
|
host->cmd = cmd;
|
|
|
|
|
|
|
|
switch (mmc_cmd_type(cmd)) {
|
|
|
|
case MMC_CMD_BC:
|
|
|
|
mxs_mmc_bc(host);
|
|
|
|
break;
|
|
|
|
case MMC_CMD_BCR:
|
|
|
|
mxs_mmc_ac(host);
|
|
|
|
break;
|
|
|
|
case MMC_CMD_AC:
|
|
|
|
mxs_mmc_ac(host);
|
|
|
|
break;
|
|
|
|
case MMC_CMD_ADTC:
|
|
|
|
mxs_mmc_adtc(host);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_warn(mmc_dev(host->mmc),
|
|
|
|
"%s: unknown MMC command\n", __func__);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mxs_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
|
|
|
|
{
|
|
|
|
struct mxs_mmc_host *host = mmc_priv(mmc);
|
|
|
|
|
|
|
|
WARN_ON(host->mrq != NULL);
|
|
|
|
host->mrq = mrq;
|
2017-01-15 01:29:18 +08:00
|
|
|
|
|
|
|
if (mrq->sbc)
|
|
|
|
mxs_mmc_start_cmd(host, mrq->sbc);
|
|
|
|
else
|
|
|
|
mxs_mmc_start_cmd(host, mrq->cmd);
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mxs_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
|
|
|
|
{
|
|
|
|
struct mxs_mmc_host *host = mmc_priv(mmc);
|
|
|
|
|
|
|
|
if (ios->bus_width == MMC_BUS_WIDTH_8)
|
|
|
|
host->bus_width = 2;
|
|
|
|
else if (ios->bus_width == MMC_BUS_WIDTH_4)
|
|
|
|
host->bus_width = 1;
|
|
|
|
else
|
|
|
|
host->bus_width = 0;
|
|
|
|
|
|
|
|
if (ios->clock)
|
2012-08-03 23:26:10 +08:00
|
|
|
mxs_ssp_set_clk_rate(&host->ssp, ios->clock);
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mxs_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
|
|
|
|
{
|
|
|
|
struct mxs_mmc_host *host = mmc_priv(mmc);
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
|
|
|
|
|
|
|
host->sdio_irq_en = enable;
|
|
|
|
|
|
|
|
if (enable) {
|
|
|
|
writel(BM_SSP_CTRL0_SDIO_IRQ_CHECK,
|
2012-08-03 23:26:09 +08:00
|
|
|
ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
|
2011-02-21 18:35:28 +08:00
|
|
|
writel(BM_SSP_CTRL1_SDIO_IRQ_EN,
|
2012-10-02 04:52:43 +08:00
|
|
|
ssp->base + HW_SSP_CTRL1(ssp) + STMP_OFFSET_REG_SET);
|
2011-02-21 18:35:28 +08:00
|
|
|
} else {
|
|
|
|
writel(BM_SSP_CTRL0_SDIO_IRQ_CHECK,
|
2012-08-03 23:26:09 +08:00
|
|
|
ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);
|
2011-02-21 18:35:28 +08:00
|
|
|
writel(BM_SSP_CTRL1_SDIO_IRQ_EN,
|
2012-08-03 23:26:09 +08:00
|
|
|
ssp->base + HW_SSP_CTRL1(ssp) + STMP_OFFSET_REG_CLR);
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
2012-07-17 22:16:10 +08:00
|
|
|
|
2012-09-25 20:41:02 +08:00
|
|
|
if (enable && readl(ssp->base + HW_SSP_STATUS(ssp)) &
|
2012-07-17 22:16:10 +08:00
|
|
|
BM_SSP_STATUS_SDIO_IRQ)
|
|
|
|
mmc_signal_sdio_irq(host->mmc);
|
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct mmc_host_ops mxs_mmc_ops = {
|
|
|
|
.request = mxs_mmc_request,
|
2013-12-05 21:34:50 +08:00
|
|
|
.get_ro = mmc_gpio_get_ro,
|
2011-02-21 18:35:28 +08:00
|
|
|
.get_cd = mxs_mmc_get_cd,
|
|
|
|
.set_ios = mxs_mmc_set_ios,
|
|
|
|
.enable_sdio_irq = mxs_mmc_enable_sdio_irq,
|
|
|
|
};
|
|
|
|
|
2015-05-01 23:49:18 +08:00
|
|
|
static const struct platform_device_id mxs_ssp_ids[] = {
|
2012-05-05 20:24:01 +08:00
|
|
|
{
|
|
|
|
.name = "imx23-mmc",
|
2012-08-03 23:26:07 +08:00
|
|
|
.driver_data = IMX23_SSP,
|
2012-05-05 20:24:01 +08:00
|
|
|
}, {
|
|
|
|
.name = "imx28-mmc",
|
2012-08-03 23:26:07 +08:00
|
|
|
.driver_data = IMX28_SSP,
|
2012-05-05 20:24:01 +08:00
|
|
|
}, {
|
|
|
|
/* sentinel */
|
|
|
|
}
|
|
|
|
};
|
2012-08-03 23:26:07 +08:00
|
|
|
MODULE_DEVICE_TABLE(platform, mxs_ssp_ids);
|
2012-05-05 20:24:01 +08:00
|
|
|
|
2012-05-06 13:30:44 +08:00
|
|
|
static const struct of_device_id mxs_mmc_dt_ids[] = {
|
2012-08-03 23:26:07 +08:00
|
|
|
{ .compatible = "fsl,imx23-mmc", .data = (void *) IMX23_SSP, },
|
|
|
|
{ .compatible = "fsl,imx28-mmc", .data = (void *) IMX28_SSP, },
|
2012-05-06 13:30:44 +08:00
|
|
|
{ /* sentinel */ }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, mxs_mmc_dt_ids);
|
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
static int mxs_mmc_probe(struct platform_device *pdev)
|
|
|
|
{
|
2012-05-06 13:30:44 +08:00
|
|
|
const struct of_device_id *of_id =
|
|
|
|
of_match_device(mxs_mmc_dt_ids, &pdev->dev);
|
2014-04-20 05:59:18 +08:00
|
|
|
struct device_node *np = pdev->dev.of_node;
|
2011-02-21 18:35:28 +08:00
|
|
|
struct mxs_mmc_host *host;
|
|
|
|
struct mmc_host *mmc;
|
2013-12-05 21:34:51 +08:00
|
|
|
int ret = 0, irq_err;
|
2012-06-26 16:38:57 +08:00
|
|
|
struct regulator *reg_vmmc;
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
irq_err = platform_get_irq(pdev, 0);
|
2014-11-19 21:16:57 +08:00
|
|
|
if (irq_err < 0)
|
2014-11-19 21:16:58 +08:00
|
|
|
return irq_err;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
mmc = mmc_alloc_host(sizeof(struct mxs_mmc_host), &pdev->dev);
|
2012-05-06 11:20:40 +08:00
|
|
|
if (!mmc)
|
|
|
|
return -ENOMEM;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
host = mmc_priv(mmc);
|
2012-08-03 23:26:09 +08:00
|
|
|
ssp = &host->ssp;
|
|
|
|
ssp->dev = &pdev->dev;
|
2019-07-17 16:52:59 +08:00
|
|
|
ssp->base = devm_platform_ioremap_resource(pdev, 0);
|
2013-01-21 18:09:11 +08:00
|
|
|
if (IS_ERR(ssp->base)) {
|
|
|
|
ret = PTR_ERR(ssp->base);
|
2011-02-21 18:35:28 +08:00
|
|
|
goto out_mmc_free;
|
|
|
|
}
|
|
|
|
|
2013-02-26 10:10:38 +08:00
|
|
|
ssp->devid = (enum mxs_ssp_id) of_id->data;
|
2012-05-06 13:30:44 +08:00
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
host->mmc = mmc;
|
|
|
|
host->sdio_irq_en = 0;
|
|
|
|
|
2012-06-26 16:38:57 +08:00
|
|
|
reg_vmmc = devm_regulator_get(&pdev->dev, "vmmc");
|
|
|
|
if (!IS_ERR(reg_vmmc)) {
|
|
|
|
ret = regulator_enable(reg_vmmc);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&pdev->dev,
|
|
|
|
"Failed to enable vmmc regulator: %d\n", ret);
|
|
|
|
goto out_mmc_free;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-04 04:02:37 +08:00
|
|
|
ssp->clk = devm_clk_get(&pdev->dev, NULL);
|
2012-08-03 23:26:09 +08:00
|
|
|
if (IS_ERR(ssp->clk)) {
|
|
|
|
ret = PTR_ERR(ssp->clk);
|
2012-05-06 11:20:40 +08:00
|
|
|
goto out_mmc_free;
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
2014-11-19 21:16:59 +08:00
|
|
|
ret = clk_prepare_enable(ssp->clk);
|
|
|
|
if (ret)
|
|
|
|
goto out_mmc_free;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
2013-07-04 04:02:38 +08:00
|
|
|
ret = mxs_mmc_reset(host);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&pdev->dev, "Failed to reset mmc: %d\n", ret);
|
|
|
|
goto out_clk_disable;
|
|
|
|
}
|
2011-02-21 18:35:28 +08:00
|
|
|
|
2019-12-17 19:28:47 +08:00
|
|
|
ssp->dmach = dma_request_chan(&pdev->dev, "rx-tx");
|
|
|
|
if (IS_ERR(ssp->dmach)) {
|
2011-02-21 18:35:28 +08:00
|
|
|
dev_err(mmc_dev(host->mmc),
|
|
|
|
"%s: failed to request dma\n", __func__);
|
2019-12-17 19:28:47 +08:00
|
|
|
ret = PTR_ERR(ssp->dmach);
|
2013-07-04 04:02:37 +08:00
|
|
|
goto out_clk_disable;
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* set mmc core parameters */
|
|
|
|
mmc->ops = &mxs_mmc_ops;
|
|
|
|
mmc->caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED |
|
2020-05-08 19:29:02 +08:00
|
|
|
MMC_CAP_SDIO_IRQ | MMC_CAP_NEEDS_POLL | MMC_CAP_CMD23;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
2014-04-20 05:59:18 +08:00
|
|
|
host->broken_cd = of_property_read_bool(np, "broken-cd");
|
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
mmc->f_min = 400000;
|
|
|
|
mmc->f_max = 288000000;
|
2013-12-05 21:34:51 +08:00
|
|
|
|
|
|
|
ret = mmc_of_parse(mmc);
|
|
|
|
if (ret)
|
|
|
|
goto out_clk_disable;
|
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
|
|
|
|
|
|
|
|
mmc->max_segs = 52;
|
|
|
|
mmc->max_blk_size = 1 << 0xf;
|
2012-08-03 23:26:09 +08:00
|
|
|
mmc->max_blk_count = (ssp_is_old(ssp)) ? 0xff : 0xffffff;
|
|
|
|
mmc->max_req_size = (ssp_is_old(ssp)) ? 0xffff : 0xffffffff;
|
2012-08-03 23:26:12 +08:00
|
|
|
mmc->max_seg_size = dma_get_max_seg_size(ssp->dmach->device->dev);
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
platform_set_drvdata(pdev, mmc);
|
|
|
|
|
2016-11-06 03:45:07 +08:00
|
|
|
spin_lock_init(&host->lock);
|
|
|
|
|
2012-05-06 11:20:40 +08:00
|
|
|
ret = devm_request_irq(&pdev->dev, irq_err, mxs_mmc_irq_handler, 0,
|
2014-11-18 10:37:12 +08:00
|
|
|
dev_name(&pdev->dev), host);
|
2011-02-21 18:35:28 +08:00
|
|
|
if (ret)
|
|
|
|
goto out_free_dma;
|
|
|
|
|
|
|
|
ret = mmc_add_host(mmc);
|
|
|
|
if (ret)
|
2012-05-06 11:20:40 +08:00
|
|
|
goto out_free_dma;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
dev_info(mmc_dev(host->mmc), "initialized\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_free_dma:
|
2014-12-17 07:57:50 +08:00
|
|
|
dma_release_channel(ssp->dmach);
|
2013-07-04 04:02:37 +08:00
|
|
|
out_clk_disable:
|
2012-08-03 23:26:09 +08:00
|
|
|
clk_disable_unprepare(ssp->clk);
|
2011-02-21 18:35:28 +08:00
|
|
|
out_mmc_free:
|
|
|
|
mmc_free_host(mmc);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mxs_mmc_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct mmc_host *mmc = platform_get_drvdata(pdev);
|
|
|
|
struct mxs_mmc_host *host = mmc_priv(mmc);
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
mmc_remove_host(mmc);
|
|
|
|
|
2012-08-03 23:26:12 +08:00
|
|
|
if (ssp->dmach)
|
|
|
|
dma_release_channel(ssp->dmach);
|
2011-02-21 18:35:28 +08:00
|
|
|
|
2012-08-03 23:26:09 +08:00
|
|
|
clk_disable_unprepare(ssp->clk);
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
mmc_free_host(mmc);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-18 10:43:39 +08:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2011-02-21 18:35:28 +08:00
|
|
|
static int mxs_mmc_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct mmc_host *mmc = dev_get_drvdata(dev);
|
|
|
|
struct mxs_mmc_host *host = mmc_priv(mmc);
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
2012-08-03 23:26:09 +08:00
|
|
|
clk_disable_unprepare(ssp->clk);
|
2013-09-25 21:21:53 +08:00
|
|
|
return 0;
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mxs_mmc_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct mmc_host *mmc = dev_get_drvdata(dev);
|
|
|
|
struct mxs_mmc_host *host = mmc_priv(mmc);
|
2012-08-03 23:26:09 +08:00
|
|
|
struct mxs_ssp *ssp = &host->ssp;
|
2011-02-21 18:35:28 +08:00
|
|
|
|
2014-11-19 21:16:59 +08:00
|
|
|
return clk_prepare_enable(ssp->clk);
|
2011-02-21 18:35:28 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-11-18 10:43:39 +08:00
|
|
|
static SIMPLE_DEV_PM_OPS(mxs_mmc_pm_ops, mxs_mmc_suspend, mxs_mmc_resume);
|
|
|
|
|
2011-02-21 18:35:28 +08:00
|
|
|
static struct platform_driver mxs_mmc_driver = {
|
|
|
|
.probe = mxs_mmc_probe,
|
|
|
|
.remove = mxs_mmc_remove,
|
2012-08-03 23:26:07 +08:00
|
|
|
.id_table = mxs_ssp_ids,
|
2011-02-21 18:35:28 +08:00
|
|
|
.driver = {
|
|
|
|
.name = DRIVER_NAME,
|
|
|
|
.pm = &mxs_mmc_pm_ops,
|
2012-05-21 12:33:27 +08:00
|
|
|
.of_match_table = mxs_mmc_dt_ids,
|
2011-02-21 18:35:28 +08:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-11-26 12:55:43 +08:00
|
|
|
module_platform_driver(mxs_mmc_driver);
|
2011-02-21 18:35:28 +08:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("FREESCALE MXS MMC peripheral");
|
|
|
|
MODULE_AUTHOR("Freescale Semiconductor");
|
|
|
|
MODULE_LICENSE("GPL");
|
2013-01-08 06:41:52 +08:00
|
|
|
MODULE_ALIAS("platform:" DRIVER_NAME);
|