Linux-2.6.12-rc2
[linux-3.10.git] / arch / arm / mach-integrator / impd1.c
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>
21
22 #include <asm/io.h>
23 #include <asm/hardware/icst525.h>
24 #include <asm/hardware/amba.h>
25 #include <asm/hardware/amba_clcd.h>
26 #include <asm/arch/lm.h>
27 #include <asm/arch/impd1.h>
28 #include <asm/sizes.h>
29
30 #include "clock.h"
31
32 static int module_id;
33
34 module_param_named(lmid, module_id, int, 0444);
35 MODULE_PARM_DESC(lmid, "logic module stack position");
36
37 struct impd1_module {
38         void __iomem    *base;
39         struct clk      vcos[2];
40 };
41
42 static 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
51 static 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
70 #if DEBUG
71         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
80 void 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
90 EXPORT_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
104 static 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
131 static 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
158 static 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  */
189 static 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  */
219 static 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  */
227 static 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
233 static 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
263 static 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
274 static 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
280 static 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
291 struct impd1_device {
292         unsigned long   offset;
293         unsigned int    irq[2];
294         unsigned int    id;
295         void            *platform_data;
296 };
297
298 static 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
342 static const char *impd1_vconames[2] = {
343         "CLCDCLK",
344         "AUXVCO2",
345 };
346
347 static 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
358         impd1 = kmalloc(sizeof(struct impd1_module), GFP_KERNEL);
359         if (!impd1) {
360                 ret = -ENOMEM;
361                 goto release_lm;
362         }
363         memset(impd1, 0, sizeof(struct impd1_module));
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
373         printk("IM-PD1 found at 0x%08lx\n", dev->resource.start);
374
375         for (i = 0; i < ARRAY_SIZE(impd1->vcos); i++) {
376                 impd1->vcos[i].owner = THIS_MODULE,
377                 impd1->vcos[i].name = impd1_vconames[i],
378                 impd1->vcos[i].params = &impd1_vco_params,
379                 impd1->vcos[i].data = impd1,
380                 impd1->vcos[i].setvco = impd1_setvco;
381
382                 clk_register(&impd1->vcos[i]);
383         }
384
385         for (i = 0; i < ARRAY_SIZE(impd1_devs); i++) {
386                 struct impd1_device *idev = impd1_devs + i;
387                 struct amba_device *d;
388                 unsigned long pc_base;
389
390                 pc_base = dev->resource.start + idev->offset;
391
392                 d = kmalloc(sizeof(struct amba_device), GFP_KERNEL);
393                 if (!d)
394                         continue;
395
396                 memset(d, 0, sizeof(struct amba_device));
397
398                 snprintf(d->dev.bus_id, sizeof(d->dev.bus_id),
399                          "lm%x:%5.5lx", dev->id, idev->offset >> 12);
400
401                 d->dev.parent   = &dev->dev;
402                 d->res.start    = dev->resource.start + idev->offset;
403                 d->res.end      = d->res.start + SZ_4K - 1;
404                 d->res.flags    = IORESOURCE_MEM;
405                 d->irq[0]       = dev->irq;
406                 d->irq[1]       = dev->irq;
407                 d->periphid     = idev->id;
408                 d->dev.platform_data = idev->platform_data;
409
410                 ret = amba_device_register(d, &dev->resource);
411                 if (ret) {
412                         printk("unable to register device %s: %d\n",
413                                 d->dev.bus_id, ret);
414                         kfree(d);
415                 }
416         }
417
418         return 0;
419
420  free_impd1:
421         if (impd1 && impd1->base)
422                 iounmap(impd1->base);
423         if (impd1)
424                 kfree(impd1);
425  release_lm:
426         release_mem_region(dev->resource.start, SZ_4K);
427         return ret;
428 }
429
430 static void impd1_remove(struct lm_device *dev)
431 {
432         struct impd1_module *impd1 = lm_get_drvdata(dev);
433         struct list_head *l, *n;
434         int i;
435
436         list_for_each_safe(l, n, &dev->dev.children) {
437                 struct device *d = list_to_dev(l);
438
439                 device_unregister(d);
440         }
441
442         for (i = 0; i < ARRAY_SIZE(impd1->vcos); i++)
443                 clk_unregister(&impd1->vcos[i]);
444
445         lm_set_drvdata(dev, NULL);
446
447         iounmap(impd1->base);
448         kfree(impd1);
449         release_mem_region(dev->resource.start, SZ_4K);
450 }
451
452 static struct lm_driver impd1_driver = {
453         .drv = {
454                 .name   = "impd1",
455         },
456         .probe          = impd1_probe,
457         .remove         = impd1_remove,
458 };
459
460 static int __init impd1_init(void)
461 {
462         return lm_driver_register(&impd1_driver);
463 }
464
465 static void __exit impd1_exit(void)
466 {
467         lm_driver_unregister(&impd1_driver);
468 }
469
470 module_init(impd1_init);
471 module_exit(impd1_exit);
472
473 MODULE_LICENSE("GPL");
474 MODULE_DESCRIPTION("Integrator/IM-PD1 logic module core driver");
475 MODULE_AUTHOR("Deep Blue Solutions Ltd");