[linux-2.6-block.git] / arch / arm / mach-integrator / impd1.c

/*
 *  linux/arch/arm/mach-integrator/impd1.c
 *
 *  Copyright (C) 2003 Deep Blue Solutions Ltd, All Rights Reserved.
 *
 * 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 provides the core support for the IM-PD1 module.
 *
 * Module / boot parameters.
 *   lmid=n   impd1.lmid=n - set the logic module position in stack to 'n'
 */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/amba/bus.h>
#include <linux/amba/clcd.h>
#include <linux/io.h>
#include <linux/slab.h>

#include <asm/clkdev.h>
#include <mach/clkdev.h>
#include <asm/hardware/icst525.h>
#include <mach/lm.h>
#include <mach/impd1.h>
#include <asm/sizes.h>

static int module_id;

module_param_named(lmid, module_id, int, 0444);
MODULE_PARM_DESC(lmid, "logic module stack position");

struct impd1_module {
	void __iomem	*base;
	struct clk	vcos[2];
	struct clk_lookup *clks[3];
};

static const struct icst525_params impd1_vco_params = {
	.ref		= 24000,	/* 24 MHz */
	.vco_max	= 200000,	/* 200 MHz */
	.vd_min		= 12,
	.vd_max		= 519,
	.rd_min		= 3,
	.rd_max		= 120,
};

static void impd1_setvco(struct clk *clk, struct icst525_vco vco)
{
	struct impd1_module *impd1 = clk->data;
	int vconr = clk - impd1->vcos;
	u32 val;

	val = vco.v | (vco.r << 9) | (vco.s << 16);

	writel(0xa05f, impd1->base + IMPD1_LOCK);
	switch (vconr) {
	case 0:
		writel(val, impd1->base + IMPD1_OSC1);
		break;
	case 1:
		writel(val, impd1->base + IMPD1_OSC2);
		break;
	}
	writel(0, impd1->base + IMPD1_LOCK);

#ifdef DEBUG
	vco.v = val & 0x1ff;
	vco.r = (val >> 9) & 0x7f;
	vco.s = (val >> 16) & 7;

	pr_debug("IM-PD1: VCO%d clock is %ld kHz\n",
		 vconr, icst525_khz(&impd1_vco_params, vco));
#endif
}

void impd1_tweak_control(struct device *dev, u32 mask, u32 val)
{
	struct impd1_module *impd1 = dev_get_drvdata(dev);
	u32 cur;

	val &= mask;
	cur = readl(impd1->base + IMPD1_CTRL) & ~mask;
	writel(cur | val, impd1->base + IMPD1_CTRL);
}

EXPORT_SYMBOL(impd1_tweak_control);

/*
 * CLCD support
 */
#define PANEL		PROSPECTOR

#define LTM10C209		1
#define PROSPECTOR		2
#define SVGA			3
#define VGA			4

#if PANEL == VGA
#define PANELTYPE	vga
static struct clcd_panel vga = {
	.mode		= {
		.name		= "VGA",
		.refresh	= 60,
		.xres		= 640,
		.yres		= 480,
		.pixclock	= 39721,
		.left_margin	= 40,
		.right_margin	= 24,
		.upper_margin	= 32,
		.lower_margin	= 11,
		.hsync_len	= 96,
		.vsync_len	= 2,
		.sync		= 0,
		.vmode		= FB_VMODE_NONINTERLACED,
	},
	.width		= -1,
	.height		= -1,
	.tim2		= TIM2_BCD | TIM2_IPC,
	.cntl		= CNTL_LCDTFT | CNTL_LCDVCOMP(1),
	.connector	= IMPD1_CTRL_DISP_VGA,
	.bpp		= 16,
	.grayscale	= 0,
};

#elif PANEL == SVGA
#define PANELTYPE	svga
static struct clcd_panel svga = {
	.mode		= {
		.name		= "SVGA",
		.refresh	= 0,
		.xres		= 800,
		.yres		= 600,
		.pixclock	= 27778,
		.left_margin	= 20,
		.right_margin	= 20,
		.upper_margin	= 5,
		.lower_margin	= 5,
		.hsync_len	= 164,
		.vsync_len	= 62,
		.sync		= 0,
		.vmode		= FB_VMODE_NONINTERLACED,
	},
	.width		= -1,
	.height		= -1,
	.tim2		= TIM2_BCD,
	.cntl		= CNTL_LCDTFT | CNTL_LCDVCOMP(1),
	.connector	= IMPD1_CTRL_DISP_VGA,
	.bpp		= 16,
	.grayscale	= 0,
};

#elif PANEL == PROSPECTOR
#define PANELTYPE	prospector
static struct clcd_panel prospector = {
	.mode		= {
		.name		= "PROSPECTOR",
		.refresh	= 0,
		.xres		= 640,
		.yres		= 480,
		.pixclock	= 40000,
		.left_margin	= 33,
		.right_margin	= 64,
		.upper_margin	= 36,
		.lower_margin	= 7,
		.hsync_len	= 64,
		.vsync_len	= 25,
		.sync		= FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
		.vmode		= FB_VMODE_NONINTERLACED,
	},
	.width		= -1,
	.height		= -1,
	.tim2		= TIM2_BCD,
	.cntl		= CNTL_LCDTFT | CNTL_LCDVCOMP(1),
	.fixedtimings	= 1,
	.connector	= IMPD1_CTRL_DISP_LCD,
	.bpp		= 16,
	.grayscale	= 0,
};

#elif PANEL == LTM10C209
#define PANELTYPE	ltm10c209
/*
 * Untested.
 */
static struct clcd_panel ltm10c209 = {
	.mode		= {
		.name		= "LTM10C209",
		.refresh	= 0,
		.xres		= 640,
		.yres		= 480,
		.pixclock	= 40000,
		.left_margin	= 20,
		.right_margin	= 20,
		.upper_margin	= 19,
		.lower_margin	= 19,
		.hsync_len	= 20,
		.vsync_len	= 10,
		.sync		= FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
		.vmode		= FB_VMODE_NONINTERLACED,
	},
	.width		= -1,
	.height		= -1,
	.tim2		= TIM2_BCD,
	.cntl		= CNTL_LCDTFT | CNTL_LCDVCOMP(1),
	.fixedtimings	= 1,
	.connector	= IMPD1_CTRL_DISP_LCD,
	.bpp		= 16,
	.grayscale	= 0,
};
#endif

/*
 * Disable all display connectors on the interface module.
 */
static void impd1fb_clcd_disable(struct clcd_fb *fb)
{
	impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK, 0);
}

/*
 * Enable the relevant connector on the interface module.
 */
static void impd1fb_clcd_enable(struct clcd_fb *fb)
{
	impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK,
			fb->panel->connector | IMPD1_CTRL_DISP_ENABLE);
}

static int impd1fb_clcd_setup(struct clcd_fb *fb)
{
	unsigned long framebase = fb->dev->res.start + 0x01000000;
	unsigned long framesize = SZ_1M;
	int ret = 0;

	fb->panel = &PANELTYPE;

	if (!request_mem_region(framebase, framesize, "clcd framebuffer")) {
		printk(KERN_ERR "IM-PD1: unable to reserve framebuffer\n");
		return -EBUSY;
	}

	fb->fb.screen_base = ioremap(framebase, framesize);
	if (!fb->fb.screen_base) {
		printk(KERN_ERR "IM-PD1: unable to map framebuffer\n");
		ret = -ENOMEM;
		goto free_buffer;
	}

	fb->fb.fix.smem_start	= framebase;
	fb->fb.fix.smem_len	= framesize;

	return 0;

 free_buffer:
	release_mem_region(framebase, framesize);
	return ret;
}

static int impd1fb_clcd_mmap(struct clcd_fb *fb, struct vm_area_struct *vma)
{
	unsigned long start, size;

	start = vma->vm_pgoff + (fb->fb.fix.smem_start >> PAGE_SHIFT);
	size = vma->vm_end - vma->vm_start;

	return remap_pfn_range(vma, vma->vm_start, start, size,
			       vma->vm_page_prot);
}

static void impd1fb_clcd_remove(struct clcd_fb *fb)
{
	iounmap(fb->fb.screen_base);
	release_mem_region(fb->fb.fix.smem_start, fb->fb.fix.smem_len);
}

static struct clcd_board impd1_clcd_data = {
	.name		= "IM-PD/1",
	.check		= clcdfb_check,
	.decode		= clcdfb_decode,
	.disable	= impd1fb_clcd_disable,
	.enable		= impd1fb_clcd_enable,
	.setup		= impd1fb_clcd_setup,
	.mmap		= impd1fb_clcd_mmap,
	.remove		= impd1fb_clcd_remove,
};

struct impd1_device {
	unsigned long	offset;
	unsigned int	irq[2];
	unsigned int	id;
	void		*platform_data;
};

static struct impd1_device impd1_devs[] = {
	{
		.offset	= 0x03000000,
		.id	= 0x00041190,
	}, {
		.offset	= 0x00100000,
		.irq	= { 1 },
		.id	= 0x00141011,
	}, {
		.offset	= 0x00200000,
		.irq	= { 2 },
		.id	= 0x00141011,
	}, {
		.offset	= 0x00300000,
		.irq	= { 3 },
		.id	= 0x00041022,
	}, {
		.offset	= 0x00400000,
		.irq	= { 4 },
		.id	= 0x00041061,
	}, {
		.offset	= 0x00500000,
		.irq	= { 5 },
		.id	= 0x00041061,
	}, {
		.offset	= 0x00600000,
		.irq	= { 6 },
		.id	= 0x00041130,
	}, {
		.offset	= 0x00700000,
		.irq	= { 7, 8 },
		.id	= 0x00041181,
	}, {
		.offset	= 0x00800000,
		.irq	= { 9 },
		.id	= 0x00041041,
	}, {
		.offset	= 0x01000000,
		.irq	= { 11 },
		.id	= 0x00041110,
		.platform_data = &impd1_clcd_data,
	}
};

static struct clk fixed_14745600 = {
	.rate = 14745600,
};

static int impd1_probe(struct lm_device *dev)
{
	struct impd1_module *impd1;
	int i, ret;

	if (dev->id != module_id)
		return -EINVAL;

	if (!request_mem_region(dev->resource.start, SZ_4K, "LM registers"))
		return -EBUSY;

	impd1 = kzalloc(sizeof(struct impd1_module), GFP_KERNEL);
	if (!impd1) {
		ret = -ENOMEM;
		goto release_lm;
	}

	impd1->base = ioremap(dev->resource.start, SZ_4K);
	if (!impd1->base) {
		ret = -ENOMEM;
		goto free_impd1;
	}

	lm_set_drvdata(dev, impd1);

	printk("IM-PD1 found at 0x%08lx\n",
		(unsigned long)dev->resource.start);

	for (i = 0; i < ARRAY_SIZE(impd1->vcos); i++) {
		impd1->vcos[i].owner = THIS_MODULE,
		impd1->vcos[i].params = &impd1_vco_params,
		impd1->vcos[i].data = impd1,
		impd1->vcos[i].setvco = impd1_setvco;
	}

	impd1->clks[0] = clkdev_alloc(&impd1->vcos[0], NULL, "lm%x:01000",
					dev->id);
	impd1->clks[1] = clkdev_alloc(&fixed_14745600, NULL, "lm%x:00100",
					dev->id);
	impd1->clks[2] = clkdev_alloc(&fixed_14745600, NULL, "lm%x:00200",
					dev->id);
	for (i = 0; i < ARRAY_SIZE(impd1->clks); i++)
		clkdev_add(impd1->clks[i]);

	for (i = 0; i < ARRAY_SIZE(impd1_devs); i++) {
		struct impd1_device *idev = impd1_devs + i;
		struct amba_device *d;
		unsigned long pc_base;

		pc_base = dev->resource.start + idev->offset;

		d = kzalloc(sizeof(struct amba_device), GFP_KERNEL);
		if (!d)
			continue;

		dev_set_name(&d->dev, "lm%x:%5.5lx", dev->id, idev->offset >> 12);
		d->dev.parent	= &dev->dev;
		d->res.start	= dev->resource.start + idev->offset;
		d->res.end	= d->res.start + SZ_4K - 1;
		d->res.flags	= IORESOURCE_MEM;
		d->irq[0]	= dev->irq;
		d->irq[1]	= dev->irq;
		d->periphid	= idev->id;
		d->dev.platform_data = idev->platform_data;

		ret = amba_device_register(d, &dev->resource);
		if (ret) {
			dev_err(&d->dev, "unable to register device: %d\n", ret);
			kfree(d);
		}
	}

	return 0;

 free_impd1:
	if (impd1 && impd1->base)
		iounmap(impd1->base);
	kfree(impd1);
 release_lm:
	release_mem_region(dev->resource.start, SZ_4K);
	return ret;
}

static int impd1_remove_one(struct device *dev, void *data)
{
	device_unregister(dev);
	return 0;
}

static void impd1_remove(struct lm_device *dev)
{
	struct impd1_module *impd1 = lm_get_drvdata(dev);
	int i;

	device_for_each_child(&dev->dev, NULL, impd1_remove_one);

	for (i = 0; i < ARRAY_SIZE(impd1->clks); i++)
		clkdev_drop(impd1->clks[i]);

	lm_set_drvdata(dev, NULL);

	iounmap(impd1->base);
	kfree(impd1);
	release_mem_region(dev->resource.start, SZ_4K);
}

static struct lm_driver impd1_driver = {
	.drv = {
		.name	= "impd1",
	},
	.probe		= impd1_probe,
	.remove		= impd1_remove,
};

static int __init impd1_init(void)
{
	return lm_driver_register(&impd1_driver);
}

static void __exit impd1_exit(void)
{
	lm_driver_unregister(&impd1_driver);
}

module_init(impd1_init);
module_exit(impd1_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Integrator/IM-PD1 logic module core driver");
MODULE_AUTHOR("Deep Blue Solutions Ltd");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/arm/mach-integrator/impd1.c
	3	*
	4	* Copyright (C) 2003 Deep Blue Solutions Ltd, All Rights Reserved.
	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	* This file provides the core support for the IM-PD1 module.
	11	*
	12	* Module / boot parameters.
	13	* lmid=n impd1.lmid=n - set the logic module position in stack to 'n'
	14	*/
	15	#include <linux/module.h>
	16	#include <linux/moduleparam.h>
	17	#include <linux/init.h>
	18	#include <linux/device.h>
	19	#include <linux/errno.h>
	20	#include <linux/mm.h>
a62c80e5 RK	21	#include <linux/amba/bus.h>
a62c80e5 RK	22	#include <linux/amba/clcd.h>
fced80c7	23	#include <linux/io.h>
5a0e3ad6	24	#include <linux/slab.h>
1da177e4	25
d72fbdf0 RK	26	#include <asm/clkdev.h>
d72fbdf0 RK	27	#include <mach/clkdev.h>
1da177e4	28	#include <asm/hardware/icst525.h>
a09e64fb RK	29	#include <mach/lm.h>
a09e64fb RK	30	#include <mach/impd1.h>
1da177e4 LT	31	#include <asm/sizes.h>
1da177e4 LT	32
1da177e4 LT	33	static int module_id;
	34
	35	module_param_named(lmid, module_id, int, 0444);
	36	MODULE_PARM_DESC(lmid, "logic module stack position");
	37
	38	struct impd1_module {
	39	void __iomem *base;
	40	struct clk vcos[2];
d72fbdf0	41	struct clk_lookup *clks[3];
1da177e4 LT	42	};
	43
	44	static const struct icst525_params impd1_vco_params = {
	45	.ref = 24000, /* 24 MHz */
	46	.vco_max = 200000, /* 200 MHz */
	47	.vd_min = 12,
	48	.vd_max = 519,
	49	.rd_min = 3,
	50	.rd_max = 120,
	51	};
	52
	53	static void impd1_setvco(struct clk *clk, struct icst525_vco vco)
	54	{
	55	struct impd1_module *impd1 = clk->data;
	56	int vconr = clk - impd1->vcos;
	57	u32 val;
	58
	59	val = vco.v \| (vco.r << 9) \| (vco.s << 16);
	60
	61	writel(0xa05f, impd1->base + IMPD1_LOCK);
	62	switch (vconr) {
	63	case 0:
	64	writel(val, impd1->base + IMPD1_OSC1);
	65	break;
	66	case 1:
	67	writel(val, impd1->base + IMPD1_OSC2);
	68	break;
	69	}
	70	writel(0, impd1->base + IMPD1_LOCK);
	71
d1856637	72	#ifdef DEBUG
1da177e4 LT	73	vco.v = val & 0x1ff;
	74	vco.r = (val >> 9) & 0x7f;
	75	vco.s = (val >> 16) & 7;
	76
	77	pr_debug("IM-PD1: VCO%d clock is %ld kHz\n",
	78	vconr, icst525_khz(&impd1_vco_params, vco));
	79	#endif
	80	}
	81
	82	void impd1_tweak_control(struct device *dev, u32 mask, u32 val)
	83	{
	84	struct impd1_module *impd1 = dev_get_drvdata(dev);
	85	u32 cur;
	86
	87	val &= mask;
	88	cur = readl(impd1->base + IMPD1_CTRL) & ~mask;
	89	writel(cur \| val, impd1->base + IMPD1_CTRL);
	90	}
	91
	92	EXPORT_SYMBOL(impd1_tweak_control);
	93
	94	/*
	95	* CLCD support
	96	*/
	97	#define PANEL PROSPECTOR
	98
	99	#define LTM10C209 1
	100	#define PROSPECTOR 2
	101	#define SVGA 3
	102	#define VGA 4
	103
	104	#if PANEL == VGA
	105	#define PANELTYPE vga
	106	static struct clcd_panel vga = {
	107	.mode = {
	108	.name = "VGA",
	109	.refresh = 60,
	110	.xres = 640,
	111	.yres = 480,
	112	.pixclock = 39721,
	113	.left_margin = 40,
	114	.right_margin = 24,
	115	.upper_margin = 32,
	116	.lower_margin = 11,
	117	.hsync_len = 96,
	118	.vsync_len = 2,
	119	.sync = 0,
	120	.vmode = FB_VMODE_NONINTERLACED,
	121	},
	122	.width = -1,
	123	.height = -1,
	124	.tim2 = TIM2_BCD \| TIM2_IPC,
	125	.cntl = CNTL_LCDTFT \| CNTL_LCDVCOMP(1),
	126	.connector = IMPD1_CTRL_DISP_VGA,
	127	.bpp = 16,
	128	.grayscale = 0,
	129	};
	130
	131	#elif PANEL == SVGA
	132	#define PANELTYPE svga
	133	static struct clcd_panel svga = {
	134	.mode = {
	135	.name = "SVGA",
	136	.refresh = 0,
137	.xres = 800,
138	.yres = 600,
139	.pixclock = 27778,
140	.left_margin = 20,
141	.right_margin = 20,
142	.upper_margin = 5,
143	.lower_margin = 5,
144	.hsync_len = 164,
145	.vsync_len = 62,
146	.sync = 0,
147	.vmode = FB_VMODE_NONINTERLACED,
148	},
149	.width = -1,
150	.height = -1,
151	.tim2 = TIM2_BCD,
152	.cntl = CNTL_LCDTFT \| CNTL_LCDVCOMP(1),
153	.connector = IMPD1_CTRL_DISP_VGA,
154	.bpp = 16,
155	.grayscale = 0,
156	};
157
158	#elif PANEL == PROSPECTOR
159	#define PANELTYPE prospector
160	static struct clcd_panel prospector = {
161	.mode = {
162	.name = "PROSPECTOR",
163	.refresh = 0,
164	.xres = 640,
165	.yres = 480,
166	.pixclock = 40000,
167	.left_margin = 33,
168	.right_margin = 64,
169	.upper_margin = 36,
170	.lower_margin = 7,
171	.hsync_len = 64,
172	.vsync_len = 25,
173	.sync = FB_SYNC_HOR_HIGH_ACT \| FB_SYNC_VERT_HIGH_ACT,
174	.vmode = FB_VMODE_NONINTERLACED,
175	},
176	.width = -1,
177	.height = -1,
178	.tim2 = TIM2_BCD,
179	.cntl = CNTL_LCDTFT \| CNTL_LCDVCOMP(1),
180	.fixedtimings = 1,
181	.connector = IMPD1_CTRL_DISP_LCD,
182	.bpp = 16,
183	.grayscale = 0,
184	};
185
186	#elif PANEL == LTM10C209
187	#define PANELTYPE ltm10c209
188	/*
189	* Untested.
190	*/
191	static struct clcd_panel ltm10c209 = {
192	.mode = {
193	.name = "LTM10C209",
194	.refresh = 0,
195	.xres = 640,
196	.yres = 480,
197	.pixclock = 40000,
198	.left_margin = 20,
199	.right_margin = 20,
200	.upper_margin = 19,
201	.lower_margin = 19,
202	.hsync_len = 20,
203	.vsync_len = 10,
204	.sync = FB_SYNC_HOR_HIGH_ACT \| FB_SYNC_VERT_HIGH_ACT,
205	.vmode = FB_VMODE_NONINTERLACED,
206	},
207	.width = -1,
208	.height = -1,
209	.tim2 = TIM2_BCD,
210	.cntl = CNTL_LCDTFT \| CNTL_LCDVCOMP(1),
211	.fixedtimings = 1,
212	.connector = IMPD1_CTRL_DISP_LCD,
213	.bpp = 16,
214	.grayscale = 0,
215	};
216	#endif
217
218	/*
219	* Disable all display connectors on the interface module.
220	*/
221	static void impd1fb_clcd_disable(struct clcd_fb *fb)
222	{
223	impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK, 0);
224	}
225
226	/*
227	* Enable the relevant connector on the interface module.
228	*/
229	static void impd1fb_clcd_enable(struct clcd_fb *fb)
230	{
231	impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK,
232	fb->panel->connector \| IMPD1_CTRL_DISP_ENABLE);
233	}
234
235	static int impd1fb_clcd_setup(struct clcd_fb *fb)
236	{
237	unsigned long framebase = fb->dev->res.start + 0x01000000;
238	unsigned long framesize = SZ_1M;
239	int ret = 0;
240
241	fb->panel = &PANELTYPE;
242
243	if (!request_mem_region(framebase, framesize, "clcd framebuffer")) {
244	printk(KERN_ERR "IM-PD1: unable to reserve framebuffer\n");
245	return -EBUSY;
246	}
247
248	fb->fb.screen_base = ioremap(framebase, framesize);
249	if (!fb->fb.screen_base) {
250	printk(KERN_ERR "IM-PD1: unable to map framebuffer\n");
251	ret = -ENOMEM;
252	goto free_buffer;
253	}
254
255	fb->fb.fix.smem_start = framebase;
256	fb->fb.fix.smem_len = framesize;
257
258	return 0;
259
260	free_buffer:
261	release_mem_region(framebase, framesize);
262	return ret;
263	}
264
265	static int impd1fb_clcd_mmap(struct clcd_fb fb, struct vm_area_struct vma)
266	{
267	unsigned long start, size;
268
269	start = vma->vm_pgoff + (fb->fb.fix.smem_start >> PAGE_SHIFT);
270	size = vma->vm_end - vma->vm_start;
271
272	return remap_pfn_range(vma, vma->vm_start, start, size,
273	vma->vm_page_prot);
274	}
275
276	static void impd1fb_clcd_remove(struct clcd_fb *fb)
277	{
278	iounmap(fb->fb.screen_base);
279	release_mem_region(fb->fb.fix.smem_start, fb->fb.fix.smem_len);
280	}
281
282	static struct clcd_board impd1_clcd_data = {
283	.name = "IM-PD/1",
284	.check = clcdfb_check,
285	.decode = clcdfb_decode,
286	.disable = impd1fb_clcd_disable,
287	.enable = impd1fb_clcd_enable,
288	.setup = impd1fb_clcd_setup,
289	.mmap = impd1fb_clcd_mmap,
290	.remove = impd1fb_clcd_remove,
291	};
292
293	struct impd1_device {
294	unsigned long offset;
295	unsigned int irq[2];
296	unsigned int id;
297	void *platform_data;
298	};
299
300	static struct impd1_device impd1_devs[] = {
301	{
302	.offset = 0x03000000,
303	.id = 0x00041190,
304	}, {
305	.offset = 0x00100000,
306	.irq = { 1 },
307	.id = 0x00141011,
308	}, {
309	.offset = 0x00200000,
310	.irq = { 2 },
311	.id = 0x00141011,
312	}, {
313	.offset = 0x00300000,
314	.irq = { 3 },
315	.id = 0x00041022,
316	}, {
317	.offset = 0x00400000,
318	.irq = { 4 },
319	.id = 0x00041061,
320	}, {
321	.offset = 0x00500000,
322	.irq = { 5 },
323	.id = 0x00041061,
324	}, {
325	.offset = 0x00600000,
326	.irq = { 6 },
327	.id = 0x00041130,
328	}, {
329	.offset = 0x00700000,
330	.irq = { 7, 8 },
331	.id = 0x00041181,
332	}, {
333	.offset = 0x00800000,
334	.irq = { 9 },
335	.id = 0x00041041,
336	}, {
337	.offset = 0x01000000,
338	.irq = { 11 },
339	.id = 0x00041110,
340	.platform_data = &impd1_clcd_data,
341	}
342	};
343
d72fbdf0 RK	344	static struct clk fixed_14745600 = {
d72fbdf0 RK	345	.rate = 14745600,
1da177e4 LT	346	};
	347
	348	static int impd1_probe(struct lm_device *dev)
	349	{
	350	struct impd1_module *impd1;
	351	int i, ret;
	352
	353	if (dev->id != module_id)
	354	return -EINVAL;
	355
	356	if (!request_mem_region(dev->resource.start, SZ_4K, "LM registers"))
	357	return -EBUSY;
	358
d2a02b93	359	impd1 = kzalloc(sizeof(struct impd1_module), GFP_KERNEL);
1da177e4 LT	360	if (!impd1) {
	361	ret = -ENOMEM;
	362	goto release_lm;
	363	}
1da177e4 LT	364
	365	impd1->base = ioremap(dev->resource.start, SZ_4K);
	366	if (!impd1->base) {
	367	ret = -ENOMEM;
	368	goto free_impd1;
	369	}
	370
	371	lm_set_drvdata(dev, impd1);
	372
7c28472a RK	373	printk("IM-PD1 found at 0x%08lx\n",
7c28472a RK	374	(unsigned long)dev->resource.start);
1da177e4 LT	375
	376	for (i = 0; i < ARRAY_SIZE(impd1->vcos); i++) {
	377	impd1->vcos[i].owner = THIS_MODULE,
1da177e4 LT	378	impd1->vcos[i].params = &impd1_vco_params,
	379	impd1->vcos[i].data = impd1,
	380	impd1->vcos[i].setvco = impd1_setvco;
1da177e4 LT	381	}
1da177e4 LT	382
d72fbdf0 RK	383	impd1->clks[0] = clkdev_alloc(&impd1->vcos[0], NULL, "lm%x:01000",
	384	dev->id);
	385	impd1->clks[1] = clkdev_alloc(&fixed_14745600, NULL, "lm%x:00100",
	386	dev->id);
	387	impd1->clks[2] = clkdev_alloc(&fixed_14745600, NULL, "lm%x:00200",
	388	dev->id);
	389	for (i = 0; i < ARRAY_SIZE(impd1->clks); i++)
	390	clkdev_add(impd1->clks[i]);
	391
1da177e4 LT	392	for (i = 0; i < ARRAY_SIZE(impd1_devs); i++) {
	393	struct impd1_device *idev = impd1_devs + i;
	394	struct amba_device *d;
	395	unsigned long pc_base;
	396
	397	pc_base = dev->resource.start + idev->offset;
	398
d2a02b93	399	d = kzalloc(sizeof(struct amba_device), GFP_KERNEL);
1da177e4 LT	400	if (!d)
	401	continue;
	402
3f978704	403	dev_set_name(&d->dev, "lm%x:%5.5lx", dev->id, idev->offset >> 12);
1da177e4 LT	404	d->dev.parent = &dev->dev;
	405	d->res.start = dev->resource.start + idev->offset;
	406	d->res.end = d->res.start + SZ_4K - 1;
	407	d->res.flags = IORESOURCE_MEM;
	408	d->irq[0] = dev->irq;
	409	d->irq[1] = dev->irq;
	410	d->periphid = idev->id;
	411	d->dev.platform_data = idev->platform_data;
	412
	413	ret = amba_device_register(d, &dev->resource);
	414	if (ret) {
faa64c93	415	dev_err(&d->dev, "unable to register device: %d\n", ret);
1da177e4 LT	416	kfree(d);
	417	}
	418	}
	419
	420	return 0;
	421
	422	free_impd1:
	423	if (impd1 && impd1->base)
	424	iounmap(impd1->base);
b2325fe1	425	kfree(impd1);
1da177e4 LT	426	release_lm:
	427	release_mem_region(dev->resource.start, SZ_4K);
	428	return ret;
	429	}
	430
d1856637 RK	431	static int impd1_remove_one(struct device dev, void data)
	432	{
	433	device_unregister(dev);
	434	return 0;
	435	}
	436
1da177e4 LT	437	static void impd1_remove(struct lm_device *dev)
	438	{
	439	struct impd1_module *impd1 = lm_get_drvdata(dev);
1da177e4 LT	440	int i;
1da177e4 LT	441
d1856637	442	device_for_each_child(&dev->dev, NULL, impd1_remove_one);
1da177e4	443
d72fbdf0 RK	444	for (i = 0; i < ARRAY_SIZE(impd1->clks); i++)
d72fbdf0 RK	445	clkdev_drop(impd1->clks[i]);
1da177e4 LT	446
	447	lm_set_drvdata(dev, NULL);
	448
	449	iounmap(impd1->base);
	450	kfree(impd1);
	451	release_mem_region(dev->resource.start, SZ_4K);
	452	}
	453
	454	static struct lm_driver impd1_driver = {
	455	.drv = {
	456	.name = "impd1",
	457	},
	458	.probe = impd1_probe,
	459	.remove = impd1_remove,
	460	};
	461
	462	static int __init impd1_init(void)
	463	{
	464	return lm_driver_register(&impd1_driver);
	465	}
	466
	467	static void __exit impd1_exit(void)
	468	{
	469	lm_driver_unregister(&impd1_driver);
	470	}
	471
	472	module_init(impd1_init);
	473	module_exit(impd1_exit);
	474
	475	MODULE_LICENSE("GPL");
	476	MODULE_DESCRIPTION("Integrator/IM-PD1 logic module core driver");
	477	MODULE_AUTHOR("Deep Blue Solutions Ltd");