2018-05-06 21:58:06 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2014-05-05 13:42:31 +00:00
|
|
|
/*
|
|
|
|
* (C) Copyright 2007-2011
|
|
|
|
* Allwinner Technology Co., Ltd. <www.allwinnertech.com>
|
|
|
|
* Aaron <leafy.myeh@allwinnertech.com>
|
|
|
|
*
|
|
|
|
* MMC driver for allwinner sunxi platform.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <common.h>
|
2017-07-04 19:31:27 +00:00
|
|
|
#include <dm.h>
|
2015-04-22 15:03:17 +00:00
|
|
|
#include <errno.h>
|
2020-05-10 17:40:05 +00:00
|
|
|
#include <log.h>
|
2014-05-05 13:42:31 +00:00
|
|
|
#include <malloc.h>
|
|
|
|
#include <mmc.h>
|
2019-01-29 15:54:13 +00:00
|
|
|
#include <clk.h>
|
|
|
|
#include <reset.h>
|
2021-09-11 21:50:47 +00:00
|
|
|
#include <asm/gpio.h>
|
2014-05-05 13:42:31 +00:00
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/arch/clock.h>
|
|
|
|
#include <asm/arch/cpu.h>
|
|
|
|
#include <asm/arch/mmc.h>
|
2020-05-10 17:40:11 +00:00
|
|
|
#include <linux/delay.h>
|
2014-05-05 13:42:31 +00:00
|
|
|
|
2021-05-05 08:57:47 +00:00
|
|
|
#ifndef CCM_MMC_CTRL_MODE_SEL_NEW
|
|
|
|
#define CCM_MMC_CTRL_MODE_SEL_NEW 0
|
|
|
|
#endif
|
|
|
|
|
2017-07-04 19:31:27 +00:00
|
|
|
struct sunxi_mmc_plat {
|
|
|
|
struct mmc_config cfg;
|
|
|
|
struct mmc mmc;
|
|
|
|
};
|
|
|
|
|
2017-07-04 19:31:23 +00:00
|
|
|
struct sunxi_mmc_priv {
|
2014-05-05 13:42:31 +00:00
|
|
|
unsigned mmc_no;
|
|
|
|
uint32_t *mclkreg;
|
|
|
|
unsigned fatal_err;
|
2017-07-04 19:31:27 +00:00
|
|
|
struct gpio_desc cd_gpio; /* Change Detect GPIO */
|
2014-05-05 13:42:31 +00:00
|
|
|
struct sunxi_mmc *reg;
|
|
|
|
struct mmc_config cfg;
|
|
|
|
};
|
|
|
|
|
2017-07-04 19:31:27 +00:00
|
|
|
#if !CONFIG_IS_ENABLED(DM_MMC)
|
2014-05-05 13:42:31 +00:00
|
|
|
/* support 4 mmc hosts */
|
2017-07-04 19:31:23 +00:00
|
|
|
struct sunxi_mmc_priv mmc_host[4];
|
2014-05-05 13:42:31 +00:00
|
|
|
|
2014-10-31 15:55:02 +00:00
|
|
|
static int sunxi_mmc_getcd_gpio(int sdc_no)
|
|
|
|
{
|
|
|
|
switch (sdc_no) {
|
|
|
|
case 0: return sunxi_name_to_gpio(CONFIG_MMC0_CD_PIN);
|
|
|
|
case 1: return sunxi_name_to_gpio(CONFIG_MMC1_CD_PIN);
|
|
|
|
case 2: return sunxi_name_to_gpio(CONFIG_MMC2_CD_PIN);
|
|
|
|
case 3: return sunxi_name_to_gpio(CONFIG_MMC3_CD_PIN);
|
|
|
|
}
|
2015-04-22 15:03:17 +00:00
|
|
|
return -EINVAL;
|
2014-10-31 15:55:02 +00:00
|
|
|
}
|
|
|
|
|
2014-05-05 13:42:31 +00:00
|
|
|
static int mmc_resource_init(int sdc_no)
|
|
|
|
{
|
2017-07-04 19:31:24 +00:00
|
|
|
struct sunxi_mmc_priv *priv = &mmc_host[sdc_no];
|
2014-05-05 13:42:31 +00:00
|
|
|
struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
|
2014-10-31 15:55:02 +00:00
|
|
|
int cd_pin, ret = 0;
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
debug("init mmc %d resource\n", sdc_no);
|
|
|
|
|
|
|
|
switch (sdc_no) {
|
|
|
|
case 0:
|
2017-07-04 19:31:24 +00:00
|
|
|
priv->reg = (struct sunxi_mmc *)SUNXI_MMC0_BASE;
|
|
|
|
priv->mclkreg = &ccm->sd0_clk_cfg;
|
2014-05-05 13:42:31 +00:00
|
|
|
break;
|
|
|
|
case 1:
|
2017-07-04 19:31:24 +00:00
|
|
|
priv->reg = (struct sunxi_mmc *)SUNXI_MMC1_BASE;
|
|
|
|
priv->mclkreg = &ccm->sd1_clk_cfg;
|
2014-05-05 13:42:31 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2017-07-04 19:31:24 +00:00
|
|
|
priv->reg = (struct sunxi_mmc *)SUNXI_MMC2_BASE;
|
|
|
|
priv->mclkreg = &ccm->sd2_clk_cfg;
|
2014-05-05 13:42:31 +00:00
|
|
|
break;
|
2018-07-21 08:20:29 +00:00
|
|
|
#ifdef SUNXI_MMC3_BASE
|
2014-05-05 13:42:31 +00:00
|
|
|
case 3:
|
2017-07-04 19:31:24 +00:00
|
|
|
priv->reg = (struct sunxi_mmc *)SUNXI_MMC3_BASE;
|
|
|
|
priv->mclkreg = &ccm->sd3_clk_cfg;
|
2014-05-05 13:42:31 +00:00
|
|
|
break;
|
2018-07-21 08:20:29 +00:00
|
|
|
#endif
|
2014-05-05 13:42:31 +00:00
|
|
|
default:
|
|
|
|
printf("Wrong mmc number %d\n", sdc_no);
|
|
|
|
return -1;
|
|
|
|
}
|
2017-07-04 19:31:24 +00:00
|
|
|
priv->mmc_no = sdc_no;
|
2014-05-05 13:42:31 +00:00
|
|
|
|
2014-10-31 15:55:02 +00:00
|
|
|
cd_pin = sunxi_mmc_getcd_gpio(sdc_no);
|
2015-04-22 15:03:17 +00:00
|
|
|
if (cd_pin >= 0) {
|
2014-10-31 15:55:02 +00:00
|
|
|
ret = gpio_request(cd_pin, "mmc_cd");
|
2015-05-30 14:39:10 +00:00
|
|
|
if (!ret) {
|
|
|
|
sunxi_gpio_set_pull(cd_pin, SUNXI_GPIO_PULL_UP);
|
2014-12-20 03:41:25 +00:00
|
|
|
ret = gpio_direction_input(cd_pin);
|
2015-05-30 14:39:10 +00:00
|
|
|
}
|
2014-12-20 03:41:25 +00:00
|
|
|
}
|
2014-10-31 15:55:02 +00:00
|
|
|
|
|
|
|
return ret;
|
2014-05-05 13:42:31 +00:00
|
|
|
}
|
2017-07-04 19:31:27 +00:00
|
|
|
#endif
|
2014-05-05 13:42:31 +00:00
|
|
|
|
2021-05-05 09:06:24 +00:00
|
|
|
/*
|
|
|
|
* All A64 and later MMC controllers feature auto-calibration. This would
|
|
|
|
* normally be detected via the compatible string, but we need something
|
|
|
|
* which works in the SPL as well.
|
|
|
|
*/
|
|
|
|
static bool sunxi_mmc_can_calibrate(void)
|
|
|
|
{
|
|
|
|
return IS_ENABLED(CONFIG_MACH_SUN50I) ||
|
|
|
|
IS_ENABLED(CONFIG_MACH_SUN50I_H5) ||
|
|
|
|
IS_ENABLED(CONFIG_SUN50I_GEN_H6) ||
|
|
|
|
IS_ENABLED(CONFIG_MACH_SUN8I_R40);
|
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:24 +00:00
|
|
|
static int mmc_set_mod_clk(struct sunxi_mmc_priv *priv, unsigned int hz)
|
2014-12-07 19:55:10 +00:00
|
|
|
{
|
|
|
|
unsigned int pll, pll_hz, div, n, oclk_dly, sclk_dly;
|
2021-05-05 08:57:47 +00:00
|
|
|
bool new_mode = IS_ENABLED(CONFIG_MMC_SUNXI_HAS_NEW_MODE);
|
2017-08-23 10:03:41 +00:00
|
|
|
u32 val = 0;
|
|
|
|
|
2018-11-10 04:41:46 +00:00
|
|
|
/* A83T support new mode only on eMMC */
|
|
|
|
if (IS_ENABLED(CONFIG_MACH_SUN8I_A83T) && priv->mmc_no != 2)
|
|
|
|
new_mode = false;
|
2017-08-23 10:03:41 +00:00
|
|
|
|
2014-12-07 19:55:10 +00:00
|
|
|
if (hz <= 24000000) {
|
|
|
|
pll = CCM_MMC_CTRL_OSCM24;
|
|
|
|
pll_hz = 24000000;
|
|
|
|
} else {
|
2015-01-14 18:05:03 +00:00
|
|
|
#ifdef CONFIG_MACH_SUN9I
|
|
|
|
pll = CCM_MMC_CTRL_PLL_PERIPH0;
|
|
|
|
pll_hz = clock_get_pll4_periph0();
|
|
|
|
#else
|
2021-05-05 08:57:47 +00:00
|
|
|
/*
|
|
|
|
* SoCs since the A64 (H5, H6, H616) actually use the doubled
|
|
|
|
* rate of PLL6/PERIPH0 as an input clock, but compensate for
|
|
|
|
* that with a fixed post-divider of 2 in the mod clock.
|
|
|
|
* This cancels each other out, so for simplicity we just
|
|
|
|
* pretend it's always PLL6 without a post divider here.
|
|
|
|
*/
|
2014-12-07 19:55:10 +00:00
|
|
|
pll = CCM_MMC_CTRL_PLL6;
|
|
|
|
pll_hz = clock_get_pll6();
|
2015-01-14 18:05:03 +00:00
|
|
|
#endif
|
2014-12-07 19:55:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
div = pll_hz / hz;
|
|
|
|
if (pll_hz % hz)
|
|
|
|
div++;
|
|
|
|
|
|
|
|
n = 0;
|
|
|
|
while (div > 16) {
|
|
|
|
n++;
|
|
|
|
div = (div + 1) / 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n > 3) {
|
2017-07-04 19:31:24 +00:00
|
|
|
printf("mmc %u error cannot set clock to %u\n", priv->mmc_no,
|
|
|
|
hz);
|
2014-12-07 19:55:10 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* determine delays */
|
|
|
|
if (hz <= 400000) {
|
|
|
|
oclk_dly = 0;
|
2015-09-23 14:13:10 +00:00
|
|
|
sclk_dly = 0;
|
2014-12-07 19:55:10 +00:00
|
|
|
} else if (hz <= 25000000) {
|
|
|
|
oclk_dly = 0;
|
|
|
|
sclk_dly = 5;
|
2015-09-23 14:13:10 +00:00
|
|
|
} else {
|
2020-12-18 22:02:11 +00:00
|
|
|
if (IS_ENABLED(CONFIG_MACH_SUN9I)) {
|
|
|
|
if (hz <= 52000000)
|
|
|
|
oclk_dly = 5;
|
|
|
|
else
|
|
|
|
oclk_dly = 2;
|
|
|
|
} else {
|
|
|
|
if (hz <= 52000000)
|
|
|
|
oclk_dly = 3;
|
|
|
|
else
|
|
|
|
oclk_dly = 1;
|
|
|
|
}
|
2015-09-23 14:13:10 +00:00
|
|
|
sclk_dly = 4;
|
2014-12-07 19:55:10 +00:00
|
|
|
}
|
|
|
|
|
2017-08-23 10:03:41 +00:00
|
|
|
if (new_mode) {
|
2021-05-05 08:57:47 +00:00
|
|
|
val |= CCM_MMC_CTRL_MODE_SEL_NEW;
|
2017-08-31 13:57:48 +00:00
|
|
|
setbits_le32(&priv->reg->ntsr, SUNXI_MMC_NTSR_MODE_SEL_NEW);
|
2021-05-05 09:06:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!sunxi_mmc_can_calibrate()) {
|
2018-11-06 04:24:28 +00:00
|
|
|
/*
|
|
|
|
* Use hardcoded delay values if controller doesn't support
|
|
|
|
* calibration
|
|
|
|
*/
|
2017-08-23 10:03:41 +00:00
|
|
|
val = CCM_MMC_CTRL_OCLK_DLY(oclk_dly) |
|
|
|
|
CCM_MMC_CTRL_SCLK_DLY(sclk_dly);
|
|
|
|
}
|
|
|
|
|
|
|
|
writel(CCM_MMC_CTRL_ENABLE| pll | CCM_MMC_CTRL_N(n) |
|
|
|
|
CCM_MMC_CTRL_M(div) | val, priv->mclkreg);
|
2014-12-07 19:55:10 +00:00
|
|
|
|
|
|
|
debug("mmc %u set mod-clk req %u parent %u n %u m %u rate %u\n",
|
2017-07-04 19:31:24 +00:00
|
|
|
priv->mmc_no, hz, pll_hz, 1u << n, div, pll_hz / (1u << n) / div);
|
2014-12-07 19:55:10 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:25 +00:00
|
|
|
static int mmc_update_clk(struct sunxi_mmc_priv *priv)
|
2014-05-05 13:42:31 +00:00
|
|
|
{
|
|
|
|
unsigned int cmd;
|
|
|
|
unsigned timeout_msecs = 2000;
|
2018-03-21 11:18:58 +00:00
|
|
|
unsigned long start = get_timer(0);
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
cmd = SUNXI_MMC_CMD_START |
|
|
|
|
SUNXI_MMC_CMD_UPCLK_ONLY |
|
|
|
|
SUNXI_MMC_CMD_WAIT_PRE_OVER;
|
2018-03-21 11:18:58 +00:00
|
|
|
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(cmd, &priv->reg->cmd);
|
|
|
|
while (readl(&priv->reg->cmd) & SUNXI_MMC_CMD_START) {
|
2018-03-21 11:18:58 +00:00
|
|
|
if (get_timer(start) > timeout_msecs)
|
2014-05-05 13:42:31 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* clock update sets various irq status bits, clear these */
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(readl(&priv->reg->rint), &priv->reg->rint);
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:25 +00:00
|
|
|
static int mmc_config_clock(struct sunxi_mmc_priv *priv, struct mmc *mmc)
|
2014-05-05 13:42:31 +00:00
|
|
|
{
|
2017-07-04 19:31:24 +00:00
|
|
|
unsigned rval = readl(&priv->reg->clkcr);
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
/* Disable Clock */
|
|
|
|
rval &= ~SUNXI_MMC_CLK_ENABLE;
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(rval, &priv->reg->clkcr);
|
2017-07-04 19:31:25 +00:00
|
|
|
if (mmc_update_clk(priv))
|
2014-05-05 13:42:31 +00:00
|
|
|
return -1;
|
|
|
|
|
2014-12-07 19:55:10 +00:00
|
|
|
/* Set mod_clk to new rate */
|
2017-07-04 19:31:24 +00:00
|
|
|
if (mmc_set_mod_clk(priv, mmc->clock))
|
2014-12-07 19:55:10 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* Clear internal divider */
|
2014-05-05 13:42:31 +00:00
|
|
|
rval &= ~SUNXI_MMC_CLK_DIVIDER_MASK;
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(rval, &priv->reg->clkcr);
|
2014-12-07 19:55:10 +00:00
|
|
|
|
2021-05-05 09:06:24 +00:00
|
|
|
#if defined(CONFIG_SUNXI_GEN_SUN6I) || defined(CONFIG_SUN50I_GEN_H6)
|
2018-11-06 04:24:28 +00:00
|
|
|
/* A64 supports calibration of delays on MMC controller and we
|
|
|
|
* have to set delay of zero before starting calibration.
|
|
|
|
* Allwinner BSP driver sets a delay only in the case of
|
|
|
|
* using HS400 which is not supported by mainline U-Boot or
|
|
|
|
* Linux at the moment
|
|
|
|
*/
|
2021-05-05 09:06:24 +00:00
|
|
|
if (sunxi_mmc_can_calibrate())
|
|
|
|
writel(SUNXI_MMC_CAL_DL_SW_EN, &priv->reg->samp_dl);
|
2018-11-06 04:24:28 +00:00
|
|
|
#endif
|
|
|
|
|
2014-05-05 13:42:31 +00:00
|
|
|
/* Re-enable Clock */
|
|
|
|
rval |= SUNXI_MMC_CLK_ENABLE;
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(rval, &priv->reg->clkcr);
|
2017-07-04 19:31:25 +00:00
|
|
|
if (mmc_update_clk(priv))
|
2014-05-05 13:42:31 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:25 +00:00
|
|
|
static int sunxi_mmc_set_ios_common(struct sunxi_mmc_priv *priv,
|
|
|
|
struct mmc *mmc)
|
2014-05-05 13:42:31 +00:00
|
|
|
{
|
2014-12-07 19:55:10 +00:00
|
|
|
debug("set ios: bus_width: %x, clock: %d\n",
|
|
|
|
mmc->bus_width, mmc->clock);
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
/* Change clock first */
|
2017-07-04 19:31:25 +00:00
|
|
|
if (mmc->clock && mmc_config_clock(priv, mmc) != 0) {
|
2017-07-04 19:31:24 +00:00
|
|
|
priv->fatal_err = 1;
|
2016-12-30 06:30:16 +00:00
|
|
|
return -EINVAL;
|
2014-05-05 13:42:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Change bus width */
|
|
|
|
if (mmc->bus_width == 8)
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(0x2, &priv->reg->width);
|
2014-05-05 13:42:31 +00:00
|
|
|
else if (mmc->bus_width == 4)
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(0x1, &priv->reg->width);
|
2014-05-05 13:42:31 +00:00
|
|
|
else
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(0x0, &priv->reg->width);
|
2016-12-30 06:30:16 +00:00
|
|
|
|
|
|
|
return 0;
|
2014-05-05 13:42:31 +00:00
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:27 +00:00
|
|
|
#if !CONFIG_IS_ENABLED(DM_MMC)
|
2015-01-31 22:42:14 +00:00
|
|
|
static int sunxi_mmc_core_init(struct mmc *mmc)
|
2014-05-05 13:42:31 +00:00
|
|
|
{
|
2017-07-04 19:31:24 +00:00
|
|
|
struct sunxi_mmc_priv *priv = mmc->priv;
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
/* Reset controller */
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(SUNXI_MMC_GCTRL_RESET, &priv->reg->gctrl);
|
2014-06-09 09:36:55 +00:00
|
|
|
udelay(1000);
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-07-04 19:31:27 +00:00
|
|
|
#endif
|
2014-05-05 13:42:31 +00:00
|
|
|
|
2017-07-04 19:31:25 +00:00
|
|
|
static int mmc_trans_data_by_cpu(struct sunxi_mmc_priv *priv, struct mmc *mmc,
|
|
|
|
struct mmc_data *data)
|
2014-05-05 13:42:31 +00:00
|
|
|
{
|
|
|
|
const int reading = !!(data->flags & MMC_DATA_READ);
|
|
|
|
const uint32_t status_bit = reading ? SUNXI_MMC_STATUS_FIFO_EMPTY :
|
|
|
|
SUNXI_MMC_STATUS_FIFO_FULL;
|
|
|
|
unsigned i;
|
|
|
|
unsigned *buff = (unsigned int *)(reading ? data->dest : data->src);
|
mmc: sunxi: Increase MMIO FIFO read performance
To avoid the complexity of DMA operations (with chained descriptors), we
use repeated MMIO reads and writes to the SD_FIFO_REG, which allows us
to drain or fill the MMC data buffer FIFO very easily.
However those MMIO accesses are somewhat costly, so this limits our MMC
performance, to between 17 and 22 MB/s, but down to 9.5 MB/s on the H6
(partly due to the lower AHB1 frequency).
As it turns out we read the FIFO status register after *every* word we
read or write, which effectively doubles the number of MMIO accesses,
thus effectively more than halving our performance.
To avoid this overhead, we can make use of the FIFO level bits, which are
in the very same FIFO status registers.
So for a read request, we now can collect as many words as the FIFO
level originally indicated, and only then need to update the status
register.
We don't know for sure the size of the FIFO (and it seems to differ
across SoCs anyway), so writing is more fragile, which is why we still
use the old method for that. If we find a minimum FIFO size available on
all SoCs, we could use that, in a later optimisation.
This patch increases the eMMC read speed on a Pine64-LTS from about
22MB/s to 44 MB/s. SD card reads don't gain that much, but with 23 MB/s
we now reach the practical limit for 3.3V SD cards.
On the H6 we double our transfer speed, from 9.5 MB/s to 19.7 MB/s.
Signed-off-by: Andre Przywara <andre.przywara@arm.com>
2021-05-05 10:33:40 +00:00
|
|
|
unsigned word_cnt = (data->blocksize * data->blocks) >> 2;
|
|
|
|
unsigned timeout_msecs = word_cnt >> 6;
|
|
|
|
uint32_t status;
|
2018-03-21 11:18:58 +00:00
|
|
|
unsigned long start;
|
|
|
|
|
|
|
|
if (timeout_msecs < 2000)
|
|
|
|
timeout_msecs = 2000;
|
2014-05-05 13:42:31 +00:00
|
|
|
|
2014-06-09 09:36:55 +00:00
|
|
|
/* Always read / write data through the CPU */
|
2017-07-04 19:31:24 +00:00
|
|
|
setbits_le32(&priv->reg->gctrl, SUNXI_MMC_GCTRL_ACCESS_BY_AHB);
|
2014-06-09 09:36:55 +00:00
|
|
|
|
2018-03-21 11:18:58 +00:00
|
|
|
start = get_timer(0);
|
|
|
|
|
mmc: sunxi: Increase MMIO FIFO read performance
To avoid the complexity of DMA operations (with chained descriptors), we
use repeated MMIO reads and writes to the SD_FIFO_REG, which allows us
to drain or fill the MMC data buffer FIFO very easily.
However those MMIO accesses are somewhat costly, so this limits our MMC
performance, to between 17 and 22 MB/s, but down to 9.5 MB/s on the H6
(partly due to the lower AHB1 frequency).
As it turns out we read the FIFO status register after *every* word we
read or write, which effectively doubles the number of MMIO accesses,
thus effectively more than halving our performance.
To avoid this overhead, we can make use of the FIFO level bits, which are
in the very same FIFO status registers.
So for a read request, we now can collect as many words as the FIFO
level originally indicated, and only then need to update the status
register.
We don't know for sure the size of the FIFO (and it seems to differ
across SoCs anyway), so writing is more fragile, which is why we still
use the old method for that. If we find a minimum FIFO size available on
all SoCs, we could use that, in a later optimisation.
This patch increases the eMMC read speed on a Pine64-LTS from about
22MB/s to 44 MB/s. SD card reads don't gain that much, but with 23 MB/s
we now reach the practical limit for 3.3V SD cards.
On the H6 we double our transfer speed, from 9.5 MB/s to 19.7 MB/s.
Signed-off-by: Andre Przywara <andre.przywara@arm.com>
2021-05-05 10:33:40 +00:00
|
|
|
for (i = 0; i < word_cnt;) {
|
|
|
|
unsigned int in_fifo;
|
|
|
|
|
|
|
|
while ((status = readl(&priv->reg->status)) & status_bit) {
|
2018-03-21 11:18:58 +00:00
|
|
|
if (get_timer(start) > timeout_msecs)
|
2014-05-05 13:42:31 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
mmc: sunxi: Increase MMIO FIFO read performance
To avoid the complexity of DMA operations (with chained descriptors), we
use repeated MMIO reads and writes to the SD_FIFO_REG, which allows us
to drain or fill the MMC data buffer FIFO very easily.
However those MMIO accesses are somewhat costly, so this limits our MMC
performance, to between 17 and 22 MB/s, but down to 9.5 MB/s on the H6
(partly due to the lower AHB1 frequency).
As it turns out we read the FIFO status register after *every* word we
read or write, which effectively doubles the number of MMIO accesses,
thus effectively more than halving our performance.
To avoid this overhead, we can make use of the FIFO level bits, which are
in the very same FIFO status registers.
So for a read request, we now can collect as many words as the FIFO
level originally indicated, and only then need to update the status
register.
We don't know for sure the size of the FIFO (and it seems to differ
across SoCs anyway), so writing is more fragile, which is why we still
use the old method for that. If we find a minimum FIFO size available on
all SoCs, we could use that, in a later optimisation.
This patch increases the eMMC read speed on a Pine64-LTS from about
22MB/s to 44 MB/s. SD card reads don't gain that much, but with 23 MB/s
we now reach the practical limit for 3.3V SD cards.
On the H6 we double our transfer speed, from 9.5 MB/s to 19.7 MB/s.
Signed-off-by: Andre Przywara <andre.przywara@arm.com>
2021-05-05 10:33:40 +00:00
|
|
|
/*
|
|
|
|
* For writing we do not easily know the FIFO size, so have
|
|
|
|
* to check the FIFO status after every word written.
|
|
|
|
* TODO: For optimisation we could work out a minimum FIFO
|
|
|
|
* size across all SoCs, and use that together with the current
|
|
|
|
* fill level to write chunks of words.
|
|
|
|
*/
|
|
|
|
if (!reading) {
|
|
|
|
writel(buff[i++], &priv->reg->fifo);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The status register holds the current FIFO level, so we
|
|
|
|
* can be sure to collect as many words from the FIFO
|
|
|
|
* register without checking the status register after every
|
|
|
|
* read. That saves half of the costly MMIO reads, effectively
|
|
|
|
* doubling the read performance.
|
2021-09-03 15:49:16 +00:00
|
|
|
* Some SoCs (A20) report a level of 0 if the FIFO is
|
|
|
|
* completely full (value masked out?). Use a safe minimal
|
|
|
|
* FIFO size in this case.
|
mmc: sunxi: Increase MMIO FIFO read performance
To avoid the complexity of DMA operations (with chained descriptors), we
use repeated MMIO reads and writes to the SD_FIFO_REG, which allows us
to drain or fill the MMC data buffer FIFO very easily.
However those MMIO accesses are somewhat costly, so this limits our MMC
performance, to between 17 and 22 MB/s, but down to 9.5 MB/s on the H6
(partly due to the lower AHB1 frequency).
As it turns out we read the FIFO status register after *every* word we
read or write, which effectively doubles the number of MMIO accesses,
thus effectively more than halving our performance.
To avoid this overhead, we can make use of the FIFO level bits, which are
in the very same FIFO status registers.
So for a read request, we now can collect as many words as the FIFO
level originally indicated, and only then need to update the status
register.
We don't know for sure the size of the FIFO (and it seems to differ
across SoCs anyway), so writing is more fragile, which is why we still
use the old method for that. If we find a minimum FIFO size available on
all SoCs, we could use that, in a later optimisation.
This patch increases the eMMC read speed on a Pine64-LTS from about
22MB/s to 44 MB/s. SD card reads don't gain that much, but with 23 MB/s
we now reach the practical limit for 3.3V SD cards.
On the H6 we double our transfer speed, from 9.5 MB/s to 19.7 MB/s.
Signed-off-by: Andre Przywara <andre.przywara@arm.com>
2021-05-05 10:33:40 +00:00
|
|
|
*/
|
2021-09-03 15:49:16 +00:00
|
|
|
in_fifo = SUNXI_MMC_STATUS_FIFO_LEVEL(status);
|
|
|
|
if (in_fifo == 0 && (status & SUNXI_MMC_STATUS_FIFO_FULL))
|
|
|
|
in_fifo = 32;
|
|
|
|
for (; in_fifo > 0; in_fifo--)
|
mmc: sunxi: Increase MMIO FIFO read performance
To avoid the complexity of DMA operations (with chained descriptors), we
use repeated MMIO reads and writes to the SD_FIFO_REG, which allows us
to drain or fill the MMC data buffer FIFO very easily.
However those MMIO accesses are somewhat costly, so this limits our MMC
performance, to between 17 and 22 MB/s, but down to 9.5 MB/s on the H6
(partly due to the lower AHB1 frequency).
As it turns out we read the FIFO status register after *every* word we
read or write, which effectively doubles the number of MMIO accesses,
thus effectively more than halving our performance.
To avoid this overhead, we can make use of the FIFO level bits, which are
in the very same FIFO status registers.
So for a read request, we now can collect as many words as the FIFO
level originally indicated, and only then need to update the status
register.
We don't know for sure the size of the FIFO (and it seems to differ
across SoCs anyway), so writing is more fragile, which is why we still
use the old method for that. If we find a minimum FIFO size available on
all SoCs, we could use that, in a later optimisation.
This patch increases the eMMC read speed on a Pine64-LTS from about
22MB/s to 44 MB/s. SD card reads don't gain that much, but with 23 MB/s
we now reach the practical limit for 3.3V SD cards.
On the H6 we double our transfer speed, from 9.5 MB/s to 19.7 MB/s.
Signed-off-by: Andre Przywara <andre.przywara@arm.com>
2021-05-05 10:33:40 +00:00
|
|
|
buff[i++] = readl_relaxed(&priv->reg->fifo);
|
|
|
|
dmb();
|
2014-05-05 13:42:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:25 +00:00
|
|
|
static int mmc_rint_wait(struct sunxi_mmc_priv *priv, struct mmc *mmc,
|
|
|
|
uint timeout_msecs, uint done_bit, const char *what)
|
2014-05-05 13:42:31 +00:00
|
|
|
{
|
|
|
|
unsigned int status;
|
2018-03-21 11:18:58 +00:00
|
|
|
unsigned long start = get_timer(0);
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
do {
|
2017-07-04 19:31:24 +00:00
|
|
|
status = readl(&priv->reg->rint);
|
2018-03-21 11:18:58 +00:00
|
|
|
if ((get_timer(start) > timeout_msecs) ||
|
2014-05-05 13:42:31 +00:00
|
|
|
(status & SUNXI_MMC_RINT_INTERRUPT_ERROR_BIT)) {
|
|
|
|
debug("%s timeout %x\n", what,
|
|
|
|
status & SUNXI_MMC_RINT_INTERRUPT_ERROR_BIT);
|
2016-07-19 07:33:36 +00:00
|
|
|
return -ETIMEDOUT;
|
2014-05-05 13:42:31 +00:00
|
|
|
}
|
|
|
|
} while (!(status & done_bit));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:25 +00:00
|
|
|
static int sunxi_mmc_send_cmd_common(struct sunxi_mmc_priv *priv,
|
|
|
|
struct mmc *mmc, struct mmc_cmd *cmd,
|
|
|
|
struct mmc_data *data)
|
2014-05-05 13:42:31 +00:00
|
|
|
{
|
|
|
|
unsigned int cmdval = SUNXI_MMC_CMD_START;
|
|
|
|
unsigned int timeout_msecs;
|
|
|
|
int error = 0;
|
|
|
|
unsigned int status = 0;
|
|
|
|
unsigned int bytecnt = 0;
|
|
|
|
|
2017-07-04 19:31:24 +00:00
|
|
|
if (priv->fatal_err)
|
2014-05-05 13:42:31 +00:00
|
|
|
return -1;
|
|
|
|
if (cmd->resp_type & MMC_RSP_BUSY)
|
|
|
|
debug("mmc cmd %d check rsp busy\n", cmd->cmdidx);
|
|
|
|
if (cmd->cmdidx == 12)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!cmd->cmdidx)
|
|
|
|
cmdval |= SUNXI_MMC_CMD_SEND_INIT_SEQ;
|
|
|
|
if (cmd->resp_type & MMC_RSP_PRESENT)
|
|
|
|
cmdval |= SUNXI_MMC_CMD_RESP_EXPIRE;
|
|
|
|
if (cmd->resp_type & MMC_RSP_136)
|
|
|
|
cmdval |= SUNXI_MMC_CMD_LONG_RESPONSE;
|
|
|
|
if (cmd->resp_type & MMC_RSP_CRC)
|
|
|
|
cmdval |= SUNXI_MMC_CMD_CHK_RESPONSE_CRC;
|
|
|
|
|
|
|
|
if (data) {
|
2016-03-29 15:29:09 +00:00
|
|
|
if ((u32)(long)data->dest & 0x3) {
|
2014-05-05 13:42:31 +00:00
|
|
|
error = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmdval |= SUNXI_MMC_CMD_DATA_EXPIRE|SUNXI_MMC_CMD_WAIT_PRE_OVER;
|
|
|
|
if (data->flags & MMC_DATA_WRITE)
|
|
|
|
cmdval |= SUNXI_MMC_CMD_WRITE;
|
|
|
|
if (data->blocks > 1)
|
|
|
|
cmdval |= SUNXI_MMC_CMD_AUTO_STOP;
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(data->blocksize, &priv->reg->blksz);
|
|
|
|
writel(data->blocks * data->blocksize, &priv->reg->bytecnt);
|
2014-05-05 13:42:31 +00:00
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:24 +00:00
|
|
|
debug("mmc %d, cmd %d(0x%08x), arg 0x%08x\n", priv->mmc_no,
|
2014-05-05 13:42:31 +00:00
|
|
|
cmd->cmdidx, cmdval | cmd->cmdidx, cmd->cmdarg);
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(cmd->cmdarg, &priv->reg->arg);
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
if (!data)
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(cmdval | cmd->cmdidx, &priv->reg->cmd);
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* transfer data and check status
|
|
|
|
* STATREG[2] : FIFO empty
|
|
|
|
* STATREG[3] : FIFO full
|
|
|
|
*/
|
|
|
|
if (data) {
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
bytecnt = data->blocksize * data->blocks;
|
|
|
|
debug("trans data %d bytes\n", bytecnt);
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(cmdval | cmd->cmdidx, &priv->reg->cmd);
|
2017-07-04 19:31:25 +00:00
|
|
|
ret = mmc_trans_data_by_cpu(priv, mmc, data);
|
2014-05-05 13:42:31 +00:00
|
|
|
if (ret) {
|
2017-07-04 19:31:24 +00:00
|
|
|
error = readl(&priv->reg->rint) &
|
2014-05-05 13:42:31 +00:00
|
|
|
SUNXI_MMC_RINT_INTERRUPT_ERROR_BIT;
|
2016-07-19 07:33:36 +00:00
|
|
|
error = -ETIMEDOUT;
|
2014-05-05 13:42:31 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:25 +00:00
|
|
|
error = mmc_rint_wait(priv, mmc, 1000, SUNXI_MMC_RINT_COMMAND_DONE,
|
|
|
|
"cmd");
|
2014-05-05 13:42:31 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (data) {
|
2014-06-09 09:36:55 +00:00
|
|
|
timeout_msecs = 120;
|
2014-05-05 13:42:31 +00:00
|
|
|
debug("cacl timeout %x msec\n", timeout_msecs);
|
2017-07-04 19:31:25 +00:00
|
|
|
error = mmc_rint_wait(priv, mmc, timeout_msecs,
|
2014-05-05 13:42:31 +00:00
|
|
|
data->blocks > 1 ?
|
|
|
|
SUNXI_MMC_RINT_AUTO_COMMAND_DONE :
|
|
|
|
SUNXI_MMC_RINT_DATA_OVER,
|
|
|
|
"data");
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd->resp_type & MMC_RSP_BUSY) {
|
2018-03-21 11:18:58 +00:00
|
|
|
unsigned long start = get_timer(0);
|
2014-05-05 13:42:31 +00:00
|
|
|
timeout_msecs = 2000;
|
2018-03-21 11:18:58 +00:00
|
|
|
|
2014-05-05 13:42:31 +00:00
|
|
|
do {
|
2017-07-04 19:31:24 +00:00
|
|
|
status = readl(&priv->reg->status);
|
2018-03-21 11:18:58 +00:00
|
|
|
if (get_timer(start) > timeout_msecs) {
|
2014-05-05 13:42:31 +00:00
|
|
|
debug("busy timeout\n");
|
2016-07-19 07:33:36 +00:00
|
|
|
error = -ETIMEDOUT;
|
2014-05-05 13:42:31 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} while (status & SUNXI_MMC_STATUS_CARD_DATA_BUSY);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd->resp_type & MMC_RSP_136) {
|
2017-07-04 19:31:24 +00:00
|
|
|
cmd->response[0] = readl(&priv->reg->resp3);
|
|
|
|
cmd->response[1] = readl(&priv->reg->resp2);
|
|
|
|
cmd->response[2] = readl(&priv->reg->resp1);
|
|
|
|
cmd->response[3] = readl(&priv->reg->resp0);
|
2014-05-05 13:42:31 +00:00
|
|
|
debug("mmc resp 0x%08x 0x%08x 0x%08x 0x%08x\n",
|
|
|
|
cmd->response[3], cmd->response[2],
|
|
|
|
cmd->response[1], cmd->response[0]);
|
|
|
|
} else {
|
2017-07-04 19:31:24 +00:00
|
|
|
cmd->response[0] = readl(&priv->reg->resp0);
|
2014-05-05 13:42:31 +00:00
|
|
|
debug("mmc resp 0x%08x\n", cmd->response[0]);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
if (error < 0) {
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(SUNXI_MMC_GCTRL_RESET, &priv->reg->gctrl);
|
2017-07-04 19:31:25 +00:00
|
|
|
mmc_update_clk(priv);
|
2014-05-05 13:42:31 +00:00
|
|
|
}
|
2017-07-04 19:31:24 +00:00
|
|
|
writel(0xffffffff, &priv->reg->rint);
|
|
|
|
writel(readl(&priv->reg->gctrl) | SUNXI_MMC_GCTRL_FIFO_RESET,
|
|
|
|
&priv->reg->gctrl);
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-07-04 19:31:27 +00:00
|
|
|
#if !CONFIG_IS_ENABLED(DM_MMC)
|
2017-07-04 19:31:25 +00:00
|
|
|
static int sunxi_mmc_set_ios_legacy(struct mmc *mmc)
|
|
|
|
{
|
|
|
|
struct sunxi_mmc_priv *priv = mmc->priv;
|
|
|
|
|
|
|
|
return sunxi_mmc_set_ios_common(priv, mmc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sunxi_mmc_send_cmd_legacy(struct mmc *mmc, struct mmc_cmd *cmd,
|
|
|
|
struct mmc_data *data)
|
|
|
|
{
|
|
|
|
struct sunxi_mmc_priv *priv = mmc->priv;
|
|
|
|
|
|
|
|
return sunxi_mmc_send_cmd_common(priv, mmc, cmd, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sunxi_mmc_getcd_legacy(struct mmc *mmc)
|
2014-10-02 18:29:26 +00:00
|
|
|
{
|
2017-07-04 19:31:24 +00:00
|
|
|
struct sunxi_mmc_priv *priv = mmc->priv;
|
2014-10-31 15:55:02 +00:00
|
|
|
int cd_pin;
|
2014-10-02 18:29:26 +00:00
|
|
|
|
2017-07-04 19:31:24 +00:00
|
|
|
cd_pin = sunxi_mmc_getcd_gpio(priv->mmc_no);
|
2015-04-22 15:03:17 +00:00
|
|
|
if (cd_pin < 0)
|
2014-10-02 18:29:26 +00:00
|
|
|
return 1;
|
|
|
|
|
2014-12-20 03:41:25 +00:00
|
|
|
return !gpio_get_value(cd_pin);
|
2014-10-02 18:29:26 +00:00
|
|
|
}
|
|
|
|
|
2014-05-05 13:42:31 +00:00
|
|
|
static const struct mmc_ops sunxi_mmc_ops = {
|
2017-07-04 19:31:25 +00:00
|
|
|
.send_cmd = sunxi_mmc_send_cmd_legacy,
|
|
|
|
.set_ios = sunxi_mmc_set_ios_legacy,
|
2015-01-31 22:42:14 +00:00
|
|
|
.init = sunxi_mmc_core_init,
|
2017-07-04 19:31:25 +00:00
|
|
|
.getcd = sunxi_mmc_getcd_legacy,
|
2014-05-05 13:42:31 +00:00
|
|
|
};
|
|
|
|
|
2014-10-02 19:13:54 +00:00
|
|
|
struct mmc *sunxi_mmc_init(int sdc_no)
|
2014-05-05 13:42:31 +00:00
|
|
|
{
|
2017-07-04 19:31:26 +00:00
|
|
|
struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
|
2017-07-04 19:31:25 +00:00
|
|
|
struct sunxi_mmc_priv *priv = &mmc_host[sdc_no];
|
|
|
|
struct mmc_config *cfg = &priv->cfg;
|
2017-07-04 19:31:26 +00:00
|
|
|
int ret;
|
2014-05-05 13:42:31 +00:00
|
|
|
|
2017-07-04 19:31:25 +00:00
|
|
|
memset(priv, '\0', sizeof(struct sunxi_mmc_priv));
|
2014-05-05 13:42:31 +00:00
|
|
|
|
|
|
|
cfg->name = "SUNXI SD/MMC";
|
|
|
|
cfg->ops = &sunxi_mmc_ops;
|
|
|
|
|
|
|
|
cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34;
|
|
|
|
cfg->host_caps = MMC_MODE_4BIT;
|
2020-12-18 22:02:11 +00:00
|
|
|
|
|
|
|
if ((IS_ENABLED(CONFIG_MACH_SUN50I) || IS_ENABLED(CONFIG_MACH_SUN8I) ||
|
|
|
|
IS_ENABLED(CONFIG_SUN50I_GEN_H6)) && (sdc_no == 2))
|
2016-03-29 15:29:10 +00:00
|
|
|
cfg->host_caps = MMC_MODE_8BIT;
|
2020-12-18 22:02:11 +00:00
|
|
|
|
2015-03-23 22:56:59 +00:00
|
|
|
cfg->host_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
|
2014-05-05 13:42:31 +00:00
|
|
|
cfg->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
|
|
|
|
|
|
|
|
cfg->f_min = 400000;
|
|
|
|
cfg->f_max = 52000000;
|
|
|
|
|
2014-10-31 15:55:02 +00:00
|
|
|
if (mmc_resource_init(sdc_no) != 0)
|
|
|
|
return NULL;
|
|
|
|
|
2017-07-04 19:31:26 +00:00
|
|
|
/* config ahb clock */
|
|
|
|
debug("init mmc %d clock and io\n", sdc_no);
|
2021-01-11 20:11:35 +00:00
|
|
|
#if !defined(CONFIG_SUN50I_GEN_H6)
|
2017-07-04 19:31:26 +00:00
|
|
|
setbits_le32(&ccm->ahb_gate0, 1 << AHB_GATE_OFFSET_MMC(sdc_no));
|
|
|
|
|
|
|
|
#ifdef CONFIG_SUNXI_GEN_SUN6I
|
|
|
|
/* unassert reset */
|
|
|
|
setbits_le32(&ccm->ahb_reset0_cfg, 1 << AHB_RESET_OFFSET_MMC(sdc_no));
|
|
|
|
#endif
|
|
|
|
#if defined(CONFIG_MACH_SUN9I)
|
|
|
|
/* sun9i has a mmc-common module, also set the gate and reset there */
|
|
|
|
writel(SUNXI_MMC_COMMON_CLK_GATE | SUNXI_MMC_COMMON_RESET,
|
|
|
|
SUNXI_MMC_COMMON_BASE + 4 * sdc_no);
|
2018-07-21 08:20:29 +00:00
|
|
|
#endif
|
2021-01-11 20:11:35 +00:00
|
|
|
#else /* CONFIG_SUN50I_GEN_H6 */
|
2018-07-21 08:20:29 +00:00
|
|
|
setbits_le32(&ccm->sd_gate_reset, 1 << sdc_no);
|
|
|
|
/* unassert reset */
|
|
|
|
setbits_le32(&ccm->sd_gate_reset, 1 << (RESET_SHIFT + sdc_no));
|
2017-07-04 19:31:26 +00:00
|
|
|
#endif
|
|
|
|
ret = mmc_set_mod_clk(priv, 24000000);
|
|
|
|
if (ret)
|
|
|
|
return NULL;
|
2014-05-05 13:42:31 +00:00
|
|
|
|
2017-08-23 11:41:33 +00:00
|
|
|
return mmc_create(cfg, priv);
|
2014-05-05 13:42:31 +00:00
|
|
|
}
|
2017-07-04 19:31:27 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
static int sunxi_mmc_set_ios(struct udevice *dev)
|
|
|
|
{
|
2020-12-03 23:55:20 +00:00
|
|
|
struct sunxi_mmc_plat *plat = dev_get_plat(dev);
|
2017-07-04 19:31:27 +00:00
|
|
|
struct sunxi_mmc_priv *priv = dev_get_priv(dev);
|
|
|
|
|
|
|
|
return sunxi_mmc_set_ios_common(priv, &plat->mmc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sunxi_mmc_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
|
|
|
|
struct mmc_data *data)
|
|
|
|
{
|
2020-12-03 23:55:20 +00:00
|
|
|
struct sunxi_mmc_plat *plat = dev_get_plat(dev);
|
2017-07-04 19:31:27 +00:00
|
|
|
struct sunxi_mmc_priv *priv = dev_get_priv(dev);
|
|
|
|
|
|
|
|
return sunxi_mmc_send_cmd_common(priv, &plat->mmc, cmd, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sunxi_mmc_getcd(struct udevice *dev)
|
|
|
|
{
|
2021-04-21 08:33:04 +00:00
|
|
|
struct mmc *mmc = mmc_get_mmc_dev(dev);
|
2017-07-04 19:31:27 +00:00
|
|
|
struct sunxi_mmc_priv *priv = dev_get_priv(dev);
|
|
|
|
|
2021-04-21 08:33:04 +00:00
|
|
|
/* If polling, assume that the card is always present. */
|
|
|
|
if ((mmc->cfg->host_caps & MMC_CAP_NONREMOVABLE) ||
|
|
|
|
(mmc->cfg->host_caps & MMC_CAP_NEEDS_POLL))
|
|
|
|
return 1;
|
|
|
|
|
2018-02-01 22:39:19 +00:00
|
|
|
if (dm_gpio_is_valid(&priv->cd_gpio)) {
|
|
|
|
int cd_state = dm_gpio_get_value(&priv->cd_gpio);
|
2017-07-04 19:31:27 +00:00
|
|
|
|
2021-04-21 08:33:04 +00:00
|
|
|
if (mmc->cfg->host_caps & MMC_CAP_CD_ACTIVE_HIGH)
|
|
|
|
return !cd_state;
|
|
|
|
else
|
|
|
|
return cd_state;
|
2018-02-01 22:39:19 +00:00
|
|
|
}
|
2017-07-04 19:31:27 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct dm_mmc_ops sunxi_mmc_ops = {
|
|
|
|
.send_cmd = sunxi_mmc_send_cmd,
|
|
|
|
.set_ios = sunxi_mmc_set_ios,
|
|
|
|
.get_cd = sunxi_mmc_getcd,
|
|
|
|
};
|
|
|
|
|
2021-01-11 20:11:44 +00:00
|
|
|
static unsigned get_mclk_offset(void)
|
|
|
|
{
|
|
|
|
if (IS_ENABLED(CONFIG_MACH_SUN9I_A80))
|
|
|
|
return 0x410;
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_SUN50I_GEN_H6))
|
|
|
|
return 0x830;
|
|
|
|
|
|
|
|
return 0x88;
|
|
|
|
};
|
|
|
|
|
2017-07-04 19:31:27 +00:00
|
|
|
static int sunxi_mmc_probe(struct udevice *dev)
|
|
|
|
{
|
|
|
|
struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev);
|
2020-12-03 23:55:20 +00:00
|
|
|
struct sunxi_mmc_plat *plat = dev_get_plat(dev);
|
2017-07-04 19:31:27 +00:00
|
|
|
struct sunxi_mmc_priv *priv = dev_get_priv(dev);
|
2019-01-29 15:54:13 +00:00
|
|
|
struct reset_ctl_bulk reset_bulk;
|
|
|
|
struct clk gate_clk;
|
2017-07-04 19:31:27 +00:00
|
|
|
struct mmc_config *cfg = &plat->cfg;
|
|
|
|
struct ofnode_phandle_args args;
|
2019-01-29 15:54:13 +00:00
|
|
|
u32 *ccu_reg;
|
2021-04-21 08:33:04 +00:00
|
|
|
int ret;
|
2017-07-04 19:31:27 +00:00
|
|
|
|
|
|
|
cfg->name = dev->name;
|
|
|
|
|
|
|
|
cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34;
|
2021-04-21 08:33:04 +00:00
|
|
|
cfg->host_caps = MMC_MODE_HS_52MHz | MMC_MODE_HS;
|
2017-07-04 19:31:27 +00:00
|
|
|
cfg->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
|
|
|
|
|
|
|
|
cfg->f_min = 400000;
|
|
|
|
cfg->f_max = 52000000;
|
|
|
|
|
2021-04-21 08:33:04 +00:00
|
|
|
ret = mmc_of_parse(dev, cfg);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2021-04-29 08:31:58 +00:00
|
|
|
priv->reg = dev_read_addr_ptr(dev);
|
2017-07-04 19:31:27 +00:00
|
|
|
|
|
|
|
/* We don't have a sunxi clock driver so find the clock address here */
|
|
|
|
ret = dev_read_phandle_with_args(dev, "clocks", "#clock-cells", 0,
|
|
|
|
1, &args);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2021-04-29 08:31:58 +00:00
|
|
|
ccu_reg = (u32 *)(uintptr_t)ofnode_get_addr(args.node);
|
2017-07-04 19:31:27 +00:00
|
|
|
|
2019-01-09 11:28:39 +00:00
|
|
|
priv->mmc_no = ((uintptr_t)priv->reg - SUNXI_MMC0_BASE) / 0x1000;
|
2021-01-11 20:11:44 +00:00
|
|
|
priv->mclkreg = (void *)ccu_reg + get_mclk_offset() + priv->mmc_no * 4;
|
2019-01-29 15:54:13 +00:00
|
|
|
|
|
|
|
ret = clk_get_by_name(dev, "ahb", &gate_clk);
|
|
|
|
if (!ret)
|
|
|
|
clk_enable(&gate_clk);
|
|
|
|
|
|
|
|
ret = reset_get_bulk(dev, &reset_bulk);
|
|
|
|
if (!ret)
|
|
|
|
reset_deassert_bulk(&reset_bulk);
|
2017-07-04 19:31:27 +00:00
|
|
|
|
|
|
|
ret = mmc_set_mod_clk(priv, 24000000);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* This GPIO is optional */
|
2021-04-21 08:33:04 +00:00
|
|
|
if (!gpio_request_by_name(dev, "cd-gpios", 0, &priv->cd_gpio,
|
2017-07-04 19:31:27 +00:00
|
|
|
GPIOD_IS_IN)) {
|
|
|
|
int cd_pin = gpio_get_number(&priv->cd_gpio);
|
|
|
|
|
|
|
|
sunxi_gpio_set_pull(cd_pin, SUNXI_GPIO_PULL_UP);
|
|
|
|
}
|
|
|
|
|
|
|
|
upriv->mmc = &plat->mmc;
|
|
|
|
|
|
|
|
/* Reset controller */
|
|
|
|
writel(SUNXI_MMC_GCTRL_RESET, &priv->reg->gctrl);
|
|
|
|
udelay(1000);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sunxi_mmc_bind(struct udevice *dev)
|
|
|
|
{
|
2020-12-03 23:55:20 +00:00
|
|
|
struct sunxi_mmc_plat *plat = dev_get_plat(dev);
|
2017-07-04 19:31:27 +00:00
|
|
|
|
|
|
|
return mmc_bind(dev, &plat->mmc, &plat->cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct udevice_id sunxi_mmc_ids[] = {
|
2021-01-11 20:11:44 +00:00
|
|
|
{ .compatible = "allwinner,sun4i-a10-mmc" },
|
|
|
|
{ .compatible = "allwinner,sun5i-a13-mmc" },
|
|
|
|
{ .compatible = "allwinner,sun7i-a20-mmc" },
|
|
|
|
{ .compatible = "allwinner,sun8i-a83t-emmc" },
|
|
|
|
{ .compatible = "allwinner,sun9i-a80-mmc" },
|
|
|
|
{ .compatible = "allwinner,sun50i-a64-mmc" },
|
|
|
|
{ .compatible = "allwinner,sun50i-a64-emmc" },
|
|
|
|
{ .compatible = "allwinner,sun50i-h6-mmc" },
|
|
|
|
{ .compatible = "allwinner,sun50i-h6-emmc" },
|
|
|
|
{ .compatible = "allwinner,sun50i-a100-mmc" },
|
|
|
|
{ .compatible = "allwinner,sun50i-a100-emmc" },
|
2019-01-09 11:28:39 +00:00
|
|
|
{ /* sentinel */ }
|
2017-07-04 19:31:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
U_BOOT_DRIVER(sunxi_mmc_drv) = {
|
|
|
|
.name = "sunxi_mmc",
|
|
|
|
.id = UCLASS_MMC,
|
|
|
|
.of_match = sunxi_mmc_ids,
|
|
|
|
.bind = sunxi_mmc_bind,
|
|
|
|
.probe = sunxi_mmc_probe,
|
|
|
|
.ops = &sunxi_mmc_ops,
|
2020-12-03 23:55:18 +00:00
|
|
|
.plat_auto = sizeof(struct sunxi_mmc_plat),
|
2020-12-03 23:55:17 +00:00
|
|
|
.priv_auto = sizeof(struct sunxi_mmc_priv),
|
2017-07-04 19:31:27 +00:00
|
|
|
};
|
|
|
|
#endif
|