Commit 536ac998 authored by Zhangfei Gao's avatar Zhangfei Gao Committed by Chris Ball
Browse files

mmc: add new sdhci-pxa driver for Marvell SoCs 



Support Marvell PXA168/PXA910/MMP2 SD Host Controller.

Signed-off-by: default avatarZhangfei Gao <zhangfei.gao@marvell.com>
Acked-by: default avatarHaojian Zhuang <haojian.zhuang@marvell.com>
Signed-off-by: default avatarChris Ball <cjb@laptop.org>
parent 5e71b7a6

arch/arm/plat-pxa/include/plat/sdhci.h

0 → 100644
+32 −0
Original line number Diff line number Diff line 
/* linux/arch/arm/plat-pxa/include/plat/sdhci.h

 *

 * Copyright 2010 Marvell

 *	Zhangfei Gao <zhangfei.gao@marvell.com>

 *

 * PXA Platform - SDHCI platform data definitions

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#ifndef __PLAT_PXA_SDHCI_H

#define __PLAT_PXA_SDHCI_H



/* pxa specific flag */

/* Require clock free running */

#define PXA_FLAG_DISABLE_CLOCK_GATING (1<<0)



/*

 * struct pxa_sdhci_platdata() - Platform device data for PXA SDHCI

 * @max_speed: the maximum speed supported

 * @quirks: quirks of specific device

 * @flags: flags for platform requirement

 */

struct sdhci_pxa_platdata {

	unsigned int	max_speed;

	unsigned int	quirks;

	unsigned int	flags;

};



#endif /* __PLAT_PXA_SDHCI_H */

drivers/mmc/host/Kconfig

+12 −0
Original line number Diff line number Diff line
@@ -155,6 +155,18 @@ config MMC_SDHCI_S3C 


	  If unsure, say N.



config MMC_SDHCI_PXA

	tristate "Marvell PXA168/PXA910/MMP2 SD Host Controller support"

	depends on ARCH_PXA || ARCH_MMP

	select MMC_SDHCI

	select MMC_SDHCI_IO_ACCESSORS

	help

	  This selects the Marvell(R) PXA168/PXA910/MMP2 SD Host Controller.

	  If you have a PXA168/PXA910/MMP2 platform with SD Host Controller

	  and a card slot, say Y or M here.



	  If unsure, say N.



config MMC_SDHCI_SPEAR

	tristate "SDHCI support on ST SPEAr platform"

	depends on MMC_SDHCI && PLAT_SPEAR

drivers/mmc/host/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ obj-$(CONFIG_MMC_IMX) += imxmmc.o 
obj-$(CONFIG_MMC_MXC)		+= mxcmmc.o

obj-$(CONFIG_MMC_SDHCI)		+= sdhci.o

obj-$(CONFIG_MMC_SDHCI_PCI)	+= sdhci-pci.o

obj-$(CONFIG_MMC_SDHCI_PXA)	+= sdhci-pxa.o

obj-$(CONFIG_MMC_SDHCI_S3C)	+= sdhci-s3c.o

obj-$(CONFIG_MMC_SDHCI_SPEAR)	+= sdhci-spear.o

obj-$(CONFIG_MMC_WBSD)		+= wbsd.o

drivers/mmc/host/sdhci-pxa.c

0 → 100644
+253 −0
Original line number Diff line number Diff line 
/* linux/drivers/mmc/host/sdhci-pxa.c

 *

 * 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>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



/* Supports:

 * SDHCI support for MMP2/PXA910/PXA168

 *

 * Refer to sdhci-s3c.c.

 */



#include <linux/delay.h>

#include <linux/platform_device.h>

#include <linux/mmc/host.h>

#include <linux/clk.h>

#include <linux/io.h>

#include <linux/err.h>

#include <plat/sdhci.h>

#include "sdhci.h"



#define DRIVER_NAME	"sdhci-pxa"



#define SD_FIFO_PARAM		0x104

#define DIS_PAD_SD_CLK_GATE	0x400



struct sdhci_pxa {

	struct sdhci_host		*host;

	struct sdhci_pxa_platdata	*pdata;

	struct clk			*clk;

	struct resource			*res;



	u8 clk_enable;

};



/*****************************************************************************\

 *                                                                           *

 * SDHCI core callbacks                                                      *

 *                                                                           *

\*****************************************************************************/

static void set_clock(struct sdhci_host *host, unsigned int clock)

{

	struct sdhci_pxa *pxa = sdhci_priv(host);

	u32 tmp = 0;



	if (clock == 0) {

		if (pxa->clk_enable) {

			clk_disable(pxa->clk);

			pxa->clk_enable = 0;

		}

	} else {

		if (0 == pxa->clk_enable) {

			if (pxa->pdata->flags & PXA_FLAG_DISABLE_CLOCK_GATING) {

				tmp = readl(host->ioaddr + SD_FIFO_PARAM);

				tmp |= DIS_PAD_SD_CLK_GATE;

				writel(tmp, host->ioaddr + SD_FIFO_PARAM);

			}

			clk_enable(pxa->clk);

			pxa->clk_enable = 1;

		}

	}

}



static struct sdhci_ops sdhci_pxa_ops = {

	.set_clock = set_clock,

};



/*****************************************************************************\

 *                                                                           *

 * Device probing/removal                                                    *

 *                                                                           *

\*****************************************************************************/



static int __devinit sdhci_pxa_probe(struct platform_device *pdev)

{

	struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;

	struct device *dev = &pdev->dev;

	struct sdhci_host *host = NULL;

	struct resource *iomem = NULL;

	struct sdhci_pxa *pxa = NULL;

	int ret, irq;



	irq = platform_get_irq(pdev, 0);

	if (irq < 0) {

		dev_err(dev, "no irq specified\n");

		return irq;

	}



	iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!iomem) {

		dev_err(dev, "no memory specified\n");

		return -ENOENT;

	}



	host = sdhci_alloc_host(&pdev->dev, sizeof(struct sdhci_pxa));

	if (IS_ERR(host)) {

		dev_err(dev, "failed to alloc host\n");

		return PTR_ERR(host);

	}



	pxa = sdhci_priv(host);

	pxa->host = host;

	pxa->pdata = pdata;

	pxa->clk_enable = 0;



	pxa->clk = clk_get(dev, "PXA-SDHCLK");

	if (IS_ERR(pxa->clk)) {

		dev_err(dev, "failed to get io clock\n");

		ret = PTR_ERR(pxa->clk);

		goto out;

	}



	pxa->res = request_mem_region(iomem->start, resource_size(iomem),

				      mmc_hostname(host->mmc));

	if (!pxa->res) {

		dev_err(&pdev->dev, "cannot request region\n");

		ret = -EBUSY;

		goto out;

	}



	host->ioaddr = ioremap(iomem->start, resource_size(iomem));

	if (!host->ioaddr) {

		dev_err(&pdev->dev, "failed to remap registers\n");

		ret = -ENOMEM;

		goto out;

	}



	host->hw_name = "MMC";

	host->ops = &sdhci_pxa_ops;

	host->irq = irq;

	host->quirks = SDHCI_QUIRK_BROKEN_ADMA | SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;



	if (pdata->quirks)

		host->quirks |= pdata->quirks;



	ret = sdhci_add_host(host);

	if (ret) {

		dev_err(&pdev->dev, "failed to add host\n");

		goto out;

	}



	if (pxa->pdata->max_speed)

		host->mmc->f_max = pxa->pdata->max_speed;



	platform_set_drvdata(pdev, host);



	return 0;

out:

	if (host) {

		clk_put(pxa->clk);

		if (host->ioaddr)

			iounmap(host->ioaddr);

		if (pxa->res)

			release_mem_region(pxa->res->start,

					   resource_size(pxa->res));

		sdhci_free_host(host);

	}



	return ret;

}



static int __devexit sdhci_pxa_remove(struct platform_device *pdev)

{

	struct sdhci_host *host = platform_get_drvdata(pdev);

	struct sdhci_pxa *pxa = sdhci_priv(host);

	int dead = 0;

	u32 scratch;



	if (host) {

		scratch = readl(host->ioaddr + SDHCI_INT_STATUS);

		if (scratch == (u32)-1)

			dead = 1;



		sdhci_remove_host(host, dead);



		if (host->ioaddr)

			iounmap(host->ioaddr);

		if (pxa->res)

			release_mem_region(pxa->res->start,

					   resource_size(pxa->res));

		if (pxa->clk_enable) {

			clk_disable(pxa->clk);

			pxa->clk_enable = 0;

		}

		clk_put(pxa->clk);



		sdhci_free_host(host);

		platform_set_drvdata(pdev, NULL);

	}



	return 0;

}



#ifdef CONFIG_PM

static int sdhci_pxa_suspend(struct platform_device *dev, pm_message_t state)

{

	struct sdhci_host *host = platform_get_drvdata(dev);



	return sdhci_suspend_host(host, state);

}



static int sdhci_pxa_resume(struct platform_device *dev)

{

	struct sdhci_host *host = platform_get_drvdata(dev);



	return sdhci_resume_host(host);

}

#else

#define sdhci_pxa_suspend	NULL

#define sdhci_pxa_resume	NULL

#endif



static struct platform_driver sdhci_pxa_driver = {

	.probe		= sdhci_pxa_probe,

	.remove		= __devexit_p(sdhci_pxa_remove),

	.suspend	= sdhci_pxa_suspend,

	.resume		= sdhci_pxa_resume,

	.driver		= {

		.name	= DRIVER_NAME,

		.owner	= THIS_MODULE,

	},

};



/*****************************************************************************\

 *                                                                           *

 * Driver init/exit                                                          *

 *                                                                           *

\*****************************************************************************/



static int __init sdhci_pxa_init(void)

{

	return platform_driver_register(&sdhci_pxa_driver);

}



static void __exit sdhci_pxa_exit(void)

{

	platform_driver_unregister(&sdhci_pxa_driver);

}



module_init(sdhci_pxa_init);

module_exit(sdhci_pxa_exit);



MODULE_DESCRIPTION("SDH controller driver for PXA168/PXA910/MMP2");

MODULE_AUTHOR("Zhangfei Gao <zhangfei.gao@marvell.com>");

MODULE_LICENSE("GPL v2");

CRA Git | Maintained and supported by SUSTech CRA and CCSE