[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 sh_mobile_sdhi_get_cd(struct platform_device *tmio)
{
	struct platform_device *pdev = to_platform_device(tmio->dev.parent);
	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;

	if (p && p->get_cd)
		return p->get_cd(pdev);
	else
		return -ENOSYS;
}

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 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->get_cd = sh_mobile_sdhi_get_cd;
	mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
	if (p) {
		mmc_data->flags = p->tmio_flags;
		mmc_data->ocr_mask = p->tmio_ocr_mask;
		mmc_data->capabilities |= p->tmio_caps;
	}

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

	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
998283e2 AH	68	static int sh_mobile_sdhi_get_cd(struct platform_device *tmio)
	69	{
	70	struct platform_device *pdev = to_platform_device(tmio->dev.parent);
	71	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
	72
	73	if (p && p->get_cd)
	74	return p->get_cd(pdev);
	75	else
	76	return -ENOSYS;
	77	}
	78
25ab998e	79	static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
a87d5638 MD	80	{
a87d5638 MD	81	struct sh_mobile_sdhi *priv;
056676da GL	82	struct tmio_mmc_data *mmc_data;
056676da GL	83	struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
a87d5638 MD	84	struct resource *mem;
	85	char clk_name[8];
	86	int ret, irq;
	87
	88	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	89	if (!mem)
	90	dev_err(&pdev->dev, "missing MEM resource\n");
	91
	92	irq = platform_get_irq(pdev, 0);
	93	if (irq < 0)
	94	dev_err(&pdev->dev, "missing IRQ resource\n");
	95
	96	if (!mem \|\| (irq < 0))
	97	return -EINVAL;
	98
	99	priv = kzalloc(sizeof(struct sh_mobile_sdhi), GFP_KERNEL);
	100	if (priv == NULL) {
	101	dev_err(&pdev->dev, "kzalloc failed\n");
	102	return -ENOMEM;
	103	}
	104
056676da GL	105	mmc_data = &priv->mmc_data;
056676da GL	106
a87d5638 MD	107	snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id);
	108	priv->clk = clk_get(&pdev->dev, clk_name);
	109	if (IS_ERR(priv->clk)) {
	110	dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
	111	ret = PTR_ERR(priv->clk);
	112	kfree(priv);
	113	return ret;
	114	}
	115
	116	clk_enable(priv->clk);
	117
056676da GL	118	mmc_data->hclk = clk_get_rate(priv->clk);
056676da GL	119	mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
998283e2	120	mmc_data->get_cd = sh_mobile_sdhi_get_cd;
056676da	121	mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
bb0fe533	122	if (p) {
f87c20a9	123	mmc_data->flags = p->tmio_flags;
bb0fe533	124	mmc_data->ocr_mask = p->tmio_ocr_mask;
998283e2	125	mmc_data->capabilities \|= p->tmio_caps;
bb0fe533	126	}
056676da	127
f1334fb3 YG	128	/*
	129	* All SDHI blocks support 2-byte and larger block sizes in 4-bit
	130	* bus width mode.
	131	*/
	132	mmc_data->flags \|= TMIO_MMC_BLKSZ_2BYTES;
	133
056676da GL	134	if (p && p->dma_slave_tx >= 0 && p->dma_slave_rx >= 0) {
	135	priv->param_tx.slave_id = p->dma_slave_tx;
	136	priv->param_rx.slave_id = p->dma_slave_rx;
	137	priv->dma_priv.chan_priv_tx = &priv->param_tx;
	138	priv->dma_priv.chan_priv_rx = &priv->param_rx;
	139	mmc_data->dma = &priv->dma_priv;
	140	}
a87d5638 MD	141
a87d5638 MD	142	memcpy(&priv->cell_mmc, &sh_mobile_sdhi_cell, sizeof(priv->cell_mmc));
056676da	143	priv->cell_mmc.driver_data = mmc_data;
a87d5638 MD	144	priv->cell_mmc.platform_data = &priv->cell_mmc;
	145	priv->cell_mmc.data_size = sizeof(priv->cell_mmc);
	146
	147	platform_set_drvdata(pdev, priv);
	148
	149	ret = mfd_add_devices(&pdev->dev, pdev->id,
	150	&priv->cell_mmc, 1, mem, irq);
	151	if (ret) {
	152	clk_disable(priv->clk);
	153	clk_put(priv->clk);
	154	kfree(priv);
	155	}
	156
	157	return ret;
	158	}
	159
	160	static int sh_mobile_sdhi_remove(struct platform_device *pdev)
	161	{
	162	struct sh_mobile_sdhi *priv = platform_get_drvdata(pdev);
	163
	164	mfd_remove_devices(&pdev->dev);
	165	clk_disable(priv->clk);
	166	clk_put(priv->clk);
	167	kfree(priv);
	168
	169	return 0;
	170	}
	171
	172	static struct platform_driver sh_mobile_sdhi_driver = {
	173	.driver = {
	174	.name = "sh_mobile_sdhi",
	175	.owner = THIS_MODULE,
	176	},
	177	.probe = sh_mobile_sdhi_probe,
	178	.remove = __devexit_p(sh_mobile_sdhi_remove),
	179	};
	180
	181	static int __init sh_mobile_sdhi_init(void)
	182	{
	183	return platform_driver_register(&sh_mobile_sdhi_driver);
	184	}
	185
	186	static void __exit sh_mobile_sdhi_exit(void)
	187	{
	188	platform_driver_unregister(&sh_mobile_sdhi_driver);
	189	}
	190
	191	module_init(sh_mobile_sdhi_init);
	192	module_exit(sh_mobile_sdhi_exit);
	193
	194	MODULE_DESCRIPTION("SuperH Mobile SDHI driver");
	195	MODULE_AUTHOR("Magnus Damm");
	196	MODULE_LICENSE("GPL v2");