[deliverable/linux.git] / drivers / mmc / host / sh_mobile_sdhi.c

/*
 * SuperH Mobile SDHI
 *
 * Copyright (C) 2009 Magnus Damm
 *
 * 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.
 *
 * Based on "Compaq ASIC3 support":
 *
 * Copyright 2001 Compaq Computer Corporation.
 * Copyright 2004-2005 Phil Blundell
 * Copyright 2007-2008 OpenedHand Ltd.
 *
 * Authors: Phil Blundell <pb@handhelds.org>,
 *	    Samuel Ortiz <sameo@openedhand.com>
 *
 */

#include <linux/kernel.h>
#include <linux/clk.h>
#include <linux/slab.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/mmc/host.h>
#include <linux/mmc/sh_mobile_sdhi.h>
#include <linux/mfd/tmio.h>
#include <linux/sh_dma.h>
#include <linux/delay.h>

#include "tmio_mmc.h"

struct sh_mobile_sdhi {
	struct clk *clk;
	struct tmio_mmc_data mmc_data;
	struct sh_dmae_slave param_tx;
	struct sh_dmae_slave param_rx;
	struct tmio_mmc_dma dma_priv;
};

static int sh_mobile_sdhi_clk_enable(struct platform_device *pdev, unsigned int *f)
{
	struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
	struct tmio_mmc_host *host = mmc_priv(mmc);
	struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
	int ret = clk_enable(priv->clk);
	if (ret < 0)
		return ret;

	*f = clk_get_rate(priv->clk);
	return 0;
}

static void sh_mobile_sdhi_clk_disable(struct platform_device *pdev)
{
	struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
	struct tmio_mmc_host *host = mmc_priv(mmc);
	struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
	clk_disable(priv->clk);
}

static void sh_mobile_sdhi_set_pwr(struct platform_device *pdev, int state)
{
	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;

	p->set_pwr(pdev, state);
}

static int sh_mobile_sdhi_get_cd(struct platform_device *pdev)
{
	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;

	return p->get_cd(pdev);
}

static int sh_mobile_sdhi_wait_idle(struct tmio_mmc_host *host)
{
	int timeout = 1000;

	while (--timeout && !(sd_ctrl_read16(host, CTL_STATUS2) & (1 << 13)))
		udelay(1);

	if (!timeout) {
		dev_warn(host->pdata->dev, "timeout waiting for SD bus idle\n");
		return -EBUSY;
	}

	return 0;
}

static int sh_mobile_sdhi_write16_hook(struct tmio_mmc_host *host, int addr)
{
	switch (addr)
	{
	case CTL_SD_CMD:
	case CTL_STOP_INTERNAL_ACTION:
	case CTL_XFER_BLK_COUNT:
	case CTL_SD_CARD_CLK_CTL:
	case CTL_SD_XFER_LEN:
	case CTL_SD_MEM_CARD_OPT:
	case CTL_TRANSACTION_CTL:
	case CTL_DMA_ENABLE:
		return sh_mobile_sdhi_wait_idle(host);
	}

	return 0;
}

static void sh_mobile_sdhi_cd_wakeup(const struct platform_device *pdev)
{
	mmc_detect_change(dev_get_drvdata(&pdev->dev), msecs_to_jiffies(100));
}

static const struct sh_mobile_sdhi_ops sdhi_ops = {
	.cd_wakeup = sh_mobile_sdhi_cd_wakeup,
};

static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
{
	struct sh_mobile_sdhi *priv;
	struct tmio_mmc_data *mmc_data;
	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
	struct tmio_mmc_host *host;
	char clk_name[8];
	int irq, ret, i = 0;
	bool multiplexed_isr = true;

	priv = kzalloc(sizeof(struct sh_mobile_sdhi), GFP_KERNEL);
	if (priv == NULL) {
		dev_err(&pdev->dev, "kzalloc failed\n");
		return -ENOMEM;
	}

	mmc_data = &priv->mmc_data;

	if (p) {
		p->pdata = mmc_data;
		if (p->init) {
			ret = p->init(pdev, &sdhi_ops);
			if (ret)
				goto einit;
		}
	}

	snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id);
	priv->clk = clk_get(&pdev->dev, clk_name);
	if (IS_ERR(priv->clk)) {
		dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
		ret = PTR_ERR(priv->clk);
		goto eclkget;
	}

	mmc_data->clk_enable = sh_mobile_sdhi_clk_enable;
	mmc_data->clk_disable = sh_mobile_sdhi_clk_disable;
	mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
	if (p) {
		mmc_data->flags = p->tmio_flags;
		if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT)
			mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
		mmc_data->ocr_mask = p->tmio_ocr_mask;
		mmc_data->capabilities |= p->tmio_caps;
		mmc_data->capabilities2 |= p->tmio_caps2;
		mmc_data->cd_gpio = p->cd_gpio;
		if (p->set_pwr)
			mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
		if (p->get_cd)
			mmc_data->get_cd = sh_mobile_sdhi_get_cd;

		if (p->dma_slave_tx > 0 && p->dma_slave_rx > 0) {
			priv->param_tx.slave_id = p->dma_slave_tx;
			priv->param_rx.slave_id = p->dma_slave_rx;
			priv->dma_priv.chan_priv_tx = &priv->param_tx;
			priv->dma_priv.chan_priv_rx = &priv->param_rx;
			priv->dma_priv.alignment_shift = 1; /* 2-byte alignment */
			mmc_data->dma = &priv->dma_priv;
		}
	}

	/*
	 * All SDHI blocks support 2-byte and larger block sizes in 4-bit
	 * bus width mode.
	 */
	mmc_data->flags |= TMIO_MMC_BLKSZ_2BYTES;

	/*
	 * All SDHI blocks support SDIO IRQ signalling.
	 */
	mmc_data->flags |= TMIO_MMC_SDIO_IRQ;

	ret = tmio_mmc_host_probe(&host, pdev, mmc_data);
	if (ret < 0)
		goto eprobe;

	/*
	 * Allow one or more specific (named) ISRs or
	 * one or more multiplexed (un-named) ISRs.
	 */

	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_CARD_DETECT);
	if (irq >= 0) {
		multiplexed_isr = false;
		ret = request_irq(irq, tmio_mmc_card_detect_irq, 0,
				  dev_name(&pdev->dev), host);
		if (ret)
			goto eirq_card_detect;
	}

	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDIO);
	if (irq >= 0) {
		multiplexed_isr = false;
		ret = request_irq(irq, tmio_mmc_sdio_irq, 0,
				  dev_name(&pdev->dev), host);
		if (ret)
			goto eirq_sdio;
	}

	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDCARD);
	if (irq >= 0) {
		multiplexed_isr = false;
		ret = request_irq(irq, tmio_mmc_sdcard_irq, 0,
				  dev_name(&pdev->dev), host);
		if (ret)
			goto eirq_sdcard;
	} else if (!multiplexed_isr) {
		dev_err(&pdev->dev,
			"Principal SD-card IRQ is missing among named interrupts\n");
		ret = irq;
		goto eirq_sdcard;
	}

	if (multiplexed_isr) {
		while (1) {
			irq = platform_get_irq(pdev, i);
			if (irq < 0)
				break;
			i++;
			ret = request_irq(irq, tmio_mmc_irq, 0,
					  dev_name(&pdev->dev), host);
			if (ret)
				goto eirq_multiplexed;
		}

		/* There must be at least one IRQ source */
		if (!i)
			goto eirq_multiplexed;
	}

	dev_info(&pdev->dev, "%s base at 0x%08lx clock rate %u MHz\n",
		 mmc_hostname(host->mmc), (unsigned long)
		 (platform_get_resource(pdev, IORESOURCE_MEM, 0)->start),
		 mmc_data->hclk / 1000000);

	return ret;

eirq_multiplexed:
	while (i--) {
		irq = platform_get_irq(pdev, i);
		free_irq(irq, host);
	}
eirq_sdcard:
	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDIO);
	if (irq >= 0)
		free_irq(irq, host);
eirq_sdio:
	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_CARD_DETECT);
	if (irq >= 0)
		free_irq(irq, host);
eirq_card_detect:
	tmio_mmc_host_remove(host);
eprobe:
	clk_put(priv->clk);
eclkget:
	if (p && p->cleanup)
		p->cleanup(pdev);
einit:
	kfree(priv);
	return ret;
}

static int sh_mobile_sdhi_remove(struct platform_device *pdev)
{
	struct mmc_host *mmc = platform_get_drvdata(pdev);
	struct tmio_mmc_host *host = mmc_priv(mmc);
	struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
	int i = 0, irq;

	if (p)
		p->pdata = NULL;

	tmio_mmc_host_remove(host);

	while (1) {
		irq = platform_get_irq(pdev, i++);
		if (irq < 0)
			break;
		free_irq(irq, host);
	}

	clk_put(priv->clk);

	if (p && p->cleanup)
		p->cleanup(pdev);

	kfree(priv);

	return 0;
}

static const struct dev_pm_ops tmio_mmc_dev_pm_ops = {
	.suspend = tmio_mmc_host_suspend,
	.resume = tmio_mmc_host_resume,
	.runtime_suspend = tmio_mmc_host_runtime_suspend,
	.runtime_resume = tmio_mmc_host_runtime_resume,
};

static const struct of_device_id sh_mobile_sdhi_of_match[] = {
	{ .compatible = "renesas,shmobile-sdhi" },
	{ }
};
MODULE_DEVICE_TABLE(of, sh_mobile_sdhi_of_match);

static struct platform_driver sh_mobile_sdhi_driver = {
	.driver		= {
		.name	= "sh_mobile_sdhi",
		.owner	= THIS_MODULE,
		.pm	= &tmio_mmc_dev_pm_ops,
		.of_match_table = sh_mobile_sdhi_of_match,
	},
	.probe		= sh_mobile_sdhi_probe,
	.remove		= __devexit_p(sh_mobile_sdhi_remove),
};

module_platform_driver(sh_mobile_sdhi_driver);

MODULE_DESCRIPTION("SuperH Mobile SDHI driver");
MODULE_AUTHOR("Magnus Damm");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:sh_mobile_sdhi");
Commit	Line	Data
a87d5638 MD	1	/*
	2	* SuperH Mobile SDHI
	3	*
	4	* Copyright (C) 2009 Magnus Damm
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	* Based on "Compaq ASIC3 support":
	11	*
	12	* Copyright 2001 Compaq Computer Corporation.
	13	* Copyright 2004-2005 Phil Blundell
	14	* Copyright 2007-2008 OpenedHand Ltd.
	15	*
	16	* Authors: Phil Blundell <pb@handhelds.org>,
	17	* Samuel Ortiz <sameo@openedhand.com>
	18	*
	19	*/
	20
	21	#include <linux/kernel.h>
	22	#include <linux/clk.h>
5a0e3ad6	23	#include <linux/slab.h>
c7bb4487	24	#include <linux/mod_devicetable.h>
88b47679	25	#include <linux/module.h>
a87d5638	26	#include <linux/platform_device.h>
3c49e810	27	#include <linux/mmc/host.h>
42051e8a	28	#include <linux/mmc/sh_mobile_sdhi.h>
a87d5638	29	#include <linux/mfd/tmio.h>
056676da	30	#include <linux/sh_dma.h>
973ed3af	31	#include <linux/delay.h>
a87d5638	32
42051e8a GL	33	#include "tmio_mmc.h"
42051e8a GL	34
a87d5638 MD	35	struct sh_mobile_sdhi {
	36	struct clk *clk;
	37	struct tmio_mmc_data mmc_data;
056676da GL	38	struct sh_dmae_slave param_tx;
	39	struct sh_dmae_slave param_rx;
	40	struct tmio_mmc_dma dma_priv;
a87d5638 MD	41	};
a87d5638 MD	42
56c49287 GL	43	static int sh_mobile_sdhi_clk_enable(struct platform_device pdev, unsigned int f)
	44	{
	45	struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
	46	struct tmio_mmc_host *host = mmc_priv(mmc);
	47	struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
	48	int ret = clk_enable(priv->clk);
	49	if (ret < 0)
	50	return ret;
	51
	52	*f = clk_get_rate(priv->clk);
	53	return 0;
	54	}
	55
	56	static void sh_mobile_sdhi_clk_disable(struct platform_device *pdev)
	57	{
	58	struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
	59	struct tmio_mmc_host *host = mmc_priv(mmc);
	60	struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
	61	clk_disable(priv->clk);
	62	}
	63
42051e8a	64	static void sh_mobile_sdhi_set_pwr(struct platform_device *pdev, int state)
be9cd7b6	65	{
be9cd7b6 MD	66	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
be9cd7b6 MD	67
71da63e7	68	p->set_pwr(pdev, state);
be9cd7b6 MD	69	}
be9cd7b6 MD	70
42051e8a	71	static int sh_mobile_sdhi_get_cd(struct platform_device *pdev)
998283e2	72	{
998283e2 AH	73	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
998283e2 AH	74
71da63e7	75	return p->get_cd(pdev);
998283e2 AH	76	}
998283e2 AH	77
973ed3af SH	78	static int sh_mobile_sdhi_wait_idle(struct tmio_mmc_host *host)
	79	{
	80	int timeout = 1000;
	81
	82	while (--timeout && !(sd_ctrl_read16(host, CTL_STATUS2) & (1 << 13)))
	83	udelay(1);
	84
	85	if (!timeout) {
	86	dev_warn(host->pdata->dev, "timeout waiting for SD bus idle\n");
	87	return -EBUSY;
	88	}
	89
	90	return 0;
	91	}
	92
	93	static int sh_mobile_sdhi_write16_hook(struct tmio_mmc_host *host, int addr)
	94	{
	95	switch (addr)
	96	{
	97	case CTL_SD_CMD:
	98	case CTL_STOP_INTERNAL_ACTION:
	99	case CTL_XFER_BLK_COUNT:
	100	case CTL_SD_CARD_CLK_CTL:
	101	case CTL_SD_XFER_LEN:
	102	case CTL_SD_MEM_CARD_OPT:
	103	case CTL_TRANSACTION_CTL:
	104	case CTL_DMA_ENABLE:
	105	return sh_mobile_sdhi_wait_idle(host);
	106	}
	107
	108	return 0;
	109	}
	110
7f524217 GL	111	static void sh_mobile_sdhi_cd_wakeup(const struct platform_device *pdev)
	112	{
	113	mmc_detect_change(dev_get_drvdata(&pdev->dev), msecs_to_jiffies(100));
	114	}
	115
	116	static const struct sh_mobile_sdhi_ops sdhi_ops = {
	117	.cd_wakeup = sh_mobile_sdhi_cd_wakeup,
	118	};
	119
25ab998e	120	static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
a87d5638 MD	121	{
a87d5638 MD	122	struct sh_mobile_sdhi *priv;
056676da GL	123	struct tmio_mmc_data *mmc_data;
056676da GL	124	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
42051e8a	125	struct tmio_mmc_host *host;
a87d5638	126	char clk_name[8];
d5098cb6 SH	127	int irq, ret, i = 0;
d5098cb6 SH	128	bool multiplexed_isr = true;
a87d5638 MD	129
	130	priv = kzalloc(sizeof(struct sh_mobile_sdhi), GFP_KERNEL);
	131	if (priv == NULL) {
	132	dev_err(&pdev->dev, "kzalloc failed\n");
	133	return -ENOMEM;
	134	}
	135
056676da GL	136	mmc_data = &priv->mmc_data;
056676da GL	137
c7bb4487 GL	138	if (p) {
	139	p->pdata = mmc_data;
	140	if (p->init) {
	141	ret = p->init(pdev, &sdhi_ops);
	142	if (ret)
	143	goto einit;
	144	}
e82b4ac9 BH	145	}
e82b4ac9 BH	146
a87d5638 MD	147	snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id);
	148	priv->clk = clk_get(&pdev->dev, clk_name);
	149	if (IS_ERR(priv->clk)) {
	150	dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
	151	ret = PTR_ERR(priv->clk);
42051e8a	152	goto eclkget;
a87d5638 MD	153	}
a87d5638 MD	154
56c49287 GL	155	mmc_data->clk_enable = sh_mobile_sdhi_clk_enable;
56c49287 GL	156	mmc_data->clk_disable = sh_mobile_sdhi_clk_disable;
056676da	157	mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
bb0fe533	158	if (p) {
f87c20a9	159	mmc_data->flags = p->tmio_flags;
b91df159 SH	160	if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT)
b91df159 SH	161	mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
bb0fe533	162	mmc_data->ocr_mask = p->tmio_ocr_mask;
998283e2	163	mmc_data->capabilities \|= p->tmio_caps;
d7d8d500	164	mmc_data->capabilities2 \|= p->tmio_caps2;
58126c87	165	mmc_data->cd_gpio = p->cd_gpio;
c7bb4487 GL	166	if (p->set_pwr)
	167	mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
	168	if (p->get_cd)
	169	mmc_data->get_cd = sh_mobile_sdhi_get_cd;
42051e8a	170
3e713373	171	if (p->dma_slave_tx > 0 && p->dma_slave_rx > 0) {
42051e8a GL	172	priv->param_tx.slave_id = p->dma_slave_tx;
	173	priv->param_rx.slave_id = p->dma_slave_rx;
	174	priv->dma_priv.chan_priv_tx = &priv->param_tx;
	175	priv->dma_priv.chan_priv_rx = &priv->param_rx;
	176	priv->dma_priv.alignment_shift = 1; /* 2-byte alignment */
	177	mmc_data->dma = &priv->dma_priv;
	178	}
bb0fe533	179	}
056676da	180
f1334fb3 YG	181	/*
	182	* All SDHI blocks support 2-byte and larger block sizes in 4-bit
	183	* bus width mode.
	184	*/
	185	mmc_data->flags \|= TMIO_MMC_BLKSZ_2BYTES;
	186
23b66071 AH	187	/*
	188	* All SDHI blocks support SDIO IRQ signalling.
	189	*/
	190	mmc_data->flags \|= TMIO_MMC_SDIO_IRQ;
	191
42051e8a GL	192	ret = tmio_mmc_host_probe(&host, pdev, mmc_data);
	193	if (ret < 0)
	194	goto eprobe;
a87d5638	195
d5098cb6 SH	196	/*
	197	* Allow one or more specific (named) ISRs or
	198	* one or more multiplexed (un-named) ISRs.
	199	*/
	200
	201	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_CARD_DETECT);
	202	if (irq >= 0) {
	203	multiplexed_isr = false;
	204	ret = request_irq(irq, tmio_mmc_card_detect_irq, 0,
	205	dev_name(&pdev->dev), host);
	206	if (ret)
	207	goto eirq_card_detect;
	208	}
	209
	210	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDIO);
	211	if (irq >= 0) {
	212	multiplexed_isr = false;
	213	ret = request_irq(irq, tmio_mmc_sdio_irq, 0,
	214	dev_name(&pdev->dev), host);
	215	if (ret)
	216	goto eirq_sdio;
	217	}
	218
	219	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDCARD);
	220	if (irq >= 0) {
	221	multiplexed_isr = false;
	222	ret = request_irq(irq, tmio_mmc_sdcard_irq, 0,
d6a1f863	223	dev_name(&pdev->dev), host);
d5098cb6 SH	224	if (ret)
	225	goto eirq_sdcard;
	226	} else if (!multiplexed_isr) {
	227	dev_err(&pdev->dev,
	228	"Principal SD-card IRQ is missing among named interrupts\n");
	229	ret = irq;
	230	goto eirq_sdcard;
	231	}
	232
	233	if (multiplexed_isr) {
	234	while (1) {
	235	irq = platform_get_irq(pdev, i);
	236	if (irq < 0)
	237	break;
	238	i++;
	239	ret = request_irq(irq, tmio_mmc_irq, 0,
	240	dev_name(&pdev->dev), host);
	241	if (ret)
	242	goto eirq_multiplexed;
d6a1f863	243	}
d5098cb6 SH	244
	245	/* There must be at least one IRQ source */
	246	if (!i)
	247	goto eirq_multiplexed;
8e7bfdb3	248	}
d5098cb6	249
1f7d6819 MD	250	dev_info(&pdev->dev, "%s base at 0x%08lx clock rate %u MHz\n",
1f7d6819 MD	251	mmc_hostname(host->mmc), (unsigned long)
58126c87	252	(platform_get_resource(pdev, IORESOURCE_MEM, 0)->start),
1f7d6819	253	mmc_data->hclk / 1000000);
a87d5638	254
42051e8a	255	return ret;
a87d5638	256
d5098cb6 SH	257	eirq_multiplexed:
	258	while (i--) {
	259	irq = platform_get_irq(pdev, i);
	260	free_irq(irq, host);
	261	}
	262	eirq_sdcard:
	263	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDIO);
	264	if (irq >= 0)
	265	free_irq(irq, host);
	266	eirq_sdio:
	267	irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_CARD_DETECT);
	268	if (irq >= 0)
	269	free_irq(irq, host);
	270	eirq_card_detect:
8e7bfdb3	271	tmio_mmc_host_remove(host);
42051e8a	272	eprobe:
42051e8a GL	273	clk_put(priv->clk);
42051e8a GL	274	eclkget:
c7bb4487	275	if (p && p->cleanup)
e82b4ac9 BH	276	p->cleanup(pdev);
e82b4ac9 BH	277	einit:
42051e8a	278	kfree(priv);
a87d5638 MD	279	return ret;
	280	}
	281
	282	static int sh_mobile_sdhi_remove(struct platform_device *pdev)
	283	{
42051e8a GL	284	struct mmc_host *mmc = platform_get_drvdata(pdev);
	285	struct tmio_mmc_host *host = mmc_priv(mmc);
	286	struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
25958804	287	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
d5098cb6	288	int i = 0, irq;
d6a1f863	289
c7bb4487 GL	290	if (p)
c7bb4487 GL	291	p->pdata = NULL;
25958804	292
742a0c7c GL	293	tmio_mmc_host_remove(host);
742a0c7c GL	294
d5098cb6 SH	295	while (1) {
	296	irq = platform_get_irq(pdev, i++);
	297	if (irq < 0)
	298	break;
	299	free_irq(irq, host);
d6a1f863	300	}
a87d5638	301
a87d5638	302	clk_put(priv->clk);
e82b4ac9	303
c7bb4487	304	if (p && p->cleanup)
e82b4ac9 BH	305	p->cleanup(pdev);
e82b4ac9 BH	306
a87d5638 MD	307	kfree(priv);
	308
	309	return 0;
	310	}
	311
e6ee7182 GL	312	static const struct dev_pm_ops tmio_mmc_dev_pm_ops = {
	313	.suspend = tmio_mmc_host_suspend,
	314	.resume = tmio_mmc_host_resume,
25958804 GL	315	.runtime_suspend = tmio_mmc_host_runtime_suspend,
25958804 GL	316	.runtime_resume = tmio_mmc_host_runtime_resume,
e6ee7182 GL	317	};
e6ee7182 GL	318
c7bb4487 GL	319	static const struct of_device_id sh_mobile_sdhi_of_match[] = {
	320	{ .compatible = "renesas,shmobile-sdhi" },
	321	{ }
	322	};
	323	MODULE_DEVICE_TABLE(of, sh_mobile_sdhi_of_match);
	324
a87d5638 MD	325	static struct platform_driver sh_mobile_sdhi_driver = {
	326	.driver = {
	327	.name = "sh_mobile_sdhi",
	328	.owner = THIS_MODULE,
e6ee7182	329	.pm = &tmio_mmc_dev_pm_ops,
c7bb4487	330	.of_match_table = sh_mobile_sdhi_of_match,
a87d5638 MD	331	},
	332	.probe = sh_mobile_sdhi_probe,
	333	.remove = __devexit_p(sh_mobile_sdhi_remove),
	334	};
	335
d1f81a64	336	module_platform_driver(sh_mobile_sdhi_driver);
a87d5638 MD	337
	338	MODULE_DESCRIPTION("SuperH Mobile SDHI driver");
	339	MODULE_AUTHOR("Magnus Damm");
	340	MODULE_LICENSE("GPL v2");
42051e8a	341	MODULE_ALIAS("platform:sh_mobile_sdhi");