[linux-2.6-block.git] / drivers / mmc / host / sdhci-pxav3.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2010 Marvell International Ltd.
 *		Zhangfei Gao <zhangfei.gao@marvell.com>
 *		Kevin Wang <dwang4@marvell.com>
 *		Mingwei Wang <mwwang@marvell.com>
 *		Philip Rakity <prakity@marvell.com>
 *		Mark Brown <markb@marvell.com>
 */
#include <linux/err.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/mmc/card.h>
#include <linux/mmc/host.h>
#include <linux/platform_data/pxa_sdhci.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/pm.h>
#include <linux/pm_runtime.h>
#include <linux/mbus.h>

#include "sdhci.h"
#include "sdhci-pltfm.h"

#define PXAV3_RPM_DELAY_MS     50

#define SD_CLOCK_BURST_SIZE_SETUP		0x10A
#define SDCLK_SEL	0x100
#define SDCLK_DELAY_SHIFT	9
#define SDCLK_DELAY_MASK	0x1f

#define SD_CFG_FIFO_PARAM       0x100
#define SDCFG_GEN_PAD_CLK_ON	(1<<6)
#define SDCFG_GEN_PAD_CLK_CNT_MASK	0xFF
#define SDCFG_GEN_PAD_CLK_CNT_SHIFT	24

#define SD_SPI_MODE          0x108
#define SD_CE_ATA_1          0x10C

#define SD_CE_ATA_2          0x10E
#define SDCE_MISC_INT		(1<<2)
#define SDCE_MISC_INT_EN	(1<<1)

struct sdhci_pxa {
	struct clk *clk_core;
	struct clk *clk_io;
	u8	power_mode;
	void __iomem *sdio3_conf_reg;
};

/*
 * These registers are relative to the second register region, for the
 * MBus bridge.
 */
#define SDHCI_WINDOW_CTRL(i)	(0x80 + ((i) << 3))
#define SDHCI_WINDOW_BASE(i)	(0x84 + ((i) << 3))
#define SDHCI_MAX_WIN_NUM	8

/*
 * Fields below belong to SDIO3 Configuration Register (third register
 * region for the Armada 38x flavor)
 */

#define SDIO3_CONF_CLK_INV	BIT(0)
#define SDIO3_CONF_SD_FB_CLK	BIT(2)

static int mv_conf_mbus_windows(struct platform_device *pdev,
				const struct mbus_dram_target_info *dram)
{
	int i;
	void __iomem *regs;
	struct resource *res;

	if (!dram) {
		dev_err(&pdev->dev, "no mbus dram info\n");
		return -EINVAL;
	}

	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	if (!res) {
		dev_err(&pdev->dev, "cannot get mbus registers\n");
		return -EINVAL;
	}

	regs = ioremap(res->start, resource_size(res));
	if (!regs) {
		dev_err(&pdev->dev, "cannot map mbus registers\n");
		return -ENOMEM;
	}

	for (i = 0; i < SDHCI_MAX_WIN_NUM; i++) {
		writel(0, regs + SDHCI_WINDOW_CTRL(i));
		writel(0, regs + SDHCI_WINDOW_BASE(i));
	}

	for (i = 0; i < dram->num_cs; i++) {
		const struct mbus_dram_window *cs = dram->cs + i;

		/* Write size, attributes and target id to control register */
		writel(((cs->size - 1) & 0xffff0000) |
			(cs->mbus_attr << 8) |
			(dram->mbus_dram_target_id << 4) | 1,
			regs + SDHCI_WINDOW_CTRL(i));
		/* Write base address to base register */
		writel(cs->base, regs + SDHCI_WINDOW_BASE(i));
	}

	iounmap(regs);

	return 0;
}

static int armada_38x_quirks(struct platform_device *pdev,
			     struct sdhci_host *host)
{
	struct device_node *np = pdev->dev.of_node;
	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
	struct resource *res;

	host->quirks &= ~SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN;

	sdhci_read_caps(host);

	res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
					   "conf-sdio3");
	if (res) {
		pxa->sdio3_conf_reg = devm_ioremap_resource(&pdev->dev, res);
		if (IS_ERR(pxa->sdio3_conf_reg))
			return PTR_ERR(pxa->sdio3_conf_reg);
	} else {
		/*
		 * According to erratum 'FE-2946959' both SDR50 and DDR50
		 * modes require specific clock adjustments in SDIO3
		 * Configuration register, if the adjustment is not done,
		 * remove them from the capabilities.
		 */
		host->caps1 &= ~(SDHCI_SUPPORT_SDR50 | SDHCI_SUPPORT_DDR50);

		dev_warn(&pdev->dev, "conf-sdio3 register not found: disabling SDR50 and DDR50 modes.\nConsider updating your dtb\n");
	}

	/*
	 * According to erratum 'ERR-7878951' Armada 38x SDHCI
	 * controller has different capabilities than the ones shown
	 * in its registers
	 */
	if (of_property_read_bool(np, "no-1-8-v")) {
		host->caps &= ~SDHCI_CAN_VDD_180;
		host->mmc->caps &= ~MMC_CAP_1_8V_DDR;
	} else {
		host->caps &= ~SDHCI_CAN_VDD_330;
	}
	host->caps1 &= ~(SDHCI_SUPPORT_SDR104 | SDHCI_USE_SDR50_TUNING);

	return 0;
}

static void pxav3_reset(struct sdhci_host *host, u8 mask)
{
	struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
	struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;

	sdhci_reset(host, mask);

	if (mask == SDHCI_RESET_ALL) {
		/*
		 * tune timing of read data/command when crc error happen
		 * no performance impact
		 */
		if (pdata && 0 != pdata->clk_delay_cycles) {
			u16 tmp;

			tmp = readw(host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP);
			tmp |= (pdata->clk_delay_cycles & SDCLK_DELAY_MASK)
				<< SDCLK_DELAY_SHIFT;
			tmp |= SDCLK_SEL;
			writew(tmp, host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP);
		}
	}
}

#define MAX_WAIT_COUNT 5
static void pxav3_gen_init_74_clocks(struct sdhci_host *host, u8 power_mode)
{
	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
	u16 tmp;
	int count;

	if (pxa->power_mode == MMC_POWER_UP
			&& power_mode == MMC_POWER_ON) {

		dev_dbg(mmc_dev(host->mmc),
				"%s: slot->power_mode = %d,"
				"ios->power_mode = %d\n",
				__func__,
				pxa->power_mode,
				power_mode);

		/* set we want notice of when 74 clocks are sent */
		tmp = readw(host->ioaddr + SD_CE_ATA_2);
		tmp |= SDCE_MISC_INT_EN;
		writew(tmp, host->ioaddr + SD_CE_ATA_2);

		/* start sending the 74 clocks */
		tmp = readw(host->ioaddr + SD_CFG_FIFO_PARAM);
		tmp |= SDCFG_GEN_PAD_CLK_ON;
		writew(tmp, host->ioaddr + SD_CFG_FIFO_PARAM);

		/* slowest speed is about 100KHz or 10usec per clock */
		udelay(740);
		count = 0;

		while (count++ < MAX_WAIT_COUNT) {
			if ((readw(host->ioaddr + SD_CE_ATA_2)
						& SDCE_MISC_INT) == 0)
				break;
			udelay(10);
		}

		if (count == MAX_WAIT_COUNT)
			dev_warn(mmc_dev(host->mmc), "74 clock interrupt not cleared\n");

		/* clear the interrupt bit if posted */
		tmp = readw(host->ioaddr + SD_CE_ATA_2);
		tmp |= SDCE_MISC_INT;
		writew(tmp, host->ioaddr + SD_CE_ATA_2);
	}
	pxa->power_mode = power_mode;
}

static void pxav3_set_uhs_signaling(struct sdhci_host *host, unsigned int uhs)
{
	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
	u16 ctrl_2;

	/*
	 * Set V18_EN -- UHS modes do not work without this.
	 * does not change signaling voltage
	 */
	ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);

	/* Select Bus Speed Mode for host */
	ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
	switch (uhs) {
	case MMC_TIMING_UHS_SDR12:
		ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
		break;
	case MMC_TIMING_UHS_SDR25:
		ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
		break;
	case MMC_TIMING_UHS_SDR50:
		ctrl_2 |= SDHCI_CTRL_UHS_SDR50 | SDHCI_CTRL_VDD_180;
		break;
	case MMC_TIMING_UHS_SDR104:
		ctrl_2 |= SDHCI_CTRL_UHS_SDR104 | SDHCI_CTRL_VDD_180;
		break;
	case MMC_TIMING_MMC_DDR52:
	case MMC_TIMING_UHS_DDR50:
		ctrl_2 |= SDHCI_CTRL_UHS_DDR50 | SDHCI_CTRL_VDD_180;
		break;
	}

	/*
	 * Update SDIO3 Configuration register according to erratum
	 * FE-2946959
	 */
	if (pxa->sdio3_conf_reg) {
		u8 reg_val  = readb(pxa->sdio3_conf_reg);

		if (uhs == MMC_TIMING_UHS_SDR50 ||
		    uhs == MMC_TIMING_UHS_DDR50) {
			reg_val &= ~SDIO3_CONF_CLK_INV;
			reg_val |= SDIO3_CONF_SD_FB_CLK;
		} else if (uhs == MMC_TIMING_MMC_HS) {
			reg_val &= ~SDIO3_CONF_CLK_INV;
			reg_val &= ~SDIO3_CONF_SD_FB_CLK;
		} else {
			reg_val |= SDIO3_CONF_CLK_INV;
			reg_val &= ~SDIO3_CONF_SD_FB_CLK;
		}
		writeb(reg_val, pxa->sdio3_conf_reg);
	}

	sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
	dev_dbg(mmc_dev(host->mmc),
		"%s uhs = %d, ctrl_2 = %04X\n",
		__func__, uhs, ctrl_2);
}

static void pxav3_set_power(struct sdhci_host *host, unsigned char mode,
			    unsigned short vdd)
{
	struct mmc_host *mmc = host->mmc;
	u8 pwr = host->pwr;

	sdhci_set_power_noreg(host, mode, vdd);

	if (host->pwr == pwr)
		return;

	if (host->pwr == 0)
		vdd = 0;

	if (!IS_ERR(mmc->supply.vmmc))
		mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd);
}

static const struct sdhci_ops pxav3_sdhci_ops = {
	.set_clock = sdhci_set_clock,
	.set_power = pxav3_set_power,
	.platform_send_init_74_clocks = pxav3_gen_init_74_clocks,
	.get_max_clock = sdhci_pltfm_clk_get_max_clock,
	.set_bus_width = sdhci_set_bus_width,
	.reset = pxav3_reset,
	.set_uhs_signaling = pxav3_set_uhs_signaling,
};

static const struct sdhci_pltfm_data sdhci_pxav3_pdata = {
	.quirks = SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK
		| SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
		| SDHCI_QUIRK_32BIT_ADMA_SIZE
		| SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN,
	.ops = &pxav3_sdhci_ops,
};

#ifdef CONFIG_OF
static const struct of_device_id sdhci_pxav3_of_match[] = {
	{
		.compatible = "mrvl,pxav3-mmc",
	},
	{
		.compatible = "marvell,armada-380-sdhci",
	},
	{},
};
MODULE_DEVICE_TABLE(of, sdhci_pxav3_of_match);

static struct sdhci_pxa_platdata *pxav3_get_mmc_pdata(struct device *dev)
{
	struct sdhci_pxa_platdata *pdata;
	struct device_node *np = dev->of_node;
	u32 clk_delay_cycles;

	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata)
		return NULL;

	if (!of_property_read_u32(np, "mrvl,clk-delay-cycles",
				  &clk_delay_cycles))
		pdata->clk_delay_cycles = clk_delay_cycles;

	return pdata;
}
#else
static inline struct sdhci_pxa_platdata *pxav3_get_mmc_pdata(struct device *dev)
{
	return NULL;
}
#endif

static int sdhci_pxav3_probe(struct platform_device *pdev)
{
	struct sdhci_pltfm_host *pltfm_host;
	struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
	struct device *dev = &pdev->dev;
	struct device_node *np = pdev->dev.of_node;
	struct sdhci_host *host = NULL;
	struct sdhci_pxa *pxa = NULL;
	const struct of_device_id *match;
	int ret;

	host = sdhci_pltfm_init(pdev, &sdhci_pxav3_pdata, sizeof(*pxa));
	if (IS_ERR(host))
		return PTR_ERR(host);

	pltfm_host = sdhci_priv(host);
	pxa = sdhci_pltfm_priv(pltfm_host);

	pxa->clk_io = devm_clk_get(dev, "io");
	if (IS_ERR(pxa->clk_io))
		pxa->clk_io = devm_clk_get(dev, NULL);
	if (IS_ERR(pxa->clk_io)) {
		dev_err(dev, "failed to get io clock\n");
		ret = PTR_ERR(pxa->clk_io);
		goto err_clk_get;
	}
	pltfm_host->clk = pxa->clk_io;
	clk_prepare_enable(pxa->clk_io);

	pxa->clk_core = devm_clk_get(dev, "core");
	if (!IS_ERR(pxa->clk_core))
		clk_prepare_enable(pxa->clk_core);

	/* enable 1/8V DDR capable */
	host->mmc->caps |= MMC_CAP_1_8V_DDR;

	if (of_device_is_compatible(np, "marvell,armada-380-sdhci")) {
		ret = armada_38x_quirks(pdev, host);
		if (ret < 0)
			goto err_mbus_win;
		ret = mv_conf_mbus_windows(pdev, mv_mbus_dram_info());
		if (ret < 0)
			goto err_mbus_win;
	}

	match = of_match_device(of_match_ptr(sdhci_pxav3_of_match), &pdev->dev);
	if (match) {
		ret = mmc_of_parse(host->mmc);
		if (ret)
			goto err_of_parse;
		sdhci_get_of_property(pdev);
		pdata = pxav3_get_mmc_pdata(dev);
		pdev->dev.platform_data = pdata;
	} else if (pdata) {
		/* on-chip device */
		if (pdata->flags & PXA_FLAG_CARD_PERMANENT)
			host->mmc->caps |= MMC_CAP_NONREMOVABLE;

		/* If slot design supports 8 bit data, indicate this to MMC. */
		if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT)
			host->mmc->caps |= MMC_CAP_8_BIT_DATA;

		if (pdata->quirks)
			host->quirks |= pdata->quirks;
		if (pdata->quirks2)
			host->quirks2 |= pdata->quirks2;
		if (pdata->host_caps)
			host->mmc->caps |= pdata->host_caps;
		if (pdata->host_caps2)
			host->mmc->caps2 |= pdata->host_caps2;
		if (pdata->pm_caps)
			host->mmc->pm_caps |= pdata->pm_caps;
	}

	pm_runtime_get_noresume(&pdev->dev);
	pm_runtime_set_active(&pdev->dev);
	pm_runtime_set_autosuspend_delay(&pdev->dev, PXAV3_RPM_DELAY_MS);
	pm_runtime_use_autosuspend(&pdev->dev);
	pm_runtime_enable(&pdev->dev);
	pm_suspend_ignore_children(&pdev->dev, 1);

	ret = sdhci_add_host(host);
	if (ret)
		goto err_add_host;

	if (host->mmc->pm_caps & MMC_PM_WAKE_SDIO_IRQ)
		device_init_wakeup(&pdev->dev, 1);

	pm_runtime_put_autosuspend(&pdev->dev);

	return 0;

err_add_host:
	pm_runtime_disable(&pdev->dev);
	pm_runtime_put_noidle(&pdev->dev);
err_of_parse:
err_mbus_win:
	clk_disable_unprepare(pxa->clk_io);
	clk_disable_unprepare(pxa->clk_core);
err_clk_get:
	sdhci_pltfm_free(pdev);
	return ret;
}

static void sdhci_pxav3_remove(struct platform_device *pdev)
{
	struct sdhci_host *host = platform_get_drvdata(pdev);
	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);

	pm_runtime_get_sync(&pdev->dev);
	pm_runtime_disable(&pdev->dev);
	pm_runtime_put_noidle(&pdev->dev);

	sdhci_remove_host(host, 1);

	clk_disable_unprepare(pxa->clk_io);
	clk_disable_unprepare(pxa->clk_core);

	sdhci_pltfm_free(pdev);
}

#ifdef CONFIG_PM_SLEEP
static int sdhci_pxav3_suspend(struct device *dev)
{
	int ret;
	struct sdhci_host *host = dev_get_drvdata(dev);

	pm_runtime_get_sync(dev);
	if (host->tuning_mode != SDHCI_TUNING_MODE_3)
		mmc_retune_needed(host->mmc);
	ret = sdhci_suspend_host(host);
	pm_runtime_mark_last_busy(dev);
	pm_runtime_put_autosuspend(dev);

	return ret;
}

static int sdhci_pxav3_resume(struct device *dev)
{
	int ret;
	struct sdhci_host *host = dev_get_drvdata(dev);

	pm_runtime_get_sync(dev);
	ret = sdhci_resume_host(host);
	pm_runtime_mark_last_busy(dev);
	pm_runtime_put_autosuspend(dev);

	return ret;
}
#endif

#ifdef CONFIG_PM
static int sdhci_pxav3_runtime_suspend(struct device *dev)
{
	struct sdhci_host *host = dev_get_drvdata(dev);
	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
	int ret;

	ret = sdhci_runtime_suspend_host(host);
	if (ret)
		return ret;

	if (host->tuning_mode != SDHCI_TUNING_MODE_3)
		mmc_retune_needed(host->mmc);

	clk_disable_unprepare(pxa->clk_io);
	if (!IS_ERR(pxa->clk_core))
		clk_disable_unprepare(pxa->clk_core);

	return 0;
}

static int sdhci_pxav3_runtime_resume(struct device *dev)
{
	struct sdhci_host *host = dev_get_drvdata(dev);
	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);

	clk_prepare_enable(pxa->clk_io);
	if (!IS_ERR(pxa->clk_core))
		clk_prepare_enable(pxa->clk_core);

	return sdhci_runtime_resume_host(host, 0);
}
#endif

static const struct dev_pm_ops sdhci_pxav3_pmops = {
	SET_SYSTEM_SLEEP_PM_OPS(sdhci_pxav3_suspend, sdhci_pxav3_resume)
	SET_RUNTIME_PM_OPS(sdhci_pxav3_runtime_suspend,
		sdhci_pxav3_runtime_resume, NULL)
};

static struct platform_driver sdhci_pxav3_driver = {
	.driver		= {
		.name	= "sdhci-pxav3",
		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
		.of_match_table = of_match_ptr(sdhci_pxav3_of_match),
		.pm	= &sdhci_pxav3_pmops,
	},
	.probe		= sdhci_pxav3_probe,
	.remove_new	= sdhci_pxav3_remove,
};

module_platform_driver(sdhci_pxav3_driver);

MODULE_DESCRIPTION("SDHCI driver for pxav3");
MODULE_AUTHOR("Marvell International Ltd.");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
9c92ab61	1	// SPDX-License-Identifier: GPL-2.0-only
a702c8ab ZG	2	/*
	3	* Copyright (C) 2010 Marvell International Ltd.
	4	* Zhangfei Gao <zhangfei.gao@marvell.com>
	5	* Kevin Wang <dwang4@marvell.com>
	6	* Mingwei Wang <mwwang@marvell.com>
	7	* Philip Rakity <prakity@marvell.com>
	8	* Mark Brown <markb@marvell.com>
a702c8ab ZG	9	*/
	10	#include <linux/err.h>
	11	#include <linux/init.h>
	12	#include <linux/platform_device.h>
	13	#include <linux/clk.h>
	14	#include <linux/io.h>
a702c8ab ZG	15	#include <linux/mmc/card.h>
a702c8ab ZG	16	#include <linux/mmc/host.h>
bfed345e	17	#include <linux/platform_data/pxa_sdhci.h>
a702c8ab ZG	18	#include <linux/slab.h>
a702c8ab ZG	19	#include <linux/delay.h>
88b47679	20	#include <linux/module.h>
b650352d CB	21	#include <linux/of.h>
b650352d CB	22	#include <linux/of_device.h>
bb691ae4 KL	23	#include <linux/pm.h>
bb691ae4 KL	24	#include <linux/pm_runtime.h>
5491ce3f	25	#include <linux/mbus.h>
b650352d	26
a702c8ab ZG	27	#include "sdhci.h"
	28	#include "sdhci-pltfm.h"
	29
bb691ae4 KL	30	#define PXAV3_RPM_DELAY_MS 50
bb691ae4 KL	31
a702c8ab ZG	32	#define SD_CLOCK_BURST_SIZE_SETUP 0x10A
	33	#define SDCLK_SEL 0x100
	34	#define SDCLK_DELAY_SHIFT 9
	35	#define SDCLK_DELAY_MASK 0x1f
	36
	37	#define SD_CFG_FIFO_PARAM 0x100
	38	#define SDCFG_GEN_PAD_CLK_ON (1<<6)
	39	#define SDCFG_GEN_PAD_CLK_CNT_MASK 0xFF
	40	#define SDCFG_GEN_PAD_CLK_CNT_SHIFT 24
	41
	42	#define SD_SPI_MODE 0x108
	43	#define SD_CE_ATA_1 0x10C
	44
	45	#define SD_CE_ATA_2 0x10E
	46	#define SDCE_MISC_INT (1<<2)
	47	#define SDCE_MISC_INT_EN (1<<1)
	48
cc9571e8	49	struct sdhci_pxa {
8afdc9cc	50	struct clk *clk_core;
8c96a7a3	51	struct clk *clk_io;
cc9571e8	52	u8 power_mode;
1140011e	53	void __iomem *sdio3_conf_reg;
cc9571e8 SH	54	};
cc9571e8 SH	55
5491ce3f MW	56	/*
	57	* These registers are relative to the second register region, for the
	58	* MBus bridge.
	59	*/
	60	#define SDHCI_WINDOW_CTRL(i) (0x80 + ((i) << 3))
	61	#define SDHCI_WINDOW_BASE(i) (0x84 + ((i) << 3))
	62	#define SDHCI_MAX_WIN_NUM 8
	63
1140011e MW	64	/*
	65	* Fields below belong to SDIO3 Configuration Register (third register
	66	* region for the Armada 38x flavor)
	67	*/
	68
	69	#define SDIO3_CONF_CLK_INV BIT(0)
	70	#define SDIO3_CONF_SD_FB_CLK BIT(2)
	71
5491ce3f MW	72	static int mv_conf_mbus_windows(struct platform_device *pdev,
	73	const struct mbus_dram_target_info *dram)
	74	{
	75	int i;
	76	void __iomem *regs;
	77	struct resource *res;
	78
	79	if (!dram) {
	80	dev_err(&pdev->dev, "no mbus dram info\n");
	81	return -EINVAL;
	82	}
	83
	84	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	85	if (!res) {
	86	dev_err(&pdev->dev, "cannot get mbus registers\n");
	87	return -EINVAL;
	88	}
	89
	90	regs = ioremap(res->start, resource_size(res));
	91	if (!regs) {
	92	dev_err(&pdev->dev, "cannot map mbus registers\n");
	93	return -ENOMEM;
	94	}
	95
	96	for (i = 0; i < SDHCI_MAX_WIN_NUM; i++) {
	97	writel(0, regs + SDHCI_WINDOW_CTRL(i));
	98	writel(0, regs + SDHCI_WINDOW_BASE(i));
	99	}
	100
	101	for (i = 0; i < dram->num_cs; i++) {
	102	const struct mbus_dram_window *cs = dram->cs + i;
	103
	104	/* Write size, attributes and target id to control register */
	105	writel(((cs->size - 1) & 0xffff0000) \|
	106	(cs->mbus_attr << 8) \|
	107	(dram->mbus_dram_target_id << 4) \| 1,
	108	regs + SDHCI_WINDOW_CTRL(i));
	109	/* Write base address to base register */
	110	writel(cs->base, regs + SDHCI_WINDOW_BASE(i));
	111	}
	112
	113	iounmap(regs);
	114
	115	return 0;
	116	}
	117
a39128bc MW	118	static int armada_38x_quirks(struct platform_device *pdev,
a39128bc MW	119	struct sdhci_host *host)
d4b803c5	120	{
a39128bc	121	struct device_node *np = pdev->dev.of_node;
1140011e	122	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
f599da40	123	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
1140011e	124	struct resource *res;
a39128bc	125
5de76bfc	126	host->quirks &= ~SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN;
0ca33b4a	127
4f1896dd	128	sdhci_read_caps(host);
0ca33b4a	129
1140011e MW	130	res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
	131	"conf-sdio3");
	132	if (res) {
	133	pxa->sdio3_conf_reg = devm_ioremap_resource(&pdev->dev, res);
	134	if (IS_ERR(pxa->sdio3_conf_reg))
	135	return PTR_ERR(pxa->sdio3_conf_reg);
	136	} else {
	137	/*
	138	* According to erratum 'FE-2946959' both SDR50 and DDR50
	139	* modes require specific clock adjustments in SDIO3
	140	* Configuration register, if the adjustment is not done,
	141	* remove them from the capabilities.
	142	*/
1140011e MW	143	host->caps1 &= ~(SDHCI_SUPPORT_SDR50 \| SDHCI_SUPPORT_DDR50);
	144
	145	dev_warn(&pdev->dev, "conf-sdio3 register not found: disabling SDR50 and DDR50 modes.\nConsider updating your dtb\n");
	146	}
a39128bc MW	147
	148	/*
	149	* According to erratum 'ERR-7878951' Armada 38x SDHCI
	150	* controller has different capabilities than the ones shown
	151	* in its registers
	152	*/
a39128bc MW	153	if (of_property_read_bool(np, "no-1-8-v")) {
	154	host->caps &= ~SDHCI_CAN_VDD_180;
	155	host->mmc->caps &= ~MMC_CAP_1_8V_DDR;
	156	} else {
	157	host->caps &= ~SDHCI_CAN_VDD_330;
	158	}
	159	host->caps1 &= ~(SDHCI_SUPPORT_SDR104 \| SDHCI_USE_SDR50_TUNING);
	160
d4b803c5 GC	161	return 0;
	162	}
	163
03231f9b	164	static void pxav3_reset(struct sdhci_host *host, u8 mask)
a702c8ab ZG	165	{
	166	struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
	167	struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
	168
03231f9b RK	169	sdhci_reset(host, mask);
03231f9b RK	170
a702c8ab ZG	171	if (mask == SDHCI_RESET_ALL) {
	172	/*
	173	* tune timing of read data/command when crc error happen
	174	* no performance impact
	175	*/
	176	if (pdata && 0 != pdata->clk_delay_cycles) {
	177	u16 tmp;
	178
	179	tmp = readw(host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP);
	180	tmp \|= (pdata->clk_delay_cycles & SDCLK_DELAY_MASK)
	181	<< SDCLK_DELAY_SHIFT;
	182	tmp \|= SDCLK_SEL;
	183	writew(tmp, host->ioaddr + SD_CLOCK_BURST_SIZE_SETUP);
	184	}
	185	}
	186	}
	187
	188	#define MAX_WAIT_COUNT 5
	189	static void pxav3_gen_init_74_clocks(struct sdhci_host *host, u8 power_mode)
	190	{
	191	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
f599da40	192	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
a702c8ab ZG	193	u16 tmp;
	194	int count;
	195
	196	if (pxa->power_mode == MMC_POWER_UP
	197	&& power_mode == MMC_POWER_ON) {
	198
	199	dev_dbg(mmc_dev(host->mmc),
	200	"%s: slot->power_mode = %d,"
	201	"ios->power_mode = %d\n",
	202	__func__,
	203	pxa->power_mode,
	204	power_mode);
	205
	206	/* set we want notice of when 74 clocks are sent */
	207	tmp = readw(host->ioaddr + SD_CE_ATA_2);
	208	tmp \|= SDCE_MISC_INT_EN;
	209	writew(tmp, host->ioaddr + SD_CE_ATA_2);
	210
	211	/* start sending the 74 clocks */
	212	tmp = readw(host->ioaddr + SD_CFG_FIFO_PARAM);
	213	tmp \|= SDCFG_GEN_PAD_CLK_ON;
	214	writew(tmp, host->ioaddr + SD_CFG_FIFO_PARAM);
	215
	216	/* slowest speed is about 100KHz or 10usec per clock */
	217	udelay(740);
	218	count = 0;
	219
	220	while (count++ < MAX_WAIT_COUNT) {
	221	if ((readw(host->ioaddr + SD_CE_ATA_2)
	222	& SDCE_MISC_INT) == 0)
	223	break;
	224	udelay(10);
	225	}
	226
	227	if (count == MAX_WAIT_COUNT)
	228	dev_warn(mmc_dev(host->mmc), "74 clock interrupt not cleared\n");
	229
	230	/* clear the interrupt bit if posted */
	231	tmp = readw(host->ioaddr + SD_CE_ATA_2);
	232	tmp \|= SDCE_MISC_INT;
	233	writew(tmp, host->ioaddr + SD_CE_ATA_2);
	234	}
	235	pxa->power_mode = power_mode;
	236	}
	237
13e64501	238	static void pxav3_set_uhs_signaling(struct sdhci_host *host, unsigned int uhs)
a702c8ab	239	{
1140011e	240	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
f599da40	241	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
a702c8ab ZG	242	u16 ctrl_2;
	243
	244	/*
	245	* Set V18_EN -- UHS modes do not work without this.
	246	* does not change signaling voltage
	247	*/
	248	ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
	249
	250	/* Select Bus Speed Mode for host */
	251	ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
	252	switch (uhs) {
	253	case MMC_TIMING_UHS_SDR12:
	254	ctrl_2 \|= SDHCI_CTRL_UHS_SDR12;
	255	break;
	256	case MMC_TIMING_UHS_SDR25:
	257	ctrl_2 \|= SDHCI_CTRL_UHS_SDR25;
	258	break;
	259	case MMC_TIMING_UHS_SDR50:
	260	ctrl_2 \|= SDHCI_CTRL_UHS_SDR50 \| SDHCI_CTRL_VDD_180;
	261	break;
	262	case MMC_TIMING_UHS_SDR104:
	263	ctrl_2 \|= SDHCI_CTRL_UHS_SDR104 \| SDHCI_CTRL_VDD_180;
	264	break;
668e84b2	265	case MMC_TIMING_MMC_DDR52:
a702c8ab ZG	266	case MMC_TIMING_UHS_DDR50:
	267	ctrl_2 \|= SDHCI_CTRL_UHS_DDR50 \| SDHCI_CTRL_VDD_180;
	268	break;
	269	}
	270
1140011e MW	271	/*
	272	* Update SDIO3 Configuration register according to erratum
	273	* FE-2946959
	274	*/
	275	if (pxa->sdio3_conf_reg) {
	276	u8 reg_val = readb(pxa->sdio3_conf_reg);
	277
	278	if (uhs == MMC_TIMING_UHS_SDR50 \|\|
	279	uhs == MMC_TIMING_UHS_DDR50) {
	280	reg_val &= ~SDIO3_CONF_CLK_INV;
	281	reg_val \|= SDIO3_CONF_SD_FB_CLK;
fa796414 NH	282	} else if (uhs == MMC_TIMING_MMC_HS) {
	283	reg_val &= ~SDIO3_CONF_CLK_INV;
	284	reg_val &= ~SDIO3_CONF_SD_FB_CLK;
1140011e MW	285	} else {
	286	reg_val \|= SDIO3_CONF_CLK_INV;
	287	reg_val &= ~SDIO3_CONF_SD_FB_CLK;
	288	}
	289	writeb(reg_val, pxa->sdio3_conf_reg);
	290	}
	291
a702c8ab ZG	292	sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
	293	dev_dbg(mmc_dev(host->mmc),
	294	"%s uhs = %d, ctrl_2 = %04X\n",
	295	__func__, uhs, ctrl_2);
a702c8ab ZG	296	}
a702c8ab ZG	297
1dceb041 AH	298	static void pxav3_set_power(struct sdhci_host *host, unsigned char mode,
	299	unsigned short vdd)
	300	{
	301	struct mmc_host *mmc = host->mmc;
	302	u8 pwr = host->pwr;
	303
606d3131	304	sdhci_set_power_noreg(host, mode, vdd);
1dceb041 AH	305
	306	if (host->pwr == pwr)
	307	return;
	308
	309	if (host->pwr == 0)
	310	vdd = 0;
	311
d1e4f74f	312	if (!IS_ERR(mmc->supply.vmmc))
1dceb041	313	mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd);
1dceb041 AH	314	}
1dceb041 AH	315
c915568d	316	static const struct sdhci_ops pxav3_sdhci_ops = {
1771059c	317	.set_clock = sdhci_set_clock,
1dceb041	318	.set_power = pxav3_set_power,
a702c8ab	319	.platform_send_init_74_clocks = pxav3_gen_init_74_clocks,
d005d943	320	.get_max_clock = sdhci_pltfm_clk_get_max_clock,
2317f56c	321	.set_bus_width = sdhci_set_bus_width,
03231f9b	322	.reset = pxav3_reset,
b3153765	323	.set_uhs_signaling = pxav3_set_uhs_signaling,
a702c8ab ZG	324	};
a702c8ab ZG	325
d35ade8f	326	static const struct sdhci_pltfm_data sdhci_pxav3_pdata = {
e065162a	327	.quirks = SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK
73b7afb9 KL	328	\| SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
	329	\| SDHCI_QUIRK_32BIT_ADMA_SIZE
	330	\| SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN,
	331	.ops = &pxav3_sdhci_ops,
	332	};
	333
b650352d CB	334	#ifdef CONFIG_OF
	335	static const struct of_device_id sdhci_pxav3_of_match[] = {
	336	{
	337	.compatible = "mrvl,pxav3-mmc",
	338	},
5491ce3f MW	339	{
	340	.compatible = "marvell,armada-380-sdhci",
	341	},
b650352d CB	342	{},
	343	};
	344	MODULE_DEVICE_TABLE(of, sdhci_pxav3_of_match);
	345
	346	static struct sdhci_pxa_platdata pxav3_get_mmc_pdata(struct device dev)
	347	{
	348	struct sdhci_pxa_platdata *pdata;
	349	struct device_node *np = dev->of_node;
b650352d CB	350	u32 clk_delay_cycles;
	351
	352	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
	353	if (!pdata)
	354	return NULL;
	355
14460dba JZ	356	if (!of_property_read_u32(np, "mrvl,clk-delay-cycles",
14460dba JZ	357	&clk_delay_cycles))
b650352d CB	358	pdata->clk_delay_cycles = clk_delay_cycles;
	359
	360	return pdata;
	361	}
	362	#else
	363	static inline struct sdhci_pxa_platdata pxav3_get_mmc_pdata(struct device dev)
	364	{
	365	return NULL;
	366	}
	367	#endif
	368
c3be1efd	369	static int sdhci_pxav3_probe(struct platform_device *pdev)
a702c8ab ZG	370	{
	371	struct sdhci_pltfm_host *pltfm_host;
	372	struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
	373	struct device *dev = &pdev->dev;
5491ce3f	374	struct device_node *np = pdev->dev.of_node;
a702c8ab ZG	375	struct sdhci_host *host = NULL;
a702c8ab ZG	376	struct sdhci_pxa *pxa = NULL;
b650352d	377	const struct of_device_id *match;
a702c8ab	378	int ret;
a702c8ab	379
f599da40	380	host = sdhci_pltfm_init(pdev, &sdhci_pxav3_pdata, sizeof(*pxa));
3df5b281	381	if (IS_ERR(host))
a702c8ab	382	return PTR_ERR(host);
5491ce3f	383
a702c8ab	384	pltfm_host = sdhci_priv(host);
f599da40	385	pxa = sdhci_pltfm_priv(pltfm_host);
a702c8ab	386
01ae1070 SH	387	pxa->clk_io = devm_clk_get(dev, "io");
	388	if (IS_ERR(pxa->clk_io))
	389	pxa->clk_io = devm_clk_get(dev, NULL);
8c96a7a3	390	if (IS_ERR(pxa->clk_io)) {
a702c8ab	391	dev_err(dev, "failed to get io clock\n");
8c96a7a3	392	ret = PTR_ERR(pxa->clk_io);
a702c8ab ZG	393	goto err_clk_get;
a702c8ab ZG	394	}
8c96a7a3 SH	395	pltfm_host->clk = pxa->clk_io;
8c96a7a3 SH	396	clk_prepare_enable(pxa->clk_io);
a702c8ab	397
8afdc9cc SH	398	pxa->clk_core = devm_clk_get(dev, "core");
	399	if (!IS_ERR(pxa->clk_core))
	400	clk_prepare_enable(pxa->clk_core);
	401
a39128bc MW	402	/* enable 1/8V DDR capable */
	403	host->mmc->caps \|= MMC_CAP_1_8V_DDR;
	404
aa8165f9	405	if (of_device_is_compatible(np, "marvell,armada-380-sdhci")) {
a39128bc	406	ret = armada_38x_quirks(pdev, host);
d4b803c5	407	if (ret < 0)
2162d9f4	408	goto err_mbus_win;
aa8165f9 TP	409	ret = mv_conf_mbus_windows(pdev, mv_mbus_dram_info());
	410	if (ret < 0)
	411	goto err_mbus_win;
	412	}
	413
b650352d	414	match = of_match_device(of_match_ptr(sdhci_pxav3_of_match), &pdev->dev);
943647f6	415	if (match) {
d2cf6071 SB	416	ret = mmc_of_parse(host->mmc);
	417	if (ret)
	418	goto err_of_parse;
943647f6	419	sdhci_get_of_property(pdev);
b650352d	420	pdata = pxav3_get_mmc_pdata(dev);
9cd76049	421	pdev->dev.platform_data = pdata;
943647f6	422	} else if (pdata) {
c844a46f KL	423	/* on-chip device */
c844a46f KL	424	if (pdata->flags & PXA_FLAG_CARD_PERMANENT)
a702c8ab	425	host->mmc->caps \|= MMC_CAP_NONREMOVABLE;
a702c8ab ZG	426
	427	/* If slot design supports 8 bit data, indicate this to MMC. */
	428	if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT)
	429	host->mmc->caps \|= MMC_CAP_8_BIT_DATA;
	430
	431	if (pdata->quirks)
	432	host->quirks \|= pdata->quirks;
7c52d7bb KL	433	if (pdata->quirks2)
7c52d7bb KL	434	host->quirks2 \|= pdata->quirks2;
a702c8ab ZG	435	if (pdata->host_caps)
a702c8ab ZG	436	host->mmc->caps \|= pdata->host_caps;
8f63795c CB	437	if (pdata->host_caps2)
8f63795c CB	438	host->mmc->caps2 \|= pdata->host_caps2;
a702c8ab ZG	439	if (pdata->pm_caps)
	440	host->mmc->pm_caps \|= pdata->pm_caps;
	441	}
	442
62cf983a JZ	443	pm_runtime_get_noresume(&pdev->dev);
62cf983a JZ	444	pm_runtime_set_active(&pdev->dev);
bb691ae4 KL	445	pm_runtime_set_autosuspend_delay(&pdev->dev, PXAV3_RPM_DELAY_MS);
bb691ae4 KL	446	pm_runtime_use_autosuspend(&pdev->dev);
62cf983a	447	pm_runtime_enable(&pdev->dev);
bb691ae4	448	pm_suspend_ignore_children(&pdev->dev, 1);
bb691ae4	449
a702c8ab	450	ret = sdhci_add_host(host);
fb8617e1	451	if (ret)
a702c8ab	452	goto err_add_host;
a702c8ab	453
83dc9fec	454	if (host->mmc->pm_caps & MMC_PM_WAKE_SDIO_IRQ)
740b7a44	455	device_init_wakeup(&pdev->dev, 1);
740b7a44	456
bb691ae4 KL	457	pm_runtime_put_autosuspend(&pdev->dev);
bb691ae4 KL	458
a702c8ab ZG	459	return 0;
	460
	461	err_add_host:
0dcaa249	462	pm_runtime_disable(&pdev->dev);
62cf983a	463	pm_runtime_put_noidle(&pdev->dev);
87d2163d	464	err_of_parse:
aa8165f9	465	err_mbus_win:
8c96a7a3	466	clk_disable_unprepare(pxa->clk_io);
c25d9e1b	467	clk_disable_unprepare(pxa->clk_core);
a702c8ab ZG	468	err_clk_get:
a702c8ab ZG	469	sdhci_pltfm_free(pdev);
a702c8ab ZG	470	return ret;
	471	}
	472
c61394aa	473	static void sdhci_pxav3_remove(struct platform_device *pdev)
a702c8ab ZG	474	{
	475	struct sdhci_host *host = platform_get_drvdata(pdev);
	476	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
f599da40	477	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
a702c8ab	478
bb691ae4	479	pm_runtime_get_sync(&pdev->dev);
bb691ae4	480	pm_runtime_disable(&pdev->dev);
20f1f2d7 JZ	481	pm_runtime_put_noidle(&pdev->dev);
	482
	483	sdhci_remove_host(host, 1);
a702c8ab	484
8c96a7a3	485	clk_disable_unprepare(pxa->clk_io);
c25d9e1b	486	clk_disable_unprepare(pxa->clk_core);
8f63795c	487
a702c8ab	488	sdhci_pltfm_free(pdev);
a702c8ab ZG	489	}
a702c8ab ZG	490
bb691ae4 KL	491	#ifdef CONFIG_PM_SLEEP
	492	static int sdhci_pxav3_suspend(struct device *dev)
	493	{
	494	int ret;
	495	struct sdhci_host *host = dev_get_drvdata(dev);
	496
	497	pm_runtime_get_sync(dev);
d38dcad4 AH	498	if (host->tuning_mode != SDHCI_TUNING_MODE_3)
d38dcad4 AH	499	mmc_retune_needed(host->mmc);
bb691ae4 KL	500	ret = sdhci_suspend_host(host);
	501	pm_runtime_mark_last_busy(dev);
	502	pm_runtime_put_autosuspend(dev);
	503
	504	return ret;
	505	}
	506
	507	static int sdhci_pxav3_resume(struct device *dev)
	508	{
	509	int ret;
	510	struct sdhci_host *host = dev_get_drvdata(dev);
	511
	512	pm_runtime_get_sync(dev);
	513	ret = sdhci_resume_host(host);
	514	pm_runtime_mark_last_busy(dev);
	515	pm_runtime_put_autosuspend(dev);
	516
	517	return ret;
	518	}
	519	#endif
	520
162d6f98	521	#ifdef CONFIG_PM
bb691ae4 KL	522	static int sdhci_pxav3_runtime_suspend(struct device *dev)
	523	{
	524	struct sdhci_host *host = dev_get_drvdata(dev);
	525	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
f599da40	526	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
3bb10f60	527	int ret;
bb691ae4	528
3bb10f60 JZ	529	ret = sdhci_runtime_suspend_host(host);
	530	if (ret)
	531	return ret;
bb691ae4	532
d38dcad4 AH	533	if (host->tuning_mode != SDHCI_TUNING_MODE_3)
	534	mmc_retune_needed(host->mmc);
	535
8c96a7a3	536	clk_disable_unprepare(pxa->clk_io);
8afdc9cc SH	537	if (!IS_ERR(pxa->clk_core))
8afdc9cc SH	538	clk_disable_unprepare(pxa->clk_core);
bb691ae4 KL	539
	540	return 0;
	541	}
	542
	543	static int sdhci_pxav3_runtime_resume(struct device *dev)
	544	{
	545	struct sdhci_host *host = dev_get_drvdata(dev);
	546	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
f599da40	547	struct sdhci_pxa *pxa = sdhci_pltfm_priv(pltfm_host);
bb691ae4	548
8c96a7a3	549	clk_prepare_enable(pxa->clk_io);
8afdc9cc SH	550	if (!IS_ERR(pxa->clk_core))
8afdc9cc SH	551	clk_prepare_enable(pxa->clk_core);
bb691ae4	552
c6303c5d	553	return sdhci_runtime_resume_host(host, 0);
bb691ae4 KL	554	}
	555	#endif
	556
bb691ae4 KL	557	static const struct dev_pm_ops sdhci_pxav3_pmops = {
	558	SET_SYSTEM_SLEEP_PM_OPS(sdhci_pxav3_suspend, sdhci_pxav3_resume)
	559	SET_RUNTIME_PM_OPS(sdhci_pxav3_runtime_suspend,
	560	sdhci_pxav3_runtime_resume, NULL)
	561	};
	562
a702c8ab ZG	563	static struct platform_driver sdhci_pxav3_driver = {
	564	.driver = {
	565	.name = "sdhci-pxav3",
21b2cec6	566	.probe_type = PROBE_PREFER_ASYNCHRONOUS,
59d22309	567	.of_match_table = of_match_ptr(sdhci_pxav3_of_match),
a81ce772	568	.pm = &sdhci_pxav3_pmops,
a702c8ab ZG	569	},
a702c8ab ZG	570	.probe = sdhci_pxav3_probe,
c61394aa	571	.remove_new = sdhci_pxav3_remove,
a702c8ab	572	};
a702c8ab	573
d1f81a64	574	module_platform_driver(sdhci_pxav3_driver);
a702c8ab ZG	575
	576	MODULE_DESCRIPTION("SDHCI driver for pxav3");
	577	MODULE_AUTHOR("Marvell International Ltd.");
	578	MODULE_LICENSE("GPL v2");
	579