mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
30ae3e13ca
Set max_busy_timeouts for variants known to support the TOPxx bits in the SD_OPTION register. The timeout mechanism was running in the background but not yet properly handled in the driver. So, let the MMC core know when to not use R1B to avoid unhandled timeouts. My datasheets for older variants (tmio_mmc.c) suggest that they support it, too. However, actual bit descriptions are lacking, so I chose an opt-in approach. Signed-off-by: Wolfram Sang <wsa+renesas@sang-engineering.com> Reviewed-by: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com> Tested-by: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com> Link: https://lore.kernel.org/r/20201125213001.15003-2-wsa+renesas@sang-engineering.com Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
698 lines
18 KiB
C
698 lines
18 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
//
|
|
// Copyright (C) 2017-2018 Socionext Inc.
|
|
// Author: Masahiro Yamada <yamada.masahiro@socionext.com>
|
|
|
|
#include <linux/bitfield.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <linux/mfd/tmio.h>
|
|
#include <linux/mmc/host.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/pinctrl/consumer.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/reset.h>
|
|
|
|
#include "tmio_mmc.h"
|
|
|
|
#define UNIPHIER_SD_CLK_CTL_DIV1024 BIT(16)
|
|
#define UNIPHIER_SD_CLK_CTL_DIV1 BIT(10)
|
|
#define UNIPHIER_SD_CLKCTL_OFFEN BIT(9) // auto SDCLK stop
|
|
#define UNIPHIER_SD_CC_EXT_MODE 0x1b0
|
|
#define UNIPHIER_SD_CC_EXT_MODE_DMA BIT(1)
|
|
#define UNIPHIER_SD_HOST_MODE 0x1c8
|
|
#define UNIPHIER_SD_VOLT 0x1e4
|
|
#define UNIPHIER_SD_VOLT_MASK GENMASK(1, 0)
|
|
#define UNIPHIER_SD_VOLT_OFF 0
|
|
#define UNIPHIER_SD_VOLT_330 1 // 3.3V signal
|
|
#define UNIPHIER_SD_VOLT_180 2 // 1.8V signal
|
|
#define UNIPHIER_SD_DMA_MODE 0x410
|
|
#define UNIPHIER_SD_DMA_MODE_DIR_MASK GENMASK(17, 16)
|
|
#define UNIPHIER_SD_DMA_MODE_DIR_TO_DEV 0
|
|
#define UNIPHIER_SD_DMA_MODE_DIR_FROM_DEV 1
|
|
#define UNIPHIER_SD_DMA_MODE_WIDTH_MASK GENMASK(5, 4)
|
|
#define UNIPHIER_SD_DMA_MODE_WIDTH_8 0
|
|
#define UNIPHIER_SD_DMA_MODE_WIDTH_16 1
|
|
#define UNIPHIER_SD_DMA_MODE_WIDTH_32 2
|
|
#define UNIPHIER_SD_DMA_MODE_WIDTH_64 3
|
|
#define UNIPHIER_SD_DMA_MODE_ADDR_INC BIT(0) // 1: inc, 0: fixed
|
|
#define UNIPHIER_SD_DMA_CTL 0x414
|
|
#define UNIPHIER_SD_DMA_CTL_START BIT(0) // start DMA (auto cleared)
|
|
#define UNIPHIER_SD_DMA_RST 0x418
|
|
#define UNIPHIER_SD_DMA_RST_CH1 BIT(9)
|
|
#define UNIPHIER_SD_DMA_RST_CH0 BIT(8)
|
|
#define UNIPHIER_SD_DMA_ADDR_L 0x440
|
|
#define UNIPHIER_SD_DMA_ADDR_H 0x444
|
|
|
|
/*
|
|
* IP is extended to support various features: built-in DMA engine,
|
|
* 1/1024 divisor, etc.
|
|
*/
|
|
#define UNIPHIER_SD_CAP_EXTENDED_IP BIT(0)
|
|
/* RX channel of the built-in DMA controller is broken (Pro5) */
|
|
#define UNIPHIER_SD_CAP_BROKEN_DMA_RX BIT(1)
|
|
|
|
struct uniphier_sd_priv {
|
|
struct tmio_mmc_data tmio_data;
|
|
struct pinctrl *pinctrl;
|
|
struct pinctrl_state *pinstate_uhs;
|
|
struct clk *clk;
|
|
struct reset_control *rst;
|
|
struct reset_control *rst_br;
|
|
struct reset_control *rst_hw;
|
|
struct dma_chan *chan;
|
|
enum dma_data_direction dma_dir;
|
|
unsigned long clk_rate;
|
|
unsigned long caps;
|
|
};
|
|
|
|
static void *uniphier_sd_priv(struct tmio_mmc_host *host)
|
|
{
|
|
return container_of(host->pdata, struct uniphier_sd_priv, tmio_data);
|
|
}
|
|
|
|
static void uniphier_sd_dma_endisable(struct tmio_mmc_host *host, int enable)
|
|
{
|
|
sd_ctrl_write16(host, CTL_DMA_ENABLE, enable ? DMA_ENABLE_DMASDRW : 0);
|
|
}
|
|
|
|
/* external DMA engine */
|
|
static void uniphier_sd_external_dma_issue(unsigned long arg)
|
|
{
|
|
struct tmio_mmc_host *host = (void *)arg;
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
|
|
uniphier_sd_dma_endisable(host, 1);
|
|
dma_async_issue_pending(priv->chan);
|
|
}
|
|
|
|
static void uniphier_sd_external_dma_callback(void *param,
|
|
const struct dmaengine_result *result)
|
|
{
|
|
struct tmio_mmc_host *host = param;
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
unsigned long flags;
|
|
|
|
dma_unmap_sg(mmc_dev(host->mmc), host->sg_ptr, host->sg_len,
|
|
priv->dma_dir);
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
|
|
|
if (result->result == DMA_TRANS_NOERROR) {
|
|
/*
|
|
* When the external DMA engine is enabled, strangely enough,
|
|
* the DATAEND flag can be asserted even if the DMA engine has
|
|
* not been kicked yet. Enable the TMIO_STAT_DATAEND irq only
|
|
* after we make sure the DMA engine finishes the transfer,
|
|
* hence, in this callback.
|
|
*/
|
|
tmio_mmc_enable_mmc_irqs(host, TMIO_STAT_DATAEND);
|
|
} else {
|
|
host->data->error = -ETIMEDOUT;
|
|
tmio_mmc_do_data_irq(host);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
}
|
|
|
|
static void uniphier_sd_external_dma_start(struct tmio_mmc_host *host,
|
|
struct mmc_data *data)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
enum dma_transfer_direction dma_tx_dir;
|
|
struct dma_async_tx_descriptor *desc;
|
|
dma_cookie_t cookie;
|
|
int sg_len;
|
|
|
|
if (!priv->chan)
|
|
goto force_pio;
|
|
|
|
if (data->flags & MMC_DATA_READ) {
|
|
priv->dma_dir = DMA_FROM_DEVICE;
|
|
dma_tx_dir = DMA_DEV_TO_MEM;
|
|
} else {
|
|
priv->dma_dir = DMA_TO_DEVICE;
|
|
dma_tx_dir = DMA_MEM_TO_DEV;
|
|
}
|
|
|
|
sg_len = dma_map_sg(mmc_dev(host->mmc), host->sg_ptr, host->sg_len,
|
|
priv->dma_dir);
|
|
if (sg_len == 0)
|
|
goto force_pio;
|
|
|
|
desc = dmaengine_prep_slave_sg(priv->chan, host->sg_ptr, sg_len,
|
|
dma_tx_dir, DMA_CTRL_ACK);
|
|
if (!desc)
|
|
goto unmap_sg;
|
|
|
|
desc->callback_result = uniphier_sd_external_dma_callback;
|
|
desc->callback_param = host;
|
|
|
|
cookie = dmaengine_submit(desc);
|
|
if (cookie < 0)
|
|
goto unmap_sg;
|
|
|
|
host->dma_on = true;
|
|
|
|
return;
|
|
|
|
unmap_sg:
|
|
dma_unmap_sg(mmc_dev(host->mmc), host->sg_ptr, host->sg_len,
|
|
priv->dma_dir);
|
|
force_pio:
|
|
uniphier_sd_dma_endisable(host, 0);
|
|
}
|
|
|
|
static void uniphier_sd_external_dma_enable(struct tmio_mmc_host *host,
|
|
bool enable)
|
|
{
|
|
}
|
|
|
|
static void uniphier_sd_external_dma_request(struct tmio_mmc_host *host,
|
|
struct tmio_mmc_data *pdata)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
struct dma_chan *chan;
|
|
|
|
chan = dma_request_chan(mmc_dev(host->mmc), "rx-tx");
|
|
if (IS_ERR(chan)) {
|
|
dev_warn(mmc_dev(host->mmc),
|
|
"failed to request DMA channel. falling back to PIO\n");
|
|
return; /* just use PIO even for -EPROBE_DEFER */
|
|
}
|
|
|
|
/* this driver uses a single channel for both RX an TX */
|
|
priv->chan = chan;
|
|
host->chan_rx = chan;
|
|
host->chan_tx = chan;
|
|
|
|
tasklet_init(&host->dma_issue, uniphier_sd_external_dma_issue,
|
|
(unsigned long)host);
|
|
}
|
|
|
|
static void uniphier_sd_external_dma_release(struct tmio_mmc_host *host)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
|
|
if (priv->chan)
|
|
dma_release_channel(priv->chan);
|
|
}
|
|
|
|
static void uniphier_sd_external_dma_abort(struct tmio_mmc_host *host)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
|
|
uniphier_sd_dma_endisable(host, 0);
|
|
|
|
if (priv->chan)
|
|
dmaengine_terminate_sync(priv->chan);
|
|
}
|
|
|
|
static void uniphier_sd_external_dma_dataend(struct tmio_mmc_host *host)
|
|
{
|
|
uniphier_sd_dma_endisable(host, 0);
|
|
|
|
tmio_mmc_do_data_irq(host);
|
|
}
|
|
|
|
static const struct tmio_mmc_dma_ops uniphier_sd_external_dma_ops = {
|
|
.start = uniphier_sd_external_dma_start,
|
|
.enable = uniphier_sd_external_dma_enable,
|
|
.request = uniphier_sd_external_dma_request,
|
|
.release = uniphier_sd_external_dma_release,
|
|
.abort = uniphier_sd_external_dma_abort,
|
|
.dataend = uniphier_sd_external_dma_dataend,
|
|
};
|
|
|
|
static void uniphier_sd_internal_dma_issue(unsigned long arg)
|
|
{
|
|
struct tmio_mmc_host *host = (void *)arg;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
|
tmio_mmc_enable_mmc_irqs(host, TMIO_STAT_DATAEND);
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
uniphier_sd_dma_endisable(host, 1);
|
|
writel(UNIPHIER_SD_DMA_CTL_START, host->ctl + UNIPHIER_SD_DMA_CTL);
|
|
}
|
|
|
|
static void uniphier_sd_internal_dma_start(struct tmio_mmc_host *host,
|
|
struct mmc_data *data)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
struct scatterlist *sg = host->sg_ptr;
|
|
dma_addr_t dma_addr;
|
|
unsigned int dma_mode_dir;
|
|
u32 dma_mode;
|
|
int sg_len;
|
|
|
|
if ((data->flags & MMC_DATA_READ) && !host->chan_rx)
|
|
goto force_pio;
|
|
|
|
if (WARN_ON(host->sg_len != 1))
|
|
goto force_pio;
|
|
|
|
if (!IS_ALIGNED(sg->offset, 8))
|
|
goto force_pio;
|
|
|
|
if (data->flags & MMC_DATA_READ) {
|
|
priv->dma_dir = DMA_FROM_DEVICE;
|
|
dma_mode_dir = UNIPHIER_SD_DMA_MODE_DIR_FROM_DEV;
|
|
} else {
|
|
priv->dma_dir = DMA_TO_DEVICE;
|
|
dma_mode_dir = UNIPHIER_SD_DMA_MODE_DIR_TO_DEV;
|
|
}
|
|
|
|
sg_len = dma_map_sg(mmc_dev(host->mmc), sg, 1, priv->dma_dir);
|
|
if (sg_len == 0)
|
|
goto force_pio;
|
|
|
|
dma_mode = FIELD_PREP(UNIPHIER_SD_DMA_MODE_DIR_MASK, dma_mode_dir);
|
|
dma_mode |= FIELD_PREP(UNIPHIER_SD_DMA_MODE_WIDTH_MASK,
|
|
UNIPHIER_SD_DMA_MODE_WIDTH_64);
|
|
dma_mode |= UNIPHIER_SD_DMA_MODE_ADDR_INC;
|
|
|
|
writel(dma_mode, host->ctl + UNIPHIER_SD_DMA_MODE);
|
|
|
|
dma_addr = sg_dma_address(data->sg);
|
|
writel(lower_32_bits(dma_addr), host->ctl + UNIPHIER_SD_DMA_ADDR_L);
|
|
writel(upper_32_bits(dma_addr), host->ctl + UNIPHIER_SD_DMA_ADDR_H);
|
|
|
|
host->dma_on = true;
|
|
|
|
return;
|
|
force_pio:
|
|
uniphier_sd_dma_endisable(host, 0);
|
|
}
|
|
|
|
static void uniphier_sd_internal_dma_enable(struct tmio_mmc_host *host,
|
|
bool enable)
|
|
{
|
|
}
|
|
|
|
static void uniphier_sd_internal_dma_request(struct tmio_mmc_host *host,
|
|
struct tmio_mmc_data *pdata)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
|
|
/*
|
|
* Due to a hardware bug, Pro5 cannot use DMA for RX.
|
|
* We can still use DMA for TX, but PIO for RX.
|
|
*/
|
|
if (!(priv->caps & UNIPHIER_SD_CAP_BROKEN_DMA_RX))
|
|
host->chan_rx = (void *)0xdeadbeaf;
|
|
|
|
host->chan_tx = (void *)0xdeadbeaf;
|
|
|
|
tasklet_init(&host->dma_issue, uniphier_sd_internal_dma_issue,
|
|
(unsigned long)host);
|
|
}
|
|
|
|
static void uniphier_sd_internal_dma_release(struct tmio_mmc_host *host)
|
|
{
|
|
/* Each value is set to zero to assume "disabling" each DMA */
|
|
host->chan_rx = NULL;
|
|
host->chan_tx = NULL;
|
|
}
|
|
|
|
static void uniphier_sd_internal_dma_abort(struct tmio_mmc_host *host)
|
|
{
|
|
u32 tmp;
|
|
|
|
uniphier_sd_dma_endisable(host, 0);
|
|
|
|
tmp = readl(host->ctl + UNIPHIER_SD_DMA_RST);
|
|
tmp &= ~(UNIPHIER_SD_DMA_RST_CH1 | UNIPHIER_SD_DMA_RST_CH0);
|
|
writel(tmp, host->ctl + UNIPHIER_SD_DMA_RST);
|
|
|
|
tmp |= UNIPHIER_SD_DMA_RST_CH1 | UNIPHIER_SD_DMA_RST_CH0;
|
|
writel(tmp, host->ctl + UNIPHIER_SD_DMA_RST);
|
|
}
|
|
|
|
static void uniphier_sd_internal_dma_dataend(struct tmio_mmc_host *host)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
|
|
uniphier_sd_dma_endisable(host, 0);
|
|
dma_unmap_sg(mmc_dev(host->mmc), host->sg_ptr, 1, priv->dma_dir);
|
|
|
|
tmio_mmc_do_data_irq(host);
|
|
}
|
|
|
|
static const struct tmio_mmc_dma_ops uniphier_sd_internal_dma_ops = {
|
|
.start = uniphier_sd_internal_dma_start,
|
|
.enable = uniphier_sd_internal_dma_enable,
|
|
.request = uniphier_sd_internal_dma_request,
|
|
.release = uniphier_sd_internal_dma_release,
|
|
.abort = uniphier_sd_internal_dma_abort,
|
|
.dataend = uniphier_sd_internal_dma_dataend,
|
|
};
|
|
|
|
static int uniphier_sd_clk_enable(struct tmio_mmc_host *host)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
struct mmc_host *mmc = host->mmc;
|
|
int ret;
|
|
|
|
ret = clk_prepare_enable(priv->clk);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = clk_set_rate(priv->clk, ULONG_MAX);
|
|
if (ret)
|
|
goto disable_clk;
|
|
|
|
priv->clk_rate = clk_get_rate(priv->clk);
|
|
|
|
/* If max-frequency property is set, use it. */
|
|
if (!mmc->f_max)
|
|
mmc->f_max = priv->clk_rate;
|
|
|
|
/*
|
|
* 1/512 is the finest divisor in the original IP. Newer versions
|
|
* also supports 1/1024 divisor. (UniPhier-specific extension)
|
|
*/
|
|
if (priv->caps & UNIPHIER_SD_CAP_EXTENDED_IP)
|
|
mmc->f_min = priv->clk_rate / 1024;
|
|
else
|
|
mmc->f_min = priv->clk_rate / 512;
|
|
|
|
ret = reset_control_deassert(priv->rst);
|
|
if (ret)
|
|
goto disable_clk;
|
|
|
|
ret = reset_control_deassert(priv->rst_br);
|
|
if (ret)
|
|
goto assert_rst;
|
|
|
|
return 0;
|
|
|
|
assert_rst:
|
|
reset_control_assert(priv->rst);
|
|
disable_clk:
|
|
clk_disable_unprepare(priv->clk);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void uniphier_sd_clk_disable(struct tmio_mmc_host *host)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
|
|
reset_control_assert(priv->rst_br);
|
|
reset_control_assert(priv->rst);
|
|
clk_disable_unprepare(priv->clk);
|
|
}
|
|
|
|
static void uniphier_sd_hw_reset(struct mmc_host *mmc)
|
|
{
|
|
struct tmio_mmc_host *host = mmc_priv(mmc);
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
|
|
reset_control_assert(priv->rst_hw);
|
|
/* For eMMC, minimum is 1us but give it 9us for good measure */
|
|
udelay(9);
|
|
reset_control_deassert(priv->rst_hw);
|
|
/* For eMMC, minimum is 200us but give it 300us for good measure */
|
|
usleep_range(300, 1000);
|
|
}
|
|
|
|
static void uniphier_sd_set_clock(struct tmio_mmc_host *host,
|
|
unsigned int clock)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
unsigned long divisor;
|
|
u32 tmp;
|
|
|
|
tmp = readl(host->ctl + (CTL_SD_CARD_CLK_CTL << 1));
|
|
|
|
/* stop the clock before changing its rate to avoid a glitch signal */
|
|
tmp &= ~CLK_CTL_SCLKEN;
|
|
writel(tmp, host->ctl + (CTL_SD_CARD_CLK_CTL << 1));
|
|
|
|
if (clock == 0)
|
|
return;
|
|
|
|
tmp &= ~UNIPHIER_SD_CLK_CTL_DIV1024;
|
|
tmp &= ~UNIPHIER_SD_CLK_CTL_DIV1;
|
|
tmp &= ~CLK_CTL_DIV_MASK;
|
|
|
|
divisor = priv->clk_rate / clock;
|
|
|
|
/*
|
|
* In the original IP, bit[7:0] represents the divisor.
|
|
* bit7 set: 1/512, ... bit0 set:1/4, all bits clear: 1/2
|
|
*
|
|
* The IP does not define a way to achieve 1/1. For UniPhier variants,
|
|
* bit10 is used for 1/1. Newer versions of UniPhier variants use
|
|
* bit16 for 1/1024.
|
|
*/
|
|
if (divisor <= 1)
|
|
tmp |= UNIPHIER_SD_CLK_CTL_DIV1;
|
|
else if (priv->caps & UNIPHIER_SD_CAP_EXTENDED_IP && divisor > 512)
|
|
tmp |= UNIPHIER_SD_CLK_CTL_DIV1024;
|
|
else
|
|
tmp |= roundup_pow_of_two(divisor) >> 2;
|
|
|
|
writel(tmp, host->ctl + (CTL_SD_CARD_CLK_CTL << 1));
|
|
|
|
tmp |= CLK_CTL_SCLKEN;
|
|
writel(tmp, host->ctl + (CTL_SD_CARD_CLK_CTL << 1));
|
|
}
|
|
|
|
static void uniphier_sd_host_init(struct tmio_mmc_host *host)
|
|
{
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
u32 val;
|
|
|
|
/*
|
|
* Connected to 32bit AXI.
|
|
* This register holds settings for SoC-specific internal bus
|
|
* connection. What is worse, the register spec was changed,
|
|
* breaking the backward compatibility. Write an appropriate
|
|
* value depending on a flag associated with a compatible string.
|
|
*/
|
|
if (priv->caps & UNIPHIER_SD_CAP_EXTENDED_IP)
|
|
val = 0x00000101;
|
|
else
|
|
val = 0x00000000;
|
|
|
|
writel(val, host->ctl + UNIPHIER_SD_HOST_MODE);
|
|
|
|
val = 0;
|
|
/*
|
|
* If supported, the controller can automatically
|
|
* enable/disable the clock line to the card.
|
|
*/
|
|
if (priv->caps & UNIPHIER_SD_CAP_EXTENDED_IP)
|
|
val |= UNIPHIER_SD_CLKCTL_OFFEN;
|
|
|
|
writel(val, host->ctl + (CTL_SD_CARD_CLK_CTL << 1));
|
|
}
|
|
|
|
static int uniphier_sd_start_signal_voltage_switch(struct mmc_host *mmc,
|
|
struct mmc_ios *ios)
|
|
{
|
|
struct tmio_mmc_host *host = mmc_priv(mmc);
|
|
struct uniphier_sd_priv *priv = uniphier_sd_priv(host);
|
|
struct pinctrl_state *pinstate = NULL;
|
|
u32 val, tmp;
|
|
|
|
switch (ios->signal_voltage) {
|
|
case MMC_SIGNAL_VOLTAGE_330:
|
|
val = UNIPHIER_SD_VOLT_330;
|
|
break;
|
|
case MMC_SIGNAL_VOLTAGE_180:
|
|
val = UNIPHIER_SD_VOLT_180;
|
|
pinstate = priv->pinstate_uhs;
|
|
break;
|
|
default:
|
|
return -ENOTSUPP;
|
|
}
|
|
|
|
tmp = readl(host->ctl + UNIPHIER_SD_VOLT);
|
|
tmp &= ~UNIPHIER_SD_VOLT_MASK;
|
|
tmp |= FIELD_PREP(UNIPHIER_SD_VOLT_MASK, val);
|
|
writel(tmp, host->ctl + UNIPHIER_SD_VOLT);
|
|
|
|
if (pinstate)
|
|
pinctrl_select_state(priv->pinctrl, pinstate);
|
|
else
|
|
pinctrl_select_default_state(mmc_dev(mmc));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int uniphier_sd_uhs_init(struct tmio_mmc_host *host,
|
|
struct uniphier_sd_priv *priv)
|
|
{
|
|
priv->pinctrl = devm_pinctrl_get(mmc_dev(host->mmc));
|
|
if (IS_ERR(priv->pinctrl))
|
|
return PTR_ERR(priv->pinctrl);
|
|
|
|
priv->pinstate_uhs = pinctrl_lookup_state(priv->pinctrl, "uhs");
|
|
if (IS_ERR(priv->pinstate_uhs))
|
|
return PTR_ERR(priv->pinstate_uhs);
|
|
|
|
host->ops.start_signal_voltage_switch =
|
|
uniphier_sd_start_signal_voltage_switch;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int uniphier_sd_probe(struct platform_device *pdev)
|
|
{
|
|
struct device *dev = &pdev->dev;
|
|
struct uniphier_sd_priv *priv;
|
|
struct tmio_mmc_data *tmio_data;
|
|
struct tmio_mmc_host *host;
|
|
int irq, ret;
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
if (irq < 0)
|
|
return irq;
|
|
|
|
priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
|
|
if (!priv)
|
|
return -ENOMEM;
|
|
|
|
priv->caps = (unsigned long)of_device_get_match_data(dev);
|
|
|
|
priv->clk = devm_clk_get(dev, NULL);
|
|
if (IS_ERR(priv->clk)) {
|
|
dev_err(dev, "failed to get clock\n");
|
|
return PTR_ERR(priv->clk);
|
|
}
|
|
|
|
priv->rst = devm_reset_control_get_shared(dev, "host");
|
|
if (IS_ERR(priv->rst)) {
|
|
dev_err(dev, "failed to get host reset\n");
|
|
return PTR_ERR(priv->rst);
|
|
}
|
|
|
|
/* old version has one more reset */
|
|
if (!(priv->caps & UNIPHIER_SD_CAP_EXTENDED_IP)) {
|
|
priv->rst_br = devm_reset_control_get_shared(dev, "bridge");
|
|
if (IS_ERR(priv->rst_br)) {
|
|
dev_err(dev, "failed to get bridge reset\n");
|
|
return PTR_ERR(priv->rst_br);
|
|
}
|
|
}
|
|
|
|
tmio_data = &priv->tmio_data;
|
|
tmio_data->flags |= TMIO_MMC_32BIT_DATA_PORT;
|
|
tmio_data->flags |= TMIO_MMC_USE_BUSY_TIMEOUT;
|
|
|
|
host = tmio_mmc_host_alloc(pdev, tmio_data);
|
|
if (IS_ERR(host))
|
|
return PTR_ERR(host);
|
|
|
|
if (host->mmc->caps & MMC_CAP_HW_RESET) {
|
|
priv->rst_hw = devm_reset_control_get_exclusive(dev, "hw");
|
|
if (IS_ERR(priv->rst_hw)) {
|
|
dev_err(dev, "failed to get hw reset\n");
|
|
ret = PTR_ERR(priv->rst_hw);
|
|
goto free_host;
|
|
}
|
|
host->ops.hw_reset = uniphier_sd_hw_reset;
|
|
}
|
|
|
|
if (host->mmc->caps & MMC_CAP_UHS) {
|
|
ret = uniphier_sd_uhs_init(host, priv);
|
|
if (ret) {
|
|
dev_warn(dev,
|
|
"failed to setup UHS (error %d). Disabling UHS.",
|
|
ret);
|
|
host->mmc->caps &= ~MMC_CAP_UHS;
|
|
}
|
|
}
|
|
|
|
if (priv->caps & UNIPHIER_SD_CAP_EXTENDED_IP)
|
|
host->dma_ops = &uniphier_sd_internal_dma_ops;
|
|
else
|
|
host->dma_ops = &uniphier_sd_external_dma_ops;
|
|
|
|
host->bus_shift = 1;
|
|
host->clk_enable = uniphier_sd_clk_enable;
|
|
host->clk_disable = uniphier_sd_clk_disable;
|
|
host->set_clock = uniphier_sd_set_clock;
|
|
|
|
ret = uniphier_sd_clk_enable(host);
|
|
if (ret)
|
|
goto free_host;
|
|
|
|
uniphier_sd_host_init(host);
|
|
|
|
tmio_data->ocr_mask = MMC_VDD_32_33 | MMC_VDD_33_34;
|
|
if (host->mmc->caps & MMC_CAP_UHS)
|
|
tmio_data->ocr_mask |= MMC_VDD_165_195;
|
|
|
|
tmio_data->max_segs = 1;
|
|
tmio_data->max_blk_count = U16_MAX;
|
|
|
|
ret = tmio_mmc_host_probe(host);
|
|
if (ret)
|
|
goto free_host;
|
|
|
|
ret = devm_request_irq(dev, irq, tmio_mmc_irq, IRQF_SHARED,
|
|
dev_name(dev), host);
|
|
if (ret)
|
|
goto remove_host;
|
|
|
|
return 0;
|
|
|
|
remove_host:
|
|
tmio_mmc_host_remove(host);
|
|
free_host:
|
|
tmio_mmc_host_free(host);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int uniphier_sd_remove(struct platform_device *pdev)
|
|
{
|
|
struct tmio_mmc_host *host = platform_get_drvdata(pdev);
|
|
|
|
tmio_mmc_host_remove(host);
|
|
uniphier_sd_clk_disable(host);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct of_device_id uniphier_sd_match[] = {
|
|
{
|
|
.compatible = "socionext,uniphier-sd-v2.91",
|
|
},
|
|
{
|
|
.compatible = "socionext,uniphier-sd-v3.1",
|
|
.data = (void *)(UNIPHIER_SD_CAP_EXTENDED_IP |
|
|
UNIPHIER_SD_CAP_BROKEN_DMA_RX),
|
|
},
|
|
{
|
|
.compatible = "socionext,uniphier-sd-v3.1.1",
|
|
.data = (void *)UNIPHIER_SD_CAP_EXTENDED_IP,
|
|
},
|
|
{ /* sentinel */ }
|
|
};
|
|
MODULE_DEVICE_TABLE(of, uniphier_sd_match);
|
|
|
|
static struct platform_driver uniphier_sd_driver = {
|
|
.probe = uniphier_sd_probe,
|
|
.remove = uniphier_sd_remove,
|
|
.driver = {
|
|
.name = "uniphier-sd",
|
|
.probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
.of_match_table = uniphier_sd_match,
|
|
},
|
|
};
|
|
module_platform_driver(uniphier_sd_driver);
|
|
|
|
MODULE_AUTHOR("Masahiro Yamada <yamada.masahiro@socionext.com>");
|
|
MODULE_DESCRIPTION("UniPhier SD/eMMC host controller driver");
|
|
MODULE_LICENSE("GPL v2");
|