[deliverable/linux.git] / drivers / mmc / host / sdhci-dove.c

/*
 * sdhci-dove.c Support for SDHCI on Marvell's Dove SoC
 *
 * Author: Saeed Bishara <saeed@marvell.com>
 *	   Mike Rapoport <mike@compulab.co.il>
 * Based on sdhci-cns3xxx.c
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/clk.h>
#include <linux/err.h>
#include <linux/gpio.h>
#include <linux/io.h>
#include <linux/mmc/host.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_gpio.h>

#include "sdhci-pltfm.h"

struct sdhci_dove_priv {
	struct clk *clk;
	int gpio_cd;
};

static irqreturn_t sdhci_dove_carddetect_irq(int irq, void *data)
{
	struct sdhci_host *host = data;

	tasklet_schedule(&host->card_tasklet);
	return IRQ_HANDLED;
}

static u16 sdhci_dove_readw(struct sdhci_host *host, int reg)
{
	u16 ret;

	switch (reg) {
	case SDHCI_HOST_VERSION:
	case SDHCI_SLOT_INT_STATUS:
		/* those registers don't exist */
		return 0;
	default:
		ret = readw(host->ioaddr + reg);
	}
	return ret;
}

static u32 sdhci_dove_readl(struct sdhci_host *host, int reg)
{
	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
	struct sdhci_dove_priv *priv = pltfm_host->priv;
	u32 ret;

	ret = readl(host->ioaddr + reg);

	switch (reg) {
	case SDHCI_CAPABILITIES:
		/* Mask the support for 3.0V */
		ret &= ~SDHCI_CAN_VDD_300;
		break;
	case SDHCI_PRESENT_STATE:
		if (gpio_is_valid(priv->gpio_cd)) {
			if (gpio_get_value(priv->gpio_cd) == 0)
				ret |= SDHCI_CARD_PRESENT;
			else
				ret &= ~SDHCI_CARD_PRESENT;
		}
		break;
	}
	return ret;
}

static const struct sdhci_ops sdhci_dove_ops = {
	.read_w	= sdhci_dove_readw,
	.read_l	= sdhci_dove_readl,
};

static const struct sdhci_pltfm_data sdhci_dove_pdata = {
	.ops	= &sdhci_dove_ops,
	.quirks	= SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
		  SDHCI_QUIRK_NO_BUSY_IRQ |
		  SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
		  SDHCI_QUIRK_FORCE_DMA |
		  SDHCI_QUIRK_NO_HISPD_BIT,
};

static int sdhci_dove_probe(struct platform_device *pdev)
{
	struct sdhci_host *host;
	struct sdhci_pltfm_host *pltfm_host;
	struct sdhci_dove_priv *priv;
	int ret;

	priv = devm_kzalloc(&pdev->dev, sizeof(struct sdhci_dove_priv),
			    GFP_KERNEL);
	if (!priv) {
		dev_err(&pdev->dev, "unable to allocate private data");
		return -ENOMEM;
	}

	priv->clk = devm_clk_get(&pdev->dev, NULL);

	if (pdev->dev.of_node) {
		priv->gpio_cd = of_get_named_gpio(pdev->dev.of_node,
						  "cd-gpios", 0);
	} else {
		priv->gpio_cd = -EINVAL;
	}

	if (gpio_is_valid(priv->gpio_cd)) {
		ret = gpio_request(priv->gpio_cd, "sdhci-cd");
		if (ret) {
			dev_err(&pdev->dev, "card detect gpio request failed: %d\n",
				ret);
			return ret;
		}
		gpio_direction_input(priv->gpio_cd);
	}

	host = sdhci_pltfm_init(pdev, &sdhci_dove_pdata, 0);
	if (IS_ERR(host)) {
		ret = PTR_ERR(host);
		goto err_sdhci_pltfm_init;
	}

	pltfm_host = sdhci_priv(host);
	pltfm_host->priv = priv;

	if (!IS_ERR(priv->clk))
		clk_prepare_enable(priv->clk);

	sdhci_get_of_property(pdev);

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

	/*
	 * We must request the IRQ after sdhci_add_host(), as the tasklet only
	 * gets setup in sdhci_add_host() and we oops.
	 */
	if (gpio_is_valid(priv->gpio_cd)) {
		ret = request_irq(gpio_to_irq(priv->gpio_cd),
				  sdhci_dove_carddetect_irq,
				  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
				  mmc_hostname(host->mmc), host);
		if (ret) {
			dev_err(&pdev->dev, "card detect irq request failed: %d\n",
				ret);
			goto err_request_irq;
		}
	}

	return 0;

err_request_irq:
	sdhci_remove_host(host, 0);
err_sdhci_add:
	if (!IS_ERR(priv->clk))
		clk_disable_unprepare(priv->clk);
	sdhci_pltfm_free(pdev);
err_sdhci_pltfm_init:
	if (gpio_is_valid(priv->gpio_cd))
		gpio_free(priv->gpio_cd);
	return ret;
}

static int sdhci_dove_remove(struct platform_device *pdev)
{
	struct sdhci_host *host = platform_get_drvdata(pdev);
	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
	struct sdhci_dove_priv *priv = pltfm_host->priv;

	sdhci_pltfm_unregister(pdev);

	if (gpio_is_valid(priv->gpio_cd)) {
		free_irq(gpio_to_irq(priv->gpio_cd), host);
		gpio_free(priv->gpio_cd);
	}

	if (!IS_ERR(priv->clk))
		clk_disable_unprepare(priv->clk);

	return 0;
}

static const struct of_device_id sdhci_dove_of_match_table[] = {
	{ .compatible = "marvell,dove-sdhci", },
	{}
};
MODULE_DEVICE_TABLE(of, sdhci_dove_of_match_table);

static struct platform_driver sdhci_dove_driver = {
	.driver		= {
		.name	= "sdhci-dove",
		.owner	= THIS_MODULE,
		.pm	= SDHCI_PLTFM_PMOPS,
		.of_match_table = of_match_ptr(sdhci_dove_of_match_table),
	},
	.probe		= sdhci_dove_probe,
	.remove		= sdhci_dove_remove,
};

module_platform_driver(sdhci_dove_driver);

MODULE_DESCRIPTION("SDHCI driver for Dove");
MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>, "
	      "Mike Rapoport <mike@compulab.co.il>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
985b1aa0 MR	1	/*
	2	* sdhci-dove.c Support for SDHCI on Marvell's Dove SoC
	3	*
	4	* Author: Saeed Bishara <saeed@marvell.com>
	5	* Mike Rapoport <mike@compulab.co.il>
	6	* Based on sdhci-cns3xxx.c
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	20	*/
	21
30b87c60 SH	22	#include <linux/clk.h>
30b87c60 SH	23	#include <linux/err.h>
f8ec589b RK	24	#include <linux/gpio.h>
f8ec589b RK	25	#include <linux/io.h>
985b1aa0	26	#include <linux/mmc/host.h>
f8ec589b	27	#include <linux/module.h>
4ee7ed0d	28	#include <linux/of.h>
f8ec589b	29	#include <linux/of_gpio.h>
985b1aa0	30
985b1aa0 MR	31	#include "sdhci-pltfm.h"
985b1aa0 MR	32
30b87c60 SH	33	struct sdhci_dove_priv {
30b87c60 SH	34	struct clk *clk;
f8ec589b	35	int gpio_cd;
30b87c60 SH	36	};
30b87c60 SH	37
f8ec589b RK	38	static irqreturn_t sdhci_dove_carddetect_irq(int irq, void *data)
	39	{
	40	struct sdhci_host *host = data;
	41
	42	tasklet_schedule(&host->card_tasklet);
	43	return IRQ_HANDLED;
	44	}
	45
985b1aa0 MR	46	static u16 sdhci_dove_readw(struct sdhci_host *host, int reg)
	47	{
	48	u16 ret;
	49
	50	switch (reg) {
	51	case SDHCI_HOST_VERSION:
	52	case SDHCI_SLOT_INT_STATUS:
	53	/* those registers don't exist */
	54	return 0;
	55	default:
	56	ret = readw(host->ioaddr + reg);
	57	}
	58	return ret;
	59	}
	60
	61	static u32 sdhci_dove_readl(struct sdhci_host *host, int reg)
	62	{
f8ec589b RK	63	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
f8ec589b RK	64	struct sdhci_dove_priv *priv = pltfm_host->priv;
985b1aa0 MR	65	u32 ret;
985b1aa0 MR	66
f8ec589b RK	67	ret = readl(host->ioaddr + reg);
f8ec589b RK	68
985b1aa0 MR	69	switch (reg) {
985b1aa0 MR	70	case SDHCI_CAPABILITIES:
985b1aa0 MR	71	/* Mask the support for 3.0V */
	72	ret &= ~SDHCI_CAN_VDD_300;
	73	break;
f8ec589b RK	74	case SDHCI_PRESENT_STATE:
	75	if (gpio_is_valid(priv->gpio_cd)) {
	76	if (gpio_get_value(priv->gpio_cd) == 0)
	77	ret \|= SDHCI_CARD_PRESENT;
	78	else
	79	ret &= ~SDHCI_CARD_PRESENT;
	80	}
	81	break;
985b1aa0 MR	82	}
	83	return ret;
	84	}
	85
c915568d	86	static const struct sdhci_ops sdhci_dove_ops = {
985b1aa0 MR	87	.read_w = sdhci_dove_readw,
	88	.read_l = sdhci_dove_readl,
	89	};
	90
1db5eebf	91	static const struct sdhci_pltfm_data sdhci_dove_pdata = {
985b1aa0 MR	92	.ops = &sdhci_dove_ops,
	93	.quirks = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER \|
	94	SDHCI_QUIRK_NO_BUSY_IRQ \|
	95	SDHCI_QUIRK_BROKEN_TIMEOUT_VAL \|
a9ca1d54 SH	96	SDHCI_QUIRK_FORCE_DMA \|
a9ca1d54 SH	97	SDHCI_QUIRK_NO_HISPD_BIT,
985b1aa0	98	};
85d6509d	99
c3be1efd	100	static int sdhci_dove_probe(struct platform_device *pdev)
85d6509d	101	{
30b87c60 SH	102	struct sdhci_host *host;
	103	struct sdhci_pltfm_host *pltfm_host;
	104	struct sdhci_dove_priv *priv;
	105	int ret;
	106
30b87c60 SH	107	priv = devm_kzalloc(&pdev->dev, sizeof(struct sdhci_dove_priv),
	108	GFP_KERNEL);
	109	if (!priv) {
	110	dev_err(&pdev->dev, "unable to allocate private data");
ee3298a2	111	return -ENOMEM;
30b87c60 SH	112	}
30b87c60 SH	113
7430e77e	114	priv->clk = devm_clk_get(&pdev->dev, NULL);
ee3298a2	115
f8ec589b RK	116	if (pdev->dev.of_node) {
	117	priv->gpio_cd = of_get_named_gpio(pdev->dev.of_node,
	118	"cd-gpios", 0);
	119	} else {
	120	priv->gpio_cd = -EINVAL;
	121	}
	122
	123	if (gpio_is_valid(priv->gpio_cd)) {
	124	ret = gpio_request(priv->gpio_cd, "sdhci-cd");
	125	if (ret) {
	126	dev_err(&pdev->dev, "card detect gpio request failed: %d\n",
	127	ret);
	128	return ret;
	129	}
	130	gpio_direction_input(priv->gpio_cd);
	131	}
	132
0e748234	133	host = sdhci_pltfm_init(pdev, &sdhci_dove_pdata, 0);
c430689f RK	134	if (IS_ERR(host)) {
	135	ret = PTR_ERR(host);
	136	goto err_sdhci_pltfm_init;
	137	}
ee3298a2	138
30b87c60 SH	139	pltfm_host = sdhci_priv(host);
	140	pltfm_host->priv = priv;
	141
c430689f RK	142	if (!IS_ERR(priv->clk))
	143	clk_prepare_enable(priv->clk);
	144
	145	sdhci_get_of_property(pdev);
	146
	147	ret = sdhci_add_host(host);
	148	if (ret)
	149	goto err_sdhci_add;
	150
f8ec589b RK	151	/*
	152	* We must request the IRQ after sdhci_add_host(), as the tasklet only
	153	* gets setup in sdhci_add_host() and we oops.
	154	*/
	155	if (gpio_is_valid(priv->gpio_cd)) {
	156	ret = request_irq(gpio_to_irq(priv->gpio_cd),
	157	sdhci_dove_carddetect_irq,
	158	IRQF_TRIGGER_FALLING \| IRQF_TRIGGER_RISING,
	159	mmc_hostname(host->mmc), host);
	160	if (ret) {
	161	dev_err(&pdev->dev, "card detect irq request failed: %d\n",
	162	ret);
	163	goto err_request_irq;
	164	}
	165	}
	166
30b87c60 SH	167	return 0;
30b87c60 SH	168
f8ec589b RK	169	err_request_irq:
f8ec589b RK	170	sdhci_remove_host(host, 0);
c430689f	171	err_sdhci_add:
7430e77e	172	if (!IS_ERR(priv->clk))
ee3298a2	173	clk_disable_unprepare(priv->clk);
c430689f RK	174	sdhci_pltfm_free(pdev);
c430689f RK	175	err_sdhci_pltfm_init:
f8ec589b RK	176	if (gpio_is_valid(priv->gpio_cd))
f8ec589b RK	177	gpio_free(priv->gpio_cd);
30b87c60	178	return ret;
85d6509d SG	179	}
85d6509d SG	180
6e0ee714	181	static int sdhci_dove_remove(struct platform_device *pdev)
85d6509d	182	{
30b87c60 SH	183	struct sdhci_host *host = platform_get_drvdata(pdev);
	184	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
	185	struct sdhci_dove_priv *priv = pltfm_host->priv;
	186
ee3298a2 RKAL	187	sdhci_pltfm_unregister(pdev);
ee3298a2 RKAL	188
f8ec589b RK	189	if (gpio_is_valid(priv->gpio_cd)) {
	190	free_irq(gpio_to_irq(priv->gpio_cd), host);
	191	gpio_free(priv->gpio_cd);
	192	}
	193
7430e77e	194	if (!IS_ERR(priv->clk))
ee3298a2	195	clk_disable_unprepare(priv->clk);
7430e77e	196
ee3298a2	197	return 0;
85d6509d SG	198	}
85d6509d SG	199
498d83e7	200	static const struct of_device_id sdhci_dove_of_match_table[] = {
4ee7ed0d SH	201	{ .compatible = "marvell,dove-sdhci", },
	202	{}
	203	};
	204	MODULE_DEVICE_TABLE(of, sdhci_dove_of_match_table);
	205
85d6509d SG	206	static struct platform_driver sdhci_dove_driver = {
	207	.driver = {
	208	.name = "sdhci-dove",
	209	.owner = THIS_MODULE,
29495aa0	210	.pm = SDHCI_PLTFM_PMOPS,
4ee7ed0d	211	.of_match_table = of_match_ptr(sdhci_dove_of_match_table),
85d6509d SG	212	},
85d6509d SG	213	.probe = sdhci_dove_probe,
0433c143	214	.remove = sdhci_dove_remove,
85d6509d SG	215	};
85d6509d SG	216
d1f81a64	217	module_platform_driver(sdhci_dove_driver);
85d6509d SG	218
	219	MODULE_DESCRIPTION("SDHCI driver for Dove");
	220	MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>, "
	221	"Mike Rapoport <mike@compulab.co.il>");
	222	MODULE_LICENSE("GPL v2");