arch/arm/mach-pxa/ezx.c

   1 /*
   2  *  ezx.c - Common code for the EZX platform.
   3  *
   4  *  Copyright (C) 2005-2006 Harald Welte <laforge@openezx.org>,
   5  *                2007-2008 Daniel Ribeiro <drwyrm@gmail.com>,
   6  *                2007-2008 Stefan Schmidt <stefan@datenfreihafen.org>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 2 as
  10  *  published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/init.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/delay.h>
  18 #include <linux/pwm_backlight.h>
  19 #include <linux/input.h>
  20 #include <linux/gpio.h>
  21 #include <linux/gpio_keys.h>
  22 #include <linux/leds-lp3944.h>
  23
  24 #include <media/soc_camera.h>
  25
  26 #include <asm/setup.h>
  27 #include <asm/mach-types.h>
  28 #include <asm/mach/arch.h>
  29
  30 #include <mach/pxa27x.h>
  31 #include <mach/pxafb.h>
  32 #include <mach/ohci.h>
  33 #include <plat/i2c.h>
  34 #include <mach/hardware.h>
  35 #include <plat/pxa27x_keypad.h>
  36 #include <mach/camera.h>
  37
  38 #include "devices.h"
  39 #include "generic.h"
  40
  41 #define EZX_NR_IRQS                     (IRQ_BOARD_START + 24)
  42
  43 #define GPIO12_A780_FLIP_LID            12
  44 #define GPIO15_A1200_FLIP_LID           15
  45 #define GPIO15_A910_FLIP_LID            15
  46 #define GPIO12_E680_LOCK_SWITCH         12
  47 #define GPIO15_E6_LOCK_SWITCH           15
  48 #define GPIO50_nCAM_EN                  50
  49 #define GPIO19_GEN1_CAM_RST             19
  50 #define GPIO28_GEN2_CAM_RST             28
  51
  52 static struct platform_pwm_backlight_data ezx_backlight_data = {
  53         .pwm_id         = 0,
  54         .max_brightness = 1023,
  55         .dft_brightness = 1023,
  56         .pwm_period_ns  = 78770,
  57 };
  58
  59 static struct platform_device ezx_backlight_device = {
  60         .name           = "pwm-backlight",
  61         .dev            = {
  62                 .parent = &pxa27x_device_pwm0.dev,
  63                 .platform_data = &ezx_backlight_data,
  64         },
  65 };
  66
  67 static struct pxafb_mode_info mode_ezx_old = {
  68         .pixclock               = 150000,
  69         .xres                   = 240,
  70         .yres                   = 320,
  71         .bpp                    = 16,
  72         .hsync_len              = 10,
  73         .left_margin            = 20,
  74         .right_margin           = 10,
  75         .vsync_len              = 2,
  76         .upper_margin           = 3,
  77         .lower_margin           = 2,
  78         .sync                   = 0,
  79 };
  80
  81 static struct pxafb_mach_info ezx_fb_info_1 = {
  82         .modes          = &mode_ezx_old,
  83         .num_modes      = 1,
  84         .lcd_conn       = LCD_COLOR_TFT_16BPP,
  85 };
  86
  87 static struct pxafb_mode_info mode_72r89803y01 = {
  88         .pixclock               = 192308,
  89         .xres                   = 240,
  90         .yres                   = 320,
  91         .bpp                    = 32,
  92         .depth                  = 18,
  93         .hsync_len              = 10,
  94         .left_margin            = 20,
  95         .right_margin           = 10,
  96         .vsync_len              = 2,
  97         .upper_margin           = 3,
  98         .lower_margin           = 2,
  99         .sync                   = 0,
 100 };
 101
 102 static struct pxafb_mach_info ezx_fb_info_2 = {
 103         .modes          = &mode_72r89803y01,
 104         .num_modes      = 1,
 105         .lcd_conn       = LCD_COLOR_TFT_18BPP,
 106 };
 107
 108 static struct platform_device *ezx_devices[] __initdata = {
 109         &ezx_backlight_device,
 110 };
 111
 112 static unsigned long ezx_pin_config[] __initdata = {
 113         /* PWM backlight */
 114         GPIO16_PWM0_OUT,
 115
 116         /* BTUART */
 117         GPIO42_BTUART_RXD,
 118         GPIO43_BTUART_TXD,
 119         GPIO44_BTUART_CTS,
 120         GPIO45_BTUART_RTS,
 121
 122         /* I2C */
 123         GPIO117_I2C_SCL,
 124         GPIO118_I2C_SDA,
 125
 126         /* PCAP SSP */
 127         GPIO29_SSP1_SCLK,
 128         GPIO25_SSP1_TXD,
 129         GPIO26_SSP1_RXD,
 130         GPIO24_GPIO,                            /* pcap chip select */
 131         GPIO1_GPIO | WAKEUP_ON_EDGE_RISE,       /* pcap interrupt */
 132         GPIO4_GPIO | MFP_LPM_DRIVE_HIGH,        /* WDI_AP */
 133         GPIO55_GPIO | MFP_LPM_DRIVE_HIGH,       /* SYS_RESTART */
 134
 135         /* MMC */
 136         GPIO32_MMC_CLK,
 137         GPIO92_MMC_DAT_0,
 138         GPIO109_MMC_DAT_1,
 139         GPIO110_MMC_DAT_2,
 140         GPIO111_MMC_DAT_3,
 141         GPIO112_MMC_CMD,
 142         GPIO11_GPIO,                            /* mmc detect */
 143
 144         /* usb to external transceiver */
 145         GPIO34_USB_P2_2,
 146         GPIO35_USB_P2_1,
 147         GPIO36_USB_P2_4,
 148         GPIO39_USB_P2_6,
 149         GPIO40_USB_P2_5,
 150         GPIO53_USB_P2_3,
 151
 152         /* usb to Neptune GSM chip */
 153         GPIO30_USB_P3_2,
 154         GPIO31_USB_P3_6,
 155         GPIO90_USB_P3_5,
 156         GPIO91_USB_P3_1,
 157         GPIO56_USB_P3_4,
 158         GPIO113_USB_P3_3,
 159 };
 160
 161 #if defined(CONFIG_MACH_EZX_A780) || defined(CONFIG_MACH_EZX_E680)
 162 static unsigned long gen1_pin_config[] __initdata = {
 163         /* flip / lockswitch */
 164         GPIO12_GPIO | WAKEUP_ON_EDGE_BOTH,
 165
 166         /* bluetooth (bcm2035) */
 167         GPIO14_GPIO | WAKEUP_ON_EDGE_RISE,      /* HOSTWAKE */
 168         GPIO48_GPIO,                            /* RESET */
 169         GPIO28_GPIO,                            /* WAKEUP */
 170
 171         /* Neptune handshake */
 172         GPIO0_GPIO | WAKEUP_ON_EDGE_FALL,       /* BP_RDY */
 173         GPIO57_GPIO | MFP_LPM_DRIVE_HIGH,       /* AP_RDY */
 174         GPIO13_GPIO | WAKEUP_ON_EDGE_BOTH,      /* WDI */
 175         GPIO3_GPIO | WAKEUP_ON_EDGE_BOTH,       /* WDI2 */
 176         GPIO82_GPIO | MFP_LPM_DRIVE_HIGH,       /* RESET */
 177         GPIO99_GPIO | MFP_LPM_DRIVE_HIGH,       /* TC_MM_EN */
 178
 179         /* sound */
 180         GPIO52_SSP3_SCLK,
 181         GPIO83_SSP3_SFRM,
 182         GPIO81_SSP3_TXD,
 183         GPIO89_SSP3_RXD,
 184
 185         /* ssp2 pins to in */
 186         GPIO22_GPIO,                            /* SSP2_SCLK */
 187         GPIO37_GPIO,                            /* SSP2_SFRM */
 188         GPIO38_GPIO,                            /* SSP2_TXD */
 189         GPIO88_GPIO,                            /* SSP2_RXD */
 190
 191         /* camera */
 192         GPIO23_CIF_MCLK,
 193         GPIO54_CIF_PCLK,
 194         GPIO85_CIF_LV,
 195         GPIO84_CIF_FV,
 196         GPIO27_CIF_DD_0,
 197         GPIO114_CIF_DD_1,
 198         GPIO51_CIF_DD_2,
 199         GPIO115_CIF_DD_3,
 200         GPIO95_CIF_DD_4,
 201         GPIO94_CIF_DD_5,
 202         GPIO17_CIF_DD_6,
 203         GPIO108_CIF_DD_7,
 204         GPIO50_GPIO | MFP_LPM_DRIVE_HIGH,       /* CAM_EN */
 205         GPIO19_GPIO | MFP_LPM_DRIVE_HIGH,       /* CAM_RST */
 206
 207         /* EMU */
 208         GPIO120_GPIO,                           /* EMU_MUX1 */
 209         GPIO119_GPIO,                           /* EMU_MUX2 */
 210         GPIO86_GPIO,                            /* SNP_INT_CTL */
 211         GPIO87_GPIO,                            /* SNP_INT_IN */
 212 };
 213 #endif
 214
 215 #if defined(CONFIG_MACH_EZX_A1200) || defined(CONFIG_MACH_EZX_A910) || \
 216         defined(CONFIG_MACH_EZX_E2) || defined(CONFIG_MACH_EZX_E6)
 217 static unsigned long gen2_pin_config[] __initdata = {
 218         /* flip / lockswitch */
 219         GPIO15_GPIO | WAKEUP_ON_EDGE_BOTH,
 220
 221         /* EOC */
 222         GPIO10_GPIO | WAKEUP_ON_EDGE_RISE,
 223
 224         /* bluetooth (bcm2045) */
 225         GPIO13_GPIO | WAKEUP_ON_EDGE_RISE,      /* HOSTWAKE */
 226         GPIO37_GPIO,                            /* RESET */
 227         GPIO57_GPIO,                            /* WAKEUP */
 228
 229         /* Neptune handshake */
 230         GPIO0_GPIO | WAKEUP_ON_EDGE_FALL,       /* BP_RDY */
 231         GPIO96_GPIO | MFP_LPM_DRIVE_HIGH,       /* AP_RDY */
 232         GPIO3_GPIO | WAKEUP_ON_EDGE_FALL,       /* WDI */
 233         GPIO116_GPIO | MFP_LPM_DRIVE_HIGH,      /* RESET */
 234         GPIO41_GPIO,                            /* BP_FLASH */
 235
 236         /* sound */
 237         GPIO52_SSP3_SCLK,
 238         GPIO83_SSP3_SFRM,
 239         GPIO81_SSP3_TXD,
 240         GPIO82_SSP3_RXD,
 241
 242         /* ssp2 pins to in */
 243         GPIO22_GPIO,                            /* SSP2_SCLK */
 244         GPIO14_GPIO,                            /* SSP2_SFRM */
 245         GPIO38_GPIO,                            /* SSP2_TXD */
 246         GPIO88_GPIO,                            /* SSP2_RXD */
 247
 248         /* camera */
 249         GPIO23_CIF_MCLK,
 250         GPIO54_CIF_PCLK,
 251         GPIO85_CIF_LV,
 252         GPIO84_CIF_FV,
 253         GPIO27_CIF_DD_0,
 254         GPIO114_CIF_DD_1,
 255         GPIO51_CIF_DD_2,
 256         GPIO115_CIF_DD_3,
 257         GPIO95_CIF_DD_4,
 258         GPIO48_CIF_DD_5,
 259         GPIO93_CIF_DD_6,
 260         GPIO12_CIF_DD_7,
 261         GPIO50_GPIO | MFP_LPM_DRIVE_HIGH,       /* CAM_EN */
 262         GPIO28_GPIO | MFP_LPM_DRIVE_HIGH,       /* CAM_RST */
 263         GPIO17_GPIO,                            /* CAM_FLASH */
 264 };
 265 #endif
 266
 267 #ifdef CONFIG_MACH_EZX_A780
 268 static unsigned long a780_pin_config[] __initdata = {
 269         /* keypad */
 270         GPIO93_KP_DKIN_0 | WAKEUP_ON_LEVEL_HIGH,
 271         GPIO100_KP_MKIN_0 | WAKEUP_ON_LEVEL_HIGH,
 272         GPIO101_KP_MKIN_1 | WAKEUP_ON_LEVEL_HIGH,
 273         GPIO102_KP_MKIN_2 | WAKEUP_ON_LEVEL_HIGH,
 274         GPIO97_KP_MKIN_3 | WAKEUP_ON_LEVEL_HIGH,
 275         GPIO98_KP_MKIN_4 | WAKEUP_ON_LEVEL_HIGH,
 276         GPIO103_KP_MKOUT_0,
 277         GPIO104_KP_MKOUT_1,
 278         GPIO105_KP_MKOUT_2,
 279         GPIO106_KP_MKOUT_3,
 280         GPIO107_KP_MKOUT_4,
 281
 282         /* attenuate sound */
 283         GPIO96_GPIO,
 284 };
 285 #endif
 286
 287 #ifdef CONFIG_MACH_EZX_E680
 288 static unsigned long e680_pin_config[] __initdata = {
 289         /* keypad */
 290         GPIO93_KP_DKIN_0 | WAKEUP_ON_LEVEL_HIGH,
 291         GPIO96_KP_DKIN_3 | WAKEUP_ON_LEVEL_HIGH,
 292         GPIO97_KP_DKIN_4 | WAKEUP_ON_LEVEL_HIGH,
 293         GPIO98_KP_DKIN_5 | WAKEUP_ON_LEVEL_HIGH,
 294         GPIO100_KP_MKIN_0 | WAKEUP_ON_LEVEL_HIGH,
 295         GPIO101_KP_MKIN_1 | WAKEUP_ON_LEVEL_HIGH,
 296         GPIO102_KP_MKIN_2 | WAKEUP_ON_LEVEL_HIGH,
 297         GPIO103_KP_MKOUT_0,
 298         GPIO104_KP_MKOUT_1,
 299         GPIO105_KP_MKOUT_2,
 300         GPIO106_KP_MKOUT_3,
 301
 302         /* MIDI */
 303         GPIO79_GPIO,                            /* VA_SEL_BUL */
 304         GPIO80_GPIO,                            /* FLT_SEL_BUL */
 305         GPIO78_GPIO,                            /* MIDI_RESET */
 306         GPIO33_GPIO,                            /* MIDI_CS */
 307         GPIO15_GPIO,                            /* MIDI_IRQ */
 308         GPIO49_GPIO,                            /* MIDI_NPWE */
 309         GPIO18_GPIO,                            /* MIDI_RDY */
 310
 311         /* leds */
 312         GPIO46_GPIO,
 313         GPIO47_GPIO,
 314 };
 315 #endif
 316
 317 #ifdef CONFIG_MACH_EZX_A1200
 318 static unsigned long a1200_pin_config[] __initdata = {
 319         /* keypad */
 320         GPIO100_KP_MKIN_0 | WAKEUP_ON_LEVEL_HIGH,
 321         GPIO101_KP_MKIN_1 | WAKEUP_ON_LEVEL_HIGH,
 322         GPIO102_KP_MKIN_2 | WAKEUP_ON_LEVEL_HIGH,
 323         GPIO97_KP_MKIN_3 | WAKEUP_ON_LEVEL_HIGH,
 324         GPIO98_KP_MKIN_4 | WAKEUP_ON_LEVEL_HIGH,
 325         GPIO103_KP_MKOUT_0,
 326         GPIO104_KP_MKOUT_1,
 327         GPIO105_KP_MKOUT_2,
 328         GPIO106_KP_MKOUT_3,
 329         GPIO107_KP_MKOUT_4,
 330         GPIO108_KP_MKOUT_5,
 331 };
 332 #endif
 333
 334 #ifdef CONFIG_MACH_EZX_A910
 335 static unsigned long a910_pin_config[] __initdata = {
 336         /* keypad */
 337         GPIO100_KP_MKIN_0 | WAKEUP_ON_LEVEL_HIGH,
 338         GPIO101_KP_MKIN_1 | WAKEUP_ON_LEVEL_HIGH,
 339         GPIO102_KP_MKIN_2 | WAKEUP_ON_LEVEL_HIGH,
 340         GPIO97_KP_MKIN_3 | WAKEUP_ON_LEVEL_HIGH,
 341         GPIO98_KP_MKIN_4 | WAKEUP_ON_LEVEL_HIGH,
 342         GPIO103_KP_MKOUT_0,
 343         GPIO104_KP_MKOUT_1,
 344         GPIO105_KP_MKOUT_2,
 345         GPIO106_KP_MKOUT_3,
 346         GPIO107_KP_MKOUT_4,
 347         GPIO108_KP_MKOUT_5,
 348
 349         /* WLAN */
 350         GPIO89_GPIO,                            /* RESET */
 351         GPIO33_GPIO,                            /* WAKEUP */
 352         GPIO94_GPIO | WAKEUP_ON_LEVEL_HIGH,     /* HOSTWAKE */
 353
 354         /* MMC CS */
 355         GPIO20_GPIO,
 356 };
 357 #endif
 358
 359 #ifdef CONFIG_MACH_EZX_E2
 360 static unsigned long e2_pin_config[] __initdata = {
 361         /* keypad */
 362         GPIO100_KP_MKIN_0 | WAKEUP_ON_LEVEL_HIGH,
 363         GPIO101_KP_MKIN_1 | WAKEUP_ON_LEVEL_HIGH,
 364         GPIO102_KP_MKIN_2 | WAKEUP_ON_LEVEL_HIGH,
 365         GPIO97_KP_MKIN_3 | WAKEUP_ON_LEVEL_HIGH,
 366         GPIO98_KP_MKIN_4 | WAKEUP_ON_LEVEL_HIGH,
 367         GPIO103_KP_MKOUT_0,
 368         GPIO104_KP_MKOUT_1,
 369         GPIO105_KP_MKOUT_2,
 370         GPIO106_KP_MKOUT_3,
 371         GPIO107_KP_MKOUT_4,
 372         GPIO108_KP_MKOUT_5,
 373 };
 374 #endif
 375
 376 #ifdef CONFIG_MACH_EZX_E6
 377 static unsigned long e6_pin_config[] __initdata = {
 378         /* keypad */
 379         GPIO100_KP_MKIN_0 | WAKEUP_ON_LEVEL_HIGH,
 380         GPIO101_KP_MKIN_1 | WAKEUP_ON_LEVEL_HIGH,
 381         GPIO102_KP_MKIN_2 | WAKEUP_ON_LEVEL_HIGH,
 382         GPIO97_KP_MKIN_3 | WAKEUP_ON_LEVEL_HIGH,
 383         GPIO98_KP_MKIN_4 | WAKEUP_ON_LEVEL_HIGH,
 384         GPIO103_KP_MKOUT_0,
 385         GPIO104_KP_MKOUT_1,
 386         GPIO105_KP_MKOUT_2,
 387         GPIO106_KP_MKOUT_3,
 388         GPIO107_KP_MKOUT_4,
 389         GPIO108_KP_MKOUT_5,
 390 };
 391 #endif
 392
 393 /* KEYPAD */
 394 #ifdef CONFIG_MACH_EZX_A780
 395 static unsigned int a780_key_map[] = {
 396         KEY(0, 0, KEY_SEND),
 397         KEY(0, 1, KEY_BACK),
 398         KEY(0, 2, KEY_END),
 399         KEY(0, 3, KEY_PAGEUP),
 400         KEY(0, 4, KEY_UP),
 401
 402         KEY(1, 0, KEY_NUMERIC_1),
 403         KEY(1, 1, KEY_NUMERIC_2),
 404         KEY(1, 2, KEY_NUMERIC_3),
 405         KEY(1, 3, KEY_SELECT),
 406         KEY(1, 4, KEY_KPENTER),
 407
 408         KEY(2, 0, KEY_NUMERIC_4),
 409         KEY(2, 1, KEY_NUMERIC_5),
 410         KEY(2, 2, KEY_NUMERIC_6),
 411         KEY(2, 3, KEY_RECORD),
 412         KEY(2, 4, KEY_LEFT),
 413
 414         KEY(3, 0, KEY_NUMERIC_7),
 415         KEY(3, 1, KEY_NUMERIC_8),
 416         KEY(3, 2, KEY_NUMERIC_9),
 417         KEY(3, 3, KEY_HOME),
 418         KEY(3, 4, KEY_RIGHT),
 419
 420         KEY(4, 0, KEY_NUMERIC_STAR),
 421         KEY(4, 1, KEY_NUMERIC_0),
 422         KEY(4, 2, KEY_NUMERIC_POUND),
 423         KEY(4, 3, KEY_PAGEDOWN),
 424         KEY(4, 4, KEY_DOWN),
 425 };
 426
 427 static struct pxa27x_keypad_platform_data a780_keypad_platform_data = {
 428         .matrix_key_rows = 5,
 429         .matrix_key_cols = 5,
 430         .matrix_key_map = a780_key_map,
 431         .matrix_key_map_size = ARRAY_SIZE(a780_key_map),
 432
 433         .direct_key_map = { KEY_CAMERA },
 434         .direct_key_num = 1,
 435
 436         .debounce_interval = 30,
 437 };
 438 #endif /* CONFIG_MACH_EZX_A780 */
 439
 440 #ifdef CONFIG_MACH_EZX_E680
 441 static unsigned int e680_key_map[] = {
 442         KEY(0, 0, KEY_UP),
 443         KEY(0, 1, KEY_RIGHT),
 444         KEY(0, 2, KEY_RESERVED),
 445         KEY(0, 3, KEY_SEND),
 446
 447         KEY(1, 0, KEY_DOWN),
 448         KEY(1, 1, KEY_LEFT),
 449         KEY(1, 2, KEY_PAGEUP),
 450         KEY(1, 3, KEY_PAGEDOWN),
 451
 452         KEY(2, 0, KEY_RESERVED),
 453         KEY(2, 1, KEY_RESERVED),
 454         KEY(2, 2, KEY_RESERVED),
 455         KEY(2, 3, KEY_KPENTER),
 456 };
 457
 458 static struct pxa27x_keypad_platform_data e680_keypad_platform_data = {
 459         .matrix_key_rows = 3,
 460         .matrix_key_cols = 4,
 461         .matrix_key_map = e680_key_map,
 462         .matrix_key_map_size = ARRAY_SIZE(e680_key_map),
 463
 464         .direct_key_map = {
 465                 KEY_CAMERA,
 466                 KEY_RESERVED,
 467                 KEY_RESERVED,
 468                 KEY_F1,
 469                 KEY_CANCEL,
 470                 KEY_F2,
 471         },
 472         .direct_key_num = 6,
 473
 474         .debounce_interval = 30,
 475 };
 476 #endif /* CONFIG_MACH_EZX_E680 */
 477
 478 #ifdef CONFIG_MACH_EZX_A1200
 479 static unsigned int a1200_key_map[] = {
 480         KEY(0, 0, KEY_RESERVED),
 481         KEY(0, 1, KEY_RIGHT),
 482         KEY(0, 2, KEY_PAGEDOWN),
 483         KEY(0, 3, KEY_RESERVED),
 484         KEY(0, 4, KEY_RESERVED),
 485         KEY(0, 5, KEY_RESERVED),
 486
 487         KEY(1, 0, KEY_RESERVED),
 488         KEY(1, 1, KEY_DOWN),
 489         KEY(1, 2, KEY_CAMERA),
 490         KEY(1, 3, KEY_RESERVED),
 491         KEY(1, 4, KEY_RESERVED),
 492         KEY(1, 5, KEY_RESERVED),
 493
 494         KEY(2, 0, KEY_RESERVED),
 495         KEY(2, 1, KEY_KPENTER),
 496         KEY(2, 2, KEY_RECORD),
 497         KEY(2, 3, KEY_RESERVED),
 498         KEY(2, 4, KEY_RESERVED),
 499         KEY(2, 5, KEY_SELECT),
 500
 501         KEY(3, 0, KEY_RESERVED),
 502         KEY(3, 1, KEY_UP),
 503         KEY(3, 2, KEY_SEND),
 504         KEY(3, 3, KEY_RESERVED),
 505         KEY(3, 4, KEY_RESERVED),
 506         KEY(3, 5, KEY_RESERVED),
 507
 508         KEY(4, 0, KEY_RESERVED),
 509         KEY(4, 1, KEY_LEFT),
 510         KEY(4, 2, KEY_PAGEUP),
 511         KEY(4, 3, KEY_RESERVED),
 512         KEY(4, 4, KEY_RESERVED),
 513         KEY(4, 5, KEY_RESERVED),
 514 };
 515
 516 static struct pxa27x_keypad_platform_data a1200_keypad_platform_data = {
 517         .matrix_key_rows = 5,
 518         .matrix_key_cols = 6,
 519         .matrix_key_map = a1200_key_map,
 520         .matrix_key_map_size = ARRAY_SIZE(a1200_key_map),
 521
 522         .debounce_interval = 30,
 523 };
 524 #endif /* CONFIG_MACH_EZX_A1200 */
 525
 526 #ifdef CONFIG_MACH_EZX_E6
 527 static unsigned int e6_key_map[] = {
 528         KEY(0, 0, KEY_RESERVED),
 529         KEY(0, 1, KEY_RIGHT),
 530         KEY(0, 2, KEY_PAGEDOWN),
 531         KEY(0, 3, KEY_RESERVED),
 532         KEY(0, 4, KEY_RESERVED),
 533         KEY(0, 5, KEY_NEXTSONG),
 534
 535         KEY(1, 0, KEY_RESERVED),
 536         KEY(1, 1, KEY_DOWN),
 537         KEY(1, 2, KEY_PROG1),
 538         KEY(1, 3, KEY_RESERVED),
 539         KEY(1, 4, KEY_RESERVED),
 540         KEY(1, 5, KEY_RESERVED),
 541
 542         KEY(2, 0, KEY_RESERVED),
 543         KEY(2, 1, KEY_ENTER),
 544         KEY(2, 2, KEY_CAMERA),
 545         KEY(2, 3, KEY_RESERVED),
 546         KEY(2, 4, KEY_RESERVED),
 547         KEY(2, 5, KEY_WWW),
 548
 549         KEY(3, 0, KEY_RESERVED),
 550         KEY(3, 1, KEY_UP),
 551         KEY(3, 2, KEY_SEND),
 552         KEY(3, 3, KEY_RESERVED),
 553         KEY(3, 4, KEY_RESERVED),
 554         KEY(3, 5, KEY_PLAYPAUSE),
 555
 556         KEY(4, 0, KEY_RESERVED),
 557         KEY(4, 1, KEY_LEFT),
 558         KEY(4, 2, KEY_PAGEUP),
 559         KEY(4, 3, KEY_RESERVED),
 560         KEY(4, 4, KEY_RESERVED),
 561         KEY(4, 5, KEY_PREVIOUSSONG),
 562 };
 563
 564 static struct pxa27x_keypad_platform_data e6_keypad_platform_data = {
 565         .matrix_key_rows = 5,
 566         .matrix_key_cols = 6,
 567         .matrix_key_map = e6_key_map,
 568         .matrix_key_map_size = ARRAY_SIZE(e6_key_map),
 569
 570         .debounce_interval = 30,
 571 };
 572 #endif /* CONFIG_MACH_EZX_E6 */
 573
 574 #ifdef CONFIG_MACH_EZX_A910
 575 static unsigned int a910_key_map[] = {
 576         KEY(0, 0, KEY_NUMERIC_6),
 577         KEY(0, 1, KEY_RIGHT),
 578         KEY(0, 2, KEY_PAGEDOWN),
 579         KEY(0, 3, KEY_KPENTER),
 580         KEY(0, 4, KEY_NUMERIC_5),
 581         KEY(0, 5, KEY_CAMERA),
 582
 583         KEY(1, 0, KEY_NUMERIC_8),
 584         KEY(1, 1, KEY_DOWN),
 585         KEY(1, 2, KEY_RESERVED),
 586         KEY(1, 3, KEY_F1), /* Left SoftKey */
 587         KEY(1, 4, KEY_NUMERIC_STAR),
 588         KEY(1, 5, KEY_RESERVED),
 589
 590         KEY(2, 0, KEY_NUMERIC_7),
 591         KEY(2, 1, KEY_NUMERIC_9),
 592         KEY(2, 2, KEY_RECORD),
 593         KEY(2, 3, KEY_F2), /* Right SoftKey */
 594         KEY(2, 4, KEY_BACK),
 595         KEY(2, 5, KEY_SELECT),
 596
 597         KEY(3, 0, KEY_NUMERIC_2),
 598         KEY(3, 1, KEY_UP),
 599         KEY(3, 2, KEY_SEND),
 600         KEY(3, 3, KEY_NUMERIC_0),
 601         KEY(3, 4, KEY_NUMERIC_1),
 602         KEY(3, 5, KEY_RECORD),
 603
 604         KEY(4, 0, KEY_NUMERIC_4),
 605         KEY(4, 1, KEY_LEFT),
 606         KEY(4, 2, KEY_PAGEUP),
 607         KEY(4, 3, KEY_NUMERIC_POUND),
 608         KEY(4, 4, KEY_NUMERIC_3),
 609         KEY(4, 5, KEY_RESERVED),
 610 };
 611
 612 static struct pxa27x_keypad_platform_data a910_keypad_platform_data = {
 613         .matrix_key_rows = 5,
 614         .matrix_key_cols = 6,
 615         .matrix_key_map = a910_key_map,
 616         .matrix_key_map_size = ARRAY_SIZE(a910_key_map),
 617
 618         .debounce_interval = 30,
 619 };
 620 #endif /* CONFIG_MACH_EZX_A910 */
 621
 622 #ifdef CONFIG_MACH_EZX_E2
 623 static unsigned int e2_key_map[] = {
 624         KEY(0, 0, KEY_NUMERIC_6),
 625         KEY(0, 1, KEY_RIGHT),
 626         KEY(0, 2, KEY_NUMERIC_9),
 627         KEY(0, 3, KEY_NEXTSONG),
 628         KEY(0, 4, KEY_NUMERIC_5),
 629         KEY(0, 5, KEY_F1), /* Left SoftKey */
 630
 631         KEY(1, 0, KEY_NUMERIC_8),
 632         KEY(1, 1, KEY_DOWN),
 633         KEY(1, 2, KEY_RESERVED),
 634         KEY(1, 3, KEY_PAGEUP),
 635         KEY(1, 4, KEY_NUMERIC_STAR),
 636         KEY(1, 5, KEY_F2), /* Right SoftKey */
 637
 638         KEY(2, 0, KEY_NUMERIC_7),
 639         KEY(2, 1, KEY_KPENTER),
 640         KEY(2, 2, KEY_RECORD),
 641         KEY(2, 3, KEY_PAGEDOWN),
 642         KEY(2, 4, KEY_BACK),
 643         KEY(2, 5, KEY_NUMERIC_0),
 644
 645         KEY(3, 0, KEY_NUMERIC_2),
 646         KEY(3, 1, KEY_UP),
 647         KEY(3, 2, KEY_SEND),
 648         KEY(3, 3, KEY_PLAYPAUSE),
 649         KEY(3, 4, KEY_NUMERIC_1),
 650         KEY(3, 5, KEY_SOUND), /* Music SoftKey */
 651
 652         KEY(4, 0, KEY_NUMERIC_4),
 653         KEY(4, 1, KEY_LEFT),
 654         KEY(4, 2, KEY_NUMERIC_POUND),
 655         KEY(4, 3, KEY_PREVIOUSSONG),
 656         KEY(4, 4, KEY_NUMERIC_3),
 657         KEY(4, 5, KEY_RESERVED),
 658 };
 659
 660 static struct pxa27x_keypad_platform_data e2_keypad_platform_data = {
 661         .matrix_key_rows = 5,
 662         .matrix_key_cols = 6,
 663         .matrix_key_map = e2_key_map,
 664         .matrix_key_map_size = ARRAY_SIZE(e2_key_map),
 665
 666         .debounce_interval = 30,
 667 };
 668 #endif /* CONFIG_MACH_EZX_E2 */
 669
 670 #ifdef CONFIG_MACH_EZX_A780
 671 /* gpio_keys */
 672 static struct gpio_keys_button a780_buttons[] = {
 673         [0] = {
 674                 .code       = SW_LID,
 675                 .gpio       = GPIO12_A780_FLIP_LID,
 676                 .active_low = 0,
 677                 .desc       = "A780 flip lid",
 678                 .type       = EV_SW,
 679                 .wakeup     = 1,
 680         },
 681 };
 682
 683 static struct gpio_keys_platform_data a780_gpio_keys_platform_data = {
 684         .buttons  = a780_buttons,
 685         .nbuttons = ARRAY_SIZE(a780_buttons),
 686 };
 687
 688 static struct platform_device a780_gpio_keys = {
 689         .name = "gpio-keys",
 690         .id   = -1,
 691         .dev  = {
 692                 .platform_data = &a780_gpio_keys_platform_data,
 693         },
 694 };
 695
 696 /* camera */
 697 static int a780_camera_init(void)
 698 {
 699         int err;
 700
 701         /*
 702          * GPIO50_nCAM_EN is active low
 703          * GPIO19_GEN1_CAM_RST is active on rising edge
 704          */
 705         err = gpio_request(GPIO50_nCAM_EN, "nCAM_EN");
 706         if (err) {
 707                 pr_err("%s: Failed to request nCAM_EN\n", __func__);
 708                 goto fail;
 709         }
 710
 711         err = gpio_request(GPIO19_GEN1_CAM_RST, "CAM_RST");
 712         if (err) {
 713                 pr_err("%s: Failed to request CAM_RST\n", __func__);
 714                 goto fail_gpio_cam_rst;
 715         }
 716
 717         gpio_direction_output(GPIO50_nCAM_EN, 1);
 718         gpio_direction_output(GPIO19_GEN1_CAM_RST, 0);
 719
 720         return 0;
 721
 722 fail_gpio_cam_rst:
 723         gpio_free(GPIO50_nCAM_EN);
 724 fail:
 725         return err;
 726 }
 727
 728 static int a780_camera_power(struct device *dev, int on)
 729 {
 730         gpio_set_value(GPIO50_nCAM_EN, !on);
 731         return 0;
 732 }
 733
 734 static int a780_camera_reset(struct device *dev)
 735 {
 736         gpio_set_value(GPIO19_GEN1_CAM_RST, 0);
 737         msleep(10);
 738         gpio_set_value(GPIO19_GEN1_CAM_RST, 1);
 739
 740         return 0;
 741 }
 742
 743 struct pxacamera_platform_data a780_pxacamera_platform_data = {
 744         .flags  = PXA_CAMERA_MASTER | PXA_CAMERA_DATAWIDTH_8 |
 745                 PXA_CAMERA_PCLK_EN | PXA_CAMERA_MCLK_EN,
 746         .mclk_10khz = 5000,
 747 };
 748
 749 static struct i2c_board_info a780_camera_i2c_board_info = {
 750         I2C_BOARD_INFO("mt9m111", 0x5d),
 751 };
 752
 753 static struct soc_camera_link a780_iclink = {
 754         .bus_id         = 0,
 755         .flags          = SOCAM_SENSOR_INVERT_PCLK,
 756         .i2c_adapter_id = 0,
 757         .board_info     = &a780_camera_i2c_board_info,
 758         .power          = a780_camera_power,
 759         .reset          = a780_camera_reset,
 760 };
 761
 762 static struct platform_device a780_camera = {
 763         .name   = "soc-camera-pdrv",
 764         .id     = 0,
 765         .dev    = {
 766                 .platform_data = &a780_iclink,
 767         },
 768 };
 769
 770 static struct platform_device *a780_devices[] __initdata = {
 771         &a780_gpio_keys,
 772 };
 773
 774 static void __init a780_init(void)
 775 {
 776         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
 777         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen1_pin_config));
 778         pxa2xx_mfp_config(ARRAY_AND_SIZE(a780_pin_config));
 779
 780         pxa_set_ffuart_info(NULL);
 781         pxa_set_btuart_info(NULL);
 782         pxa_set_stuart_info(NULL);
 783
 784         pxa_set_i2c_info(NULL);
 785
 786         set_pxa_fb_info(&ezx_fb_info_1);
 787
 788         pxa_set_keypad_info(&a780_keypad_platform_data);
 789
 790         if (a780_camera_init() == 0) {
 791                 pxa_set_camera_info(&a780_pxacamera_platform_data);
 792                 platform_device_register(&a780_camera);
 793         }
 794
 795         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
 796         platform_add_devices(ARRAY_AND_SIZE(a780_devices));
 797 }
 798
 799 MACHINE_START(EZX_A780, "Motorola EZX A780")
 800         .boot_params    = 0xa0000100,
 801         .map_io         = pxa27x_map_io,
 802         .nr_irqs        = EZX_NR_IRQS,
 803         .init_irq       = pxa27x_init_irq,
 804         .timer          = &pxa_timer,
 805         .init_machine   = a780_init,
 806 MACHINE_END
 807 #endif
 808
 809 #ifdef CONFIG_MACH_EZX_E680
 810 /* gpio_keys */
 811 static struct gpio_keys_button e680_buttons[] = {
 812         [0] = {
 813                 .code       = KEY_SCREENLOCK,
 814                 .gpio       = GPIO12_E680_LOCK_SWITCH,
 815                 .active_low = 0,
 816                 .desc       = "E680 lock switch",
 817                 .type       = EV_KEY,
 818                 .wakeup     = 1,
 819         },
 820 };
 821
 822 static struct gpio_keys_platform_data e680_gpio_keys_platform_data = {
 823         .buttons  = e680_buttons,
 824         .nbuttons = ARRAY_SIZE(e680_buttons),
 825 };
 826
 827 static struct platform_device e680_gpio_keys = {
 828         .name = "gpio-keys",
 829         .id   = -1,
 830         .dev  = {
 831                 .platform_data = &e680_gpio_keys_platform_data,
 832         },
 833 };
 834
 835 static struct i2c_board_info __initdata e680_i2c_board_info[] = {
 836         { I2C_BOARD_INFO("tea5767", 0x81) },
 837 };
 838
 839 static struct platform_device *e680_devices[] __initdata = {
 840         &e680_gpio_keys,
 841 };
 842
 843 static void __init e680_init(void)
 844 {
 845         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
 846         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen1_pin_config));
 847         pxa2xx_mfp_config(ARRAY_AND_SIZE(e680_pin_config));
 848
 849         pxa_set_ffuart_info(NULL);
 850         pxa_set_btuart_info(NULL);
 851         pxa_set_stuart_info(NULL);
 852
 853         pxa_set_i2c_info(NULL);
 854         i2c_register_board_info(0, ARRAY_AND_SIZE(e680_i2c_board_info));
 855
 856         set_pxa_fb_info(&ezx_fb_info_1);
 857
 858         pxa_set_keypad_info(&e680_keypad_platform_data);
 859
 860         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
 861         platform_add_devices(ARRAY_AND_SIZE(e680_devices));
 862 }
 863
 864 MACHINE_START(EZX_E680, "Motorola EZX E680")
 865         .boot_params    = 0xa0000100,
 866         .map_io         = pxa27x_map_io,
 867         .nr_irqs        = EZX_NR_IRQS,
 868         .init_irq       = pxa27x_init_irq,
 869         .timer          = &pxa_timer,
 870         .init_machine   = e680_init,
 871 MACHINE_END
 872 #endif
 873
 874 #ifdef CONFIG_MACH_EZX_A1200
 875 /* gpio_keys */
 876 static struct gpio_keys_button a1200_buttons[] = {
 877         [0] = {
 878                 .code       = SW_LID,
 879                 .gpio       = GPIO15_A1200_FLIP_LID,
 880                 .active_low = 0,
 881                 .desc       = "A1200 flip lid",
 882                 .type       = EV_SW,
 883                 .wakeup     = 1,
 884         },
 885 };
 886
 887 static struct gpio_keys_platform_data a1200_gpio_keys_platform_data = {
 888         .buttons  = a1200_buttons,
 889         .nbuttons = ARRAY_SIZE(a1200_buttons),
 890 };
 891
 892 static struct platform_device a1200_gpio_keys = {
 893         .name = "gpio-keys",
 894         .id   = -1,
 895         .dev  = {
 896                 .platform_data = &a1200_gpio_keys_platform_data,
 897         },
 898 };
 899
 900 static struct i2c_board_info __initdata a1200_i2c_board_info[] = {
 901         { I2C_BOARD_INFO("tea5767", 0x81) },
 902 };
 903
 904 static struct platform_device *a1200_devices[] __initdata = {
 905         &a1200_gpio_keys,
 906 };
 907
 908 static void __init a1200_init(void)
 909 {
 910         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
 911         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen2_pin_config));
 912         pxa2xx_mfp_config(ARRAY_AND_SIZE(a1200_pin_config));
 913
 914         pxa_set_ffuart_info(NULL);
 915         pxa_set_btuart_info(NULL);
 916         pxa_set_stuart_info(NULL);
 917
 918         pxa_set_i2c_info(NULL);
 919         i2c_register_board_info(0, ARRAY_AND_SIZE(a1200_i2c_board_info));
 920
 921         set_pxa_fb_info(&ezx_fb_info_2);
 922
 923         pxa_set_keypad_info(&a1200_keypad_platform_data);
 924
 925         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
 926         platform_add_devices(ARRAY_AND_SIZE(a1200_devices));
 927 }
 928
 929 MACHINE_START(EZX_A1200, "Motorola EZX A1200")
 930         .boot_params    = 0xa0000100,
 931         .map_io         = pxa27x_map_io,
 932         .nr_irqs        = EZX_NR_IRQS,
 933         .init_irq       = pxa27x_init_irq,
 934         .timer          = &pxa_timer,
 935         .init_machine   = a1200_init,
 936 MACHINE_END
 937 #endif
 938
 939 #ifdef CONFIG_MACH_EZX_A910
 940 /* gpio_keys */
 941 static struct gpio_keys_button a910_buttons[] = {
 942         [0] = {
 943                 .code       = SW_LID,
 944                 .gpio       = GPIO15_A910_FLIP_LID,
 945                 .active_low = 0,
 946                 .desc       = "A910 flip lid",
 947                 .type       = EV_SW,
 948                 .wakeup     = 1,
 949         },
 950 };
 951
 952 static struct gpio_keys_platform_data a910_gpio_keys_platform_data = {
 953         .buttons  = a910_buttons,
 954         .nbuttons = ARRAY_SIZE(a910_buttons),
 955 };
 956
 957 static struct platform_device a910_gpio_keys = {
 958         .name = "gpio-keys",
 959         .id   = -1,
 960         .dev  = {
 961                 .platform_data = &a910_gpio_keys_platform_data,
 962         },
 963 };
 964
 965 /* camera */
 966 static int a910_camera_init(void)
 967 {
 968         int err;
 969
 970         /*
 971          * GPIO50_nCAM_EN is active low
 972          * GPIO28_GEN2_CAM_RST is active on rising edge
 973          */
 974         err = gpio_request(GPIO50_nCAM_EN, "nCAM_EN");
 975         if (err) {
 976                 pr_err("%s: Failed to request nCAM_EN\n", __func__);
 977                 goto fail;
 978         }
 979
 980         err = gpio_request(GPIO28_GEN2_CAM_RST, "CAM_RST");
 981         if (err) {
 982                 pr_err("%s: Failed to request CAM_RST\n", __func__);
 983                 goto fail_gpio_cam_rst;
 984         }
 985
 986         gpio_direction_output(GPIO50_nCAM_EN, 1);
 987         gpio_direction_output(GPIO28_GEN2_CAM_RST, 0);
 988
 989         return 0;
 990
 991 fail_gpio_cam_rst:
 992         gpio_free(GPIO50_nCAM_EN);
 993 fail:
 994         return err;
 995 }
 996
 997 static int a910_camera_power(struct device *dev, int on)
 998 {
 999         gpio_set_value(GPIO50_nCAM_EN, !on);
1000         return 0;
1001 }
1002
1003 static int a910_camera_reset(struct device *dev)
1004 {
1005         gpio_set_value(GPIO28_GEN2_CAM_RST, 0);
1006         msleep(10);
1007         gpio_set_value(GPIO28_GEN2_CAM_RST, 1);
1008
1009         return 0;
1010 }
1011
1012 struct pxacamera_platform_data a910_pxacamera_platform_data = {
1013         .flags  = PXA_CAMERA_MASTER | PXA_CAMERA_DATAWIDTH_8 |
1014                 PXA_CAMERA_PCLK_EN | PXA_CAMERA_MCLK_EN,
1015         .mclk_10khz = 5000,
1016 };
1017
1018 static struct i2c_board_info a910_camera_i2c_board_info = {
1019         I2C_BOARD_INFO("mt9m111", 0x5d),
1020 };
1021
1022 static struct soc_camera_link a910_iclink = {
1023         .bus_id         = 0,
1024         .i2c_adapter_id = 0,
1025         .board_info     = &a910_camera_i2c_board_info,
1026         .power          = a910_camera_power,
1027         .reset          = a910_camera_reset,
1028 };
1029
1030 static struct platform_device a910_camera = {
1031         .name   = "soc-camera-pdrv",
1032         .id     = 0,
1033         .dev    = {
1034                 .platform_data = &a910_iclink,
1035         },
1036 };
1037
1038 /* leds-lp3944 */
1039 static struct lp3944_platform_data a910_lp3944_leds = {
1040         .leds_size = LP3944_LEDS_MAX,
1041         .leds = {
1042                 [0] = {
1043                         .name = "a910:red:",
1044                         .status = LP3944_LED_STATUS_OFF,
1045                         .type = LP3944_LED_TYPE_LED,
1046                 },
1047                 [1] = {
1048                         .name = "a910:green:",
1049                         .status = LP3944_LED_STATUS_OFF,
1050                         .type = LP3944_LED_TYPE_LED,
1051                 },
1052                 [2] {
1053                         .name = "a910:blue:",
1054                         .status = LP3944_LED_STATUS_OFF,
1055                         .type = LP3944_LED_TYPE_LED,
1056                 },
1057                 /* Leds 3 and 4 are used as display power switches */
1058                 [3] = {
1059                         .name = "a910::cli_display",
1060                         .status = LP3944_LED_STATUS_OFF,
1061                         .type = LP3944_LED_TYPE_LED_INVERTED
1062                 },
1063                 [4] = {
1064                         .name = "a910::main_display",
1065                         .status = LP3944_LED_STATUS_ON,
1066                         .type = LP3944_LED_TYPE_LED_INVERTED
1067                 },
1068                 [5] = { .type = LP3944_LED_TYPE_NONE },
1069                 [6] = {
1070                         .name = "a910::torch",
1071                         .status = LP3944_LED_STATUS_OFF,
1072                         .type = LP3944_LED_TYPE_LED,
1073                 },
1074                 [7] = {
1075                         .name = "a910::flash",
1076                         .status = LP3944_LED_STATUS_OFF,
1077                         .type = LP3944_LED_TYPE_LED_INVERTED,
1078                 },
1079         },
1080 };
1081
1082 static struct i2c_board_info __initdata a910_i2c_board_info[] = {
1083         {
1084                 I2C_BOARD_INFO("lp3944", 0x60),
1085                 .platform_data = &a910_lp3944_leds,
1086         },
1087 };
1088
1089 static struct platform_device *a910_devices[] __initdata = {
1090         &a910_gpio_keys,
1091 };
1092
1093 static void __init a910_init(void)
1094 {
1095         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
1096         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen2_pin_config));
1097         pxa2xx_mfp_config(ARRAY_AND_SIZE(a910_pin_config));
1098
1099         pxa_set_ffuart_info(NULL);
1100         pxa_set_btuart_info(NULL);
1101         pxa_set_stuart_info(NULL);
1102
1103         pxa_set_i2c_info(NULL);
1104         i2c_register_board_info(0, ARRAY_AND_SIZE(a910_i2c_board_info));
1105
1106         set_pxa_fb_info(&ezx_fb_info_2);
1107
1108         pxa_set_keypad_info(&a910_keypad_platform_data);
1109
1110         if (a910_camera_init() == 0) {
1111                 pxa_set_camera_info(&a910_pxacamera_platform_data);
1112                 platform_device_register(&a910_camera);
1113         }
1114
1115         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
1116         platform_add_devices(ARRAY_AND_SIZE(a910_devices));
1117 }
1118
1119 MACHINE_START(EZX_A910, "Motorola EZX A910")
1120         .boot_params    = 0xa0000100,
1121         .map_io         = pxa27x_map_io,
1122         .nr_irqs        = EZX_NR_IRQS,
1123         .init_irq       = pxa27x_init_irq,
1124         .timer          = &pxa_timer,
1125         .init_machine   = a910_init,
1126 MACHINE_END
1127 #endif
1128
1129 #ifdef CONFIG_MACH_EZX_E6
1130 /* gpio_keys */
1131 static struct gpio_keys_button e6_buttons[] = {
1132         [0] = {
1133                 .code       = KEY_SCREENLOCK,
1134                 .gpio       = GPIO15_E6_LOCK_SWITCH,
1135                 .active_low = 0,
1136                 .desc       = "E6 lock switch",
1137                 .type       = EV_KEY,
1138                 .wakeup     = 1,
1139         },
1140 };
1141
1142 static struct gpio_keys_platform_data e6_gpio_keys_platform_data = {
1143         .buttons  = e6_buttons,
1144         .nbuttons = ARRAY_SIZE(e6_buttons),
1145 };
1146
1147 static struct platform_device e6_gpio_keys = {
1148         .name = "gpio-keys",
1149         .id   = -1,
1150         .dev  = {
1151                 .platform_data = &e6_gpio_keys_platform_data,
1152         },
1153 };
1154
1155 static struct i2c_board_info __initdata e6_i2c_board_info[] = {
1156         { I2C_BOARD_INFO("tea5767", 0x81) },
1157 };
1158
1159 static struct platform_device *e6_devices[] __initdata = {
1160         &e6_gpio_keys,
1161 };
1162
1163 static void __init e6_init(void)
1164 {
1165         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
1166         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen2_pin_config));
1167         pxa2xx_mfp_config(ARRAY_AND_SIZE(e6_pin_config));
1168
1169         pxa_set_ffuart_info(NULL);
1170         pxa_set_btuart_info(NULL);
1171         pxa_set_stuart_info(NULL);
1172
1173         pxa_set_i2c_info(NULL);
1174         i2c_register_board_info(0, ARRAY_AND_SIZE(e6_i2c_board_info));
1175
1176         set_pxa_fb_info(&ezx_fb_info_2);
1177
1178         pxa_set_keypad_info(&e6_keypad_platform_data);
1179
1180         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
1181         platform_add_devices(ARRAY_AND_SIZE(e6_devices));
1182 }
1183
1184 MACHINE_START(EZX_E6, "Motorola EZX E6")
1185         .boot_params    = 0xa0000100,
1186         .map_io         = pxa27x_map_io,
1187         .nr_irqs        = EZX_NR_IRQS,
1188         .init_irq       = pxa27x_init_irq,
1189         .timer          = &pxa_timer,
1190         .init_machine   = e6_init,
1191 MACHINE_END
1192 #endif
1193
1194 #ifdef CONFIG_MACH_EZX_E2
1195 static struct i2c_board_info __initdata e2_i2c_board_info[] = {
1196         { I2C_BOARD_INFO("tea5767", 0x81) },
1197 };
1198
1199 static struct platform_device *e2_devices[] __initdata = {
1200 };
1201
1202 static void __init e2_init(void)
1203 {
1204         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
1205         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen2_pin_config));
1206         pxa2xx_mfp_config(ARRAY_AND_SIZE(e2_pin_config));
1207
1208         pxa_set_ffuart_info(NULL);
1209         pxa_set_btuart_info(NULL);
1210         pxa_set_stuart_info(NULL);
1211
1212         pxa_set_i2c_info(NULL);
1213         i2c_register_board_info(0, ARRAY_AND_SIZE(e2_i2c_board_info));
1214
1215         set_pxa_fb_info(&ezx_fb_info_2);
1216
1217         pxa_set_keypad_info(&e2_keypad_platform_data);
1218
1219         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
1220         platform_add_devices(ARRAY_AND_SIZE(e2_devices));
1221 }
1222
1223 MACHINE_START(EZX_E2, "Motorola EZX E2")
1224         .boot_params    = 0xa0000100,
1225         .map_io         = pxa27x_map_io,
1226         .nr_irqs        = EZX_NR_IRQS,
1227         .init_irq       = pxa27x_init_irq,
1228         .timer          = &pxa_timer,
1229         .init_machine   = e2_init,
1230 MACHINE_END
1231 #endif