arch/arm/mach-pxa/cm-x2xx.c

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