[linux-2.6-block.git] / drivers / mfd / tc6387xb.c

/*
 * Toshiba TC6387XB support
 * Copyright (c) 2005 Ian Molton
 *
 * 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 file contains TC6387XB base support.
 *
 */

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/mfd/core.h>
#include <linux/mfd/tmio.h>
#include <linux/mfd/tc6387xb.h>

enum {
	TC6387XB_CELL_MMC,
};

#ifdef CONFIG_PM
static int tc6387xb_suspend(struct platform_device *dev, pm_message_t state)
{
	struct clk *clk32k = platform_get_drvdata(dev);
	struct tc6387xb_platform_data *pdata = dev->dev.platform_data;

	if (pdata && pdata->suspend)
		pdata->suspend(dev);
	clk_disable(clk32k);

	return 0;
}

static int tc6387xb_resume(struct platform_device *dev)
{
	struct clk *clk32k = platform_get_drvdata(dev);
	struct tc6387xb_platform_data *pdata = dev->dev.platform_data;

	clk_enable(clk32k);
	if (pdata && pdata->resume)
		pdata->resume(dev);

	return 0;
}
#else
#define tc6387xb_suspend  NULL
#define tc6387xb_resume   NULL
#endif

/*--------------------------------------------------------------------------*/

static int tc6387xb_mmc_enable(struct platform_device *mmc)
{
	struct platform_device *dev      = to_platform_device(mmc->dev.parent);
	struct clk *clk32k = platform_get_drvdata(dev);

	clk_enable(clk32k);

	return 0;
}

static int tc6387xb_mmc_disable(struct platform_device *mmc)
{
	struct platform_device *dev      = to_platform_device(mmc->dev.parent);
	struct clk *clk32k = platform_get_drvdata(dev);

	clk_disable(clk32k);

	return 0;
}

/*--------------------------------------------------------------------------*/

static struct resource tc6387xb_mmc_resources[] = {
	{
		.start = 0x800,
		.end   = 0x9ff,
		.flags = IORESOURCE_MEM,
	},
	{
		.start = 0x200,
		.end   = 0x2ff,
		.flags = IORESOURCE_MEM,
	},
	{
		.start = 0,
		.end   = 0,
		.flags = IORESOURCE_IRQ,
	},
};

static struct mfd_cell tc6387xb_cells[] = {
	[TC6387XB_CELL_MMC] = {
		.name = "tmio-mmc",
		.enable = tc6387xb_mmc_enable,
		.disable = tc6387xb_mmc_disable,
		.num_resources = ARRAY_SIZE(tc6387xb_mmc_resources),
		.resources = tc6387xb_mmc_resources,
	},
};

static int tc6387xb_probe(struct platform_device *dev)
{
	struct tc6387xb_platform_data *pdata = dev->dev.platform_data;
	struct resource *iomem;
	struct clk *clk32k;
	int irq, ret;

	iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
	if (!iomem) {
		return -EINVAL;
	}

	ret  = platform_get_irq(dev, 0);
	if (ret >= 0)
		irq = ret;
	else
		goto err_resource;

	clk32k = clk_get(&dev->dev, "CLK_CK32K");
	if (IS_ERR(clk32k)) {
		ret = PTR_ERR(clk32k);
		goto err_resource;
	}
	platform_set_drvdata(dev, clk32k);

	if (pdata && pdata->enable)
		pdata->enable(dev);

	printk(KERN_INFO "Toshiba tc6387xb initialised\n");

	tc6387xb_cells[TC6387XB_CELL_MMC].platform_data =
		&tc6387xb_cells[TC6387XB_CELL_MMC];
	tc6387xb_cells[TC6387XB_CELL_MMC].data_size =
		sizeof(tc6387xb_cells[TC6387XB_CELL_MMC]);

	ret = mfd_add_devices(&dev->dev, dev->id, tc6387xb_cells,
			      ARRAY_SIZE(tc6387xb_cells), iomem, irq);

	if (!ret)
		return 0;

	clk_put(clk32k);
err_resource:
	return ret;
}

static int tc6387xb_remove(struct platform_device *dev)
{
	struct clk *clk32k = platform_get_drvdata(dev);

	mfd_remove_devices(&dev->dev);
	clk_disable(clk32k);
	clk_put(clk32k);
	platform_set_drvdata(dev, NULL);

	return 0;
}


static struct platform_driver tc6387xb_platform_driver = {
	.driver = {
		.name		= "tc6387xb",
	},
	.probe		= tc6387xb_probe,
	.remove		= tc6387xb_remove,
	.suspend        = tc6387xb_suspend,
	.resume         = tc6387xb_resume,
};


static int __init tc6387xb_init(void)
{
	return platform_driver_register(&tc6387xb_platform_driver);
}

static void __exit tc6387xb_exit(void)
{
	platform_driver_unregister(&tc6387xb_platform_driver);
}

module_init(tc6387xb_init);
module_exit(tc6387xb_exit);

MODULE_DESCRIPTION("Toshiba TC6387XB core driver");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Ian Molton");
MODULE_ALIAS("platform:tc6387xb");
Commit	Line	Data
cbdfb426 IM	1	/*
	2	* Toshiba TC6387XB support
	3	* Copyright (c) 2005 Ian Molton
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*
	9	* This file contains TC6387XB base support.
	10	*
	11	*/
	12
	13	#include <linux/module.h>
	14	#include <linux/platform_device.h>
7acb706c	15	#include <linux/clk.h>
cbdfb426 IM	16	#include <linux/err.h>
	17	#include <linux/mfd/core.h>
	18	#include <linux/mfd/tmio.h>
	19	#include <linux/mfd/tc6387xb.h>
	20
d2432a63 IM	21	enum {
	22	TC6387XB_CELL_MMC,
	23	};
	24
cbdfb426 IM	25	#ifdef CONFIG_PM
	26	static int tc6387xb_suspend(struct platform_device *dev, pm_message_t state)
	27	{
7acb706c IM	28	struct clk *clk32k = platform_get_drvdata(dev);
7acb706c IM	29	struct tc6387xb_platform_data *pdata = dev->dev.platform_data;
cbdfb426 IM	30
	31	if (pdata && pdata->suspend)
	32	pdata->suspend(dev);
7acb706c	33	clk_disable(clk32k);
cbdfb426 IM	34
	35	return 0;
	36	}
	37
	38	static int tc6387xb_resume(struct platform_device *dev)
	39	{
7acb706c IM	40	struct clk *clk32k = platform_get_drvdata(dev);
7acb706c IM	41	struct tc6387xb_platform_data *pdata = dev->dev.platform_data;
cbdfb426	42
7acb706c	43	clk_enable(clk32k);
cbdfb426 IM	44	if (pdata && pdata->resume)
	45	pdata->resume(dev);
	46
	47	return 0;
	48	}
	49	#else
	50	#define tc6387xb_suspend NULL
	51	#define tc6387xb_resume NULL
	52	#endif
	53
	54	/--------------------------------------------------------------------------/
	55
	56	static int tc6387xb_mmc_enable(struct platform_device *mmc)
	57	{
	58	struct platform_device *dev = to_platform_device(mmc->dev.parent);
7acb706c	59	struct clk *clk32k = platform_get_drvdata(dev);
cbdfb426	60
7acb706c	61	clk_enable(clk32k);
cbdfb426 IM	62
	63	return 0;
	64	}
	65
	66	static int tc6387xb_mmc_disable(struct platform_device *mmc)
	67	{
	68	struct platform_device *dev = to_platform_device(mmc->dev.parent);
7acb706c	69	struct clk *clk32k = platform_get_drvdata(dev);
cbdfb426	70
7acb706c	71	clk_disable(clk32k);
cbdfb426 IM	72
	73	return 0;
	74	}
	75
	76	/--------------------------------------------------------------------------/
	77
	78	static struct resource tc6387xb_mmc_resources[] = {
	79	{
	80	.start = 0x800,
	81	.end = 0x9ff,
	82	.flags = IORESOURCE_MEM,
	83	},
	84	{
	85	.start = 0x200,
	86	.end = 0x2ff,
	87	.flags = IORESOURCE_MEM,
	88	},
	89	{
	90	.start = 0,
	91	.end = 0,
	92	.flags = IORESOURCE_IRQ,
	93	},
	94	};
	95
	96	static struct mfd_cell tc6387xb_cells[] = {
d2432a63	97	[TC6387XB_CELL_MMC] = {
cbdfb426 IM	98	.name = "tmio-mmc",
	99	.enable = tc6387xb_mmc_enable,
	100	.disable = tc6387xb_mmc_disable,
	101	.num_resources = ARRAY_SIZE(tc6387xb_mmc_resources),
	102	.resources = tc6387xb_mmc_resources,
	103	},
	104	};
	105
	106	static int tc6387xb_probe(struct platform_device *dev)
	107	{
7acb706c	108	struct tc6387xb_platform_data *pdata = dev->dev.platform_data;
cbdfb426	109	struct resource *iomem;
7acb706c	110	struct clk *clk32k;
cbdfb426 IM	111	int irq, ret;
	112
	113	iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
	114	if (!iomem) {
7acb706c	115	return -EINVAL;
cbdfb426 IM	116	}
	117
	118	ret = platform_get_irq(dev, 0);
	119	if (ret >= 0)
	120	irq = ret;
	121	else
	122	goto err_resource;
	123
7acb706c IM	124	clk32k = clk_get(&dev->dev, "CLK_CK32K");
	125	if (IS_ERR(clk32k)) {
	126	ret = PTR_ERR(clk32k);
	127	goto err_resource;
	128	}
	129	platform_set_drvdata(dev, clk32k);
	130
	131	if (pdata && pdata->enable)
	132	pdata->enable(dev);
cbdfb426 IM	133
	134	printk(KERN_INFO "Toshiba tc6387xb initialised\n");
	135
d2432a63 IM	136	tc6387xb_cells[TC6387XB_CELL_MMC].platform_data =
	137	&tc6387xb_cells[TC6387XB_CELL_MMC];
	138	tc6387xb_cells[TC6387XB_CELL_MMC].data_size =
	139	sizeof(tc6387xb_cells[TC6387XB_CELL_MMC]);
	140
56bf2bda SO	141	ret = mfd_add_devices(&dev->dev, dev->id, tc6387xb_cells,
56bf2bda SO	142	ARRAY_SIZE(tc6387xb_cells), iomem, irq);
cbdfb426 IM	143
	144	if (!ret)
	145	return 0;
	146
7acb706c	147	clk_put(clk32k);
cbdfb426 IM	148	err_resource:
	149	return ret;
	150	}
	151
	152	static int tc6387xb_remove(struct platform_device *dev)
	153	{
7acb706c	154	struct clk *clk32k = platform_get_drvdata(dev);
cbdfb426	155
7acb706c IM	156	mfd_remove_devices(&dev->dev);
	157	clk_disable(clk32k);
	158	clk_put(clk32k);
	159	platform_set_drvdata(dev, NULL);
cbdfb426 IM	160
	161	return 0;
	162	}
	163
	164
	165	static struct platform_driver tc6387xb_platform_driver = {
	166	.driver = {
	167	.name = "tc6387xb",
	168	},
	169	.probe = tc6387xb_probe,
	170	.remove = tc6387xb_remove,
	171	.suspend = tc6387xb_suspend,
	172	.resume = tc6387xb_resume,
	173	};
	174
	175
	176	static int __init tc6387xb_init(void)
	177	{
	178	return platform_driver_register(&tc6387xb_platform_driver);
	179	}
	180
	181	static void __exit tc6387xb_exit(void)
	182	{
	183	platform_driver_unregister(&tc6387xb_platform_driver);
	184	}
	185
	186	module_init(tc6387xb_init);
	187	module_exit(tc6387xb_exit);
	188
	189	MODULE_DESCRIPTION("Toshiba TC6387XB core driver");
	190	MODULE_LICENSE("GPL v2");
	191	MODULE_AUTHOR("Ian Molton");
	192	MODULE_ALIAS("platform:tc6387xb");