[net-next-2.6.git] / drivers / mfd / 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/platform_device.h>
#include <linux/mmc/host.h>
#include <linux/mfd/core.h>
#include <linux/mfd/tmio.h>
#include <linux/mfd/sh_mobile_sdhi.h>
#include <linux/sh_dma.h>

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

static struct resource sh_mobile_sdhi_resources[] = {
	{
		.start = 0x000,
		.end   = 0x1ff,
		.flags = IORESOURCE_MEM,
	},
	{
		.start = 0,
		.end   = 0,
		.flags = IORESOURCE_IRQ,
	},
};

static struct mfd_cell sh_mobile_sdhi_cell = {
	.name          = "tmio-mmc",
	.num_resources = ARRAY_SIZE(sh_mobile_sdhi_resources),
	.resources     = sh_mobile_sdhi_resources,
};

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

	if (p && p->set_pwr)
		p->set_pwr(pdev, state);
}

static int __init 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 resource *mem;
	char clk_name[8];
	int ret, irq;

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!mem)
		dev_err(&pdev->dev, "missing MEM resource\n");

	irq = platform_get_irq(pdev, 0);
	if (irq < 0)
		dev_err(&pdev->dev, "missing IRQ resource\n");

	if (!mem || (irq < 0))
		return -EINVAL;

	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;

	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);
		kfree(priv);
		return ret;
	}

	clk_enable(priv->clk);

	mmc_data->hclk = clk_get_rate(priv->clk);
	mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
	mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
	if (p) {
		mmc_data->flags = p->tmio_flags;
		mmc_data->ocr_mask = p->tmio_ocr_mask;
	}

	if (p && 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;
		mmc_data->dma = &priv->dma_priv;
	}

	memcpy(&priv->cell_mmc, &sh_mobile_sdhi_cell, sizeof(priv->cell_mmc));
	priv->cell_mmc.driver_data = mmc_data;
	priv->cell_mmc.platform_data = &priv->cell_mmc;
	priv->cell_mmc.data_size = sizeof(priv->cell_mmc);

	platform_set_drvdata(pdev, priv);

	ret = mfd_add_devices(&pdev->dev, pdev->id,
			      &priv->cell_mmc, 1, mem, irq);
	if (ret) {
		clk_disable(priv->clk);
		clk_put(priv->clk);
		kfree(priv);
	}

	return ret;
}

static int sh_mobile_sdhi_remove(struct platform_device *pdev)
{
	struct sh_mobile_sdhi *priv = platform_get_drvdata(pdev);

	mfd_remove_devices(&pdev->dev);
	clk_disable(priv->clk);
	clk_put(priv->clk);
	kfree(priv);

	return 0;
}

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

static int __init sh_mobile_sdhi_init(void)
{
	return platform_driver_register(&sh_mobile_sdhi_driver);
}

static void __exit sh_mobile_sdhi_exit(void)
{
	platform_driver_unregister(&sh_mobile_sdhi_driver);
}

module_init(sh_mobile_sdhi_init);
module_exit(sh_mobile_sdhi_exit);

MODULE_DESCRIPTION("SuperH Mobile SDHI driver");
MODULE_AUTHOR("Magnus Damm");
MODULE_LICENSE("GPL v2");
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>
a87d5638	24	#include <linux/platform_device.h>
3c49e810	25	#include <linux/mmc/host.h>
a87d5638 MD	26	#include <linux/mfd/core.h>
a87d5638 MD	27	#include <linux/mfd/tmio.h>
be9cd7b6	28	#include <linux/mfd/sh_mobile_sdhi.h>
056676da	29	#include <linux/sh_dma.h>
a87d5638 MD	30
	31	struct sh_mobile_sdhi {
	32	struct clk *clk;
	33	struct tmio_mmc_data mmc_data;
	34	struct mfd_cell cell_mmc;
056676da GL	35	struct sh_dmae_slave param_tx;
	36	struct sh_dmae_slave param_rx;
	37	struct tmio_mmc_dma dma_priv;
a87d5638 MD	38	};
	39
	40	static struct resource sh_mobile_sdhi_resources[] = {
	41	{
	42	.start = 0x000,
	43	.end = 0x1ff,
	44	.flags = IORESOURCE_MEM,
	45	},
	46	{
	47	.start = 0,
	48	.end = 0,
	49	.flags = IORESOURCE_IRQ,
	50	},
	51	};
	52
	53	static struct mfd_cell sh_mobile_sdhi_cell = {
	54	.name = "tmio-mmc",
	55	.num_resources = ARRAY_SIZE(sh_mobile_sdhi_resources),
	56	.resources = sh_mobile_sdhi_resources,
	57	};
	58
be9cd7b6 MD	59	static void sh_mobile_sdhi_set_pwr(struct platform_device *tmio, int state)
	60	{
	61	struct platform_device *pdev = to_platform_device(tmio->dev.parent);
	62	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
	63
	64	if (p && p->set_pwr)
	65	p->set_pwr(pdev, state);
	66	}
	67
a87d5638 MD	68	static int __init sh_mobile_sdhi_probe(struct platform_device *pdev)
	69	{
	70	struct sh_mobile_sdhi *priv;
056676da GL	71	struct tmio_mmc_data *mmc_data;
056676da GL	72	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
a87d5638 MD	73	struct resource *mem;
	74	char clk_name[8];
	75	int ret, irq;
	76
	77	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	78	if (!mem)
	79	dev_err(&pdev->dev, "missing MEM resource\n");
	80
	81	irq = platform_get_irq(pdev, 0);
	82	if (irq < 0)
	83	dev_err(&pdev->dev, "missing IRQ resource\n");
	84
	85	if (!mem \|\| (irq < 0))
	86	return -EINVAL;
	87
	88	priv = kzalloc(sizeof(struct sh_mobile_sdhi), GFP_KERNEL);
	89	if (priv == NULL) {
	90	dev_err(&pdev->dev, "kzalloc failed\n");
	91	return -ENOMEM;
	92	}
	93
056676da GL	94	mmc_data = &priv->mmc_data;
056676da GL	95
a87d5638 MD	96	snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id);
	97	priv->clk = clk_get(&pdev->dev, clk_name);
	98	if (IS_ERR(priv->clk)) {
	99	dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
	100	ret = PTR_ERR(priv->clk);
	101	kfree(priv);
	102	return ret;
	103	}
	104
	105	clk_enable(priv->clk);
	106
056676da GL	107	mmc_data->hclk = clk_get_rate(priv->clk);
	108	mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
	109	mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
bb0fe533	110	if (p) {
f87c20a9	111	mmc_data->flags = p->tmio_flags;
bb0fe533 GL	112	mmc_data->ocr_mask = p->tmio_ocr_mask;
bb0fe533 GL	113	}
056676da GL	114
	115	if (p && p->dma_slave_tx >= 0 && p->dma_slave_rx >= 0) {
	116	priv->param_tx.slave_id = p->dma_slave_tx;
	117	priv->param_rx.slave_id = p->dma_slave_rx;
	118	priv->dma_priv.chan_priv_tx = &priv->param_tx;
	119	priv->dma_priv.chan_priv_rx = &priv->param_rx;
	120	mmc_data->dma = &priv->dma_priv;
	121	}
a87d5638 MD	122
a87d5638 MD	123	memcpy(&priv->cell_mmc, &sh_mobile_sdhi_cell, sizeof(priv->cell_mmc));
056676da	124	priv->cell_mmc.driver_data = mmc_data;
a87d5638 MD	125	priv->cell_mmc.platform_data = &priv->cell_mmc;
	126	priv->cell_mmc.data_size = sizeof(priv->cell_mmc);
	127
	128	platform_set_drvdata(pdev, priv);
	129
	130	ret = mfd_add_devices(&pdev->dev, pdev->id,
	131	&priv->cell_mmc, 1, mem, irq);
	132	if (ret) {
	133	clk_disable(priv->clk);
	134	clk_put(priv->clk);
	135	kfree(priv);
	136	}
	137
	138	return ret;
	139	}
	140
	141	static int sh_mobile_sdhi_remove(struct platform_device *pdev)
	142	{
	143	struct sh_mobile_sdhi *priv = platform_get_drvdata(pdev);
	144
	145	mfd_remove_devices(&pdev->dev);
	146	clk_disable(priv->clk);
	147	clk_put(priv->clk);
	148	kfree(priv);
	149
	150	return 0;
	151	}
	152
	153	static struct platform_driver sh_mobile_sdhi_driver = {
	154	.driver = {
	155	.name = "sh_mobile_sdhi",
	156	.owner = THIS_MODULE,
	157	},
	158	.probe = sh_mobile_sdhi_probe,
	159	.remove = __devexit_p(sh_mobile_sdhi_remove),
	160	};
	161
	162	static int __init sh_mobile_sdhi_init(void)
	163	{
	164	return platform_driver_register(&sh_mobile_sdhi_driver);
	165	}
	166
	167	static void __exit sh_mobile_sdhi_exit(void)
	168	{
	169	platform_driver_unregister(&sh_mobile_sdhi_driver);
	170	}
	171
	172	module_init(sh_mobile_sdhi_init);
	173	module_exit(sh_mobile_sdhi_exit);
	174
	175	MODULE_DESCRIPTION("SuperH Mobile SDHI driver");
	176	MODULE_AUTHOR("Magnus Damm");
	177	MODULE_LICENSE("GPL v2");