1 /*
2 * linux/arch/arm/mach-pxa/cm-x2xx.c
3 *
4 * Copyright (C) 2008 CompuLab, Ltd.
5 * Mike Rapoport <mike@compulab.co.il>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12 #include <linux/platform_device.h>
13 #include <linux/sysdev.h>
14 #include <linux/irq.h>
15 #include <linux/gpio.h>
16
17 #include <linux/dm9000.h>
18 #include <linux/leds.h>
19
20 #include <asm/mach/arch.h>
21 #include <asm/mach-types.h>
22 #include <asm/mach/map.h>
23
24 #include <mach/pxa2xx-regs.h>
25 #include <mach/mfp-pxa27x.h>
26 #include <mach/pxa-regs.h>
27 #include <mach/audio.h>
28 #include <mach/pxafb.h>
29
30 #include <asm/hardware/it8152.h>
31
32 #include "generic.h"
33 #include "cm-x2xx-pci.h"
34
35 extern void cmx255_init(void);
36 extern void cmx270_init(void);
37
38 /* virtual addresses for statically mapped regions */
39 #define CMX2XX_VIRT_BASE (0xe8000000)
40 #define CMX2XX_IT8152_VIRT (CMX2XX_VIRT_BASE)
41
42 /* physical address if local-bus attached devices */
43 #define CMX255_DM9000_PHYS_BASE (PXA_CS1_PHYS + (8 << 22))
44 #define CMX270_DM9000_PHYS_BASE (PXA_CS1_PHYS + (6 << 22))
45
46 /* leds */
47 #define CMX255_GPIO_RED (27)
48 #define CMX255_GPIO_GREEN (32)
49 #define CMX270_GPIO_RED (93)
50 #define CMX270_GPIO_GREEN (94)
51
52 /* GPIO IRQ usage */
53 #define GPIO22_ETHIRQ (22)
54 #define GPIO10_ETHIRQ (10)
55 #define CMX255_GPIO_IT8152_IRQ (0)
56 #define CMX270_GPIO_IT8152_IRQ (22)
57
58 #define CMX255_ETHIRQ IRQ_GPIO(GPIO22_ETHIRQ)
59 #define CMX270_ETHIRQ IRQ_GPIO(GPIO10_ETHIRQ)
60
61 #if defined(CONFIG_DM9000) || defined(CONFIG_DM9000_MODULE)
62 static struct resource cmx255_dm9000_resource[] = {
63 [0] = {
64 .start = CMX255_DM9000_PHYS_BASE,
65 .end = CMX255_DM9000_PHYS_BASE + 3,
66 .flags = IORESOURCE_MEM,
67 },
68 [1] = {
69 .start = CMX255_DM9000_PHYS_BASE + 4,
70 .end = CMX255_DM9000_PHYS_BASE + 4 + 500,
71 .flags = IORESOURCE_MEM,
72 },
73 [2] = {
74 .start = CMX255_ETHIRQ,
75 .end = CMX255_ETHIRQ,
76 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
77 }
78 };
79
80 static struct resource cmx270_dm9000_resource[] = {
81 [0] = {
82 .start = CMX270_DM9000_PHYS_BASE,
83 .end = CMX270_DM9000_PHYS_BASE + 3,
84 .flags = IORESOURCE_MEM,
85 },
86 [1] = {
87 .start = CMX270_DM9000_PHYS_BASE + 8,
88 .end = CMX270_DM9000_PHYS_BASE + 8 + 500,
89 .flags = IORESOURCE_MEM,
90 },
91 [2] = {
92 .start = CMX270_ETHIRQ,
93 .end = CMX270_ETHIRQ,
94 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
95 }
96 };
97
98 static struct dm9000_plat_data cmx270_dm9000_platdata = {
99 .flags = DM9000_PLATF_32BITONLY,
100 };
101
102 static struct platform_device cmx2xx_dm9000_device = {
103 .name = "dm9000",
104 .id = 0,
105 .num_resources = ARRAY_SIZE(cmx270_dm9000_resource),
106 .dev = {
107 .platform_data = &cmx270_dm9000_platdata,
108 }
109 };
110
cmx2xx_init_dm9000(void)111 static void __init cmx2xx_init_dm9000(void)
112 {
113 if (cpu_is_pxa25x())
114 cmx2xx_dm9000_device.resource = cmx255_dm9000_resource;
115 else
116 cmx2xx_dm9000_device.resource = cmx270_dm9000_resource;
117 platform_device_register(&cmx2xx_dm9000_device);
118 }
119 #else
cmx2xx_init_dm9000(void)120 static inline void cmx2xx_init_dm9000(void) {}
121 #endif
122
123 /* UCB1400 touchscreen controller */
124 #if defined(CONFIG_TOUCHSCREEN_UCB1400) || defined(CONFIG_TOUCHSCREEN_UCB1400_MODULE)
125 static struct platform_device cmx2xx_ts_device = {
126 .name = "ucb1400_ts",
127 .id = -1,
128 };
129
cmx2xx_init_touchscreen(void)130 static void __init cmx2xx_init_touchscreen(void)
131 {
132 platform_device_register(&cmx2xx_ts_device);
133 }
134 #else
cmx2xx_init_touchscreen(void)135 static inline void cmx2xx_init_touchscreen(void) {}
136 #endif
137
138 /* CM-X270 LEDs */
139 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
140 static struct gpio_led cmx2xx_leds[] = {
141 [0] = {
142 .name = "cm-x2xx:red",
143 .default_trigger = "nand-disk",
144 .active_low = 1,
145 },
146 [1] = {
147 .name = "cm-x2xx:green",
148 .default_trigger = "heartbeat",
149 .active_low = 1,
150 },
151 };
152
153 static struct gpio_led_platform_data cmx2xx_gpio_led_pdata = {
154 .num_leds = ARRAY_SIZE(cmx2xx_leds),
155 .leds = cmx2xx_leds,
156 };
157
158 static struct platform_device cmx2xx_led_device = {
159 .name = "leds-gpio",
160 .id = -1,
161 .dev = {
162 .platform_data = &cmx2xx_gpio_led_pdata,
163 },
164 };
165
cmx2xx_init_leds(void)166 static void __init cmx2xx_init_leds(void)
167 {
168 if (cpu_is_pxa25x()) {
169 cmx2xx_leds[0].gpio = CMX255_GPIO_RED;
170 cmx2xx_leds[1].gpio = CMX255_GPIO_GREEN;
171 } else {
172 cmx2xx_leds[0].gpio = CMX270_GPIO_RED;
173 cmx2xx_leds[1].gpio = CMX270_GPIO_GREEN;
174 }
175 platform_device_register(&cmx2xx_led_device);
176 }
177 #else
cmx2xx_init_leds(void)178 static inline void cmx2xx_init_leds(void) {}
179 #endif
180
181 #if defined(CONFIG_FB_PXA) || defined(CONFIG_FB_PXA_MODULE)
182 /*
183 Display definitions
184 keep these for backwards compatibility, although symbolic names (as
185 e.g. in lpd270.c) looks better
186 */
187 #define MTYPE_STN320x240 0
188 #define MTYPE_TFT640x480 1
189 #define MTYPE_CRT640x480 2
190 #define MTYPE_CRT800x600 3
191 #define MTYPE_TFT320x240 6
192 #define MTYPE_STN640x480 7
193
194 static struct pxafb_mode_info generic_stn_320x240_mode = {
195 .pixclock = 76923,
196 .bpp = 8,
197 .xres = 320,
198 .yres = 240,
199 .hsync_len = 3,
200 .vsync_len = 2,
201 .left_margin = 3,
202 .upper_margin = 0,
203 .right_margin = 3,
204 .lower_margin = 0,
205 .sync = (FB_SYNC_HOR_HIGH_ACT |
206 FB_SYNC_VERT_HIGH_ACT),
207 .cmap_greyscale = 0,
208 };
209
210 static struct pxafb_mach_info generic_stn_320x240 = {
211 .modes = &generic_stn_320x240_mode,
212 .num_modes = 1,
213 .lcd_conn = LCD_COLOR_STN_8BPP | LCD_PCLK_EDGE_FALL |\
214 LCD_AC_BIAS_FREQ(0xff),
215 .cmap_inverse = 0,
216 .cmap_static = 0,
217 };
218
219 static struct pxafb_mode_info generic_tft_640x480_mode = {
220 .pixclock = 38461,
221 .bpp = 8,
222 .xres = 640,
223 .yres = 480,
224 .hsync_len = 60,
225 .vsync_len = 2,
226 .left_margin = 70,
227 .upper_margin = 10,
228 .right_margin = 70,
229 .lower_margin = 5,
230 .sync = 0,
231 .cmap_greyscale = 0,
232 };
233
234 static struct pxafb_mach_info generic_tft_640x480 = {
235 .modes = &generic_tft_640x480_mode,
236 .num_modes = 1,
237 .lcd_conn = LCD_COLOR_TFT_8BPP | LCD_PCLK_EDGE_FALL |\
238 LCD_AC_BIAS_FREQ(0xff),
239 .cmap_inverse = 0,
240 .cmap_static = 0,
241 };
242
243 static struct pxafb_mode_info generic_crt_640x480_mode = {
244 .pixclock = 38461,
245 .bpp = 8,
246 .xres = 640,
247 .yres = 480,
248 .hsync_len = 63,
249 .vsync_len = 2,
250 .left_margin = 81,
251 .upper_margin = 33,
252 .right_margin = 16,
253 .lower_margin = 10,
254 .sync = (FB_SYNC_HOR_HIGH_ACT |
255 FB_SYNC_VERT_HIGH_ACT),
256 .cmap_greyscale = 0,
257 };
258
259 static struct pxafb_mach_info generic_crt_640x480 = {
260 .modes = &generic_crt_640x480_mode,
261 .num_modes = 1,
262 .lcd_conn = LCD_COLOR_TFT_8BPP | LCD_AC_BIAS_FREQ(0xff),
263 .cmap_inverse = 0,
264 .cmap_static = 0,
265 };
266
267 static struct pxafb_mode_info generic_crt_800x600_mode = {
268 .pixclock = 28846,
269 .bpp = 8,
270 .xres = 800,
271 .yres = 600,
272 .hsync_len = 63,
273 .vsync_len = 2,
274 .left_margin = 26,
275 .upper_margin = 21,
276 .right_margin = 26,
277 .lower_margin = 11,
278 .sync = (FB_SYNC_HOR_HIGH_ACT |
279 FB_SYNC_VERT_HIGH_ACT),
280 .cmap_greyscale = 0,
281 };
282
283 static struct pxafb_mach_info generic_crt_800x600 = {
284 .modes = &generic_crt_800x600_mode,
285 .num_modes = 1,
286 .lcd_conn = LCD_COLOR_TFT_8BPP | LCD_AC_BIAS_FREQ(0xff),
287 .cmap_inverse = 0,
288 .cmap_static = 0,
289 };
290
291 static struct pxafb_mode_info generic_tft_320x240_mode = {
292 .pixclock = 134615,
293 .bpp = 16,
294 .xres = 320,
295 .yres = 240,
296 .hsync_len = 63,
297 .vsync_len = 7,
298 .left_margin = 75,
299 .upper_margin = 0,
300 .right_margin = 15,
301 .lower_margin = 15,
302 .sync = 0,
303 .cmap_greyscale = 0,
304 };
305
306 static struct pxafb_mach_info generic_tft_320x240 = {
307 .modes = &generic_tft_320x240_mode,
308 .num_modes = 1,
309 .lcd_conn = LCD_COLOR_TFT_16BPP | LCD_AC_BIAS_FREQ(0xff),
310 .cmap_inverse = 0,
311 .cmap_static = 0,
312 };
313
314 static struct pxafb_mode_info generic_stn_640x480_mode = {
315 .pixclock = 57692,
316 .bpp = 8,
317 .xres = 640,
318 .yres = 480,
319 .hsync_len = 4,
320 .vsync_len = 2,
321 .left_margin = 10,
322 .upper_margin = 5,
323 .right_margin = 10,
324 .lower_margin = 5,
325 .sync = (FB_SYNC_HOR_HIGH_ACT |
326 FB_SYNC_VERT_HIGH_ACT),
327 .cmap_greyscale = 0,
328 };
329
330 static struct pxafb_mach_info generic_stn_640x480 = {
331 .modes = &generic_stn_640x480_mode,
332 .num_modes = 1,
333 .lcd_conn = LCD_COLOR_STN_8BPP | LCD_AC_BIAS_FREQ(0xff),
334 .cmap_inverse = 0,
335 .cmap_static = 0,
336 };
337
338 static struct pxafb_mach_info *cmx2xx_display = &generic_crt_640x480;
339
cmx2xx_set_display(char * str)340 static int __init cmx2xx_set_display(char *str)
341 {
342 int disp_type = simple_strtol(str, NULL, 0);
343 switch (disp_type) {
344 case MTYPE_STN320x240:
345 cmx2xx_display = &generic_stn_320x240;
346 break;
347 case MTYPE_TFT640x480:
348 cmx2xx_display = &generic_tft_640x480;
349 break;
350 case MTYPE_CRT640x480:
351 cmx2xx_display = &generic_crt_640x480;
352 break;
353 case MTYPE_CRT800x600:
354 cmx2xx_display = &generic_crt_800x600;
355 break;
356 case MTYPE_TFT320x240:
357 cmx2xx_display = &generic_tft_320x240;
358 break;
359 case MTYPE_STN640x480:
360 cmx2xx_display = &generic_stn_640x480;
361 break;
362 default: /* fallback to CRT 640x480 */
363 cmx2xx_display = &generic_crt_640x480;
364 break;
365 }
366 return 1;
367 }
368
369 /*
370 This should be done really early to get proper configuration for
371 frame buffer.
372 Indeed, pxafb parameters can be used istead, but CM-X2XX bootloader
373 has limitied line length for kernel command line, and also it will
374 break compatibitlty with proprietary releases already in field.
375 */
376 __setup("monitor=", cmx2xx_set_display);
377
cmx2xx_init_display(void)378 static void __init cmx2xx_init_display(void)
379 {
380 set_pxa_fb_info(cmx2xx_display);
381 }
382 #else
cmx2xx_init_display(void)383 static inline void cmx2xx_init_display(void) {}
384 #endif
385
386 #ifdef CONFIG_PM
387 static unsigned long sleep_save_msc[10];
388
cmx2xx_suspend(struct sys_device * dev,pm_message_t state)389 static int cmx2xx_suspend(struct sys_device *dev, pm_message_t state)
390 {
391 cmx2xx_pci_suspend();
392
393 /* save MSC registers */
394 sleep_save_msc[0] = MSC0;
395 sleep_save_msc[1] = MSC1;
396 sleep_save_msc[2] = MSC2;
397
398 /* setup power saving mode registers */
399 PCFR = 0x0;
400 PSLR = 0xff400000;
401 PMCR = 0x00000005;
402 PWER = 0x80000000;
403 PFER = 0x00000000;
404 PRER = 0x00000000;
405 PGSR0 = 0xC0018800;
406 PGSR1 = 0x004F0002;
407 PGSR2 = 0x6021C000;
408 PGSR3 = 0x00020000;
409
410 return 0;
411 }
412
cmx2xx_resume(struct sys_device * dev)413 static int cmx2xx_resume(struct sys_device *dev)
414 {
415 cmx2xx_pci_resume();
416
417 /* restore MSC registers */
418 MSC0 = sleep_save_msc[0];
419 MSC1 = sleep_save_msc[1];
420 MSC2 = sleep_save_msc[2];
421
422 return 0;
423 }
424
425 static struct sysdev_class cmx2xx_pm_sysclass = {
426 .name = "pm",
427 .resume = cmx2xx_resume,
428 .suspend = cmx2xx_suspend,
429 };
430
431 static struct sys_device cmx2xx_pm_device = {
432 .cls = &cmx2xx_pm_sysclass,
433 };
434
cmx2xx_pm_init(void)435 static int __init cmx2xx_pm_init(void)
436 {
437 int error;
438 error = sysdev_class_register(&cmx2xx_pm_sysclass);
439 if (error == 0)
440 error = sysdev_register(&cmx2xx_pm_device);
441 return error;
442 }
443 #else
cmx2xx_pm_init(void)444 static int __init cmx2xx_pm_init(void) { return 0; }
445 #endif
446
447 #if defined(CONFIG_SND_PXA2XX_AC97) || defined(CONFIG_SND_PXA2XX_AC97_MODULE)
cmx2xx_init_ac97(void)448 static void __init cmx2xx_init_ac97(void)
449 {
450 pxa_set_ac97_info(NULL);
451 }
452 #else
cmx2xx_init_ac97(void)453 static inline void cmx2xx_init_ac97(void) {}
454 #endif
455
cmx2xx_init(void)456 static void __init cmx2xx_init(void)
457 {
458 cmx2xx_pm_init();
459
460 if (cpu_is_pxa25x())
461 cmx255_init();
462 else
463 cmx270_init();
464
465 cmx2xx_init_dm9000();
466 cmx2xx_init_display();
467 cmx2xx_init_ac97();
468 cmx2xx_init_touchscreen();
469 cmx2xx_init_leds();
470 }
471
cmx2xx_init_irq(void)472 static void __init cmx2xx_init_irq(void)
473 {
474 pxa27x_init_irq();
475
476 if (cpu_is_pxa25x()) {
477 pxa25x_init_irq();
478 cmx2xx_pci_init_irq(CMX255_GPIO_IT8152_IRQ);
479 } else {
480 pxa27x_init_irq();
481 cmx2xx_pci_init_irq(CMX270_GPIO_IT8152_IRQ);
482 }
483 }
484
485 #ifdef CONFIG_PCI
486 /* Map PCI companion statically */
487 static struct map_desc cmx2xx_io_desc[] __initdata = {
488 [0] = { /* PCI bridge */
489 .virtual = CMX2XX_IT8152_VIRT,
490 .pfn = __phys_to_pfn(PXA_CS4_PHYS),
491 .length = SZ_64M,
492 .type = MT_DEVICE
493 },
494 };
495
cmx2xx_map_io(void)496 static void __init cmx2xx_map_io(void)
497 {
498 pxa_map_io();
499 iotable_init(cmx2xx_io_desc, ARRAY_SIZE(cmx2xx_io_desc));
500
501 it8152_base_address = CMX2XX_IT8152_VIRT;
502 }
503 #else
cmx2xx_map_io(void)504 static void __init cmx2xx_map_io(void)
505 {
506 pxa_map_io();
507 }
508 #endif
509
510 MACHINE_START(ARMCORE, "Compulab CM-X2XX")
511 .boot_params = 0xa0000100,
512 .phys_io = 0x40000000,
513 .io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
514 .map_io = cmx2xx_map_io,
515 .init_irq = cmx2xx_init_irq,
516 .timer = &pxa_timer,
517 .init_machine = cmx2xx_init,
518 MACHINE_END
519