[net-next-2.6.git] / drivers / mmc / host / sdhci-s3c.c

/* linux/drivers/mmc/host/sdhci-s3c.c
 *
 * Copyright 2008 Openmoko Inc.
 * Copyright 2008 Simtec Electronics
 *      Ben Dooks <ben@simtec.co.uk>
 *      http://armlinux.simtec.co.uk/
 *
 * SDHCI (HSMMC) support for Samsung SoC
 *
 * 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.
 */

#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/clk.h>
#include <linux/io.h>

#include <linux/mmc/host.h>

#include <plat/sdhci.h>
#include <plat/regs-sdhci.h>

#include "sdhci.h"

#define MAX_BUS_CLK	(4)

/**
 * struct sdhci_s3c - S3C SDHCI instance
 * @host: The SDHCI host created
 * @pdev: The platform device we where created from.
 * @ioarea: The resource created when we claimed the IO area.
 * @pdata: The platform data for this controller.
 * @cur_clk: The index of the current bus clock.
 * @clk_io: The clock for the internal bus interface.
 * @clk_bus: The clocks that are available for the SD/MMC bus clock.
 */
struct sdhci_s3c {
	struct sdhci_host	*host;
	struct platform_device	*pdev;
	struct resource		*ioarea;
	struct s3c_sdhci_platdata *pdata;
	unsigned int		cur_clk;

	struct clk		*clk_io;
	struct clk		*clk_bus[MAX_BUS_CLK];
};

static inline struct sdhci_s3c *to_s3c(struct sdhci_host *host)
{
	return sdhci_priv(host);
}

/**
 * get_curclk - convert ctrl2 register to clock source number
 * @ctrl2: Control2 register value.
 */
static u32 get_curclk(u32 ctrl2)
{
	ctrl2 &= S3C_SDHCI_CTRL2_SELBASECLK_MASK;
	ctrl2 >>= S3C_SDHCI_CTRL2_SELBASECLK_SHIFT;

	return ctrl2;
}

static void sdhci_s3c_check_sclk(struct sdhci_host *host)
{
	struct sdhci_s3c *ourhost = to_s3c(host);
	u32 tmp = readl(host->ioaddr + S3C_SDHCI_CONTROL2);

	if (get_curclk(tmp) != ourhost->cur_clk) {
		dev_dbg(&ourhost->pdev->dev, "restored ctrl2 clock setting\n");

		tmp &= ~S3C_SDHCI_CTRL2_SELBASECLK_MASK;
		tmp |= ourhost->cur_clk << S3C_SDHCI_CTRL2_SELBASECLK_SHIFT;
		writel(tmp, host->ioaddr + 0x80);
	}
}

/**
 * sdhci_s3c_get_max_clk - callback to get maximum clock frequency.
 * @host: The SDHCI host instance.
 *
 * Callback to return the maximum clock rate acheivable by the controller.
*/
static unsigned int sdhci_s3c_get_max_clk(struct sdhci_host *host)
{
	struct sdhci_s3c *ourhost = to_s3c(host);
	struct clk *busclk;
	unsigned int rate, max;
	int clk;

	/* note, a reset will reset the clock source */

	sdhci_s3c_check_sclk(host);

	for (max = 0, clk = 0; clk < MAX_BUS_CLK; clk++) {
		busclk = ourhost->clk_bus[clk];
		if (!busclk)
			continue;

		rate = clk_get_rate(busclk);
		if (rate > max)
			max = rate;
	}

	return max;
}

static unsigned int sdhci_s3c_get_timeout_clk(struct sdhci_host *host)
{
	return sdhci_s3c_get_max_clk(host) / 1000000;
}

/**
 * sdhci_s3c_consider_clock - consider one the bus clocks for current setting
 * @ourhost: Our SDHCI instance.
 * @src: The source clock index.
 * @wanted: The clock frequency wanted.
 */
static unsigned int sdhci_s3c_consider_clock(struct sdhci_s3c *ourhost,
					     unsigned int src,
					     unsigned int wanted)
{
	unsigned long rate;
	struct clk *clksrc = ourhost->clk_bus[src];
	int div;

	if (!clksrc)
		return UINT_MAX;

	rate = clk_get_rate(clksrc);

	for (div = 1; div < 256; div *= 2) {
		if ((rate / div) <= wanted)
			break;
	}

	dev_dbg(&ourhost->pdev->dev, "clk %d: rate %ld, want %d, got %ld\n",
		src, rate, wanted, rate / div);

	return (wanted - (rate / div));
}

/**
 * sdhci_s3c_set_clock - callback on clock change
 * @host: The SDHCI host being changed
 * @clock: The clock rate being requested.
 *
 * When the card's clock is going to be changed, look at the new frequency
 * and find the best clock source to go with it.
*/
static void sdhci_s3c_set_clock(struct sdhci_host *host, unsigned int clock)
{
	struct sdhci_s3c *ourhost = to_s3c(host);
	unsigned int best = UINT_MAX;
	unsigned int delta;
	int best_src = 0;
	int src;
	u32 ctrl;

	/* don't bother if the clock is going off. */
	if (clock == 0)
		return;

	for (src = 0; src < MAX_BUS_CLK; src++) {
		delta = sdhci_s3c_consider_clock(ourhost, src, clock);
		if (delta < best) {
			best = delta;
			best_src = src;
		}
	}

	dev_dbg(&ourhost->pdev->dev,
		"selected source %d, clock %d, delta %d\n",
		 best_src, clock, best);

	/* select the new clock source */

	if (ourhost->cur_clk != best_src) {
		struct clk *clk = ourhost->clk_bus[best_src];

		/* turn clock off to card before changing clock source */
		writew(0, host->ioaddr + SDHCI_CLOCK_CONTROL);

		ourhost->cur_clk = best_src;
		host->max_clk = clk_get_rate(clk);
		host->timeout_clk = sdhci_s3c_get_timeout_clk(host);

		ctrl = readl(host->ioaddr + S3C_SDHCI_CONTROL2);
		ctrl &= ~S3C_SDHCI_CTRL2_SELBASECLK_MASK;
		ctrl |= best_src << S3C_SDHCI_CTRL2_SELBASECLK_SHIFT;
		writel(ctrl, host->ioaddr + S3C_SDHCI_CONTROL2);
	}

	/* reconfigure the hardware for new clock rate */

	{
		struct mmc_ios ios;

		ios.clock = clock;

		if (ourhost->pdata->cfg_card)
			(ourhost->pdata->cfg_card)(ourhost->pdev, host->ioaddr,
						   &ios, NULL);
	}
}

static struct sdhci_ops sdhci_s3c_ops = {
	.get_max_clock		= sdhci_s3c_get_max_clk,
	.get_timeout_clock	= sdhci_s3c_get_timeout_clk,
	.set_clock		= sdhci_s3c_set_clock,
};

static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
{
	struct s3c_sdhci_platdata *pdata = pdev->dev.platform_data;
	struct device *dev = &pdev->dev;
	struct sdhci_host *host;
	struct sdhci_s3c *sc;
	struct resource *res;
	int ret, irq, ptr, clks;

	if (!pdata) {
		dev_err(dev, "no device data specified\n");
		return -ENOENT;
	}

	irq = platform_get_irq(pdev, 0);
	if (irq < 0) {
		dev_err(dev, "no irq specified\n");
		return irq;
	}

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		dev_err(dev, "no memory specified\n");
		return -ENOENT;
	}

	host = sdhci_alloc_host(dev, sizeof(struct sdhci_s3c));
	if (IS_ERR(host)) {
		dev_err(dev, "sdhci_alloc_host() failed\n");
		return PTR_ERR(host);
	}

	sc = sdhci_priv(host);

	sc->host = host;
	sc->pdev = pdev;
	sc->pdata = pdata;

	platform_set_drvdata(pdev, host);

	sc->clk_io = clk_get(dev, "hsmmc");
	if (IS_ERR(sc->clk_io)) {
		dev_err(dev, "failed to get io clock\n");
		ret = PTR_ERR(sc->clk_io);
		goto err_io_clk;
	}

	/* enable the local io clock and keep it running for the moment. */
	clk_enable(sc->clk_io);

	for (clks = 0, ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
		struct clk *clk;
		char *name = pdata->clocks[ptr];

		if (name == NULL)
			continue;

		clk = clk_get(dev, name);
		if (IS_ERR(clk)) {
			dev_err(dev, "failed to get clock %s\n", name);
			continue;
		}

		clks++;
		sc->clk_bus[ptr] = clk;
		clk_enable(clk);

		dev_info(dev, "clock source %d: %s (%ld Hz)\n",
			 ptr, name, clk_get_rate(clk));
	}

	if (clks == 0) {
		dev_err(dev, "failed to find any bus clocks\n");
		ret = -ENOENT;
		goto err_no_busclks;
	}

	sc->ioarea = request_mem_region(res->start, resource_size(res),
					mmc_hostname(host->mmc));
	if (!sc->ioarea) {
		dev_err(dev, "failed to reserve register area\n");
		ret = -ENXIO;
		goto err_req_regs;
	}

	host->ioaddr = ioremap_nocache(res->start, resource_size(res));
	if (!host->ioaddr) {
		dev_err(dev, "failed to map registers\n");
		ret = -ENXIO;
		goto err_req_regs;
	}

	/* Ensure we have minimal gpio selected CMD/CLK/Detect */
	if (pdata->cfg_gpio)
		pdata->cfg_gpio(pdev, pdata->max_width);

	host->hw_name = "samsung-hsmmc";
	host->ops = &sdhci_s3c_ops;
	host->quirks = 0;
	host->irq = irq;

	/* Setup quirks for the controller */
	host->quirks |= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC;

#ifndef CONFIG_MMC_SDHCI_S3C_DMA

	/* we currently see overruns on errors, so disable the SDMA
	 * support as well. */
	host->quirks |= SDHCI_QUIRK_BROKEN_DMA;

#endif /* CONFIG_MMC_SDHCI_S3C_DMA */

	/* It seems we do not get an DATA transfer complete on non-busy
	 * transfers, not sure if this is a problem with this specific
	 * SDHCI block, or a missing configuration that needs to be set. */
	host->quirks |= SDHCI_QUIRK_NO_BUSY_IRQ;

	host->quirks |= (SDHCI_QUIRK_32BIT_DMA_ADDR |
			 SDHCI_QUIRK_32BIT_DMA_SIZE);

	ret = sdhci_add_host(host);
	if (ret) {
		dev_err(dev, "sdhci_add_host() failed\n");
		goto err_add_host;
	}

	return 0;

 err_add_host:
	release_resource(sc->ioarea);
	kfree(sc->ioarea);

 err_req_regs:
	for (ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
		clk_disable(sc->clk_bus[ptr]);
		clk_put(sc->clk_bus[ptr]);
	}

 err_no_busclks:
	clk_disable(sc->clk_io);
	clk_put(sc->clk_io);

 err_io_clk:
	sdhci_free_host(host);

	return ret;
}

static int __devexit sdhci_s3c_remove(struct platform_device *pdev)
{
	return 0;
}

#ifdef CONFIG_PM

static int sdhci_s3c_suspend(struct platform_device *dev, pm_message_t pm)
{
	struct sdhci_host *host = platform_get_drvdata(dev);

	sdhci_suspend_host(host, pm);
	return 0;
}

static int sdhci_s3c_resume(struct platform_device *dev)
{
	struct sdhci_host *host = platform_get_drvdata(dev);

	sdhci_resume_host(host);
	return 0;
}

#else
#define sdhci_s3c_suspend NULL
#define sdhci_s3c_resume NULL
#endif

static struct platform_driver sdhci_s3c_driver = {
	.probe		= sdhci_s3c_probe,
	.remove		= __devexit_p(sdhci_s3c_remove),
	.suspend	= sdhci_s3c_suspend,
	.resume	        = sdhci_s3c_resume,
	.driver		= {
		.owner	= THIS_MODULE,
		.name	= "s3c-sdhci",
	},
};

static int __init sdhci_s3c_init(void)
{
	return platform_driver_register(&sdhci_s3c_driver);
}

static void __exit sdhci_s3c_exit(void)
{
	platform_driver_unregister(&sdhci_s3c_driver);
}

module_init(sdhci_s3c_init);
module_exit(sdhci_s3c_exit);

MODULE_DESCRIPTION("Samsung SDHCI (HSMMC) glue");
MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:s3c-sdhci");
Commit	Line	Data
0d1bb41a BD	1	/* linux/drivers/mmc/host/sdhci-s3c.c
	2	*
	3	* Copyright 2008 Openmoko Inc.
	4	* Copyright 2008 Simtec Electronics
	5	* Ben Dooks <ben@simtec.co.uk>
	6	* http://armlinux.simtec.co.uk/
	7	*
	8	* SDHCI (HSMMC) support for Samsung SoC
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*/
	14
	15	#include <linux/delay.h>
	16	#include <linux/dma-mapping.h>
	17	#include <linux/platform_device.h>
5a0e3ad6	18	#include <linux/slab.h>
0d1bb41a BD	19	#include <linux/clk.h>
	20	#include <linux/io.h>
	21
	22	#include <linux/mmc/host.h>
	23
	24	#include <plat/sdhci.h>
	25	#include <plat/regs-sdhci.h>
	26
	27	#include "sdhci.h"
	28
	29	#define MAX_BUS_CLK (4)
	30
	31	/**
	32	* struct sdhci_s3c - S3C SDHCI instance
	33	* @host: The SDHCI host created
	34	* @pdev: The platform device we where created from.
	35	* @ioarea: The resource created when we claimed the IO area.
	36	* @pdata: The platform data for this controller.
	37	* @cur_clk: The index of the current bus clock.
	38	* @clk_io: The clock for the internal bus interface.
	39	* @clk_bus: The clocks that are available for the SD/MMC bus clock.
	40	*/
	41	struct sdhci_s3c {
	42	struct sdhci_host *host;
	43	struct platform_device *pdev;
	44	struct resource *ioarea;
	45	struct s3c_sdhci_platdata *pdata;
	46	unsigned int cur_clk;
	47
	48	struct clk *clk_io;
	49	struct clk *clk_bus[MAX_BUS_CLK];
	50	};
	51
	52	static inline struct sdhci_s3c to_s3c(struct sdhci_host host)
	53	{
	54	return sdhci_priv(host);
	55	}
	56
	57	/**
	58	* get_curclk - convert ctrl2 register to clock source number
	59	* @ctrl2: Control2 register value.
	60	*/
	61	static u32 get_curclk(u32 ctrl2)
	62	{
	63	ctrl2 &= S3C_SDHCI_CTRL2_SELBASECLK_MASK;
	64	ctrl2 >>= S3C_SDHCI_CTRL2_SELBASECLK_SHIFT;
	65
	66	return ctrl2;
	67	}
	68
	69	static void sdhci_s3c_check_sclk(struct sdhci_host *host)
	70	{
	71	struct sdhci_s3c *ourhost = to_s3c(host);
	72	u32 tmp = readl(host->ioaddr + S3C_SDHCI_CONTROL2);
	73
	74	if (get_curclk(tmp) != ourhost->cur_clk) {
	75	dev_dbg(&ourhost->pdev->dev, "restored ctrl2 clock setting\n");
	76
	77	tmp &= ~S3C_SDHCI_CTRL2_SELBASECLK_MASK;
	78	tmp \|= ourhost->cur_clk << S3C_SDHCI_CTRL2_SELBASECLK_SHIFT;
	79	writel(tmp, host->ioaddr + 0x80);
	80	}
	81	}
	82
83	/**
84	* sdhci_s3c_get_max_clk - callback to get maximum clock frequency.
85	* @host: The SDHCI host instance.
86	*
87	* Callback to return the maximum clock rate acheivable by the controller.
88	*/
89	static unsigned int sdhci_s3c_get_max_clk(struct sdhci_host *host)
90	{
91	struct sdhci_s3c *ourhost = to_s3c(host);
92	struct clk *busclk;
93	unsigned int rate, max;
94	int clk;
95
96	/* note, a reset will reset the clock source */
97
98	sdhci_s3c_check_sclk(host);
99
100	for (max = 0, clk = 0; clk < MAX_BUS_CLK; clk++) {
101	busclk = ourhost->clk_bus[clk];
102	if (!busclk)
103	continue;
104
105	rate = clk_get_rate(busclk);
106	if (rate > max)
107	max = rate;
108	}
109
110	return max;
111	}
112
113	static unsigned int sdhci_s3c_get_timeout_clk(struct sdhci_host *host)
114	{
115	return sdhci_s3c_get_max_clk(host) / 1000000;
116	}
117
118	/**
119	* sdhci_s3c_consider_clock - consider one the bus clocks for current setting
120	* @ourhost: Our SDHCI instance.
121	* @src: The source clock index.
122	* @wanted: The clock frequency wanted.
123	*/
124	static unsigned int sdhci_s3c_consider_clock(struct sdhci_s3c *ourhost,
125	unsigned int src,
126	unsigned int wanted)
127	{
128	unsigned long rate;
129	struct clk *clksrc = ourhost->clk_bus[src];
130	int div;
131
132	if (!clksrc)
133	return UINT_MAX;
134
135	rate = clk_get_rate(clksrc);
136
137	for (div = 1; div < 256; div *= 2) {
138	if ((rate / div) <= wanted)
139	break;
140	}
141
142	dev_dbg(&ourhost->pdev->dev, "clk %d: rate %ld, want %d, got %ld\n",
143	src, rate, wanted, rate / div);
144
145	return (wanted - (rate / div));
146	}
147
148	/**
149	* sdhci_s3c_set_clock - callback on clock change
150	* @host: The SDHCI host being changed
151	* @clock: The clock rate being requested.
152	*
153	* When the card's clock is going to be changed, look at the new frequency
154	* and find the best clock source to go with it.
155	*/
156	static void sdhci_s3c_set_clock(struct sdhci_host *host, unsigned int clock)
157	{
158	struct sdhci_s3c *ourhost = to_s3c(host);
159	unsigned int best = UINT_MAX;
160	unsigned int delta;
161	int best_src = 0;
162	int src;
163	u32 ctrl;
164
165	/* don't bother if the clock is going off. */
166	if (clock == 0)
167	return;
168
169	for (src = 0; src < MAX_BUS_CLK; src++) {
170	delta = sdhci_s3c_consider_clock(ourhost, src, clock);
171	if (delta < best) {
172	best = delta;
173	best_src = src;
174	}
175	}
176
177	dev_dbg(&ourhost->pdev->dev,
178	"selected source %d, clock %d, delta %d\n",
179	best_src, clock, best);
180
181	/* select the new clock source */
182
183	if (ourhost->cur_clk != best_src) {
184	struct clk *clk = ourhost->clk_bus[best_src];
185
186	/* turn clock off to card before changing clock source */
187	writew(0, host->ioaddr + SDHCI_CLOCK_CONTROL);
188
189	ourhost->cur_clk = best_src;
190	host->max_clk = clk_get_rate(clk);
191	host->timeout_clk = sdhci_s3c_get_timeout_clk(host);
192
193	ctrl = readl(host->ioaddr + S3C_SDHCI_CONTROL2);
194	ctrl &= ~S3C_SDHCI_CTRL2_SELBASECLK_MASK;
195	ctrl \|= best_src << S3C_SDHCI_CTRL2_SELBASECLK_SHIFT;
196	writel(ctrl, host->ioaddr + S3C_SDHCI_CONTROL2);
197	}
198
199	/* reconfigure the hardware for new clock rate */
200
201	{
202	struct mmc_ios ios;
203
204	ios.clock = clock;
205
206	if (ourhost->pdata->cfg_card)
207	(ourhost->pdata->cfg_card)(ourhost->pdev, host->ioaddr,
208	&ios, NULL);
209	}
210	}
211
212	static struct sdhci_ops sdhci_s3c_ops = {
213	.get_max_clock = sdhci_s3c_get_max_clk,
214	.get_timeout_clock = sdhci_s3c_get_timeout_clk,
215	.set_clock = sdhci_s3c_set_clock,
216	};
217
218	static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
219	{
220	struct s3c_sdhci_platdata *pdata = pdev->dev.platform_data;
221	struct device *dev = &pdev->dev;
222	struct sdhci_host *host;
223	struct sdhci_s3c *sc;
224	struct resource *res;
225	int ret, irq, ptr, clks;
226
227	if (!pdata) {
228	dev_err(dev, "no device data specified\n");
229	return -ENOENT;
230	}
231
232	irq = platform_get_irq(pdev, 0);
233	if (irq < 0) {
234	dev_err(dev, "no irq specified\n");
235	return irq;
236	}
237
238	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
239	if (!res) {
240	dev_err(dev, "no memory specified\n");
241	return -ENOENT;
242	}
243
244	host = sdhci_alloc_host(dev, sizeof(struct sdhci_s3c));
245	if (IS_ERR(host)) {
246	dev_err(dev, "sdhci_alloc_host() failed\n");
247	return PTR_ERR(host);
248	}
249
250	sc = sdhci_priv(host);
251
252	sc->host = host;
253	sc->pdev = pdev;
254	sc->pdata = pdata;
255
256	platform_set_drvdata(pdev, host);
257
258	sc->clk_io = clk_get(dev, "hsmmc");
259	if (IS_ERR(sc->clk_io)) {
260	dev_err(dev, "failed to get io clock\n");
261	ret = PTR_ERR(sc->clk_io);
262	goto err_io_clk;
263	}
264
265	/* enable the local io clock and keep it running for the moment. */
266	clk_enable(sc->clk_io);
267
268	for (clks = 0, ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
269	struct clk *clk;
270	char *name = pdata->clocks[ptr];
271
272	if (name == NULL)
273	continue;
274
275	clk = clk_get(dev, name);
276	if (IS_ERR(clk)) {
277	dev_err(dev, "failed to get clock %s\n", name);
278	continue;
279	}
280
281	clks++;
282	sc->clk_bus[ptr] = clk;
283	clk_enable(clk);
284
285	dev_info(dev, "clock source %d: %s (%ld Hz)\n",
286	ptr, name, clk_get_rate(clk));
287	}
288
289	if (clks == 0) {
290	dev_err(dev, "failed to find any bus clocks\n");
291	ret = -ENOENT;
292	goto err_no_busclks;
293	}
294
295	sc->ioarea = request_mem_region(res->start, resource_size(res),
296	mmc_hostname(host->mmc));
297	if (!sc->ioarea) {
298	dev_err(dev, "failed to reserve register area\n");
299	ret = -ENXIO;
300	goto err_req_regs;
301	}
302
303	host->ioaddr = ioremap_nocache(res->start, resource_size(res));
304	if (!host->ioaddr) {
305	dev_err(dev, "failed to map registers\n");
306	ret = -ENXIO;
307	goto err_req_regs;
308	}
309
310	/* Ensure we have minimal gpio selected CMD/CLK/Detect */
311	if (pdata->cfg_gpio)
312	pdata->cfg_gpio(pdev, pdata->max_width);
313
314	host->hw_name = "samsung-hsmmc";
315	host->ops = &sdhci_s3c_ops;
316	host->quirks = 0;
317	host->irq = irq;
318
319	/* Setup quirks for the controller */
b2e75eff	320	host->quirks \|= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC;
0d1bb41a BD	321
	322	#ifndef CONFIG_MMC_SDHCI_S3C_DMA
	323
	324	/* we currently see overruns on errors, so disable the SDMA
	325	* support as well. */
	326	host->quirks \|= SDHCI_QUIRK_BROKEN_DMA;
	327
	328	#endif /* CONFIG_MMC_SDHCI_S3C_DMA */
	329
	330	/* It seems we do not get an DATA transfer complete on non-busy
	331	* transfers, not sure if this is a problem with this specific
	332	* SDHCI block, or a missing configuration that needs to be set. */
	333	host->quirks \|= SDHCI_QUIRK_NO_BUSY_IRQ;
	334
	335	host->quirks \|= (SDHCI_QUIRK_32BIT_DMA_ADDR \|
	336	SDHCI_QUIRK_32BIT_DMA_SIZE);
	337
	338	ret = sdhci_add_host(host);
	339	if (ret) {
	340	dev_err(dev, "sdhci_add_host() failed\n");
	341	goto err_add_host;
	342	}
	343
	344	return 0;
	345
	346	err_add_host:
	347	release_resource(sc->ioarea);
	348	kfree(sc->ioarea);
	349
	350	err_req_regs:
	351	for (ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
	352	clk_disable(sc->clk_bus[ptr]);
	353	clk_put(sc->clk_bus[ptr]);
	354	}
	355
	356	err_no_busclks:
	357	clk_disable(sc->clk_io);
	358	clk_put(sc->clk_io);
	359
	360	err_io_clk:
	361	sdhci_free_host(host);
	362
	363	return ret;
	364	}
	365
	366	static int __devexit sdhci_s3c_remove(struct platform_device *pdev)
	367	{
	368	return 0;
	369	}
	370
	371	#ifdef CONFIG_PM
	372
	373	static int sdhci_s3c_suspend(struct platform_device *dev, pm_message_t pm)
	374	{
	375	struct sdhci_host *host = platform_get_drvdata(dev);
	376
	377	sdhci_suspend_host(host, pm);
	378	return 0;
	379	}
	380
	381	static int sdhci_s3c_resume(struct platform_device *dev)
	382	{
	383	struct sdhci_host *host = platform_get_drvdata(dev);
	384
385	sdhci_resume_host(host);
386	return 0;
387	}
388
389	#else
390	#define sdhci_s3c_suspend NULL
391	#define sdhci_s3c_resume NULL
392	#endif
393
394	static struct platform_driver sdhci_s3c_driver = {
395	.probe = sdhci_s3c_probe,
396	.remove = __devexit_p(sdhci_s3c_remove),
397	.suspend = sdhci_s3c_suspend,
398	.resume = sdhci_s3c_resume,
399	.driver = {
400	.owner = THIS_MODULE,
401	.name = "s3c-sdhci",
402	},
403	};
404
405	static int __init sdhci_s3c_init(void)
406	{
407	return platform_driver_register(&sdhci_s3c_driver);
408	}
409
410	static void __exit sdhci_s3c_exit(void)
411	{
412	platform_driver_unregister(&sdhci_s3c_driver);
413	}
414
415	module_init(sdhci_s3c_init);
416	module_exit(sdhci_s3c_exit);
417
418	MODULE_DESCRIPTION("Samsung SDHCI (HSMMC) glue");
419	MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
420	MODULE_LICENSE("GPL v2");
421	MODULE_ALIAS("platform:s3c-sdhci");