?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mm: fix exec activate_mm vs TLB shootdown and lazy tlb switching race
[linux/fpc-iii.git] / arch / arm / mach-integrator / impd1.c
blob0f916c245a2e9c75c97f42e3590e21b675f0a614
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 #include <linux/amba/bus.h>
22 #include <linux/amba/clcd.h>
23 #include <linux/amba/mmci.h>
24 #include <linux/io.h>
25 #include <linux/platform_data/clk-integrator.h>
26 #include <linux/slab.h>
27 #include <linux/irqchip/arm-vic.h>
28 #include <linux/gpio/machine.h>
29
30 #include <asm/sizes.h>
31 #include "lm.h"
32 #include "impd1.h"
33
34 static int module_id;
35
36 module_param_named(lmid, module_id, int, 0444);
37 MODULE_PARM_DESC(lmid, "logic module stack position");
38
39 struct impd1_module {
40 void __iomem *base;
41 void __iomem *vic_base;
42 };
43
44 void impd1_tweak_control(struct device *dev, u32 mask, u32 val)
45 {
46 struct impd1_module *impd1 = dev_get_drvdata(dev);
47 u32 cur;
48
49 val &= mask;
50 cur = readl(impd1->base + IMPD1_CTRL) & ~mask;
51 writel(cur | val, impd1->base + IMPD1_CTRL);
52 }
53
54 EXPORT_SYMBOL(impd1_tweak_control);
55
56 /*
57 * MMC support
58 */
59 static struct mmci_platform_data mmc_data = {
60 .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34,
61 };
62
63 /*
64 * CLCD support
65 */
66 #define PANEL PROSPECTOR
67
68 #define LTM10C209 1
69 #define PROSPECTOR 2
70 #define SVGA 3
71 #define VGA 4
72
73 #if PANEL == VGA
74 #define PANELTYPE vga
75 static struct clcd_panel vga = {
76 .mode = {
77 .name = "VGA",
78 .refresh = 60,
79 .xres = 640,
80 .yres = 480,
81 .pixclock = 39721,
82 .left_margin = 40,
83 .right_margin = 24,
84 .upper_margin = 32,
85 .lower_margin = 11,
86 .hsync_len = 96,
87 .vsync_len = 2,
88 .sync = 0,
89 .vmode = FB_VMODE_NONINTERLACED,
90 },
91 .width = -1,
92 .height = -1,
93 .tim2 = TIM2_BCD | TIM2_IPC,
94 .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1),
95 .caps = CLCD_CAP_5551,
96 .connector = IMPD1_CTRL_DISP_VGA,
97 .bpp = 16,
98 .grayscale = 0,
99 };
100
101 #elif PANEL == SVGA
102 #define PANELTYPE svga
103 static struct clcd_panel svga = {
104 .mode = {
105 .name = "SVGA",
106 .refresh = 0,
107 .xres = 800,
108 .yres = 600,
109 .pixclock = 27778,
110 .left_margin = 20,
111 .right_margin = 20,
112 .upper_margin = 5,
113 .lower_margin = 5,
114 .hsync_len = 164,
115 .vsync_len = 62,
116 .sync = 0,
117 .vmode = FB_VMODE_NONINTERLACED,
118 },
119 .width = -1,
120 .height = -1,
121 .tim2 = TIM2_BCD,
122 .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1),
123 .connector = IMPD1_CTRL_DISP_VGA,
124 .caps = CLCD_CAP_5551,
125 .bpp = 16,
126 .grayscale = 0,
127 };
128
129 #elif PANEL == PROSPECTOR
130 #define PANELTYPE prospector
131 static struct clcd_panel prospector = {
132 .mode = {
133 .name = "PROSPECTOR",
134 .refresh = 0,
135 .xres = 640,
136 .yres = 480,
137 .pixclock = 40000,
138 .left_margin = 33,
139 .right_margin = 64,
140 .upper_margin = 36,
141 .lower_margin = 7,
142 .hsync_len = 64,
143 .vsync_len = 25,
144 .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
145 .vmode = FB_VMODE_NONINTERLACED,
146 },
147 .width = -1,
148 .height = -1,
149 .tim2 = TIM2_BCD,
150 .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1),
151 .caps = CLCD_CAP_5551,
152 .fixedtimings = 1,
153 .connector = IMPD1_CTRL_DISP_LCD,
154 .bpp = 16,
155 .grayscale = 0,
156 };
157
158 #elif PANEL == LTM10C209
159 #define PANELTYPE ltm10c209
160 /*
161 * Untested.
162 */
163 static struct clcd_panel ltm10c209 = {
164 .mode = {
165 .name = "LTM10C209",
166 .refresh = 0,
167 .xres = 640,
168 .yres = 480,
169 .pixclock = 40000,
170 .left_margin = 20,
171 .right_margin = 20,
172 .upper_margin = 19,
173 .lower_margin = 19,
174 .hsync_len = 20,
175 .vsync_len = 10,
176 .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
177 .vmode = FB_VMODE_NONINTERLACED,
178 },
179 .width = -1,
180 .height = -1,
181 .tim2 = TIM2_BCD,
182 .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1),
183 .caps = CLCD_CAP_5551,
184 .fixedtimings = 1,
185 .connector = IMPD1_CTRL_DISP_LCD,
186 .bpp = 16,
187 .grayscale = 0,
188 };
189 #endif
190
191 /*
192 * Disable all display connectors on the interface module.
193 */
194 static void impd1fb_clcd_disable(struct clcd_fb *fb)
195 {
196 impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK, 0);
197 }
198
199 /*
200 * Enable the relevant connector on the interface module.
201 */
202 static void impd1fb_clcd_enable(struct clcd_fb *fb)
203 {
204 impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK,
205 fb->panel->connector | IMPD1_CTRL_DISP_ENABLE);
206 }
207
208 static int impd1fb_clcd_setup(struct clcd_fb *fb)
209 {
210 unsigned long framebase = fb->dev->res.start + 0x01000000;
211 unsigned long framesize = SZ_1M;
212 int ret = 0;
213
214 fb->panel = &PANELTYPE;
215
216 if (!request_mem_region(framebase, framesize, "clcd framebuffer")) {
217 printk(KERN_ERR "IM-PD1: unable to reserve framebuffer\n");
218 return -EBUSY;
219 }
220
221 fb->fb.screen_base = ioremap(framebase, framesize);
222 if (!fb->fb.screen_base) {
223 printk(KERN_ERR "IM-PD1: unable to map framebuffer\n");
224 ret = -ENOMEM;
225 goto free_buffer;
226 }
227
228 fb->fb.fix.smem_start = framebase;
229 fb->fb.fix.smem_len = framesize;
230
231 return 0;
232
233 free_buffer:
234 release_mem_region(framebase, framesize);
235 return ret;
236 }
237
238 static int impd1fb_clcd_mmap(struct clcd_fb *fb, struct vm_area_struct *vma)
239 {
240 unsigned long start, size;
241
242 start = vma->vm_pgoff + (fb->fb.fix.smem_start >> PAGE_SHIFT);
243 size = vma->vm_end - vma->vm_start;
244
245 return remap_pfn_range(vma, vma->vm_start, start, size,
246 vma->vm_page_prot);
247 }
248
249 static void impd1fb_clcd_remove(struct clcd_fb *fb)
250 {
251 iounmap(fb->fb.screen_base);
252 release_mem_region(fb->fb.fix.smem_start, fb->fb.fix.smem_len);
253 }
254
255 static struct clcd_board impd1_clcd_data = {
256 .name = "IM-PD/1",
257 .caps = CLCD_CAP_5551 | CLCD_CAP_888,
258 .check = clcdfb_check,
259 .decode = clcdfb_decode,
260 .disable = impd1fb_clcd_disable,
261 .enable = impd1fb_clcd_enable,
262 .setup = impd1fb_clcd_setup,
263 .mmap = impd1fb_clcd_mmap,
264 .remove = impd1fb_clcd_remove,
265 };
266
267 struct impd1_device {
268 unsigned long offset;
269 unsigned int irq[2];
270 unsigned int id;
271 void *platform_data;
272 };
273
274 static struct impd1_device impd1_devs[] = {
275 {
276 .offset = 0x00100000,
277 .irq = { 1 },
278 .id = 0x00141011,
279 }, {
280 .offset = 0x00200000,
281 .irq = { 2 },
282 .id = 0x00141011,
283 }, {
284 .offset = 0x00300000,
285 .irq = { 3 },
286 .id = 0x00041022,
287 }, {
288 .offset = 0x00400000,
289 .irq = { 4 },
290 .id = 0x00041061,
291 }, {
292 .offset = 0x00500000,
293 .irq = { 5 },
294 .id = 0x00041061,
295 }, {
296 .offset = 0x00600000,
297 .irq = { 6 },
298 .id = 0x00041130,
299 }, {
300 .offset = 0x00700000,
301 .irq = { 7, 8 },
302 .id = 0x00041181,
303 .platform_data = &mmc_data,
304 }, {
305 .offset = 0x00800000,
306 .irq = { 9 },
307 .id = 0x00041041,
308 }, {
309 .offset = 0x01000000,
310 .irq = { 11 },
311 .id = 0x00041110,
312 .platform_data = &impd1_clcd_data,
313 }
314 };
315
316 /*
317 * Valid IRQs: 0 thru 9 and 11, 10 unused.
318 */
319 #define IMPD1_VALID_IRQS 0x00000bffU
320
321 /*
322 * As this module is bool, it is OK to have this as __ref() - no
323 * probe calls will be done after the initial system bootup, as devices
324 * are discovered as part of the machine startup.
325 */
326 static int __ref impd1_probe(struct lm_device *dev)
327 {
328 struct impd1_module *impd1;
329 int irq_base;
330 int i;
331
332 if (dev->id != module_id)
333 return -EINVAL;
334
335 if (!devm_request_mem_region(&dev->dev, dev->resource.start,
336 SZ_4K, "LM registers"))
337 return -EBUSY;
338
339 impd1 = devm_kzalloc(&dev->dev, sizeof(struct impd1_module),
340 GFP_KERNEL);
341 if (!impd1)
342 return -ENOMEM;
343
344 impd1->base = devm_ioremap(&dev->dev, dev->resource.start, SZ_4K);
345 if (!impd1->base)
346 return -ENOMEM;
347
348 integrator_impd1_clk_init(impd1->base, dev->id);
349
350 if (!devm_request_mem_region(&dev->dev,
351 dev->resource.start + 0x03000000,
352 SZ_4K, "VIC"))
353 return -EBUSY;
354
355 impd1->vic_base = devm_ioremap(&dev->dev,
356 dev->resource.start + 0x03000000,
357 SZ_4K);
358 if (!impd1->vic_base)
359 return -ENOMEM;
360
361 irq_base = vic_init_cascaded(impd1->vic_base, dev->irq,
362 IMPD1_VALID_IRQS, 0);
363
364 lm_set_drvdata(dev, impd1);
365
366 dev_info(&dev->dev, "IM-PD1 found at 0x%08lx\n",
367 (unsigned long)dev->resource.start);
368
369 for (i = 0; i < ARRAY_SIZE(impd1_devs); i++) {
370 struct impd1_device *idev = impd1_devs + i;
371 struct amba_device *d;
372 unsigned long pc_base;
373 char devname[32];
374 int irq1 = idev->irq[0];
375 int irq2 = idev->irq[1];
376
377 /* Translate IRQs to IM-PD1 local numberspace */
378 if (irq1)
379 irq1 += irq_base;
380 if (irq2)
381 irq2 += irq_base;
382
383 pc_base = dev->resource.start + idev->offset;
384 snprintf(devname, 32, "lm%x:%5.5lx", dev->id, idev->offset >> 12);
385
386 /* Add GPIO descriptor lookup table for the PL061 block */
387 if (idev->offset == 0x00400000) {
388 struct gpiod_lookup_table *lookup;
389 char *chipname;
390 char *mmciname;
391
392 lookup = devm_kzalloc(&dev->dev,
393 sizeof(*lookup) + 3 * sizeof(struct gpiod_lookup),
394 GFP_KERNEL);
395 chipname = devm_kstrdup(&dev->dev, devname, GFP_KERNEL);
396 mmciname = devm_kasprintf(&dev->dev, GFP_KERNEL,
397 "lm%x:00700", dev->id);
398 if (!lookup || !chipname || !mmciname)
399 return -ENOMEM;
400
401 lookup->dev_id = mmciname;
402 /*
403 * Offsets on GPIO block 1:
404 * 3 = MMC WP (write protect)
405 * 4 = MMC CD (card detect)
406 *
407 * Offsets on GPIO block 2:
408 * 0 = Up key
409 * 1 = Down key
410 * 2 = Left key
411 * 3 = Right key
412 * 4 = Key lower left
413 * 5 = Key lower right
414 */
415 /* We need the two MMCI GPIO entries */
416 lookup->table[0].chip_label = chipname;
417 lookup->table[0].chip_hwnum = 3;
418 lookup->table[0].con_id = "wp";
419 lookup->table[1].chip_label = chipname;
420 lookup->table[1].chip_hwnum = 4;
421 lookup->table[1].con_id = "cd";
422 lookup->table[1].flags = GPIO_ACTIVE_LOW;
423 gpiod_add_lookup_table(lookup);
424 }
425
426 d = amba_ahb_device_add_res(&dev->dev, devname, pc_base, SZ_4K,
427 irq1, irq2,
428 idev->platform_data, idev->id,
429 &dev->resource);
430 if (IS_ERR(d)) {
431 dev_err(&dev->dev, "unable to register device: %ld\n", PTR_ERR(d));
432 continue;
433 }
434 }
435
436 return 0;
437 }
438
439 static int impd1_remove_one(struct device *dev, void *data)
440 {
441 device_unregister(dev);
442 return 0;
443 }
444
445 static void impd1_remove(struct lm_device *dev)
446 {
447 device_for_each_child(&dev->dev, NULL, impd1_remove_one);
448 integrator_impd1_clk_exit(dev->id);
449
450 lm_set_drvdata(dev, NULL);
451 }
452
453 static struct lm_driver impd1_driver = {
454 .drv = {
455 .name = "impd1",
456 /*
457 * As we're dropping the probe() function, suppress driver
458 * binding from sysfs.
459 */
460 .suppress_bind_attrs = true,
461 },
462 .probe = impd1_probe,
463 .remove = impd1_remove,
464 };
465
466 static int __init impd1_init(void)
467 {
468 return lm_driver_register(&impd1_driver);
469 }
470
471 static void __exit impd1_exit(void)
472 {
473 lm_driver_unregister(&impd1_driver);
474 }
475
476 module_init(impd1_init);
477 module_exit(impd1_exit);
478
479 MODULE_LICENSE("GPL");
480 MODULE_DESCRIPTION("Integrator/IM-PD1 logic module core driver");
481 MODULE_AUTHOR("Deep Blue Solutions Ltd");
Linux with added FPC-III support