[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 tmio_mmc_data tc6387xb_mmc_data = {
	.hclk = 24000000,
};

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,
		.driver_data = &tc6387xb_mmc_data,
		.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
4d3792e0	78	static struct tmio_mmc_data tc6387xb_mmc_data = {
f0e46cc4 PZ	79	.hclk = 24000000,
	80	};
	81
cbdfb426 IM	82	static struct resource tc6387xb_mmc_resources[] = {
	83	{
	84	.start = 0x800,
	85	.end = 0x9ff,
	86	.flags = IORESOURCE_MEM,
	87	},
	88	{
	89	.start = 0x200,
	90	.end = 0x2ff,
	91	.flags = IORESOURCE_MEM,
	92	},
	93	{
	94	.start = 0,
	95	.end = 0,
	96	.flags = IORESOURCE_IRQ,
	97	},
	98	};
	99
	100	static struct mfd_cell tc6387xb_cells[] = {
d2432a63	101	[TC6387XB_CELL_MMC] = {
cbdfb426 IM	102	.name = "tmio-mmc",
	103	.enable = tc6387xb_mmc_enable,
	104	.disable = tc6387xb_mmc_disable,
f0e46cc4	105	.driver_data = &tc6387xb_mmc_data,
cbdfb426 IM	106	.num_resources = ARRAY_SIZE(tc6387xb_mmc_resources),
	107	.resources = tc6387xb_mmc_resources,
	108	},
	109	};
	110
	111	static int tc6387xb_probe(struct platform_device *dev)
	112	{
7acb706c	113	struct tc6387xb_platform_data *pdata = dev->dev.platform_data;
cbdfb426	114	struct resource *iomem;
7acb706c	115	struct clk *clk32k;
cbdfb426 IM	116	int irq, ret;
	117
	118	iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
	119	if (!iomem) {
7acb706c	120	return -EINVAL;
cbdfb426 IM	121	}
	122
	123	ret = platform_get_irq(dev, 0);
	124	if (ret >= 0)
	125	irq = ret;
	126	else
	127	goto err_resource;
	128
7acb706c IM	129	clk32k = clk_get(&dev->dev, "CLK_CK32K");
	130	if (IS_ERR(clk32k)) {
	131	ret = PTR_ERR(clk32k);
	132	goto err_resource;
	133	}
	134	platform_set_drvdata(dev, clk32k);
	135
	136	if (pdata && pdata->enable)
	137	pdata->enable(dev);
cbdfb426 IM	138
	139	printk(KERN_INFO "Toshiba tc6387xb initialised\n");
	140
d2432a63 IM	141	tc6387xb_cells[TC6387XB_CELL_MMC].platform_data =
	142	&tc6387xb_cells[TC6387XB_CELL_MMC];
	143	tc6387xb_cells[TC6387XB_CELL_MMC].data_size =
	144	sizeof(tc6387xb_cells[TC6387XB_CELL_MMC]);
	145
56bf2bda SO	146	ret = mfd_add_devices(&dev->dev, dev->id, tc6387xb_cells,
56bf2bda SO	147	ARRAY_SIZE(tc6387xb_cells), iomem, irq);
cbdfb426 IM	148
	149	if (!ret)
	150	return 0;
	151
7acb706c	152	clk_put(clk32k);
cbdfb426 IM	153	err_resource:
	154	return ret;
	155	}
	156
	157	static int tc6387xb_remove(struct platform_device *dev)
	158	{
7acb706c	159	struct clk *clk32k = platform_get_drvdata(dev);
cbdfb426	160
7acb706c IM	161	mfd_remove_devices(&dev->dev);
	162	clk_disable(clk32k);
	163	clk_put(clk32k);
	164	platform_set_drvdata(dev, NULL);
cbdfb426 IM	165
	166	return 0;
	167	}
	168
	169
	170	static struct platform_driver tc6387xb_platform_driver = {
	171	.driver = {
	172	.name = "tc6387xb",
	173	},
	174	.probe = tc6387xb_probe,
	175	.remove = tc6387xb_remove,
	176	.suspend = tc6387xb_suspend,
	177	.resume = tc6387xb_resume,
	178	};
	179
	180
	181	static int __init tc6387xb_init(void)
	182	{
	183	return platform_driver_register(&tc6387xb_platform_driver);
	184	}
	185
	186	static void __exit tc6387xb_exit(void)
	187	{
	188	platform_driver_unregister(&tc6387xb_platform_driver);
	189	}
	190
	191	module_init(tc6387xb_init);
	192	module_exit(tc6387xb_exit);
	193
	194	MODULE_DESCRIPTION("Toshiba TC6387XB core driver");
	195	MODULE_LICENSE("GPL v2");
	196	MODULE_AUTHOR("Ian Molton");
	197	MODULE_ALIAS("platform:tc6387xb");