2 * linux/arch/arm/mach-integrator/impd1.c
4 * Copyright (C) 2003 Deep Blue Solutions Ltd, All Rights Reserved.
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.
10 * This file provides the core support for the IM-PD1 module.
12 * Module / boot parameters.
13 * lmid=n impd1.lmid=n - set the logic module position in stack to 'n'
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>
21 #include <linux/amba/bus.h>
22 #include <linux/amba/clcd.h>
24 #include <linux/slab.h>
26 #include <asm/clkdev.h>
27 #include <mach/clkdev.h>
28 #include <asm/hardware/icst.h>
30 #include <mach/impd1.h>
31 #include <asm/sizes.h>
35 module_param_named(lmid, module_id, int, 0444);
36 MODULE_PARM_DESC(lmid, "logic module stack position");
41 struct clk_lookup *clks[3];
44 static const struct icst_params impd1_vco_params = {
45 .ref = 24000000, /* 24 MHz */
46 .vco_max = ICST525_VCO_MAX_3V,
47 .vco_min = ICST525_VCO_MIN,
52 .s2div = icst525_s2div,
53 .idx2s = icst525_idx2s,
56 static void impd1_setvco(struct clk *clk, struct icst_vco vco)
58 struct impd1_module *impd1 = clk->data;
59 u32 val = vco.v | (vco.r << 9) | (vco.s << 16);
61 writel(0xa05f, impd1->base + IMPD1_LOCK);
62 writel(val, clk->vcoreg);
63 writel(0, impd1->base + IMPD1_LOCK);
67 vco.r = (val >> 9) & 0x7f;
68 vco.s = (val >> 16) & 7;
70 pr_debug("IM-PD1: VCO%d clock is %ld Hz\n",
71 vconr, icst525_hz(&impd1_vco_params, vco));
75 static const struct clk_ops impd1_clk_ops = {
76 .round = icst_clk_round,
78 .setvco = impd1_setvco,
81 void impd1_tweak_control(struct device *dev, u32 mask, u32 val)
83 struct impd1_module *impd1 = dev_get_drvdata(dev);
87 cur = readl(impd1->base + IMPD1_CTRL) & ~mask;
88 writel(cur | val, impd1->base + IMPD1_CTRL);
91 EXPORT_SYMBOL(impd1_tweak_control);
96 #define PANEL PROSPECTOR
104 #define PANELTYPE vga
105 static struct clcd_panel vga = {
119 .vmode = FB_VMODE_NONINTERLACED,
123 .tim2 = TIM2_BCD | TIM2_IPC,
124 .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1),
125 .connector = IMPD1_CTRL_DISP_VGA,
131 #define PANELTYPE svga
132 static struct clcd_panel svga = {
146 .vmode = FB_VMODE_NONINTERLACED,
151 .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1),
152 .connector = IMPD1_CTRL_DISP_VGA,
157 #elif PANEL == PROSPECTOR
158 #define PANELTYPE prospector
159 static struct clcd_panel prospector = {
161 .name = "PROSPECTOR",
172 .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
173 .vmode = FB_VMODE_NONINTERLACED,
178 .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1),
180 .connector = IMPD1_CTRL_DISP_LCD,
185 #elif PANEL == LTM10C209
186 #define PANELTYPE ltm10c209
190 static struct clcd_panel ltm10c209 = {
203 .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
204 .vmode = FB_VMODE_NONINTERLACED,
209 .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1),
211 .connector = IMPD1_CTRL_DISP_LCD,
218 * Disable all display connectors on the interface module.
220 static void impd1fb_clcd_disable(struct clcd_fb *fb)
222 impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK, 0);
226 * Enable the relevant connector on the interface module.
228 static void impd1fb_clcd_enable(struct clcd_fb *fb)
230 impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK,
231 fb->panel->connector | IMPD1_CTRL_DISP_ENABLE);
234 static int impd1fb_clcd_setup(struct clcd_fb *fb)
236 unsigned long framebase = fb->dev->res.start + 0x01000000;
237 unsigned long framesize = SZ_1M;
240 fb->panel = &PANELTYPE;
242 if (!request_mem_region(framebase, framesize, "clcd framebuffer")) {
243 printk(KERN_ERR "IM-PD1: unable to reserve framebuffer\n");
247 fb->fb.screen_base = ioremap(framebase, framesize);
248 if (!fb->fb.screen_base) {
249 printk(KERN_ERR "IM-PD1: unable to map framebuffer\n");
254 fb->fb.fix.smem_start = framebase;
255 fb->fb.fix.smem_len = framesize;
260 release_mem_region(framebase, framesize);
264 static int impd1fb_clcd_mmap(struct clcd_fb *fb, struct vm_area_struct *vma)
266 unsigned long start, size;
268 start = vma->vm_pgoff + (fb->fb.fix.smem_start >> PAGE_SHIFT);
269 size = vma->vm_end - vma->vm_start;
271 return remap_pfn_range(vma, vma->vm_start, start, size,
275 static void impd1fb_clcd_remove(struct clcd_fb *fb)
277 iounmap(fb->fb.screen_base);
278 release_mem_region(fb->fb.fix.smem_start, fb->fb.fix.smem_len);
281 static struct clcd_board impd1_clcd_data = {
283 .check = clcdfb_check,
284 .decode = clcdfb_decode,
285 .disable = impd1fb_clcd_disable,
286 .enable = impd1fb_clcd_enable,
287 .setup = impd1fb_clcd_setup,
288 .mmap = impd1fb_clcd_mmap,
289 .remove = impd1fb_clcd_remove,
292 struct impd1_device {
293 unsigned long offset;
299 static struct impd1_device impd1_devs[] = {
301 .offset = 0x03000000,
304 .offset = 0x00100000,
308 .offset = 0x00200000,
312 .offset = 0x00300000,
316 .offset = 0x00400000,
320 .offset = 0x00500000,
324 .offset = 0x00600000,
328 .offset = 0x00700000,
332 .offset = 0x00800000,
336 .offset = 0x01000000,
339 .platform_data = &impd1_clcd_data,
343 static struct clk fixed_14745600 = {
347 static int impd1_probe(struct lm_device *dev)
349 struct impd1_module *impd1;
352 if (dev->id != module_id)
355 if (!request_mem_region(dev->resource.start, SZ_4K, "LM registers"))
358 impd1 = kzalloc(sizeof(struct impd1_module), GFP_KERNEL);
364 impd1->base = ioremap(dev->resource.start, SZ_4K);
370 lm_set_drvdata(dev, impd1);
372 printk("IM-PD1 found at 0x%08lx\n",
373 (unsigned long)dev->resource.start);
375 for (i = 0; i < ARRAY_SIZE(impd1->vcos); i++) {
376 impd1->vcos[i].ops = &impd1_clk_ops,
377 impd1->vcos[i].owner = THIS_MODULE,
378 impd1->vcos[i].params = &impd1_vco_params,
379 impd1->vcos[i].data = impd1;
381 impd1->vcos[0].vcoreg = impd1->base + IMPD1_OSC1;
382 impd1->vcos[1].vcoreg = impd1->base + IMPD1_OSC2;
384 impd1->clks[0] = clkdev_alloc(&impd1->vcos[0], NULL, "lm%x:01000",
386 impd1->clks[1] = clkdev_alloc(&fixed_14745600, NULL, "lm%x:00100",
388 impd1->clks[2] = clkdev_alloc(&fixed_14745600, NULL, "lm%x:00200",
390 for (i = 0; i < ARRAY_SIZE(impd1->clks); i++)
391 clkdev_add(impd1->clks[i]);
393 for (i = 0; i < ARRAY_SIZE(impd1_devs); i++) {
394 struct impd1_device *idev = impd1_devs + i;
395 struct amba_device *d;
396 unsigned long pc_base;
398 pc_base = dev->resource.start + idev->offset;
400 d = kzalloc(sizeof(struct amba_device), GFP_KERNEL);
404 dev_set_name(&d->dev, "lm%x:%5.5lx", dev->id, idev->offset >> 12);
405 d->dev.parent = &dev->dev;
406 d->res.start = dev->resource.start + idev->offset;
407 d->res.end = d->res.start + SZ_4K - 1;
408 d->res.flags = IORESOURCE_MEM;
409 d->irq[0] = dev->irq;
410 d->irq[1] = dev->irq;
411 d->periphid = idev->id;
412 d->dev.platform_data = idev->platform_data;
414 ret = amba_device_register(d, &dev->resource);
416 dev_err(&d->dev, "unable to register device: %d\n", ret);
424 if (impd1 && impd1->base)
425 iounmap(impd1->base);
428 release_mem_region(dev->resource.start, SZ_4K);
432 static int impd1_remove_one(struct device *dev, void *data)
434 device_unregister(dev);
438 static void impd1_remove(struct lm_device *dev)
440 struct impd1_module *impd1 = lm_get_drvdata(dev);
443 device_for_each_child(&dev->dev, NULL, impd1_remove_one);
445 for (i = 0; i < ARRAY_SIZE(impd1->clks); i++)
446 clkdev_drop(impd1->clks[i]);
448 lm_set_drvdata(dev, NULL);
450 iounmap(impd1->base);
452 release_mem_region(dev->resource.start, SZ_4K);
455 static struct lm_driver impd1_driver = {
459 .probe = impd1_probe,
460 .remove = impd1_remove,
463 static int __init impd1_init(void)
465 return lm_driver_register(&impd1_driver);
468 static void __exit impd1_exit(void)
470 lm_driver_unregister(&impd1_driver);
473 module_init(impd1_init);
474 module_exit(impd1_exit);
476 MODULE_LICENSE("GPL");
477 MODULE_DESCRIPTION("Integrator/IM-PD1 logic module core driver");
478 MODULE_AUTHOR("Deep Blue Solutions Ltd");