arch/arm/mach-pxa/magician.c

   1 /*
   2  * Support for HTC Magician PDA phones:
   3  * i-mate JAM, O2 Xda mini, Orange SPV M500, Qtek s100, Qtek s110
   4  * and T-Mobile MDA Compact.
   5  *
   6  * Copyright (c) 2006-2007 Philipp Zabel
   7  *
   8  * Based on hx4700.c, spitz.c and others.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/init.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/delay.h>
  20 #include <linux/gpio.h>
  21 #include <linux/gpio_keys.h>
  22 #include <linux/input.h>
  23 #include <linux/mfd/htc-egpio.h>
  24 #include <linux/mfd/htc-pasic3.h>
  25 #include <linux/mtd/physmap.h>
  26 #include <linux/pda_power.h>
  27 #include <linux/pwm.h>
  28 #include <linux/pwm_backlight.h>
  29 #include <linux/regulator/driver.h>
  30 #include <linux/regulator/fixed.h>
  31 #include <linux/regulator/gpio-regulator.h>
  32 #include <linux/regulator/machine.h>
  33 #include <linux/usb/gpio_vbus.h>
  34 #include <linux/i2c/pxa-i2c.h>
  35
  36 #include <mach/hardware.h>
  37 #include <asm/mach-types.h>
  38 #include <asm/mach/arch.h>
  39 #include <asm/system_info.h>
  40
  41 #include <mach/pxa27x.h>
  42 #include <mach/magician.h>
  43 #include <linux/platform_data/video-pxafb.h>
  44 #include <linux/platform_data/mmc-pxamci.h>
  45 #include <linux/platform_data/irda-pxaficp.h>
  46 #include <linux/platform_data/usb-ohci-pxa27x.h>
  47
  48 #include <linux/regulator/max1586.h>
  49
  50 #include <linux/platform_data/pxa2xx_udc.h>
  51 #include <mach/udc.h>
  52 #include <mach/pxa27x-udc.h>
  53
  54 #include "devices.h"
  55 #include "generic.h"
  56
  57 static unsigned long magician_pin_config[] __initdata = {
  58
  59         /* SDRAM and Static Memory I/O Signals */
  60         GPIO20_nSDCS_2,
  61         GPIO21_nSDCS_3,
  62         GPIO15_nCS_1,
  63         GPIO78_nCS_2,   /* PASIC3 */
  64         GPIO79_nCS_3,   /* EGPIO CPLD */
  65         GPIO80_nCS_4,
  66         GPIO33_nCS_5,
  67
  68         /* I2C UDA1380 + OV9640 */
  69         GPIO117_I2C_SCL,
  70         GPIO118_I2C_SDA,
  71
  72         /* PWM 0 - LCD backlight */
  73         GPIO16_PWM0_OUT,
  74
  75         /* I2S UDA1380 capture */
  76         GPIO28_I2S_BITCLK_OUT,
  77         GPIO29_I2S_SDATA_IN,
  78         GPIO31_I2S_SYNC,
  79         GPIO113_I2S_SYSCLK,
  80
  81         /* SSP 1 UDA1380 playback */
  82         GPIO23_SSP1_SCLK,
  83         GPIO24_SSP1_SFRM,
  84         GPIO25_SSP1_TXD,
  85
  86         /* SSP 2 TSC2046 touchscreen */
  87         GPIO19_SSP2_SCLK,
  88         GPIO14_SSP2_SFRM,
  89         GPIO89_SSP2_TXD,
  90         GPIO88_SSP2_RXD,
  91
  92         /* MMC/SD/SDHC slot */
  93         GPIO32_MMC_CLK,
  94         GPIO92_MMC_DAT_0,
  95         GPIO109_MMC_DAT_1,
  96         GPIO110_MMC_DAT_2,
  97         GPIO111_MMC_DAT_3,
  98         GPIO112_MMC_CMD,
  99
 100         /* LCD */
 101         GPIOxx_LCD_TFT_16BPP,
 102
 103         /* QCI camera interface */
 104         GPIO12_CIF_DD_7,
 105         GPIO17_CIF_DD_6,
 106         GPIO50_CIF_DD_3,
 107         GPIO51_CIF_DD_2,
 108         GPIO52_CIF_DD_4,
 109         GPIO53_CIF_MCLK,
 110         GPIO54_CIF_PCLK,
 111         GPIO55_CIF_DD_1,
 112         GPIO81_CIF_DD_0,
 113         GPIO82_CIF_DD_5,
 114         GPIO84_CIF_FV,
 115         GPIO85_CIF_LV,
 116
 117         /* Magician specific input GPIOs */
 118         GPIO9_GPIO,     /* unknown */
 119         GPIO10_GPIO,    /* GSM_IRQ */
 120         GPIO13_GPIO,    /* CPLD_IRQ */
 121         GPIO107_GPIO,   /* DS1WM_IRQ */
 122         GPIO108_GPIO,   /* GSM_READY */
 123         GPIO115_GPIO,   /* nPEN_IRQ */
 124
 125         /* I2C */
 126         GPIO117_I2C_SCL,
 127         GPIO118_I2C_SDA,
 128 };
 129
 130 /*
 131  * IrDA
 132  */
 133
 134 static struct pxaficp_platform_data magician_ficp_info = {
 135         .gpio_pwdown            = GPIO83_MAGICIAN_nIR_EN,
 136         .transceiver_cap        = IR_SIRMODE | IR_OFF,
 137         .gpio_pwdown_inverted   = 0,
 138 };
 139
 140 /*
 141  * GPIO Keys
 142  */
 143
 144 #define INIT_KEY(_code, _gpio, _desc)   \
 145         {                               \
 146                 .code   = KEY_##_code,  \
 147                 .gpio   = _gpio,        \
 148                 .desc   = _desc,        \
 149                 .type   = EV_KEY,       \
 150                 .wakeup = 1,            \
 151         }
 152
 153 static struct gpio_keys_button magician_button_table[] = {
 154         INIT_KEY(POWER,      GPIO0_MAGICIAN_KEY_POWER,      "Power button"),
 155         INIT_KEY(ESC,        GPIO37_MAGICIAN_KEY_HANGUP,    "Hangup button"),
 156         INIT_KEY(F10,        GPIO38_MAGICIAN_KEY_CONTACTS,  "Contacts button"),
 157         INIT_KEY(CALENDAR,   GPIO90_MAGICIAN_KEY_CALENDAR,  "Calendar button"),
 158         INIT_KEY(CAMERA,     GPIO91_MAGICIAN_KEY_CAMERA,    "Camera button"),
 159         INIT_KEY(UP,         GPIO93_MAGICIAN_KEY_UP,        "Up button"),
 160         INIT_KEY(DOWN,       GPIO94_MAGICIAN_KEY_DOWN,      "Down button"),
 161         INIT_KEY(LEFT,       GPIO95_MAGICIAN_KEY_LEFT,      "Left button"),
 162         INIT_KEY(RIGHT,      GPIO96_MAGICIAN_KEY_RIGHT,     "Right button"),
 163         INIT_KEY(KPENTER,    GPIO97_MAGICIAN_KEY_ENTER,     "Action button"),
 164         INIT_KEY(RECORD,     GPIO98_MAGICIAN_KEY_RECORD,    "Record button"),
 165         INIT_KEY(VOLUMEUP,   GPIO100_MAGICIAN_KEY_VOL_UP,   "Volume up"),
 166         INIT_KEY(VOLUMEDOWN, GPIO101_MAGICIAN_KEY_VOL_DOWN, "Volume down"),
 167         INIT_KEY(PHONE,      GPIO102_MAGICIAN_KEY_PHONE,    "Phone button"),
 168         INIT_KEY(PLAY,       GPIO99_MAGICIAN_HEADPHONE_IN,  "Headset button"),
 169 };
 170
 171 static struct gpio_keys_platform_data gpio_keys_data = {
 172         .buttons        = magician_button_table,
 173         .nbuttons       = ARRAY_SIZE(magician_button_table),
 174 };
 175
 176 static struct platform_device gpio_keys = {
 177         .name   = "gpio-keys",
 178         .dev    = {
 179                 .platform_data = &gpio_keys_data,
 180         },
 181         .id     = -1,
 182 };
 183
 184 /*
 185  * EGPIO (Xilinx CPLD)
 186  *
 187  * 32-bit aligned 8-bit registers
 188  * 16 possible registers (reg windows size), only 7 used:
 189  * 3x output, 1x irq, 3x input
 190  */
 191
 192 static struct resource egpio_resources[] = {
 193         [0] = {
 194                 .start  = PXA_CS3_PHYS,
 195                 .end    = PXA_CS3_PHYS + 0x20 - 1,
 196                 .flags  = IORESOURCE_MEM,
 197         },
 198         [1] = {
 199                 .start  = PXA_GPIO_TO_IRQ(GPIO13_MAGICIAN_CPLD_IRQ),
 200                 .end    = PXA_GPIO_TO_IRQ(GPIO13_MAGICIAN_CPLD_IRQ),
 201                 .flags  = IORESOURCE_IRQ,
 202         },
 203 };
 204
 205 static struct htc_egpio_chip egpio_chips[] = {
 206         [0] = {
 207                 .reg_start      = 0,
 208                 .gpio_base      = MAGICIAN_EGPIO(0, 0),
 209                 .num_gpios      = 24,
 210                 .direction      = HTC_EGPIO_OUTPUT,
 211                 /*
 212                  * Depends on modules configuration
 213                  */
 214                 .initial_values = 0x40, /* EGPIO_MAGICIAN_GSM_RESET */
 215         },
 216         [1] = {
 217                 .reg_start      = 4,
 218                 .gpio_base      = MAGICIAN_EGPIO(4, 0),
 219                 .num_gpios      = 24,
 220                 .direction      = HTC_EGPIO_INPUT,
 221         },
 222 };
 223
 224 static struct htc_egpio_platform_data egpio_info = {
 225         .reg_width      = 8,
 226         .bus_width      = 32,
 227         .irq_base       = IRQ_BOARD_START,
 228         .num_irqs       = 4,
 229         .ack_register   = 3,
 230         .chip           = egpio_chips,
 231         .num_chips      = ARRAY_SIZE(egpio_chips),
 232 };
 233
 234 static struct platform_device egpio = {
 235         .name           = "htc-egpio",
 236         .id             = -1,
 237         .resource       = egpio_resources,
 238         .num_resources  = ARRAY_SIZE(egpio_resources),
 239         .dev = {
 240                 .platform_data = &egpio_info,
 241         },
 242 };
 243
 244 /*
 245  * PXAFB LCD - Toppoly TD028STEB1 or Samsung LTP280QV
 246  */
 247
 248 static struct pxafb_mode_info toppoly_modes[] = {
 249         {
 250                 .pixclock       = 96153,
 251                 .bpp            = 16,
 252                 .xres           = 240,
 253                 .yres           = 320,
 254                 .hsync_len      = 11,
 255                 .vsync_len      = 3,
 256                 .left_margin    = 19,
 257                 .upper_margin   = 2,
 258                 .right_margin   = 10,
 259                 .lower_margin   = 2,
 260                 .sync           = 0,
 261         },
 262 };
 263
 264 static struct pxafb_mode_info samsung_modes[] = {
 265         {
 266                 .pixclock       = 226469,
 267                 .bpp            = 16,
 268                 .xres           = 240,
 269                 .yres           = 320,
 270                 .hsync_len      = 8,
 271                 .vsync_len      = 4,
 272                 .left_margin    = 9,
 273                 .upper_margin   = 4,
 274                 .right_margin   = 9,
 275                 .lower_margin   = 4,
 276                 .sync   = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
 277         },
 278 };
 279
 280 static void toppoly_lcd_power(int on, struct fb_var_screeninfo *si)
 281 {
 282         pr_debug("Toppoly LCD power: %s\n", on ? "on" : "off");
 283
 284         if (on) {
 285                 gpio_set_value(EGPIO_MAGICIAN_TOPPOLY_POWER, 1);
 286                 gpio_set_value(GPIO106_MAGICIAN_LCD_DCDC_NRESET, 1);
 287                 udelay(2000);
 288                 gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 1);
 289                 udelay(2000);
 290                 /* FIXME: enable LCDC here */
 291                 udelay(2000);
 292                 gpio_set_value(GPIO104_MAGICIAN_LCD_VOFF_EN, 1);
 293                 udelay(2000);
 294                 gpio_set_value(GPIO105_MAGICIAN_LCD_VON_EN, 1);
 295         } else {
 296                 msleep(15);
 297                 gpio_set_value(GPIO105_MAGICIAN_LCD_VON_EN, 0);
 298                 udelay(500);
 299                 gpio_set_value(GPIO104_MAGICIAN_LCD_VOFF_EN, 0);
 300                 udelay(1000);
 301                 gpio_set_value(GPIO106_MAGICIAN_LCD_DCDC_NRESET, 0);
 302                 gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 0);
 303         }
 304 }
 305
 306 static void samsung_lcd_power(int on, struct fb_var_screeninfo *si)
 307 {
 308         pr_debug("Samsung LCD power: %s\n", on ? "on" : "off");
 309
 310         if (on) {
 311                 if (system_rev < 3)
 312                         gpio_set_value(GPIO75_MAGICIAN_SAMSUNG_POWER, 1);
 313                 else
 314                         gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 1);
 315                 mdelay(6);
 316                 gpio_set_value(GPIO106_MAGICIAN_LCD_DCDC_NRESET, 1);
 317                 mdelay(6);      /* Avdd -> Voff >5ms */
 318                 gpio_set_value(GPIO104_MAGICIAN_LCD_VOFF_EN, 1);
 319                 mdelay(16);     /* Voff -> Von >(5+10)ms */
 320                 gpio_set_value(GPIO105_MAGICIAN_LCD_VON_EN, 1);
 321         } else {
 322                 gpio_set_value(GPIO105_MAGICIAN_LCD_VON_EN, 0);
 323                 mdelay(16);
 324                 gpio_set_value(GPIO104_MAGICIAN_LCD_VOFF_EN, 0);
 325                 mdelay(6);
 326                 gpio_set_value(GPIO106_MAGICIAN_LCD_DCDC_NRESET, 0);
 327                 mdelay(6);
 328                 if (system_rev < 3)
 329                         gpio_set_value(GPIO75_MAGICIAN_SAMSUNG_POWER, 0);
 330                 else
 331                         gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 0);
 332         }
 333 }
 334
 335 static struct pxafb_mach_info toppoly_info = {
 336         .modes                  = toppoly_modes,
 337         .num_modes              = 1,
 338         .fixed_modes            = 1,
 339         .lcd_conn               = LCD_COLOR_TFT_16BPP,
 340         .pxafb_lcd_power        = toppoly_lcd_power,
 341 };
 342
 343 static struct pxafb_mach_info samsung_info = {
 344         .modes                  = samsung_modes,
 345         .num_modes              = 1,
 346         .fixed_modes            = 1,
 347         .lcd_conn               = LCD_COLOR_TFT_16BPP | LCD_PCLK_EDGE_FALL |
 348                 LCD_ALTERNATE_MAPPING,
 349         .pxafb_lcd_power        = samsung_lcd_power,
 350 };
 351
 352 /*
 353  * Backlight
 354  */
 355
 356 static struct pwm_lookup magician_pwm_lookup[] = {
 357         PWM_LOOKUP("pxa27x-pwm.0", 0, "pwm-backlight", NULL, 30923,
 358                    PWM_POLARITY_NORMAL),
 359 };
 360
 361  /*
 362  * fixed regulator for pwm_backlight
 363  */
 364
 365 static struct regulator_consumer_supply pwm_backlight_supply[] = {
 366         REGULATOR_SUPPLY("power", "pwm_backlight"),
 367 };
 368
 369
 370 static struct gpio magician_bl_gpios[] = {
 371         { EGPIO_MAGICIAN_BL_POWER,      GPIOF_DIR_OUT, "Backlight power" },
 372         { EGPIO_MAGICIAN_BL_POWER2,     GPIOF_DIR_OUT, "Backlight power 2" },
 373 };
 374
 375 static int magician_backlight_init(struct device *dev)
 376 {
 377         return gpio_request_array(ARRAY_AND_SIZE(magician_bl_gpios));
 378 }
 379
 380 static int magician_backlight_notify(struct device *dev, int brightness)
 381 {
 382         pr_debug("Brightness = %i\n", brightness);
 383         gpio_set_value(EGPIO_MAGICIAN_BL_POWER, brightness);
 384         if (brightness >= 200) {
 385                 gpio_set_value(EGPIO_MAGICIAN_BL_POWER2, 1);
 386                 return brightness - 72;
 387         } else {
 388                 gpio_set_value(EGPIO_MAGICIAN_BL_POWER2, 0);
 389                 return brightness;
 390         }
 391 }
 392
 393 static void magician_backlight_exit(struct device *dev)
 394 {
 395         gpio_free_array(ARRAY_AND_SIZE(magician_bl_gpios));
 396 }
 397
 398 /*
 399  * LCD PWM backlight (main)
 400  *
 401  * MP1521 frequency should be:
 402  *      100-400 Hz = 2 .5*10^6 - 10 *10^6 ns
 403  */
 404
 405 static struct platform_pwm_backlight_data backlight_data = {
 406         .max_brightness = 272,
 407         .dft_brightness = 100,
 408         .enable_gpio    = -1,
 409         .init           = magician_backlight_init,
 410         .notify         = magician_backlight_notify,
 411         .exit           = magician_backlight_exit,
 412 };
 413
 414 static struct platform_device backlight = {
 415         .name   = "pwm-backlight",
 416         .id     = -1,
 417         .dev    = {
 418                 .parent         = &pxa27x_device_pwm0.dev,
 419                 .platform_data  = &backlight_data,
 420         },
 421 };
 422
 423 /*
 424  * GPIO LEDs, Phone keys backlight, vibra
 425  */
 426
 427 static struct gpio_led gpio_leds[] = {
 428         {
 429                 .name = "magician::vibra",
 430                 .default_trigger = "none",
 431                 .gpio = GPIO22_MAGICIAN_VIBRA_EN,
 432         },
 433         {
 434                 .name = "magician::phone_bl",
 435                 .default_trigger = "backlight",
 436                 .gpio = GPIO103_MAGICIAN_LED_KP,
 437         },
 438 };
 439
 440 static struct gpio_led_platform_data gpio_led_info = {
 441         .leds = gpio_leds,
 442         .num_leds = ARRAY_SIZE(gpio_leds),
 443 };
 444
 445 static struct platform_device leds_gpio = {
 446         .name   = "leds-gpio",
 447         .id     = -1,
 448         .dev    = {
 449                 .platform_data = &gpio_led_info,
 450         },
 451 };
 452
 453 /*
 454  * PASIC3 with DS1WM
 455  */
 456
 457 static struct resource pasic3_resources[] = {
 458         [0] = {
 459                 .start  = PXA_CS2_PHYS,
 460                 .end    = PXA_CS2_PHYS + 0x1b,
 461                 .flags  = IORESOURCE_MEM,
 462         },
 463         /* No IRQ handler in the PASIC3, DS1WM needs an external IRQ */
 464         [1] = {
 465                 .start  = PXA_GPIO_TO_IRQ(GPIO107_MAGICIAN_DS1WM_IRQ),
 466                 .end    = PXA_GPIO_TO_IRQ(GPIO107_MAGICIAN_DS1WM_IRQ),
 467                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
 468         }
 469 };
 470
 471 static struct pasic3_platform_data pasic3_platform_data = {
 472         .clock_rate = 4000000,
 473 };
 474
 475 static struct platform_device pasic3 = {
 476         .name           = "pasic3",
 477         .id             = -1,
 478         .num_resources  = ARRAY_SIZE(pasic3_resources),
 479         .resource       = pasic3_resources,
 480         .dev = {
 481                 .platform_data = &pasic3_platform_data,
 482         },
 483 };
 484
 485 /*
 486  * PXA UDC
 487  */
 488
 489 static void magician_udc_command(int cmd)
 490 {
 491         if (cmd == PXA2XX_UDC_CMD_CONNECT)
 492                 UP2OCR |= UP2OCR_DPPUE | UP2OCR_DPPUBE;
 493         else if (cmd == PXA2XX_UDC_CMD_DISCONNECT)
 494                 UP2OCR &= ~(UP2OCR_DPPUE | UP2OCR_DPPUBE);
 495 }
 496
 497 static struct pxa2xx_udc_mach_info magician_udc_info __initdata = {
 498         .udc_command    = magician_udc_command,
 499         .gpio_pullup    = GPIO27_MAGICIAN_USBC_PUEN,
 500 };
 501
 502 /*
 503  * USB device VBus detection
 504  */
 505
 506 static struct resource gpio_vbus_resource = {
 507         .flags  = IORESOURCE_IRQ,
 508         .start  = IRQ_MAGICIAN_VBUS,
 509         .end    = IRQ_MAGICIAN_VBUS,
 510 };
 511
 512 static struct gpio_vbus_mach_info gpio_vbus_info = {
 513         .gpio_pullup    = GPIO27_MAGICIAN_USBC_PUEN,
 514         .gpio_vbus      = EGPIO_MAGICIAN_CABLE_VBUS,
 515 };
 516
 517 static struct platform_device gpio_vbus = {
 518         .name           = "gpio-vbus",
 519         .id             = -1,
 520         .num_resources  = 1,
 521         .resource       = &gpio_vbus_resource,
 522         .dev = {
 523                 .platform_data = &gpio_vbus_info,
 524         },
 525 };
 526
 527 /*
 528  * External power
 529  */
 530
 531 static int magician_supply_init(struct device *dev)
 532 {
 533         int ret = -1;
 534
 535         ret = gpio_request(EGPIO_MAGICIAN_CABLE_TYPE, "Cable is AC charger");
 536         if (ret) {
 537                 pr_err("Cannot request AC/USB charger GPIO (%i)\n", ret);
 538                 goto err_ac;
 539         }
 540
 541         ret = gpio_request(EGPIO_MAGICIAN_CABLE_INSERTED, "Cable inserted");
 542         if (ret) {
 543                 pr_err("Cannot request cable detection GPIO (%i)\n", ret);
 544                 goto err_usb;
 545         }
 546
 547         return 0;
 548
 549 err_usb:
 550         gpio_free(EGPIO_MAGICIAN_CABLE_TYPE);
 551 err_ac:
 552         return ret;
 553 }
 554
 555 static void magician_set_charge(int flags)
 556 {
 557         if (flags & PDA_POWER_CHARGE_AC) {
 558                 pr_debug("Charging from AC\n");
 559                 gpio_set_value(EGPIO_MAGICIAN_NICD_CHARGE, 1);
 560         } else if (flags & PDA_POWER_CHARGE_USB) {
 561                 pr_debug("Charging from USB\n");
 562                 gpio_set_value(EGPIO_MAGICIAN_NICD_CHARGE, 1);
 563         } else {
 564                 pr_debug("Charging disabled\n");
 565                 gpio_set_value(EGPIO_MAGICIAN_NICD_CHARGE, 0);
 566         }
 567 }
 568
 569 static int magician_is_ac_online(void)
 570 {
 571         return gpio_get_value(EGPIO_MAGICIAN_CABLE_INSERTED) &&
 572                 gpio_get_value(EGPIO_MAGICIAN_CABLE_TYPE); /* AC=1 */
 573 }
 574
 575 static int magician_is_usb_online(void)
 576 {
 577         return gpio_get_value(EGPIO_MAGICIAN_CABLE_INSERTED) &&
 578                 (!gpio_get_value(EGPIO_MAGICIAN_CABLE_TYPE)); /* USB=0 */
 579 }
 580
 581 static void magician_supply_exit(struct device *dev)
 582 {
 583         gpio_free(EGPIO_MAGICIAN_CABLE_INSERTED);
 584         gpio_free(EGPIO_MAGICIAN_CABLE_TYPE);
 585 }
 586
 587 static char *magician_supplicants[] = {
 588         "ds2760-battery.0", "backup-battery"
 589 };
 590
 591 static struct pda_power_pdata power_supply_info = {
 592         .init                   = magician_supply_init,
 593         .exit                   = magician_supply_exit,
 594         .is_ac_online           = magician_is_ac_online,
 595         .is_usb_online          = magician_is_usb_online,
 596         .set_charge             = magician_set_charge,
 597         .supplied_to            = magician_supplicants,
 598         .num_supplicants        = ARRAY_SIZE(magician_supplicants),
 599 };
 600
 601 static struct resource power_supply_resources[] = {
 602         [0] = {
 603                 .name   = "ac",
 604                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE |
 605                         IORESOURCE_IRQ_LOWEDGE,
 606                 .start  = IRQ_MAGICIAN_VBUS,
 607                 .end    = IRQ_MAGICIAN_VBUS,
 608         },
 609         [1] = {
 610                 .name   = "usb",
 611                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE |
 612                         IORESOURCE_IRQ_LOWEDGE,
 613                 .start  = IRQ_MAGICIAN_VBUS,
 614                 .end    = IRQ_MAGICIAN_VBUS,
 615         },
 616 };
 617
 618 static struct platform_device power_supply = {
 619         .name   = "pda-power",
 620         .id     = -1,
 621         .dev = {
 622                 .platform_data = &power_supply_info,
 623         },
 624         .resource       = power_supply_resources,
 625         .num_resources  = ARRAY_SIZE(power_supply_resources),
 626 };
 627
 628 /*
 629  * Battery charger
 630  */
 631
 632 static struct regulator_consumer_supply bq24022_consumers[] = {
 633         REGULATOR_SUPPLY("vbus_draw", NULL),
 634         REGULATOR_SUPPLY("ac_draw", NULL),
 635 };
 636
 637 static struct regulator_init_data bq24022_init_data = {
 638         .constraints = {
 639                 .max_uA         = 500000,
 640                 .valid_ops_mask = REGULATOR_CHANGE_CURRENT |
 641                         REGULATOR_CHANGE_STATUS,
 642         },
 643         .num_consumer_supplies  = ARRAY_SIZE(bq24022_consumers),
 644         .consumer_supplies      = bq24022_consumers,
 645 };
 646
 647 static struct gpio bq24022_gpios[] = {
 648         { EGPIO_MAGICIAN_BQ24022_ISET2, GPIOF_OUT_INIT_LOW, "bq24022_iset2" },
 649 };
 650
 651 static struct gpio_regulator_state bq24022_states[] = {
 652         { .value = 100000, .gpios = (0 << 0) },
 653         { .value = 500000, .gpios = (1 << 0) },
 654 };
 655
 656 static struct gpio_regulator_config bq24022_info = {
 657         .supply_name            = "bq24022",
 658
 659         .enable_gpio            = GPIO30_MAGICIAN_BQ24022_nCHARGE_EN,
 660         .enable_high            = 0,
 661         .enabled_at_boot        = 1,
 662
 663         .gpios                  = bq24022_gpios,
 664         .nr_gpios               = ARRAY_SIZE(bq24022_gpios),
 665
 666         .states                 = bq24022_states,
 667         .nr_states              = ARRAY_SIZE(bq24022_states),
 668
 669         .type                   = REGULATOR_CURRENT,
 670         .init_data              = &bq24022_init_data,
 671 };
 672
 673 static struct platform_device bq24022 = {
 674         .name   = "gpio-regulator",
 675         .id     = -1,
 676         .dev    = {
 677                 .platform_data = &bq24022_info,
 678         },
 679 };
 680
 681 /*
 682  * Vcore regulator MAX1587A
 683  */
 684
 685 static struct regulator_consumer_supply magician_max1587a_consumers[] = {
 686         REGULATOR_SUPPLY("vcc_core", NULL),
 687 };
 688
 689 static struct regulator_init_data magician_max1587a_v3_info = {
 690         .constraints = {
 691                 .name           = "vcc_core range",
 692                 .min_uV         = 700000,
 693                 .max_uV         = 1475000,
 694                 .always_on      = 1,
 695                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
 696         },
 697         .consumer_supplies      = magician_max1587a_consumers,
 698         .num_consumer_supplies  = ARRAY_SIZE(magician_max1587a_consumers),
 699 };
 700
 701 static struct max1586_subdev_data magician_max1587a_subdevs[] = {
 702         {
 703                 .name           = "vcc_core",
 704                 .id             = MAX1586_V3,
 705                 .platform_data  = &magician_max1587a_v3_info,
 706         }
 707 };
 708
 709 static struct max1586_platform_data magician_max1587a_info = {
 710         .subdevs     = magician_max1587a_subdevs,
 711         .num_subdevs = ARRAY_SIZE(magician_max1587a_subdevs),
 712         /*
 713          * NOTICE measured directly on the PCB (board_id == 0x3a), but
 714          * if R24 is present, it will boost the voltage
 715          * (write 1.475V, get 1.645V and smoke)
 716          */
 717         .v3_gain     = MAX1586_GAIN_NO_R24,
 718 };
 719
 720 static struct i2c_board_info magician_pwr_i2c_board_info[] __initdata = {
 721         {
 722                 I2C_BOARD_INFO("max1586", 0x14),
 723                 .platform_data  = &magician_max1587a_info,
 724         },
 725 };
 726
 727 /*
 728  * MMC/SD
 729  */
 730
 731 static int magician_mci_init(struct device *dev,
 732         irq_handler_t detect_irq, void *data)
 733 {
 734         return request_irq(IRQ_MAGICIAN_SD, detect_irq, 0,
 735                 "mmc card detect", data);
 736 }
 737
 738 static void magician_mci_exit(struct device *dev, void *data)
 739 {
 740         free_irq(IRQ_MAGICIAN_SD, data);
 741 }
 742
 743 static struct pxamci_platform_data magician_mci_info = {
 744         .ocr_mask               = MMC_VDD_32_33|MMC_VDD_33_34,
 745         .init                   = magician_mci_init,
 746         .exit                   = magician_mci_exit,
 747         .gpio_card_detect       = -1,
 748         .gpio_card_ro           = EGPIO_MAGICIAN_nSD_READONLY,
 749         .gpio_card_ro_invert    = 1,
 750         .gpio_power             = EGPIO_MAGICIAN_SD_POWER,
 751 };
 752
 753
 754 /*
 755  * USB OHCI
 756  */
 757
 758 static struct pxaohci_platform_data magician_ohci_info = {
 759         .port_mode      = PMM_PERPORT_MODE,
 760         /* port1: CSR Bluetooth, port2: OTG with UDC */
 761         .flags          = ENABLE_PORT1 | ENABLE_PORT2 | POWER_CONTROL_LOW,
 762         .power_budget   = 0,
 763         .power_on_delay = 100,
 764 };
 765
 766 /*
 767  * StrataFlash
 768  */
 769
 770 static int magician_flash_init(struct platform_device *pdev)
 771 {
 772         int ret = gpio_request(EGPIO_MAGICIAN_FLASH_VPP, "flash Vpp enable");
 773
 774         if (ret) {
 775                 pr_err("Cannot request flash enable GPIO (%i)\n", ret);
 776                 return ret;
 777         }
 778
 779         ret = gpio_direction_output(EGPIO_MAGICIAN_FLASH_VPP, 1);
 780         if (ret) {
 781                 pr_err("Cannot set direction for flash enable (%i)\n", ret);
 782                 gpio_free(EGPIO_MAGICIAN_FLASH_VPP);
 783         }
 784
 785         return ret;
 786 }
 787
 788 static void magician_set_vpp(struct platform_device *pdev, int vpp)
 789 {
 790         gpio_set_value(EGPIO_MAGICIAN_FLASH_VPP, vpp);
 791 }
 792
 793 static void magician_flash_exit(struct platform_device *pdev)
 794 {
 795         gpio_free(EGPIO_MAGICIAN_FLASH_VPP);
 796 }
 797
 798 static struct resource strataflash_resource = {
 799         .start  = PXA_CS0_PHYS,
 800         .end    = PXA_CS0_PHYS + SZ_64M - 1,
 801         .flags  = IORESOURCE_MEM,
 802 };
 803
 804 static struct mtd_partition magician_flash_parts[] = {
 805         {
 806                 .name           = "Bootloader",
 807                 .offset         = 0x0,
 808                 .size           = 0x40000,
 809                 .mask_flags     = MTD_WRITEABLE, /* EXPERIMENTAL */
 810         },
 811         {
 812                 .name           = "Linux Kernel",
 813                 .offset         = 0x40000,
 814                 .size           = MTDPART_SIZ_FULL,
 815         },
 816 };
 817
 818 /*
 819  * physmap-flash driver
 820  */
 821
 822 static struct physmap_flash_data strataflash_data = {
 823         .width          = 4,
 824         .init           = magician_flash_init,
 825         .set_vpp        = magician_set_vpp,
 826         .exit           = magician_flash_exit,
 827         .parts          = magician_flash_parts,
 828         .nr_parts       = ARRAY_SIZE(magician_flash_parts),
 829 };
 830
 831 static struct platform_device strataflash = {
 832         .name           = "physmap-flash",
 833         .id             = -1,
 834         .resource       = &strataflash_resource,
 835         .num_resources  = 1,
 836         .dev = {
 837                 .platform_data = &strataflash_data,
 838         },
 839 };
 840
 841 /*
 842  * PXA I2C main controller
 843  */
 844
 845 static struct i2c_pxa_platform_data i2c_info = {
 846         /* OV9640 I2C device doesn't support fast mode */
 847         .fast_mode      = 0,
 848 };
 849
 850 /*
 851  * PXA I2C power controller
 852  */
 853
 854 static struct i2c_pxa_platform_data magician_i2c_power_info = {
 855         .fast_mode      = 1,
 856 };
 857
 858 /*
 859  * Platform devices
 860  */
 861
 862 static struct platform_device *devices[] __initdata = {
 863         &gpio_keys,
 864         &egpio,
 865         &backlight,
 866         &pasic3,
 867         &bq24022,
 868         &gpio_vbus,
 869         &power_supply,
 870         &strataflash,
 871         &leds_gpio,
 872 };
 873
 874 static struct gpio magician_global_gpios[] = {
 875         { GPIO13_MAGICIAN_CPLD_IRQ, GPIOF_IN, "CPLD_IRQ" },
 876         { GPIO107_MAGICIAN_DS1WM_IRQ, GPIOF_IN, "DS1WM_IRQ" },
 877
 878         /* NOTICE valid LCD init sequence */
 879         { GPIO106_MAGICIAN_LCD_DCDC_NRESET, GPIOF_OUT_INIT_LOW, "LCD DCDC nreset" },
 880         { GPIO104_MAGICIAN_LCD_VOFF_EN, GPIOF_OUT_INIT_LOW, "LCD VOFF enable" },
 881         { GPIO105_MAGICIAN_LCD_VON_EN, GPIOF_OUT_INIT_LOW, "LCD VON enable" },
 882 };
 883
 884 static void __init magician_init(void)
 885 {
 886         void __iomem *cpld;
 887         int lcd_select;
 888         int err;
 889
 890         pxa2xx_mfp_config(ARRAY_AND_SIZE(magician_pin_config));
 891         err = gpio_request_array(ARRAY_AND_SIZE(magician_global_gpios));
 892         if (err)
 893                 pr_err("magician: Failed to request global GPIOs: %d\n", err);
 894
 895         pxa_set_ffuart_info(NULL);
 896         pxa_set_btuart_info(NULL);
 897
 898         pwm_add_table(magician_pwm_lookup, ARRAY_SIZE(magician_pwm_lookup));
 899
 900         pxa_set_ficp_info(&magician_ficp_info);
 901         pxa27x_set_i2c_power_info(&magician_i2c_power_info);
 902         pxa_set_i2c_info(&i2c_info);
 903
 904         i2c_register_board_info(1,
 905                 ARRAY_AND_SIZE(magician_pwr_i2c_board_info));
 906
 907         pxa_set_mci_info(&magician_mci_info);
 908         pxa_set_ohci_info(&magician_ohci_info);
 909         pxa_set_udc_info(&magician_udc_info);
 910
 911         /* Check LCD type we have */
 912         cpld = ioremap_nocache(PXA_CS3_PHYS, 0x1000);
 913         if (cpld) {
 914                 u8 board_id = __raw_readb(cpld + 0x14);
 915
 916                 iounmap(cpld);
 917                 system_rev = board_id & 0x7;
 918                 lcd_select = board_id & 0x8;
 919                 pr_info("LCD type: %s\n", lcd_select ? "Samsung" : "Toppoly");
 920                 if (lcd_select && (system_rev < 3))
 921                         /* NOTICE valid LCD init sequence */
 922                         gpio_request_one(GPIO75_MAGICIAN_SAMSUNG_POWER,
 923                                 GPIOF_OUT_INIT_LOW, "Samsung LCD Power");
 924                 pxa_set_fb_info(NULL,
 925                         lcd_select ? &samsung_info : &toppoly_info);
 926         } else
 927                 pr_err("LCD detection: CPLD mapping failed\n");
 928
 929         regulator_register_always_on(0, "power", pwm_backlight_supply,
 930                 ARRAY_SIZE(pwm_backlight_supply), 5000000);
 931
 932         platform_add_devices(ARRAY_AND_SIZE(devices));
 933 }
 934
 935 MACHINE_START(MAGICIAN, "HTC Magician")
 936         .atag_offset    = 0x100,
 937         .map_io         = pxa27x_map_io,
 938         .nr_irqs        = MAGICIAN_NR_IRQS,
 939         .init_irq       = pxa27x_init_irq,
 940         .handle_irq     = pxa27x_handle_irq,
 941         .init_machine   = magician_init,
 942         .init_time      = pxa_timer_init,
 943         .restart        = pxa_restart,
 944 MACHINE_END