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>
25 #include <asm/clkdev.h>
26 #include <mach/clkdev.h>
27 #include <asm/hardware/icst525.h>
29 #include <mach/impd1.h>
30 #include <asm/sizes.h>
34 module_param_named(lmid
, module_id
, int, 0444);
35 MODULE_PARM_DESC(lmid
, "logic module stack position");
40 struct clk_lookup
*clks
[3];
43 static const struct icst_params impd1_vco_params
= {
44 .ref
= 24000000, /* 24 MHz */
45 .vco_max
= ICST525_VCO_MAX_3V
,
46 .vco_min
= ICST525_VCO_MIN
,
51 .s2div
= icst525_s2div
,
52 .idx2s
= icst525_idx2s
,
55 static void impd1_setvco(struct clk
*clk
, struct icst_vco vco
)
57 struct impd1_module
*impd1
= clk
->data
;
58 int vconr
= clk
- impd1
->vcos
;
61 val
= vco
.v
| (vco
.r
<< 9) | (vco
.s
<< 16);
63 writel(0xa05f, impd1
->base
+ IMPD1_LOCK
);
66 writel(val
, impd1
->base
+ IMPD1_OSC1
);
69 writel(val
, impd1
->base
+ IMPD1_OSC2
);
72 writel(0, impd1
->base
+ IMPD1_LOCK
);
76 vco
.r
= (val
>> 9) & 0x7f;
77 vco
.s
= (val
>> 16) & 7;
79 pr_debug("IM-PD1: VCO%d clock is %ld Hz\n",
80 vconr
, icst525_hz(&impd1_vco_params
, vco
));
84 void impd1_tweak_control(struct device
*dev
, u32 mask
, u32 val
)
86 struct impd1_module
*impd1
= dev_get_drvdata(dev
);
90 cur
= readl(impd1
->base
+ IMPD1_CTRL
) & ~mask
;
91 writel(cur
| val
, impd1
->base
+ IMPD1_CTRL
);
94 EXPORT_SYMBOL(impd1_tweak_control
);
99 #define PANEL PROSPECTOR
107 #define PANELTYPE vga
108 static struct clcd_panel vga
= {
122 .vmode
= FB_VMODE_NONINTERLACED
,
126 .tim2
= TIM2_BCD
| TIM2_IPC
,
127 .cntl
= CNTL_LCDTFT
| CNTL_LCDVCOMP(1),
128 .connector
= IMPD1_CTRL_DISP_VGA
,
134 #define PANELTYPE svga
135 static struct clcd_panel svga
= {
149 .vmode
= FB_VMODE_NONINTERLACED
,
154 .cntl
= CNTL_LCDTFT
| CNTL_LCDVCOMP(1),
155 .connector
= IMPD1_CTRL_DISP_VGA
,
160 #elif PANEL == PROSPECTOR
161 #define PANELTYPE prospector
162 static struct clcd_panel prospector
= {
164 .name
= "PROSPECTOR",
175 .sync
= FB_SYNC_HOR_HIGH_ACT
| FB_SYNC_VERT_HIGH_ACT
,
176 .vmode
= FB_VMODE_NONINTERLACED
,
181 .cntl
= CNTL_LCDTFT
| CNTL_LCDVCOMP(1),
183 .connector
= IMPD1_CTRL_DISP_LCD
,
188 #elif PANEL == LTM10C209
189 #define PANELTYPE ltm10c209
193 static struct clcd_panel ltm10c209
= {
206 .sync
= FB_SYNC_HOR_HIGH_ACT
| FB_SYNC_VERT_HIGH_ACT
,
207 .vmode
= FB_VMODE_NONINTERLACED
,
212 .cntl
= CNTL_LCDTFT
| CNTL_LCDVCOMP(1),
214 .connector
= IMPD1_CTRL_DISP_LCD
,
221 * Disable all display connectors on the interface module.
223 static void impd1fb_clcd_disable(struct clcd_fb
*fb
)
225 impd1_tweak_control(fb
->dev
->dev
.parent
, IMPD1_CTRL_DISP_MASK
, 0);
229 * Enable the relevant connector on the interface module.
231 static void impd1fb_clcd_enable(struct clcd_fb
*fb
)
233 impd1_tweak_control(fb
->dev
->dev
.parent
, IMPD1_CTRL_DISP_MASK
,
234 fb
->panel
->connector
| IMPD1_CTRL_DISP_ENABLE
);
237 static int impd1fb_clcd_setup(struct clcd_fb
*fb
)
239 unsigned long framebase
= fb
->dev
->res
.start
+ 0x01000000;
240 unsigned long framesize
= SZ_1M
;
243 fb
->panel
= &PANELTYPE
;
245 if (!request_mem_region(framebase
, framesize
, "clcd framebuffer")) {
246 printk(KERN_ERR
"IM-PD1: unable to reserve framebuffer\n");
250 fb
->fb
.screen_base
= ioremap(framebase
, framesize
);
251 if (!fb
->fb
.screen_base
) {
252 printk(KERN_ERR
"IM-PD1: unable to map framebuffer\n");
257 fb
->fb
.fix
.smem_start
= framebase
;
258 fb
->fb
.fix
.smem_len
= framesize
;
263 release_mem_region(framebase
, framesize
);
267 static int impd1fb_clcd_mmap(struct clcd_fb
*fb
, struct vm_area_struct
*vma
)
269 unsigned long start
, size
;
271 start
= vma
->vm_pgoff
+ (fb
->fb
.fix
.smem_start
>> PAGE_SHIFT
);
272 size
= vma
->vm_end
- vma
->vm_start
;
274 return remap_pfn_range(vma
, vma
->vm_start
, start
, size
,
278 static void impd1fb_clcd_remove(struct clcd_fb
*fb
)
280 iounmap(fb
->fb
.screen_base
);
281 release_mem_region(fb
->fb
.fix
.smem_start
, fb
->fb
.fix
.smem_len
);
284 static struct clcd_board impd1_clcd_data
= {
286 .check
= clcdfb_check
,
287 .decode
= clcdfb_decode
,
288 .disable
= impd1fb_clcd_disable
,
289 .enable
= impd1fb_clcd_enable
,
290 .setup
= impd1fb_clcd_setup
,
291 .mmap
= impd1fb_clcd_mmap
,
292 .remove
= impd1fb_clcd_remove
,
295 struct impd1_device
{
296 unsigned long offset
;
302 static struct impd1_device impd1_devs
[] = {
304 .offset
= 0x03000000,
307 .offset
= 0x00100000,
311 .offset
= 0x00200000,
315 .offset
= 0x00300000,
319 .offset
= 0x00400000,
323 .offset
= 0x00500000,
327 .offset
= 0x00600000,
331 .offset
= 0x00700000,
335 .offset
= 0x00800000,
339 .offset
= 0x01000000,
342 .platform_data
= &impd1_clcd_data
,
346 static struct clk fixed_14745600
= {
350 static int impd1_probe(struct lm_device
*dev
)
352 struct impd1_module
*impd1
;
355 if (dev
->id
!= module_id
)
358 if (!request_mem_region(dev
->resource
.start
, SZ_4K
, "LM registers"))
361 impd1
= kzalloc(sizeof(struct impd1_module
), GFP_KERNEL
);
367 impd1
->base
= ioremap(dev
->resource
.start
, SZ_4K
);
373 lm_set_drvdata(dev
, impd1
);
375 printk("IM-PD1 found at 0x%08lx\n",
376 (unsigned long)dev
->resource
.start
);
378 for (i
= 0; i
< ARRAY_SIZE(impd1
->vcos
); i
++) {
379 impd1
->vcos
[i
].owner
= THIS_MODULE
,
380 impd1
->vcos
[i
].params
= &impd1_vco_params
,
381 impd1
->vcos
[i
].data
= impd1
,
382 impd1
->vcos
[i
].setvco
= impd1_setvco
;
385 impd1
->clks
[0] = clkdev_alloc(&impd1
->vcos
[0], NULL
, "lm%x:01000",
387 impd1
->clks
[1] = clkdev_alloc(&fixed_14745600
, NULL
, "lm%x:00100",
389 impd1
->clks
[2] = clkdev_alloc(&fixed_14745600
, NULL
, "lm%x:00200",
391 for (i
= 0; i
< ARRAY_SIZE(impd1
->clks
); i
++)
392 clkdev_add(impd1
->clks
[i
]);
394 for (i
= 0; i
< ARRAY_SIZE(impd1_devs
); i
++) {
395 struct impd1_device
*idev
= impd1_devs
+ i
;
396 struct amba_device
*d
;
397 unsigned long pc_base
;
399 pc_base
= dev
->resource
.start
+ idev
->offset
;
401 d
= kzalloc(sizeof(struct amba_device
), GFP_KERNEL
);
405 dev_set_name(&d
->dev
, "lm%x:%5.5lx", dev
->id
, idev
->offset
>> 12);
406 d
->dev
.parent
= &dev
->dev
;
407 d
->res
.start
= dev
->resource
.start
+ idev
->offset
;
408 d
->res
.end
= d
->res
.start
+ SZ_4K
- 1;
409 d
->res
.flags
= IORESOURCE_MEM
;
410 d
->irq
[0] = dev
->irq
;
411 d
->irq
[1] = dev
->irq
;
412 d
->periphid
= idev
->id
;
413 d
->dev
.platform_data
= idev
->platform_data
;
415 ret
= amba_device_register(d
, &dev
->resource
);
417 dev_err(&d
->dev
, "unable to register device: %d\n", ret
);
425 if (impd1
&& impd1
->base
)
426 iounmap(impd1
->base
);
429 release_mem_region(dev
->resource
.start
, SZ_4K
);
433 static int impd1_remove_one(struct device
*dev
, void *data
)
435 device_unregister(dev
);
439 static void impd1_remove(struct lm_device
*dev
)
441 struct impd1_module
*impd1
= lm_get_drvdata(dev
);
444 device_for_each_child(&dev
->dev
, NULL
, impd1_remove_one
);
446 for (i
= 0; i
< ARRAY_SIZE(impd1
->clks
); i
++)
447 clkdev_drop(impd1
->clks
[i
]);
449 lm_set_drvdata(dev
, NULL
);
451 iounmap(impd1
->base
);
453 release_mem_region(dev
->resource
.start
, SZ_4K
);
456 static struct lm_driver impd1_driver
= {
460 .probe
= impd1_probe
,
461 .remove
= impd1_remove
,
464 static int __init
impd1_init(void)
466 return lm_driver_register(&impd1_driver
);
469 static void __exit
impd1_exit(void)
471 lm_driver_unregister(&impd1_driver
);
474 module_init(impd1_init
);
475 module_exit(impd1_exit
);
477 MODULE_LICENSE("GPL");
478 MODULE_DESCRIPTION("Integrator/IM-PD1 logic module core driver");
479 MODULE_AUTHOR("Deep Blue Solutions Ltd");