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 <linux/platform_data/keypad-pxa27x.h>
  33 #include <linux/platform_data/media/camera-pxa.h>
  34
  35 #include "devices.h"
  36 #include "generic.h"
  37
  38 #define EZX_NR_IRQS                     (IRQ_BOARD_START + 24)
  39
  40 #define GPIO12_A780_FLIP_LID            12
  41 #define GPIO15_A1200_FLIP_LID           15
  42 #define GPIO15_A910_FLIP_LID            15
  43 #define GPIO12_E680_LOCK_SWITCH         12
  44 #define GPIO15_E6_LOCK_SWITCH           15
  45 #define GPIO50_nCAM_EN                  50
  46 #define GPIO19_GEN1_CAM_RST             19
  47 #define GPIO28_GEN2_CAM_RST             28
  48
  49 static struct pwm_lookup ezx_pwm_lookup[] __maybe_unused = {
  50         PWM_LOOKUP("pxa27x-pwm.0", 0, "pwm-backlight.0", NULL, 78700,
  51                    PWM_POLARITY_NORMAL),
  52 };
  53
  54 static struct platform_pwm_backlight_data ezx_backlight_data = {
  55         .max_brightness = 1023,
  56         .dft_brightness = 1023,
  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 __maybe_unused = {
  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 __maybe_unused = {
 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 __maybe_unused = {
 109         &ezx_backlight_device,
 110 };
 111
 112 static unsigned long ezx_pin_config[] __initdata __maybe_unused = {
 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 const 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 matrix_keymap_data a780_matrix_keymap_data = {
 428         .keymap                 = a780_key_map,
 429         .keymap_size            = ARRAY_SIZE(a780_key_map),
 430 };
 431
 432 static struct pxa27x_keypad_platform_data a780_keypad_platform_data = {
 433         .matrix_key_rows = 5,
 434         .matrix_key_cols = 5,
 435         .matrix_keymap_data = &a780_matrix_keymap_data,
 436
 437         .direct_key_map = { KEY_CAMERA },
 438         .direct_key_num = 1,
 439
 440         .debounce_interval = 30,
 441 };
 442 #endif /* CONFIG_MACH_EZX_A780 */
 443
 444 #ifdef CONFIG_MACH_EZX_E680
 445 static const unsigned int e680_key_map[] = {
 446         KEY(0, 0, KEY_UP),
 447         KEY(0, 1, KEY_RIGHT),
 448         KEY(0, 2, KEY_RESERVED),
 449         KEY(0, 3, KEY_SEND),
 450
 451         KEY(1, 0, KEY_DOWN),
 452         KEY(1, 1, KEY_LEFT),
 453         KEY(1, 2, KEY_PAGEUP),
 454         KEY(1, 3, KEY_PAGEDOWN),
 455
 456         KEY(2, 0, KEY_RESERVED),
 457         KEY(2, 1, KEY_RESERVED),
 458         KEY(2, 2, KEY_RESERVED),
 459         KEY(2, 3, KEY_KPENTER),
 460 };
 461
 462 static struct matrix_keymap_data e680_matrix_keymap_data = {
 463         .keymap                 = e680_key_map,
 464         .keymap_size            = ARRAY_SIZE(e680_key_map),
 465 };
 466
 467 static struct pxa27x_keypad_platform_data e680_keypad_platform_data = {
 468         .matrix_key_rows = 3,
 469         .matrix_key_cols = 4,
 470         .matrix_keymap_data = &e680_matrix_keymap_data,
 471
 472         .direct_key_map = {
 473                 KEY_CAMERA,
 474                 KEY_RESERVED,
 475                 KEY_RESERVED,
 476                 KEY_F1,
 477                 KEY_CANCEL,
 478                 KEY_F2,
 479         },
 480         .direct_key_num = 6,
 481
 482         .debounce_interval = 30,
 483 };
 484 #endif /* CONFIG_MACH_EZX_E680 */
 485
 486 #ifdef CONFIG_MACH_EZX_A1200
 487 static const unsigned int a1200_key_map[] = {
 488         KEY(0, 0, KEY_RESERVED),
 489         KEY(0, 1, KEY_RIGHT),
 490         KEY(0, 2, KEY_PAGEDOWN),
 491         KEY(0, 3, KEY_RESERVED),
 492         KEY(0, 4, KEY_RESERVED),
 493         KEY(0, 5, KEY_RESERVED),
 494
 495         KEY(1, 0, KEY_RESERVED),
 496         KEY(1, 1, KEY_DOWN),
 497         KEY(1, 2, KEY_CAMERA),
 498         KEY(1, 3, KEY_RESERVED),
 499         KEY(1, 4, KEY_RESERVED),
 500         KEY(1, 5, KEY_RESERVED),
 501
 502         KEY(2, 0, KEY_RESERVED),
 503         KEY(2, 1, KEY_KPENTER),
 504         KEY(2, 2, KEY_RECORD),
 505         KEY(2, 3, KEY_RESERVED),
 506         KEY(2, 4, KEY_RESERVED),
 507         KEY(2, 5, KEY_SELECT),
 508
 509         KEY(3, 0, KEY_RESERVED),
 510         KEY(3, 1, KEY_UP),
 511         KEY(3, 2, KEY_SEND),
 512         KEY(3, 3, KEY_RESERVED),
 513         KEY(3, 4, KEY_RESERVED),
 514         KEY(3, 5, KEY_RESERVED),
 515
 516         KEY(4, 0, KEY_RESERVED),
 517         KEY(4, 1, KEY_LEFT),
 518         KEY(4, 2, KEY_PAGEUP),
 519         KEY(4, 3, KEY_RESERVED),
 520         KEY(4, 4, KEY_RESERVED),
 521         KEY(4, 5, KEY_RESERVED),
 522 };
 523
 524 static struct matrix_keymap_data a1200_matrix_keymap_data = {
 525         .keymap                 = a1200_key_map,
 526         .keymap_size            = ARRAY_SIZE(a1200_key_map),
 527 };
 528
 529 static struct pxa27x_keypad_platform_data a1200_keypad_platform_data = {
 530         .matrix_key_rows = 5,
 531         .matrix_key_cols = 6,
 532         .matrix_keymap_data = &a1200_matrix_keymap_data,
 533
 534         .debounce_interval = 30,
 535 };
 536 #endif /* CONFIG_MACH_EZX_A1200 */
 537
 538 #ifdef CONFIG_MACH_EZX_E6
 539 static const unsigned int e6_key_map[] = {
 540         KEY(0, 0, KEY_RESERVED),
 541         KEY(0, 1, KEY_RIGHT),
 542         KEY(0, 2, KEY_PAGEDOWN),
 543         KEY(0, 3, KEY_RESERVED),
 544         KEY(0, 4, KEY_RESERVED),
 545         KEY(0, 5, KEY_NEXTSONG),
 546
 547         KEY(1, 0, KEY_RESERVED),
 548         KEY(1, 1, KEY_DOWN),
 549         KEY(1, 2, KEY_PROG1),
 550         KEY(1, 3, KEY_RESERVED),
 551         KEY(1, 4, KEY_RESERVED),
 552         KEY(1, 5, KEY_RESERVED),
 553
 554         KEY(2, 0, KEY_RESERVED),
 555         KEY(2, 1, KEY_ENTER),
 556         KEY(2, 2, KEY_CAMERA),
 557         KEY(2, 3, KEY_RESERVED),
 558         KEY(2, 4, KEY_RESERVED),
 559         KEY(2, 5, KEY_WWW),
 560
 561         KEY(3, 0, KEY_RESERVED),
 562         KEY(3, 1, KEY_UP),
 563         KEY(3, 2, KEY_SEND),
 564         KEY(3, 3, KEY_RESERVED),
 565         KEY(3, 4, KEY_RESERVED),
 566         KEY(3, 5, KEY_PLAYPAUSE),
 567
 568         KEY(4, 0, KEY_RESERVED),
 569         KEY(4, 1, KEY_LEFT),
 570         KEY(4, 2, KEY_PAGEUP),
 571         KEY(4, 3, KEY_RESERVED),
 572         KEY(4, 4, KEY_RESERVED),
 573         KEY(4, 5, KEY_PREVIOUSSONG),
 574 };
 575
 576 static struct matrix_keymap_data e6_keymap_data = {
 577         .keymap                 = e6_key_map,
 578         .keymap_size            = ARRAY_SIZE(e6_key_map),
 579 };
 580
 581 static struct pxa27x_keypad_platform_data e6_keypad_platform_data = {
 582         .matrix_key_rows = 5,
 583         .matrix_key_cols = 6,
 584         .matrix_keymap_data = &e6_keymap_data,
 585
 586         .debounce_interval = 30,
 587 };
 588 #endif /* CONFIG_MACH_EZX_E6 */
 589
 590 #ifdef CONFIG_MACH_EZX_A910
 591 static const unsigned int a910_key_map[] = {
 592         KEY(0, 0, KEY_NUMERIC_6),
 593         KEY(0, 1, KEY_RIGHT),
 594         KEY(0, 2, KEY_PAGEDOWN),
 595         KEY(0, 3, KEY_KPENTER),
 596         KEY(0, 4, KEY_NUMERIC_5),
 597         KEY(0, 5, KEY_CAMERA),
 598
 599         KEY(1, 0, KEY_NUMERIC_8),
 600         KEY(1, 1, KEY_DOWN),
 601         KEY(1, 2, KEY_RESERVED),
 602         KEY(1, 3, KEY_F1), /* Left SoftKey */
 603         KEY(1, 4, KEY_NUMERIC_STAR),
 604         KEY(1, 5, KEY_RESERVED),
 605
 606         KEY(2, 0, KEY_NUMERIC_7),
 607         KEY(2, 1, KEY_NUMERIC_9),
 608         KEY(2, 2, KEY_RECORD),
 609         KEY(2, 3, KEY_F2), /* Right SoftKey */
 610         KEY(2, 4, KEY_BACK),
 611         KEY(2, 5, KEY_SELECT),
 612
 613         KEY(3, 0, KEY_NUMERIC_2),
 614         KEY(3, 1, KEY_UP),
 615         KEY(3, 2, KEY_SEND),
 616         KEY(3, 3, KEY_NUMERIC_0),
 617         KEY(3, 4, KEY_NUMERIC_1),
 618         KEY(3, 5, KEY_RECORD),
 619
 620         KEY(4, 0, KEY_NUMERIC_4),
 621         KEY(4, 1, KEY_LEFT),
 622         KEY(4, 2, KEY_PAGEUP),
 623         KEY(4, 3, KEY_NUMERIC_POUND),
 624         KEY(4, 4, KEY_NUMERIC_3),
 625         KEY(4, 5, KEY_RESERVED),
 626 };
 627
 628 static struct matrix_keymap_data a910_matrix_keymap_data = {
 629         .keymap                 = a910_key_map,
 630         .keymap_size            = ARRAY_SIZE(a910_key_map),
 631 };
 632
 633 static struct pxa27x_keypad_platform_data a910_keypad_platform_data = {
 634         .matrix_key_rows = 5,
 635         .matrix_key_cols = 6,
 636         .matrix_keymap_data = &a910_matrix_keymap_data,
 637
 638         .debounce_interval = 30,
 639 };
 640 #endif /* CONFIG_MACH_EZX_A910 */
 641
 642 #ifdef CONFIG_MACH_EZX_E2
 643 static const unsigned int e2_key_map[] = {
 644         KEY(0, 0, KEY_NUMERIC_6),
 645         KEY(0, 1, KEY_RIGHT),
 646         KEY(0, 2, KEY_NUMERIC_9),
 647         KEY(0, 3, KEY_NEXTSONG),
 648         KEY(0, 4, KEY_NUMERIC_5),
 649         KEY(0, 5, KEY_F1), /* Left SoftKey */
 650
 651         KEY(1, 0, KEY_NUMERIC_8),
 652         KEY(1, 1, KEY_DOWN),
 653         KEY(1, 2, KEY_RESERVED),
 654         KEY(1, 3, KEY_PAGEUP),
 655         KEY(1, 4, KEY_NUMERIC_STAR),
 656         KEY(1, 5, KEY_F2), /* Right SoftKey */
 657
 658         KEY(2, 0, KEY_NUMERIC_7),
 659         KEY(2, 1, KEY_KPENTER),
 660         KEY(2, 2, KEY_RECORD),
 661         KEY(2, 3, KEY_PAGEDOWN),
 662         KEY(2, 4, KEY_BACK),
 663         KEY(2, 5, KEY_NUMERIC_0),
 664
 665         KEY(3, 0, KEY_NUMERIC_2),
 666         KEY(3, 1, KEY_UP),
 667         KEY(3, 2, KEY_SEND),
 668         KEY(3, 3, KEY_PLAYPAUSE),
 669         KEY(3, 4, KEY_NUMERIC_1),
 670         KEY(3, 5, KEY_SOUND), /* Music SoftKey */
 671
 672         KEY(4, 0, KEY_NUMERIC_4),
 673         KEY(4, 1, KEY_LEFT),
 674         KEY(4, 2, KEY_NUMERIC_POUND),
 675         KEY(4, 3, KEY_PREVIOUSSONG),
 676         KEY(4, 4, KEY_NUMERIC_3),
 677         KEY(4, 5, KEY_RESERVED),
 678 };
 679
 680 static struct matrix_keymap_data e2_matrix_keymap_data = {
 681         .keymap                 = e2_key_map,
 682         .keymap_size            = ARRAY_SIZE(e2_key_map),
 683 };
 684
 685 static struct pxa27x_keypad_platform_data e2_keypad_platform_data = {
 686         .matrix_key_rows = 5,
 687         .matrix_key_cols = 6,
 688         .matrix_keymap_data = &e2_matrix_keymap_data,
 689
 690         .debounce_interval = 30,
 691 };
 692 #endif /* CONFIG_MACH_EZX_E2 */
 693
 694 #if defined(CONFIG_MACH_EZX_A780) || defined(CONFIG_MACH_EZX_A910)
 695 /* camera */
 696 static struct regulator_consumer_supply camera_regulator_supplies[] = {
 697         REGULATOR_SUPPLY("vdd", "0-005d"),
 698 };
 699
 700 static struct regulator_init_data camera_regulator_initdata = {
 701         .consumer_supplies = camera_regulator_supplies,
 702         .num_consumer_supplies = ARRAY_SIZE(camera_regulator_supplies),
 703         .constraints = {
 704                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 705         },
 706 };
 707
 708 static struct fixed_voltage_config camera_regulator_config = {
 709         .supply_name            = "camera_vdd",
 710         .microvolts             = 2800000,
 711         .init_data              = &camera_regulator_initdata,
 712 };
 713
 714 static struct platform_device camera_supply_regulator_device = {
 715         .name   = "reg-fixed-voltage",
 716         .id     = 1,
 717         .dev    = {
 718                 .platform_data = &camera_regulator_config,
 719         },
 720 };
 721
 722 static struct gpiod_lookup_table camera_supply_gpiod_table = {
 723         .dev_id = "reg-fixed-voltage.1",
 724         .table = {
 725                 GPIO_LOOKUP("gpio-pxa", GPIO50_nCAM_EN,
 726                             NULL, GPIO_ACTIVE_LOW),
 727                 { },
 728         },
 729 };
 730 #endif
 731
 732 #ifdef CONFIG_MACH_EZX_A780
 733 /* gpio_keys */
 734 static struct gpio_keys_button a780_buttons[] = {
 735         [0] = {
 736                 .code       = SW_LID,
 737                 .gpio       = GPIO12_A780_FLIP_LID,
 738                 .active_low = 0,
 739                 .desc       = "A780 flip lid",
 740                 .type       = EV_SW,
 741                 .wakeup     = 1,
 742         },
 743 };
 744
 745 static struct gpio_keys_platform_data a780_gpio_keys_platform_data = {
 746         .buttons  = a780_buttons,
 747         .nbuttons = ARRAY_SIZE(a780_buttons),
 748 };
 749
 750 static struct platform_device a780_gpio_keys = {
 751         .name = "gpio-keys",
 752         .id   = -1,
 753         .dev  = {
 754                 .platform_data = &a780_gpio_keys_platform_data,
 755         },
 756 };
 757
 758 /* camera */
 759 static int a780_camera_reset(struct device *dev)
 760 {
 761         gpio_set_value(GPIO19_GEN1_CAM_RST, 0);
 762         msleep(10);
 763         gpio_set_value(GPIO19_GEN1_CAM_RST, 1);
 764
 765         return 0;
 766 }
 767
 768 static int a780_camera_init(void)
 769 {
 770         int err;
 771
 772         /*
 773          * GPIO50_nCAM_EN is active low
 774          * GPIO19_GEN1_CAM_RST is active on rising edge
 775          */
 776         err = gpio_request(GPIO19_GEN1_CAM_RST, "CAM_RST");
 777         if (err) {
 778                 pr_err("%s: Failed to request CAM_RST\n", __func__);
 779                 return err;
 780         }
 781
 782         gpio_direction_output(GPIO19_GEN1_CAM_RST, 0);
 783         a780_camera_reset(NULL);
 784
 785         return 0;
 786 }
 787
 788 struct pxacamera_platform_data a780_pxacamera_platform_data = {
 789         .flags  = PXA_CAMERA_MASTER | PXA_CAMERA_DATAWIDTH_8 |
 790                 PXA_CAMERA_PCLK_EN | PXA_CAMERA_MCLK_EN |
 791                 PXA_CAMERA_PCP,
 792         .mclk_10khz = 5000,
 793         .sensor_i2c_adapter_id = 0,
 794         .sensor_i2c_address = 0x5d,
 795 };
 796
 797 static struct i2c_board_info a780_i2c_board_info[] = {
 798         {
 799                 I2C_BOARD_INFO("mt9m111", 0x5d),
 800         },
 801 };
 802
 803 static struct platform_device *a780_devices[] __initdata = {
 804         &a780_gpio_keys,
 805         &camera_supply_regulator_device,
 806 };
 807
 808 static void __init a780_init(void)
 809 {
 810         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
 811         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen1_pin_config));
 812         pxa2xx_mfp_config(ARRAY_AND_SIZE(a780_pin_config));
 813
 814         pxa_set_ffuart_info(NULL);
 815         pxa_set_btuart_info(NULL);
 816         pxa_set_stuart_info(NULL);
 817
 818         pxa_set_i2c_info(NULL);
 819         i2c_register_board_info(0, ARRAY_AND_SIZE(a780_i2c_board_info));
 820
 821         pxa_set_fb_info(NULL, &ezx_fb_info_1);
 822
 823         pxa_set_keypad_info(&a780_keypad_platform_data);
 824
 825         if (a780_camera_init() == 0)
 826                 pxa_set_camera_info(&a780_pxacamera_platform_data);
 827
 828         gpiod_add_lookup_table(&camera_supply_gpiod_table);
 829         pwm_add_table(ezx_pwm_lookup, ARRAY_SIZE(ezx_pwm_lookup));
 830         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
 831         platform_add_devices(ARRAY_AND_SIZE(a780_devices));
 832         regulator_has_full_constraints();
 833 }
 834
 835 MACHINE_START(EZX_A780, "Motorola EZX A780")
 836         .atag_offset    = 0x100,
 837         .map_io         = pxa27x_map_io,
 838         .nr_irqs        = EZX_NR_IRQS,
 839         .init_irq       = pxa27x_init_irq,
 840         .handle_irq       = pxa27x_handle_irq,
 841         .init_time      = pxa_timer_init,
 842         .init_machine   = a780_init,
 843         .restart        = pxa_restart,
 844 MACHINE_END
 845 #endif
 846
 847 #ifdef CONFIG_MACH_EZX_E680
 848 /* gpio_keys */
 849 static struct gpio_keys_button e680_buttons[] = {
 850         [0] = {
 851                 .code       = KEY_SCREENLOCK,
 852                 .gpio       = GPIO12_E680_LOCK_SWITCH,
 853                 .active_low = 0,
 854                 .desc       = "E680 lock switch",
 855                 .type       = EV_KEY,
 856                 .wakeup     = 1,
 857         },
 858 };
 859
 860 static struct gpio_keys_platform_data e680_gpio_keys_platform_data = {
 861         .buttons  = e680_buttons,
 862         .nbuttons = ARRAY_SIZE(e680_buttons),
 863 };
 864
 865 static struct platform_device e680_gpio_keys = {
 866         .name = "gpio-keys",
 867         .id   = -1,
 868         .dev  = {
 869                 .platform_data = &e680_gpio_keys_platform_data,
 870         },
 871 };
 872
 873 static struct i2c_board_info __initdata e680_i2c_board_info[] = {
 874         { I2C_BOARD_INFO("tea5767", 0x81) },
 875 };
 876
 877 static struct platform_device *e680_devices[] __initdata = {
 878         &e680_gpio_keys,
 879 };
 880
 881 static void __init e680_init(void)
 882 {
 883         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
 884         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen1_pin_config));
 885         pxa2xx_mfp_config(ARRAY_AND_SIZE(e680_pin_config));
 886
 887         pxa_set_ffuart_info(NULL);
 888         pxa_set_btuart_info(NULL);
 889         pxa_set_stuart_info(NULL);
 890
 891         pxa_set_i2c_info(NULL);
 892         i2c_register_board_info(0, ARRAY_AND_SIZE(e680_i2c_board_info));
 893
 894         pxa_set_fb_info(NULL, &ezx_fb_info_1);
 895
 896         pxa_set_keypad_info(&e680_keypad_platform_data);
 897
 898         pwm_add_table(ezx_pwm_lookup, ARRAY_SIZE(ezx_pwm_lookup));
 899         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
 900         platform_add_devices(ARRAY_AND_SIZE(e680_devices));
 901 }
 902
 903 MACHINE_START(EZX_E680, "Motorola EZX E680")
 904         .atag_offset    = 0x100,
 905         .map_io         = pxa27x_map_io,
 906         .nr_irqs        = EZX_NR_IRQS,
 907         .init_irq       = pxa27x_init_irq,
 908         .handle_irq       = pxa27x_handle_irq,
 909         .init_time      = pxa_timer_init,
 910         .init_machine   = e680_init,
 911         .restart        = pxa_restart,
 912 MACHINE_END
 913 #endif
 914
 915 #ifdef CONFIG_MACH_EZX_A1200
 916 /* gpio_keys */
 917 static struct gpio_keys_button a1200_buttons[] = {
 918         [0] = {
 919                 .code       = SW_LID,
 920                 .gpio       = GPIO15_A1200_FLIP_LID,
 921                 .active_low = 0,
 922                 .desc       = "A1200 flip lid",
 923                 .type       = EV_SW,
 924                 .wakeup     = 1,
 925         },
 926 };
 927
 928 static struct gpio_keys_platform_data a1200_gpio_keys_platform_data = {
 929         .buttons  = a1200_buttons,
 930         .nbuttons = ARRAY_SIZE(a1200_buttons),
 931 };
 932
 933 static struct platform_device a1200_gpio_keys = {
 934         .name = "gpio-keys",
 935         .id   = -1,
 936         .dev  = {
 937                 .platform_data = &a1200_gpio_keys_platform_data,
 938         },
 939 };
 940
 941 static struct i2c_board_info __initdata a1200_i2c_board_info[] = {
 942         { I2C_BOARD_INFO("tea5767", 0x81) },
 943 };
 944
 945 static struct platform_device *a1200_devices[] __initdata = {
 946         &a1200_gpio_keys,
 947 };
 948
 949 static void __init a1200_init(void)
 950 {
 951         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
 952         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen2_pin_config));
 953         pxa2xx_mfp_config(ARRAY_AND_SIZE(a1200_pin_config));
 954
 955         pxa_set_ffuart_info(NULL);
 956         pxa_set_btuart_info(NULL);
 957         pxa_set_stuart_info(NULL);
 958
 959         pxa_set_i2c_info(NULL);
 960         i2c_register_board_info(0, ARRAY_AND_SIZE(a1200_i2c_board_info));
 961
 962         pxa_set_fb_info(NULL, &ezx_fb_info_2);
 963
 964         pxa_set_keypad_info(&a1200_keypad_platform_data);
 965
 966         pwm_add_table(ezx_pwm_lookup, ARRAY_SIZE(ezx_pwm_lookup));
 967         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
 968         platform_add_devices(ARRAY_AND_SIZE(a1200_devices));
 969 }
 970
 971 MACHINE_START(EZX_A1200, "Motorola EZX A1200")
 972         .atag_offset    = 0x100,
 973         .map_io         = pxa27x_map_io,
 974         .nr_irqs        = EZX_NR_IRQS,
 975         .init_irq       = pxa27x_init_irq,
 976         .handle_irq       = pxa27x_handle_irq,
 977         .init_time      = pxa_timer_init,
 978         .init_machine   = a1200_init,
 979         .restart        = pxa_restart,
 980 MACHINE_END
 981 #endif
 982
 983 #ifdef CONFIG_MACH_EZX_A910
 984 /* gpio_keys */
 985 static struct gpio_keys_button a910_buttons[] = {
 986         [0] = {
 987                 .code       = SW_LID,
 988                 .gpio       = GPIO15_A910_FLIP_LID,
 989                 .active_low = 0,
 990                 .desc       = "A910 flip lid",
 991                 .type       = EV_SW,
 992                 .wakeup     = 1,
 993         },
 994 };
 995
 996 static struct gpio_keys_platform_data a910_gpio_keys_platform_data = {
 997         .buttons  = a910_buttons,
 998         .nbuttons = ARRAY_SIZE(a910_buttons),
 999 };
1000
1001 static struct platform_device a910_gpio_keys = {
1002         .name = "gpio-keys",
1003         .id   = -1,
1004         .dev  = {
1005                 .platform_data = &a910_gpio_keys_platform_data,
1006         },
1007 };
1008
1009 /* camera */
1010 static int a910_camera_reset(struct device *dev)
1011 {
1012         gpio_set_value(GPIO28_GEN2_CAM_RST, 0);
1013         msleep(10);
1014         gpio_set_value(GPIO28_GEN2_CAM_RST, 1);
1015
1016         return 0;
1017 }
1018
1019 static int a910_camera_init(void)
1020 {
1021         int err;
1022
1023         /*
1024          * GPIO50_nCAM_EN is active low
1025          * GPIO28_GEN2_CAM_RST is active on rising edge
1026          */
1027         err = gpio_request(GPIO28_GEN2_CAM_RST, "CAM_RST");
1028         if (err) {
1029                 pr_err("%s: Failed to request CAM_RST\n", __func__);
1030                 return err;
1031         }
1032
1033         gpio_direction_output(GPIO28_GEN2_CAM_RST, 0);
1034         a910_camera_reset(NULL);
1035
1036         return 0;
1037 }
1038
1039 struct pxacamera_platform_data a910_pxacamera_platform_data = {
1040         .flags  = PXA_CAMERA_MASTER | PXA_CAMERA_DATAWIDTH_8 |
1041                 PXA_CAMERA_PCLK_EN | PXA_CAMERA_MCLK_EN |
1042                 PXA_CAMERA_PCP,
1043         .mclk_10khz = 5000,
1044         .sensor_i2c_adapter_id = 0,
1045         .sensor_i2c_address = 0x5d,
1046 };
1047
1048 /* leds-lp3944 */
1049 static struct lp3944_platform_data a910_lp3944_leds = {
1050         .leds_size = LP3944_LEDS_MAX,
1051         .leds = {
1052                 [0] = {
1053                         .name = "a910:red:",
1054                         .status = LP3944_LED_STATUS_OFF,
1055                         .type = LP3944_LED_TYPE_LED,
1056                 },
1057                 [1] = {
1058                         .name = "a910:green:",
1059                         .status = LP3944_LED_STATUS_OFF,
1060                         .type = LP3944_LED_TYPE_LED,
1061                 },
1062                 [2] {
1063                         .name = "a910:blue:",
1064                         .status = LP3944_LED_STATUS_OFF,
1065                         .type = LP3944_LED_TYPE_LED,
1066                 },
1067                 /* Leds 3 and 4 are used as display power switches */
1068                 [3] = {
1069                         .name = "a910::cli_display",
1070                         .status = LP3944_LED_STATUS_OFF,
1071                         .type = LP3944_LED_TYPE_LED_INVERTED
1072                 },
1073                 [4] = {
1074                         .name = "a910::main_display",
1075                         .status = LP3944_LED_STATUS_ON,
1076                         .type = LP3944_LED_TYPE_LED_INVERTED
1077                 },
1078                 [5] = { .type = LP3944_LED_TYPE_NONE },
1079                 [6] = {
1080                         .name = "a910::torch",
1081                         .status = LP3944_LED_STATUS_OFF,
1082                         .type = LP3944_LED_TYPE_LED,
1083                 },
1084                 [7] = {
1085                         .name = "a910::flash",
1086                         .status = LP3944_LED_STATUS_OFF,
1087                         .type = LP3944_LED_TYPE_LED_INVERTED,
1088                 },
1089         },
1090 };
1091
1092 static struct i2c_board_info __initdata a910_i2c_board_info[] = {
1093         {
1094                 I2C_BOARD_INFO("lp3944", 0x60),
1095                 .platform_data = &a910_lp3944_leds,
1096         },
1097         {
1098                 I2C_BOARD_INFO("mt9m111", 0x5d),
1099         },
1100 };
1101
1102 static struct platform_device *a910_devices[] __initdata = {
1103         &a910_gpio_keys,
1104         &camera_supply_regulator_device,
1105 };
1106
1107 static void __init a910_init(void)
1108 {
1109         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
1110         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen2_pin_config));
1111         pxa2xx_mfp_config(ARRAY_AND_SIZE(a910_pin_config));
1112
1113         pxa_set_ffuart_info(NULL);
1114         pxa_set_btuart_info(NULL);
1115         pxa_set_stuart_info(NULL);
1116
1117         pxa_set_i2c_info(NULL);
1118         i2c_register_board_info(0, ARRAY_AND_SIZE(a910_i2c_board_info));
1119
1120         pxa_set_fb_info(NULL, &ezx_fb_info_2);
1121
1122         pxa_set_keypad_info(&a910_keypad_platform_data);
1123
1124         if (a910_camera_init() == 0)
1125                 pxa_set_camera_info(&a910_pxacamera_platform_data);
1126
1127         gpiod_add_lookup_table(&camera_supply_gpiod_table);
1128         pwm_add_table(ezx_pwm_lookup, ARRAY_SIZE(ezx_pwm_lookup));
1129         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
1130         platform_add_devices(ARRAY_AND_SIZE(a910_devices));
1131         regulator_has_full_constraints();
1132 }
1133
1134 MACHINE_START(EZX_A910, "Motorola EZX A910")
1135         .atag_offset    = 0x100,
1136         .map_io         = pxa27x_map_io,
1137         .nr_irqs        = EZX_NR_IRQS,
1138         .init_irq       = pxa27x_init_irq,
1139         .handle_irq       = pxa27x_handle_irq,
1140         .init_time      = pxa_timer_init,
1141         .init_machine   = a910_init,
1142         .restart        = pxa_restart,
1143 MACHINE_END
1144 #endif
1145
1146 #ifdef CONFIG_MACH_EZX_E6
1147 /* gpio_keys */
1148 static struct gpio_keys_button e6_buttons[] = {
1149         [0] = {
1150                 .code       = KEY_SCREENLOCK,
1151                 .gpio       = GPIO15_E6_LOCK_SWITCH,
1152                 .active_low = 0,
1153                 .desc       = "E6 lock switch",
1154                 .type       = EV_KEY,
1155                 .wakeup     = 1,
1156         },
1157 };
1158
1159 static struct gpio_keys_platform_data e6_gpio_keys_platform_data = {
1160         .buttons  = e6_buttons,
1161         .nbuttons = ARRAY_SIZE(e6_buttons),
1162 };
1163
1164 static struct platform_device e6_gpio_keys = {
1165         .name = "gpio-keys",
1166         .id   = -1,
1167         .dev  = {
1168                 .platform_data = &e6_gpio_keys_platform_data,
1169         },
1170 };
1171
1172 static struct i2c_board_info __initdata e6_i2c_board_info[] = {
1173         { I2C_BOARD_INFO("tea5767", 0x81) },
1174 };
1175
1176 static struct platform_device *e6_devices[] __initdata = {
1177         &e6_gpio_keys,
1178 };
1179
1180 static void __init e6_init(void)
1181 {
1182         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
1183         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen2_pin_config));
1184         pxa2xx_mfp_config(ARRAY_AND_SIZE(e6_pin_config));
1185
1186         pxa_set_ffuart_info(NULL);
1187         pxa_set_btuart_info(NULL);
1188         pxa_set_stuart_info(NULL);
1189
1190         pxa_set_i2c_info(NULL);
1191         i2c_register_board_info(0, ARRAY_AND_SIZE(e6_i2c_board_info));
1192
1193         pxa_set_fb_info(NULL, &ezx_fb_info_2);
1194
1195         pxa_set_keypad_info(&e6_keypad_platform_data);
1196
1197         pwm_add_table(ezx_pwm_lookup, ARRAY_SIZE(ezx_pwm_lookup));
1198         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
1199         platform_add_devices(ARRAY_AND_SIZE(e6_devices));
1200 }
1201
1202 MACHINE_START(EZX_E6, "Motorola EZX E6")
1203         .atag_offset    = 0x100,
1204         .map_io         = pxa27x_map_io,
1205         .nr_irqs        = EZX_NR_IRQS,
1206         .init_irq       = pxa27x_init_irq,
1207         .handle_irq       = pxa27x_handle_irq,
1208         .init_time      = pxa_timer_init,
1209         .init_machine   = e6_init,
1210         .restart        = pxa_restart,
1211 MACHINE_END
1212 #endif
1213
1214 #ifdef CONFIG_MACH_EZX_E2
1215 static struct i2c_board_info __initdata e2_i2c_board_info[] = {
1216         { I2C_BOARD_INFO("tea5767", 0x81) },
1217 };
1218
1219 static struct platform_device *e2_devices[] __initdata = {
1220 };
1221
1222 static void __init e2_init(void)
1223 {
1224         pxa2xx_mfp_config(ARRAY_AND_SIZE(ezx_pin_config));
1225         pxa2xx_mfp_config(ARRAY_AND_SIZE(gen2_pin_config));
1226         pxa2xx_mfp_config(ARRAY_AND_SIZE(e2_pin_config));
1227
1228         pxa_set_ffuart_info(NULL);
1229         pxa_set_btuart_info(NULL);
1230         pxa_set_stuart_info(NULL);
1231
1232         pxa_set_i2c_info(NULL);
1233         i2c_register_board_info(0, ARRAY_AND_SIZE(e2_i2c_board_info));
1234
1235         pxa_set_fb_info(NULL, &ezx_fb_info_2);
1236
1237         pxa_set_keypad_info(&e2_keypad_platform_data);
1238
1239         pwm_add_table(ezx_pwm_lookup, ARRAY_SIZE(ezx_pwm_lookup));
1240         platform_add_devices(ARRAY_AND_SIZE(ezx_devices));
1241         platform_add_devices(ARRAY_AND_SIZE(e2_devices));
1242 }
1243
1244 MACHINE_START(EZX_E2, "Motorola EZX E2")
1245         .atag_offset    = 0x100,
1246         .map_io         = pxa27x_map_io,
1247         .nr_irqs        = EZX_NR_IRQS,
1248         .init_irq       = pxa27x_init_irq,
1249         .handle_irq       = pxa27x_handle_irq,
1250         .init_time      = pxa_timer_init,
1251         .init_machine   = e2_init,
1252         .restart        = pxa_restart,
1253 MACHINE_END
1254 #endif