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