arch/arm/mach-pxa/ezx.c

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