arch/arm/mach-rk2818/board-raho.c

   1 /* linux/arch/arm/mach-rk2818/board-phonesdk.c
   2  *
   3  * Copyright (C) 2010 ROCKCHIP, Inc.
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/init.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/input.h>
  20 #include <linux/io.h>
  21 #include <linux/delay.h>
  22 #include <linux/i2c.h>
  23 #include <linux/spi/spi.h>
  24 #include <linux/mmc/host.h>
  25 #include <linux/circ_buf.h>
  26 #include <linux/miscdevice.h>
  27
  28 #include <mach/hardware.h>
  29 #include <asm/mach-types.h>
  30 #include <asm/mach/arch.h>
  31 #include <asm/mach/map.h>
  32 #include <asm/mach/flash.h>
  33
  34 #include <mach/irqs.h>
  35 #include <mach/board.h>
  36 #include <mach/rk2818_iomap.h>
  37 #include <mach/iomux.h>
  38 #include <mach/gpio.h>
  39 #include <mach/spi_fpga.h>
  40 #include <mach/rk2818_camera.h>                          /* ddl@rock-chips.com : camera support */
  41 #include <mach/rk2818_nand.h>
  42
  43 #include <linux/mtd/nand.h>
  44 #include <linux/mtd/partitions.h>
  45 #include <linux/dm9000.h>
  46 #include <linux/capella_cm3602.h>
  47
  48 #include <media/soc_camera.h>                               /* ddl@rock-chips.com : camera support */
  49
  50
  51 #include "devices.h"
  52
  53 #include "../../../drivers/spi/rk2818_spim.h"
  54 #include <linux/regulator/rk2818_lp8725.h>
  55 #include "../../../drivers/input/touchscreen/xpt2046_ts.h"
  56 #include "../../../drivers/staging/android/timed_gpio.h"
  57 #include "../../../sound/soc/codecs/wm8994.h"
  58 #include "../../../drivers/headset_observe/rk2818_headset.h"
  59
  60 /* --------------------------------------------------------------------
  61  *  ÉùÃ÷ÁËrk2818_gpioBankÊý×é£¬²¢¶¨ÒåÁËGPIO¼Ä´æÆ÷×éIDºÍ¼Ä´æÆ÷»ùµØÖ·¡£
  62  * -------------------------------------------------------------------- */
  63
  64 static struct rk2818_gpio_bank rk2818_gpioBank[] = {
  65                 {
  66                 .id             = RK2818_ID_PIOA,
  67                 .offset         = RK2818_GPIO0_BASE,
  68                 .clock          = NULL,
  69         },
  70                 {
  71                 .id             = RK2818_ID_PIOB,
  72                 .offset         = RK2818_GPIO0_BASE,
  73                 .clock          = NULL,
  74         },
  75                 {
  76                 .id             = RK2818_ID_PIOC,
  77                 .offset         = RK2818_GPIO0_BASE,
  78                 .clock          = NULL,
  79         },
  80                 {
  81                 .id             = RK2818_ID_PIOD,
  82                 .offset         = RK2818_GPIO0_BASE,
  83                 .clock          = NULL,
  84         },
  85                 {
  86                 .id             = RK2818_ID_PIOE,
  87                 .offset         = RK2818_GPIO1_BASE,
  88                 .clock          = NULL,
  89         },
  90                 {
  91                 .id             = RK2818_ID_PIOF,
  92                 .offset         = RK2818_GPIO1_BASE,
  93                 .clock          = NULL,
  94         },
  95                 {
  96                 .id             = RK2818_ID_PIOG,
  97                 .offset         = RK2818_GPIO1_BASE,
  98                 .clock          = NULL,
  99         },
 100                 {
 101                 .id             = RK2818_ID_PIOH,
 102                 .offset         = RK2818_GPIO1_BASE,
 103                 .clock          = NULL,
 104         }
 105 };
 106
 107 //IOÓ³Éä·½Ê½ÃèÊö £¬Ã¿¸öÎªÒ»¶ÎÏßÐÔÁ¬ÐøÓ³Éä
 108 static struct map_desc rk2818_io_desc[] __initdata = {
 109
 110         {
 111                 .virtual        = RK2818_MCDMA_BASE,                                    //ÐéÄâµØÖ·
 112                 .pfn            = __phys_to_pfn(RK2818_MCDMA_PHYS),    //ÎïÀíµØÖ·£¬ÐëÓëÒ³±í¶ÔÆë
 113                 .length         = RK2818_MCDMA_SIZE,                                                    //³¤¶È
 114                 .type           = MT_DEVICE                                                     //Ó³Éä·½Ê½
 115         },
 116
 117         {
 118                 .virtual        = RK2818_DWDMA_BASE,
 119                 .pfn            = __phys_to_pfn(RK2818_DWDMA_PHYS),
 120                 .length         = RK2818_DWDMA_SIZE,
 121                 .type           = MT_DEVICE
 122         },
 123
 124         {
 125                 .virtual        = RK2818_INTC_BASE,
 126                 .pfn            = __phys_to_pfn(RK2818_INTC_PHYS),
 127                 .length         = RK2818_INTC_SIZE,
 128                 .type           = MT_DEVICE
 129         },
 130
 131         {
 132                 .virtual        = RK2818_NANDC_BASE,
 133                 .pfn            = __phys_to_pfn(RK2818_NANDC_PHYS),
 134                 .length         = RK2818_NANDC_SIZE,
 135                 .type           = MT_DEVICE
 136         },
 137
 138         {
 139                 .virtual        = RK2818_SDRAMC_BASE,
 140                 .pfn            = __phys_to_pfn(RK2818_SDRAMC_PHYS),
 141                 .length         = RK2818_SDRAMC_SIZE,
 142                 .type           = MT_DEVICE
 143         },
 144
 145         {
 146                 .virtual        = RK2818_ARMDARBITER_BASE,
 147                 .pfn            = __phys_to_pfn(RK2818_ARMDARBITER_PHYS),
 148                 .length         = RK2818_ARMDARBITER_SIZE,
 149                 .type           = MT_DEVICE
 150         },
 151
 152         {
 153                 .virtual        = RK2818_APB_BASE,
 154                 .pfn            = __phys_to_pfn(RK2818_APB_PHYS),
 155                 .length         = 0xa0000,
 156                 .type           = MT_DEVICE
 157         },
 158
 159         {
 160                 .virtual        = RK2818_WDT_BASE,
 161                 .pfn            = __phys_to_pfn(RK2818_WDT_PHYS),
 162                 .length         = 0xa0000,                      ///apb bus i2s i2c spi no map in this
 163                 .type           = MT_DEVICE
 164         },
 165 };
 166
 167 /*****************************************************************************************
 168  * sd/mmc devices
 169  * author: kfx@rock-chips.com
 170 *****************************************************************************************/
 171 static int rk2818_sdmmc0_io_init(void)
 172 {
 173     rk2818_mux_api_set(GPIOH_MMC0D_SEL_NAME, IOMUXA_SDMMC0_DATA123);
 174         rk2818_mux_api_set(GPIOH_MMC0_SEL_NAME, IOMUXA_SDMMC0_CMD_DATA0_CLKOUT);
 175
 176     return 0;
 177 }
 178
 179 static int rk2818_sdmmc1_io_init(void)
 180 {
 181         rk2818_mux_api_set(GPIOG_MMC1_SEL_NAME, IOMUXA_SDMMC1_CMD_DATA0_CLKOUT);
 182         rk2818_mux_api_set(GPIOG_MMC1D_SEL_NAME, IOMUXA_SDMMC1_DATA123);
 183
 184     return 0;
 185 }
 186 #define CONFIG_SDMMC0_USE_DMA
 187 #define CONFIG_SDMMC1_USE_DMA
 188 struct rk2818_sdmmc_platform_data default_sdmmc0_data = {
 189         .host_ocr_avail = (MMC_VDD_27_28|MMC_VDD_28_29|MMC_VDD_29_30|
 190                                            MMC_VDD_30_31|MMC_VDD_31_32|MMC_VDD_32_33|
 191                                            MMC_VDD_33_34|MMC_VDD_34_35| MMC_VDD_35_36),
 192         .host_caps      = (MMC_CAP_4_BIT_DATA|MMC_CAP_MMC_HIGHSPEED|MMC_CAP_SD_HIGHSPEED),
 193         .io_init = rk2818_sdmmc0_io_init,
 194         .no_detect = 0,
 195         .dma_name = "sd_mmc",
 196 #ifdef CONFIG_SDMMC0_USE_DMA
 197         .use_dma  = 1,
 198 #else
 199         .use_dma = 0,
 200 #endif
 201 };
 202 struct rk2818_sdmmc_platform_data default_sdmmc1_data = {
 203         .host_ocr_avail = (MMC_VDD_26_27|MMC_VDD_27_28|MMC_VDD_28_29|
 204                                            MMC_VDD_29_30|MMC_VDD_30_31|MMC_VDD_31_32|
 205                                            MMC_VDD_32_33|MMC_VDD_33_34),
 206         .host_caps      = (MMC_CAP_4_BIT_DATA|MMC_CAP_SDIO_IRQ|
 207                                    MMC_CAP_MMC_HIGHSPEED|MMC_CAP_SD_HIGHSPEED),
 208         .io_init = rk2818_sdmmc1_io_init,
 209         .no_detect = 1,
 210         .dma_name = "sdio",
 211 #ifdef CONFIG_SDMMC1_USE_DMA
 212         .use_dma  = 1,
 213 #else
 214         .use_dma = 0,
 215 #endif
 216 };
 217
 218 /*****************************************************************************************
 219  * extern gpio devices
 220  * author: xxx@rock-chips.com
 221  *****************************************************************************************/
 222 #if defined (CONFIG_GPIO_PCA9554)
 223 struct rk2818_gpio_expander_info  extern_gpio_settinginfo[] = {
 224         {
 225                 .gpio_num               =RK2818_PIN_PI0,
 226                 .pin_type           = GPIO_IN,
 227                 //.pin_value                    =GPIO_HIGH,
 228          },
 229
 230         {
 231                 .gpio_num               =RK2818_PIN_PI4,// tp3
 232                 .pin_type           = GPIO_IN,
 233                 //.pin_value                    =GPIO_HIGH,
 234          },
 235
 236          {
 237                 .gpio_num               =RK2818_PIN_PI5,//tp4
 238                 .pin_type           = GPIO_IN,
 239                 //.pin_value                    =GPIO_HIGH,
 240          },
 241          {
 242                 .gpio_num               =RK2818_PIN_PI6,//tp2
 243                 .pin_type           = GPIO_OUT,
 244                 //.pin_value                    =GPIO_HIGH,
 245          },
 246          {
 247                 .gpio_num               =RK2818_PIN_PI7,//tp1
 248                 .pin_type           = GPIO_OUT,
 249                 .pin_value                      =GPIO_HIGH,
 250          },
 251
 252
 253
 254 };
 255
 256 struct pca9554_platform_data rk2818_pca9554_data={
 257         .gpio_base=GPIO_EXPANDER_BASE,
 258         .gpio_pin_num=CONFIG_EXPANDED_GPIO_NUM,
 259         .gpio_irq_start=NR_AIC_IRQS + 2*NUM_GROUP,
 260         .irq_pin_num=CONFIG_EXPANDED_GPIO_IRQ_NUM,
 261         .pca9954_irq_pin=RK2818_PIN_PE2,
 262         .settinginfo=extern_gpio_settinginfo,
 263         .settinginfolen=ARRAY_SIZE(extern_gpio_settinginfo),
 264         .names="pca9554",
 265 };
 266 #endif
 267
 268 /*****************************************************************************************
 269  *regulator devices  drivers/regulator/rk2818_lp8725.c  linux/regulator/rk2818_lp8725.h
 270  *author: cym
 271 *****************************************************************************************/
 272 #if defined (CONFIG_RK2818_REGULATOR_LP8725)
 273 /*ldo1 2V8OUT USB2.5V LCD_VCC*/
 274 static struct regulator_consumer_supply ldo1_consumers[] = {
 275         {
 276                 .supply = "ldo1",
 277         }
 278 };
 279
 280 static struct regulator_init_data rk2818_lp8725_ldo1_data = {
 281         .constraints = {
 282                 .name = "LDO1",
 283                 .min_uV = 1200000,
 284                 .max_uV = 3300000,
 285                 .apply_uV = 1,
 286                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 287         },
 288         .num_consumer_supplies = ARRAY_SIZE(ldo1_consumers),
 289         .consumer_supplies = ldo1_consumers,
 290 };
 291
 292 /*ldo2 CAMERA_1V8 SD_CARD*/
 293 static struct regulator_consumer_supply ldo2_consumers[] = {
 294         {
 295                 .supply = "ldo2",
 296         }
 297 };
 298
 299 static struct regulator_init_data rk2818_lp8725_ldo2_data = {
 300         .constraints = {
 301                 .name = "LDO2",
 302                 .min_uV = 1200000,
 303                 .max_uV = 3300000,
 304                 .apply_uV = 1,
 305                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 306         },
 307         .num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
 308         .consumer_supplies = ldo2_consumers,
 309 };
 310
 311 /*ldo3 VCC_NAND WIFI/BT/FM_BCM4325*/
 312 static struct regulator_consumer_supply ldo3_consumers[] = {
 313         {
 314                 .supply = "ldo3",
 315         }
 316 };
 317
 318 static struct regulator_init_data rk2818_lp8725_ldo3_data = {
 319         .constraints = {
 320                 .name = "LDO3",
 321                 .min_uV = 1200000,
 322                 .max_uV = 3300000,
 323                 .apply_uV = 1,
 324                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 325         },
 326         .num_consumer_supplies = ARRAY_SIZE(ldo3_consumers),
 327         .consumer_supplies = ldo3_consumers,
 328 };
 329
 330 /*ldo4 VCCA CODEC_WM8994*/
 331 static struct regulator_consumer_supply ldo4_consumers[] = {
 332         {
 333                 .supply = "ldo4",
 334         }
 335 };
 336
 337 static struct regulator_init_data rk2818_lp8725_ldo4_data = {
 338         .constraints = {
 339                 .name = "LDO4",
 340                 .min_uV = 1200000,
 341                 .max_uV = 3300000,
 342                 .apply_uV = 1,
 343                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 344         },
 345         .num_consumer_supplies = ARRAY_SIZE(ldo4_consumers),
 346         .consumer_supplies = ldo4_consumers,
 347 };
 348
 349 /*ldo5 AVDD18 CODEC_WM8994*/
 350 static struct regulator_consumer_supply ldo5_consumers[] = {
 351         {
 352                 .supply = "ldo5",
 353         }
 354 };
 355
 356 static struct regulator_init_data rk2818_lp8725_ldo5_data = {
 357         .constraints = {
 358                 .name = "LDO5",
 359                 .min_uV = 1200000,
 360                 .max_uV = 3300000,
 361                 .apply_uV = 1,
 362                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 363         },
 364         .num_consumer_supplies = ARRAY_SIZE(ldo5_consumers),
 365         .consumer_supplies = ldo5_consumers,
 366 };
 367
 368 /*lilo1 VCCIO Sensor£¨3M£©*/
 369 static struct regulator_consumer_supply lilo1_consumers[] = {
 370         {
 371                 .supply = "lilo1",
 372         }
 373 };
 374
 375 static struct regulator_init_data rk2818_lp8725_lilo1_data = {
 376         .constraints = {
 377                 .name = "LILO1",
 378                 .min_uV = 800000,
 379                 .max_uV = 3300000,
 380                 .apply_uV = 1,
 381                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 382         },
 383         .num_consumer_supplies = ARRAY_SIZE(lilo1_consumers),
 384         .consumer_supplies = lilo1_consumers
 385 };
 386
 387 /*lilo2 VCC33_SD Sensor£¨3M£©*/
 388 static struct regulator_consumer_supply lilo2_consumers[] = {
 389         {
 390                 .supply = "lilo2",
 391         }
 392 };
 393
 394 static struct regulator_init_data rk2818_lp8725_lilo2_data = {
 395         .constraints = {
 396                 .name = "LILO2",
 397                 .min_uV = 800000,
 398                 .max_uV = 3300000,
 399                 .apply_uV = 1,
 400                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 401         },
 402         .num_consumer_supplies = ARRAY_SIZE(lilo2_consumers),
 403         .consumer_supplies = lilo2_consumers
 404 };
 405
 406 /*buck1 VDD12 Core*/
 407 static struct regulator_consumer_supply buck1_consumers[] = {
 408         {
 409                 .supply = "vdd12",
 410         }
 411 };
 412
 413 static struct regulator_init_data rk2818_lp8725_buck1_data = {
 414         .constraints = {
 415                 .name = "VDD12",
 416                 .min_uV = 800000,
 417                 .max_uV = 1500000,
 418                 .apply_uV = 1,
 419                 .always_on = 1,
 420                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE | REGULATOR_CHANGE_MODE,
 421                 .valid_modes_mask = REGULATOR_MODE_IDLE | REGULATOR_MODE_NORMAL,
 422         },
 423         .num_consumer_supplies = ARRAY_SIZE(buck1_consumers),
 424         .consumer_supplies = buck1_consumers
 425 };
 426
 427 /*buck2 VDDDR MobileDDR VCC*/
 428 static struct regulator_consumer_supply buck2_consumers[] = {
 429         {
 430                 .supply = "vccdr",
 431         }
 432 };
 433
 434 static struct regulator_init_data rk2818_lp8725_buck2_data = {
 435         .constraints = {
 436                 .name = "VCCDR",
 437                 .min_uV = 1800000,
 438                 .max_uV = 1800000,
 439                 .apply_uV = 1,
 440                 .always_on = 1,
 441                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 442         },
 443         .num_consumer_supplies = ARRAY_SIZE(buck2_consumers),
 444         .consumer_supplies = buck2_consumers
 445 };
 446
 447 /*buck1_v2 VDD12 Core*/
 448 static struct regulator_consumer_supply buck1_v2_consumers[] = {
 449         {
 450                 .supply = "vdd12_v2",
 451         }
 452 };
 453
 454 static struct regulator_init_data rk2818_lp8725_buck1_v2_data = {
 455         .constraints = {
 456                 .name = "VDD12_V2",
 457                 .min_uV = 800000,
 458                 .max_uV = 1500000,
 459                 .apply_uV = 1,
 460                 //.always_on = 1,
 461                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE | REGULATOR_CHANGE_MODE,
 462         },
 463         .num_consumer_supplies = ARRAY_SIZE(buck1_v2_consumers),
 464         .consumer_supplies = buck1_v2_consumers
 465 };
 466
 467 /*buck2_v2 VDDDR MobileDDR VCC*/
 468 static struct regulator_consumer_supply buck2_v2_consumers[] = {
 469         {
 470                 .supply = "vccdr_v2",
 471         }
 472 };
 473
 474 static struct regulator_init_data rk2818_lp8725_buck2_v2_data = {
 475         .constraints = {
 476                 .name = "VCCDR_V2",
 477                 .min_uV = 1800000,
 478                 .max_uV = 1800000,
 479                 .apply_uV = 1,
 480                 //.always_on = 1,
 481                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 482         },
 483         .num_consumer_supplies = ARRAY_SIZE(buck2_v2_consumers),
 484         .consumer_supplies = buck2_v2_consumers
 485 };
 486
 487 struct lp8725_regulator_subdev rk2818_lp8725_regulator_subdev[] = {
 488         {
 489                 .id=LP8725_LDO1,
 490                 .initdata=&rk2818_lp8725_ldo1_data,
 491          },
 492
 493         {
 494                 .id=LP8725_LDO2,
 495                 .initdata=&rk2818_lp8725_ldo2_data,
 496          },
 497
 498         {
 499                 .id=LP8725_LDO3,
 500                 .initdata=&rk2818_lp8725_ldo3_data,
 501          },
 502
 503         {
 504                 .id=LP8725_LDO4,
 505                 .initdata=&rk2818_lp8725_ldo4_data,
 506          },
 507
 508         {
 509                 .id=LP8725_LDO5,
 510                 .initdata=&rk2818_lp8725_ldo5_data,
 511          },
 512
 513         {
 514                 .id=LP8725_LILO1,
 515                 .initdata=&rk2818_lp8725_lilo1_data,
 516          },
 517
 518         {
 519                 .id=LP8725_LILO2,
 520                 .initdata=&rk2818_lp8725_lilo2_data,
 521          },
 522
 523         {
 524                 .id=LP8725_DCDC1,
 525                 .initdata=&rk2818_lp8725_buck1_data,
 526          },
 527
 528         {
 529                 .id=LP8725_DCDC2,
 530                 .initdata=&rk2818_lp8725_buck2_data,
 531          },
 532         {
 533                 .id=LP8725_DCDC1_V2,
 534                 .initdata=&rk2818_lp8725_buck1_v2_data,
 535          },
 536
 537         {
 538                 .id=LP8725_DCDC2_V2,
 539                 .initdata=&rk2818_lp8725_buck2_v2_data,
 540          },
 541 };
 542
 543 struct lp8725_platform_data rk2818_lp8725_data={
 544         .num_regulators=LP8725_NUM_REGULATORS,
 545         .regulators=rk2818_lp8725_regulator_subdev,
 546 };
 547 #endif
 548
 549 /*****************************************************************************************
 550  * gsensor devices
 551 *****************************************************************************************/
 552 #define GS_IRQ_PIN RK2818_PIN_PE3
 553
 554 struct rk2818_gs_platform_data rk2818_gs_platdata = {
 555         .gsensor_irq_pin = GS_IRQ_PIN,
 556 };
 557
 558 /*****************************************************************************************
 559  * wm8994  codec
 560  * author: cjq@rock-chips.com
 561  *****************************************************************************************/
 562 static struct wm8994_platform_data wm8994_data = {
 563     .mic_input = 0,
 564     .micBase_vcc = 0,
 565     .bb_input = 0,
 566     .bb_output = 0,
 567     .frequence = 0,
 568     .enable_pin = 0,
 569     .headset_pin = 0,
 570     .headset_call_vol = 0,
 571     .speaker_call_vol = 0,
 572     .earpiece_call_vol = 0,
 573     .bt_call_vol = 0,
 574 };// must initialize
 575
 576 /*****************************************************************************************
 577  * i2c devices
 578  * author: kfx@rock-chips.com
 579 *****************************************************************************************/
 580 static void rk2818_i2c0_io_init(void)
 581 {
 582         rk2818_mux_api_set(GPIOE_I2C0_SEL_NAME, IOMUXA_I2C0);
 583 }
 584
 585 static void rk2818_i2c1_io_init(void)
 586 {
 587         rk2818_mux_api_set(GPIOE_U1IR_I2C1_NAME, IOMUXA_I2C1);
 588 }
 589
 590 struct rk2818_i2c_platform_data default_i2c0_data = {
 591         .bus_num    = 0,
 592         .flags      = 0,
 593         .slave_addr = 0xff,
 594         .scl_rate  = 400*1000,
 595         .mode       = I2C_MODE_IRQ, //I2C_MODE_POLL
 596         .io_init = rk2818_i2c0_io_init,
 597 };
 598 struct rk2818_i2c_platform_data default_i2c1_data = {
 599 #ifdef CONFIG_I2C0_RK2818
 600         .bus_num    = 1,
 601 #else
 602         .bus_num        = 0,
 603 #endif
 604         .flags      = 0,
 605         .slave_addr = 0xff,
 606         .scl_rate  = 400*1000,
 607         .mode       = I2C_MODE_IRQ, //I2C_MODE_POLL
 608         .io_init = rk2818_i2c1_io_init,
 609 };
 610
 611 struct rk2818_i2c_spi_data default_i2c2_data = {
 612         .bus_num    = 2,
 613         .flags      = 0,
 614         .slave_addr = 0xff,
 615         .scl_rate  = 400*1000,
 616
 617 };
 618 struct rk2818_i2c_spi_data default_i2c3_data = {
 619
 620         .bus_num    = 3,
 621         .flags      = 0,
 622         .slave_addr = 0xff,
 623         .scl_rate  = 400*1000,
 624
 625 };
 626 static struct i2c_board_info __initdata board_i2c0_devices[] = {
 627 #if defined (CONFIG_RK1000_CONTROL)
 628         {
 629                 .type                   = "rk1000_control",
 630                 .addr           = 0x40,
 631                 .flags                  = 0,
 632         },
 633 #endif
 634
 635 #if defined (CONFIG_RK1000_TVOUT)
 636         {
 637                 .type                   = "rk1000_tvout",
 638                 .addr           = 0x42,
 639                 .flags                  = 0,
 640         },
 641 #endif
 642 #if defined (CONFIG_SND_SOC_RK1000)
 643         {
 644                 .type                   = "rk1000_i2c_codec",
 645                 .addr           = 0x60,
 646                 .flags                  = 0,
 647         },
 648 #endif
 649 #if defined (CONFIG_SND_SOC_WM8988)
 650         {
 651                 .type                   = "wm8988",
 652                 .addr           = 0x1a,
 653                 .flags                  = 0,
 654         }
 655 #endif
 656 #if defined (CONFIG_TOUCHSCREEN_IT7250)  //add by robert for ctp_it7250
 657     {
 658         .type           = "Ctp_it7250",
 659         .addr           = 0x46,
 660         .flags          = 0,
 661         .irq            = RK2818_PIN_PE1,
 662     },
 663 #endif  //end add
 664 };
 665 static struct i2c_board_info __initdata board_i2c1_devices[] = {
 666 #if defined (CONFIG_RTC_HYM8563)
 667         {
 668                 .type                   = "rtc_hym8563",
 669                 .addr           = 0x51,
 670                 .flags                  = 0,
 671         },
 672 #endif
 673 #if defined (CONFIG_RTC_DRV_S35392A)
 674         {
 675                 .type                   = "rtc-s35392a",
 676                 .addr           = 0x30,
 677                 .flags                  = 0,
 678         },
 679 #endif
 680 #if defined (CONFIG_FM_QN8006)
 681         {
 682                 .type                   = "fm_qn8006",
 683                 .addr           = 0x2b,
 684                 .flags                  = 0,
 685         },
 686 #endif
 687 #if defined (CONFIG_GPIO_PCA9554)
 688         {
 689                 .type                   = "extend_gpio_pca9554",
 690                 .addr           = 0x3c,
 691                 .flags                  = 0,
 692                 .platform_data=&rk2818_pca9554_data.gpio_base,
 693         },
 694 #endif
 695 #if defined (CONFIG_RK2818_REGULATOR_LP8725)
 696         {
 697                 .type                   = "lp8725",
 698                 .addr           = 0x79,
 699                 .flags                  = 0,
 700                 .platform_data=&rk2818_lp8725_data,
 701         },
 702 #endif
 703 #if defined (CONFIG_GS_MMA7660)
 704     {
 705         .type           = "gs_mma7660",
 706         .addr           = 0x4c,
 707         .flags          = 0,
 708         .irq            = GS_IRQ_PIN,
 709                 .platform_data = &rk2818_gs_platdata,
 710     },
 711 #endif
 712
 713 };
 714
 715 static struct i2c_board_info __initdata board_i2c2_devices[] = {
 716
 717 };
 718
 719 static struct i2c_board_info __initdata board_i2c3_devices[] = {
 720 #if defined (CONFIG_SND_SOC_WM8994)
 721         {
 722                 .type                   = "wm8994",
 723                 .addr           = 0x1a,
 724                 .flags                  = 0,
 725                 .platform_data  = &wm8994_data,
 726         },
 727 #endif
 728 };
 729
 730 /*****************************************************************************************
 731  * camera  devices
 732  * author: ddl@rock-chips.com
 733  *****************************************************************************************/
 734 #define RK2818_CAM_POWER_PIN    FPGA_PIO1_05//SPI_GPIO_P1_05
 735 #define RK2818_CAM_RESET_PIN    FPGA_PIO1_14//SPI_GPIO_P1_14
 736
 737 static int rk28_sensor_io_init(void);
 738 static int rk28_sensor_io_deinit(void);
 739
 740 struct rk28camera_platform_data rk28_camera_platform_data = {
 741     .io_init = rk28_sensor_io_init,
 742     .io_deinit = rk28_sensor_io_deinit,
 743     .gpio_res = {
 744         {
 745             .gpio_reset = RK2818_CAM_RESET_PIN,
 746             .gpio_power = RK2818_CAM_POWER_PIN,
 747             .dev_name = "ov2655"
 748         }, {
 749             .gpio_reset = INVALID_GPIO,
 750             .gpio_power = INVALID_GPIO,
 751             .dev_name = NULL
 752         }
 753     }
 754 };
 755
 756 static int rk28_sensor_io_init(void)
 757 {
 758     int ret = 0, i;
 759     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
 760
 761     printk("\n%s....%d    ******** ddl *********\n",__FUNCTION__,__LINE__);
 762
 763     for (i=0; i<2; i++) {
 764         camera_reset = rk28_camera_platform_data.gpio_res[i].gpio_reset;
 765         camera_power = rk28_camera_platform_data.gpio_res[i].gpio_power;
 766
 767         if (camera_power != INVALID_GPIO) {
 768             ret = gpio_request(camera_power, "camera power");
 769             if (ret)
 770                 continue;
 771
 772             gpio_set_value(camera_reset, 1);
 773             gpio_direction_output(camera_power, 0);
 774         }
 775
 776         if (camera_reset != INVALID_GPIO) {
 777             ret = gpio_request(camera_reset, "camera reset");
 778             if (ret) {
 779                 if (camera_power != INVALID_GPIO)
 780                     gpio_free(camera_power);
 781
 782                 continue;
 783             }
 784
 785             gpio_set_value(camera_reset, 0);
 786             gpio_direction_output(camera_reset, 0);
 787         }
 788     }
 789
 790     return 0;
 791 }
 792
 793 static int rk28_sensor_io_deinit(void)
 794 {
 795     unsigned int i;
 796     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
 797
 798     printk("\n%s....%d    ******** ddl *********\n",__FUNCTION__,__LINE__);
 799
 800     for (i=0; i<2; i++) {
 801         camera_reset = rk28_camera_platform_data.gpio_res[i].gpio_reset;
 802         camera_power = rk28_camera_platform_data.gpio_res[i].gpio_power;
 803
 804         if (camera_power != INVALID_GPIO){
 805             gpio_direction_input(camera_power);
 806             gpio_free(camera_power);
 807         }
 808
 809         if (camera_reset != INVALID_GPIO)  {
 810             gpio_direction_input(camera_reset);
 811             gpio_free(camera_reset);
 812         }
 813     }
 814
 815     return 0;
 816 }
 817
 818
 819 static int rk28_sensor_power(struct device *dev, int on)
 820 {
 821     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
 822
 823     if(rk28_camera_platform_data.gpio_res[0].dev_name &&  (strcmp(rk28_camera_platform_data.gpio_res[0].dev_name, dev_name(dev)) == 0)) {
 824         camera_reset = rk28_camera_platform_data.gpio_res[0].gpio_reset;
 825         camera_power = rk28_camera_platform_data.gpio_res[0].gpio_power;
 826     } else if (rk28_camera_platform_data.gpio_res[1].dev_name && (strcmp(rk28_camera_platform_data.gpio_res[1].dev_name, dev_name(dev)) == 0)) {
 827         camera_reset = rk28_camera_platform_data.gpio_res[1].gpio_reset;
 828         camera_power = rk28_camera_platform_data.gpio_res[1].gpio_power;
 829     }
 830
 831     if (camera_reset != INVALID_GPIO) {
 832         gpio_set_value(camera_reset, !on);
 833         //printk("\n%s..%s..ResetPin=%d ..PinLevel = %x   ******** ddl *********\n",__FUNCTION__,dev_name(dev),camera_reset, on);
 834     }
 835     if (camera_power != INVALID_GPIO)  {
 836         gpio_set_value(camera_power, !on);
 837         printk("\n%s..%s..PowerPin=%d ..PinLevel = %x   ******** ddl *********\n",__FUNCTION__,dev_name(dev), camera_power, !on);
 838     }
 839     if (camera_reset != INVALID_GPIO) {
 840         msleep(3);          /* delay 3 ms */
 841         gpio_set_value(camera_reset,on);
 842         printk("\n%s..%s..ResetPin= %d..PinLevel = %x   ******** ddl *********\n",__FUNCTION__,dev_name(dev), camera_reset, on);
 843     }
 844     return 0;
 845 }
 846
 847
 848 #define OV2655_IIC_ADDR             0x60
 849 static struct i2c_board_info rk2818_i2c_cam_info[] = {
 850 #ifdef CONFIG_SOC_CAMERA_OV2655
 851         {
 852                 I2C_BOARD_INFO("ov2655", OV2655_IIC_ADDR>>1)
 853         },
 854 #endif
 855 };
 856
 857 struct soc_camera_link rk2818_iclink = {
 858         .bus_id         = RK28_CAM_PLATFORM_DEV_ID,
 859         .power          = rk28_sensor_power,
 860         .board_info     = &rk2818_i2c_cam_info[0],
 861         .i2c_adapter_id = 2,
 862 #ifdef CONFIG_SOC_CAMERA_OV2655
 863         .module_name    = "ov2655",
 864 #endif
 865 };
 866
 867 /*****************************************************************************************
 868  * battery  devices
 869  * author: lw@rock-chips.com
 870  *****************************************************************************************/
 871 #define CHARGEOK_PIN    SPI_GPIO_P6_06//RK2818_PIN_PB1
 872 struct rk2818_battery_platform_data rk2818_battery_platdata = {
 873         .charge_ok_pin = CHARGEOK_PIN,
 874         .charge_ok_level = 0,
 875 };
 876
 877
 878 /*****************************************************************************************
 879  * serial devices
 880  * author: lhh@rock-chips.com
 881  *****************************************************************************************/
 882 static int serial_io_init(void)
 883 {
 884         int ret;
 885 #if 1
 886         //cz@rock-chips.com
 887         //20100808
 888         //UART0µÄËÄ¸ö¹Ü½ÅÏÈIOMUX³ÉGPIO
 889         //È»ºó·Ö±ðÉèÖÃÊäÈëÊä³ö/À¸ßÀµÍ´¦Àí
 890         //×îºóÔÙIOMUX³ÉUART
 891         //·ÀÖ¹Ö±½ÓIOMUX³ÉUARTºóËÄ¸ö¹Ü½ÅµÄ×´Ì¬²»¶ÔÊ±
 892         //²Ù×÷UARTµ¼ÖÂUART_USR_BUSYÊ¼ÖÕÎª1Ôì³ÉÈçÏÂËÀÑ»·
 893         //while(rk2818_uart_read(port,UART_USR)&UART_USR_BUSY)
 894         //UARTËÄ¸ö¹Ü½ÅÔÚÎ´´«ÊäÊ±Õý³£×´Ì¬Ó¦¸ÃÎª£º
 895         //RX/TX£ºHIGH
 896         //CTS/RTS£ºLOW
 897         //×¢Òâ£ºCTS/RTSÎªµÍÓÐÐ§£¬Ó²¼þÉÏ²»Ó¦¸ÃÇ¿ÐÐ×öÉÏÀ
 898                 rk2818_mux_api_set(GPIOG1_UART0_MMC1WPT_NAME, IOMUXA_GPIO1_C1 /*IOMUXA_UART0_SOUT*/);
 899                 rk2818_mux_api_set(GPIOG0_UART0_MMC1DET_NAME, IOMUXA_GPIO1_C0 /*IOMUXA_UART0_SIN*/);
 900
 901                 ret = gpio_request(RK2818_PIN_PG0, NULL);
 902                 if(ret != 0)
 903                 {
 904                   gpio_free(RK2818_PIN_PG0);
 905                 }
 906                 gpio_direction_output(RK2818_PIN_PG0,GPIO_HIGH);
 907
 908
 909                 ret = gpio_request(RK2818_PIN_PG1, NULL);
 910                 if(ret != 0)
 911                 {
 912                   gpio_free(RK2818_PIN_PG1);
 913                 }
 914                 gpio_direction_output(RK2818_PIN_PG1,GPIO_HIGH);
 915
 916                 gpio_pull_updown(RK2818_PIN_PG1,GPIOPullUp);
 917                 gpio_pull_updown(RK2818_PIN_PG0,GPIOPullUp);
 918
 919                 rk2818_mux_api_set(GPIOG1_UART0_MMC1WPT_NAME, IOMUXA_UART0_SOUT);
 920                 rk2818_mux_api_set(GPIOG0_UART0_MMC1DET_NAME, IOMUXA_UART0_SIN);
 921
 922                 rk2818_mux_api_set(GPIOB2_U0CTSN_SEL_NAME, IOMUXB_GPIO0_B2/*IOMUXB_UART0_CTS_N*/);
 923                 rk2818_mux_api_set(GPIOB3_U0RTSN_SEL_NAME, IOMUXB_GPIO0_B3/*IOMUXB_UART0_RTS_N*/);
 924
 925                 ret = gpio_request(RK2818_PIN_PB2, NULL);
 926                 if(ret != 0)
 927                 {
 928                   gpio_free(RK2818_PIN_PB2);
 929                 }
 930                 gpio_direction_input(RK2818_PIN_PB2);
 931         //        gpio_direction_output(RK2818_PIN_PB2,GPIO_LOW);
 932
 933                 ret = gpio_request(RK2818_PIN_PB3, NULL);
 934                 if(ret != 0)
 935                 {
 936                   gpio_free(RK2818_PIN_PB3);
 937                 }
 938                 gpio_direction_output(RK2818_PIN_PB3,GPIO_LOW);
 939 #endif
 940
 941         rk2818_mux_api_set(GPIOB2_U0CTSN_SEL_NAME, IOMUXB_UART0_CTS_N);
 942         rk2818_mux_api_set(GPIOB3_U0RTSN_SEL_NAME, IOMUXB_UART0_RTS_N);
 943
 944         return 0;
 945 }
 946
 947 struct rk2818_serial_platform_data rk2818_serial0_platdata = {
 948         .io_init = serial_io_init,
 949 };
 950
 951 /*****************************************************************************************
 952  * i2s devices
 953  * author: lhhrock-chips.com
 954  *****************************************************************************************/
 955 static int i2s_io_init(void)
 956 {
 957     /* Configure the I2S pins in correct mode */
 958     rk2818_mux_api_set(CXGPIO_I2S_SEL_NAME,IOMUXB_I2S_INTERFACE);
 959         return 0;
 960 }
 961
 962 struct rk2818_i2s_platform_data rk2818_i2s_platdata = {
 963         .io_init = i2s_io_init,
 964 };
 965
 966
 967 /*****************************************************************************************
 968  * spi devices
 969  * author: lhhrock-chips.com
 970  *****************************************************************************************/
 971 #define SPI_CHIPSELECT_NUM 3
 972 struct spi_cs_gpio rk2818_spi_cs_gpios[SPI_CHIPSELECT_NUM] = {
 973         {
 974                 .name = "spi cs0",
 975                 .cs_gpio = RK2818_PIN_PB4,
 976                 .cs_iomux_name = GPIOB4_SPI0CS0_MMC0D4_NAME,//if no iomux,set it NULL
 977                 .cs_iomux_mode = IOMUXA_GPIO0_B4,
 978         },
 979         {
 980                 .name = "spi cs1",
 981                 .cs_gpio = RK2818_PIN_PB0,
 982                 .cs_iomux_name = GPIOB0_SPI0CSN1_MMC1PCA_NAME,
 983                 .cs_iomux_mode = IOMUXA_GPIO0_B0,
 984         },
 985         {
 986                 .name = "spi cs2",
 987                 .cs_gpio = RK2818_PIN_PF5,
 988                 .cs_iomux_name = GPIOF5_APWM3_DPWM3_NAME,
 989                 .cs_iomux_mode = IOMUXB_GPIO1_B5,
 990         }
 991 };
 992
 993 static int spi_io_init(struct spi_cs_gpio *cs_gpios, int cs_num)
 994 {
 995         int i,j,ret;
 996         //clk
 997         rk2818_mux_api_set(GPIOB_SPI0_MMC0_NAME, IOMUXA_SPI0);
 998         //cs
 999         if (cs_gpios) {
1000                 for (i=0; i<cs_num; i++) {
1001                         rk2818_mux_api_set(cs_gpios[i].cs_iomux_name, cs_gpios[i].cs_iomux_mode);
1002                         ret = gpio_request(cs_gpios[i].cs_gpio, cs_gpios[i].name);
1003                         if (ret) {
1004                                 for (j=0;j<i;j++) {
1005                                         gpio_free(cs_gpios[j].cs_gpio);
1006                                         rk2818_mux_api_mode_resume(cs_gpios[j].cs_iomux_name);
1007                                 }
1008                                 printk("[fun:%s, line:%d], gpio request err\n", __func__, __LINE__);
1009                                 return -1;
1010                         }
1011                 }
1012         }
1013         return 0;
1014 }
1015
1016 static int spi_io_deinit(struct spi_cs_gpio *cs_gpios, int cs_num)
1017 {
1018         int i;
1019         rk2818_mux_api_mode_resume(GPIOB_SPI0_MMC0_NAME);
1020
1021         if (cs_gpios) {
1022                 for (i=0; i<cs_num; i++) {
1023                         gpio_free(cs_gpios[i].cs_gpio);
1024                         rk2818_mux_api_mode_resume(cs_gpios[i].cs_iomux_name);
1025                 }
1026         }
1027
1028         return 0;
1029 }
1030
1031 struct rk2818_spi_platform_data rk2818_spi_platdata = {
1032         .num_chipselect = SPI_CHIPSELECT_NUM,//raho ´ó°åÐèÒªÖ§³Ö3¸öÆ¬Ñ¡ dxj
1033         .chipselect_gpios = rk2818_spi_cs_gpios,
1034         .io_init = spi_io_init,
1035         .io_deinit = spi_io_deinit,
1036 };
1037
1038
1039 /*****************************************************************************************
1040  * xpt2046 touch panel
1041  * author: dxjrock-chips.com
1042  *****************************************************************************************/
1043 #define XPT2046_GPIO_INT           RK2818_PIN_PE1
1044 #define DEBOUNCE_REPTIME  3
1045
1046 #if defined(CONFIG_TOUCHSCREEN_XPT2046_320X480_SPI)
1047 static struct xpt2046_platform_data xpt2046_info = {
1048         .model                  = 2046,
1049         .keep_vref_on   = 1,
1050         .swap_xy                = 0,
1051         .x_min                  = 0,
1052         .x_max                  = 320,
1053         .y_min                  = 0,
1054         .y_max                  = 480,
1055         .debounce_max           = 7,
1056         .debounce_rep           = DEBOUNCE_REPTIME,
1057         .debounce_tol           = 20,
1058         .gpio_pendown           = XPT2046_GPIO_INT,
1059         .penirq_recheck_delay_usecs = 1,
1060 };
1061 #elif defined(CONFIG_TOUCHSCREEN_XPT2046_320X480_CBN_SPI)
1062 static struct xpt2046_platform_data xpt2046_info = {
1063         .model                  = 2046,
1064         .keep_vref_on   = 1,
1065         .swap_xy                = 0,
1066         .x_min                  = 0,
1067         .x_max                  = 320,
1068         .y_min                  = 0,
1069         .y_max                  = 480,
1070         .debounce_max           = 7,
1071         .debounce_rep           = DEBOUNCE_REPTIME,
1072         .debounce_tol           = 20,
1073         .gpio_pendown           = XPT2046_GPIO_INT,
1074         .penirq_recheck_delay_usecs = 1,
1075 };
1076 #elif defined(CONFIG_TOUCHSCREEN_XPT2046_SPI)
1077 static struct xpt2046_platform_data xpt2046_info = {
1078         .model                  = 2046,
1079         .keep_vref_on   = 1,
1080         .swap_xy                = 1,
1081         .x_min                  = 0,
1082         .x_max                  = 800,
1083         .y_min                  = 0,
1084         .y_max                  = 480,
1085         .debounce_max           = 7,
1086         .debounce_rep           = DEBOUNCE_REPTIME,
1087         .debounce_tol           = 20,
1088         .gpio_pendown           = XPT2046_GPIO_INT,
1089
1090         .penirq_recheck_delay_usecs = 1,
1091 };
1092 #elif defined(CONFIG_TOUCHSCREEN_XPT2046_CBN_SPI)
1093 static struct xpt2046_platform_data xpt2046_info = {
1094         .model                  = 2046,
1095         .keep_vref_on   = 1,
1096         .swap_xy                = 1,
1097         .x_min                  = 0,
1098         .x_max                  = 800,
1099         .y_min                  = 0,
1100         .y_max                  = 480,
1101         .debounce_max           = 7,
1102         .debounce_rep           = DEBOUNCE_REPTIME,
1103         .debounce_tol           = 20,
1104         .gpio_pendown           = XPT2046_GPIO_INT,
1105
1106         .penirq_recheck_delay_usecs = 1,
1107 };
1108 #endif
1109
1110 static struct spi_board_info board_spi_devices[] = {
1111 #if defined(CONFIG_SPI_FPGA)
1112         {       /* fpga ice65l08xx */
1113                 .modalias       = "spi_fpga",
1114                 .chip_select    = 1,
1115                 .max_speed_hz   = 12 * 1000 * 1000,
1116                 .bus_num        = 0,
1117                 .mode   = SPI_MODE_0,
1118                 //.platform_data = &rk2818_spi_platdata,
1119         },
1120 #endif
1121 #if defined(CONFIG_ENC28J60)
1122         {       /* net chip */
1123                 .modalias       = "enc28j60",
1124                 .chip_select    = 1,
1125                 .max_speed_hz   = 12 * 1000 * 1000,
1126                 .bus_num        = 0,
1127                 .mode   = SPI_MODE_0,
1128         },
1129 #endif
1130 #if defined(CONFIG_TOUCHSCREEN_XPT2046_320X480_SPI) || defined(CONFIG_TOUCHSCREEN_XPT2046_320X480_CBN_SPI)\
1131     ||defined(CONFIG_TOUCHSCREEN_XPT2046_SPI) || defined(CONFIG_TOUCHSCREEN_XPT2046_CBN_SPI)
1132         {
1133                 .modalias       = "xpt2046_ts",
1134                 .chip_select    = 2,
1135                 .max_speed_hz   = 125 * 1000 * 26,/* (max sample rate @ 3V) * (cmd + data + overhead) */
1136                 .bus_num        = 0,
1137                 .irq = XPT2046_GPIO_INT,
1138                 .platform_data = &xpt2046_info,
1139         },
1140 #endif
1141 #if defined(CONFIG_SMS_SPI_ROCKCHIP)
1142         {
1143                 .modalias       = "siano1186",
1144                 .chip_select    = 0,
1145                 .max_speed_hz   = 12*1000*1000,
1146                 .bus_num        = 0,
1147                 .irq            = RK2818_PIN_PA6,
1148         },
1149 #endif
1150 };
1151
1152 /*****************************************************************************************
1153  * lcd  devices
1154  * author: zyw@rock-chips.com
1155  *****************************************************************************************/
1156 //#ifdef  CONFIG_LCD_TD043MGEA1
1157 #define LCD_TXD_PIN          RK2818_PIN_PE4
1158 #define LCD_CLK_PIN          RK2818_PIN_PE5
1159 #define LCD_CS_PIN           RK2818_PIN_PH6
1160 #define LCD_TXD_MUX_NAME     GPIOE_I2C0_SEL_NAME
1161 #define LCD_CLK_MUX_NAME     NULL
1162 #define LCD_CS_MUX_NAME      GPIOH6_IQ_SEL_NAME
1163 #define LCD_TXD_MUX_MODE     1
1164 #define LCD_CLK_MUX_MODE     1
1165 #define LCD_CS_MUX_MODE      0
1166 //#endif
1167 static int rk2818_lcd_io_init(void)
1168 {
1169     int ret = 0;
1170
1171     rk2818_mux_api_set(LCD_CS_MUX_NAME, LCD_CS_MUX_MODE);
1172     if (LCD_CS_PIN != INVALID_GPIO) {
1173         ret = gpio_request(LCD_CS_PIN, NULL);
1174         if(ret != 0)
1175         {
1176             goto err1;
1177             printk(">>>>>> lcd cs gpio_request err \n ");
1178         }
1179     }
1180
1181     rk2818_mux_api_set(LCD_CLK_MUX_NAME, LCD_CLK_MUX_MODE);
1182     if (LCD_CLK_PIN != INVALID_GPIO) {
1183         ret = gpio_request(LCD_CLK_PIN, NULL);
1184         if(ret != 0)
1185         {
1186             goto err2;
1187             printk(">>>>>> lcd clk gpio_request err \n ");
1188         }
1189     }
1190
1191     rk2818_mux_api_set(LCD_TXD_MUX_NAME, LCD_TXD_MUX_MODE);
1192     if (LCD_TXD_PIN != INVALID_GPIO) {
1193         ret = gpio_request(LCD_TXD_PIN, NULL);
1194         if(ret != 0)
1195         {
1196             goto err3;
1197             printk(">>>>>> lcd txd gpio_request err \n ");
1198         }
1199     }
1200
1201     return 0;
1202
1203 err3:
1204     if (LCD_CLK_PIN != INVALID_GPIO) {
1205         gpio_free(LCD_CLK_PIN);
1206     }
1207 err2:
1208     if (LCD_CS_PIN != INVALID_GPIO) {
1209         gpio_free(LCD_CS_PIN);
1210     }
1211 err1:
1212     return ret;
1213 }
1214
1215 static int rk2818_lcd_io_deinit(void)
1216 {
1217     int ret = 0;
1218     gpio_free(LCD_CS_PIN);
1219     rk2818_mux_api_mode_resume(LCD_CS_MUX_NAME);
1220     gpio_free(LCD_CLK_PIN);
1221     gpio_free(LCD_TXD_PIN);
1222     rk2818_mux_api_mode_resume(LCD_TXD_MUX_NAME);
1223     rk2818_mux_api_mode_resume(LCD_CLK_MUX_NAME);
1224
1225     return ret;
1226 }
1227
1228 struct rk2818lcd_info rk2818_lcd_info = {
1229     .txd_pin  = LCD_TXD_PIN,
1230     .clk_pin = LCD_CLK_PIN,
1231     .cs_pin = LCD_CS_PIN,
1232     .io_init   = rk2818_lcd_io_init,
1233     .io_deinit = rk2818_lcd_io_deinit,
1234 };
1235
1236
1237 /*****************************************************************************************
1238  * frame buffe  devices
1239  * author: zyw@rock-chips.com
1240  *****************************************************************************************/
1241 #define FB_ID                       0
1242 #define FB_DISPLAY_ON_PIN           INVALID_GPIO
1243 #define FB_LCD_STANDBY_PIN          INVALID_GPIO
1244 #define FB_MCU_FMK_PIN              INVALID_GPIO
1245
1246 #define FB_DISPLAY_ON_VALUE         GPIO_LOW
1247 #define FB_LCD_STANDBY_VALUE        0
1248
1249 #define FB_DISPLAY_ON_MUX_NAME      NULL
1250 #define FB_DISPLAY_ON_MUX_MODE      0
1251
1252 #define FB_LCD_STANDBY_MUX_NAME     NULL
1253 #define FB_LCD_STANDBY_MUX_MODE     1
1254
1255 #define FB_MCU_FMK_PIN_MUX_NAME     NULL
1256 #define FB_MCU_FMK_MUX_MODE         0
1257
1258 #define FB_DATA0_16_MUX_NAME       GPIOC_LCDC16BIT_SEL_NAME
1259 #define FB_DATA0_16_MUX_MODE        1
1260
1261 #define FB_DATA17_18_MUX_NAME      GPIOC_LCDC18BIT_SEL_NAME
1262 #define FB_DATA17_18_MUX_MODE       1
1263
1264 #define FB_DATA19_24_MUX_NAME      GPIOC_LCDC24BIT_SEL_NAME
1265 #define FB_DATA19_24_MUX_MODE       1
1266
1267 #define FB_DEN_MUX_NAME            CXGPIO_LCDDEN_SEL_NAME
1268 #define FB_DEN_MUX_MODE             1
1269
1270 #define FB_VSYNC_MUX_NAME          CXGPIO_LCDVSYNC_SEL_NAME
1271 #define FB_VSYNC_MUX_MODE           1
1272
1273 #define FB_MCU_FMK_MUX_NAME        NULL
1274 #define FB_MCU_FMK_MUX_MODE         0
1275
1276 static int rk2818_fb_io_init(struct rk2818_fb_setting_info *fb_setting)
1277 {
1278     int ret = 0;
1279     if(fb_setting->data_num <=16)
1280         rk2818_mux_api_set(FB_DATA0_16_MUX_NAME, FB_DATA0_16_MUX_MODE);
1281     if(fb_setting->data_num >16 && fb_setting->data_num<=18)
1282         rk2818_mux_api_set(FB_DATA17_18_MUX_NAME, FB_DATA17_18_MUX_MODE);
1283     if(fb_setting->data_num >18)
1284         rk2818_mux_api_set(FB_DATA19_24_MUX_NAME, FB_DATA19_24_MUX_MODE);
1285
1286     if(fb_setting->vsync_en)
1287         rk2818_mux_api_set(FB_VSYNC_MUX_NAME, FB_VSYNC_MUX_MODE);
1288
1289     if(fb_setting->den_en)
1290         rk2818_mux_api_set(FB_DEN_MUX_NAME, FB_DEN_MUX_MODE);
1291
1292     if(fb_setting->mcu_fmk_en && FB_MCU_FMK_MUX_NAME && (FB_MCU_FMK_PIN != INVALID_GPIO))
1293     {
1294         rk2818_mux_api_set(FB_MCU_FMK_MUX_NAME, FB_MCU_FMK_MUX_MODE);
1295         ret = gpio_request(FB_MCU_FMK_PIN, NULL);
1296         if(ret != 0)
1297         {
1298             gpio_free(FB_MCU_FMK_PIN);
1299             printk(">>>>>> FB_MCU_FMK_PIN gpio_request err \n ");
1300         }
1301         gpio_direction_input(FB_MCU_FMK_PIN);
1302     }
1303
1304     if(fb_setting->disp_on_en && FB_DISPLAY_ON_MUX_NAME && (FB_DISPLAY_ON_PIN != INVALID_GPIO))
1305     {
1306         rk2818_mux_api_set(FB_DISPLAY_ON_MUX_NAME, FB_DISPLAY_ON_MUX_MODE);
1307         ret = gpio_request(FB_DISPLAY_ON_PIN, NULL);
1308         if(ret != 0)
1309         {
1310             gpio_free(FB_DISPLAY_ON_PIN);
1311             printk(">>>>>> FB_DISPLAY_ON_PIN gpio_request err \n ");
1312         }
1313     }
1314
1315     if(fb_setting->disp_on_en && FB_LCD_STANDBY_MUX_NAME && (FB_LCD_STANDBY_PIN != INVALID_GPIO))
1316     {
1317         rk2818_mux_api_set(FB_LCD_STANDBY_MUX_NAME, FB_LCD_STANDBY_MUX_MODE);
1318         ret = gpio_request(FB_LCD_STANDBY_PIN, NULL);
1319         if(ret != 0)
1320         {
1321             gpio_free(FB_LCD_STANDBY_PIN);
1322             printk(">>>>>> FB_LCD_STANDBY_PIN gpio_request err \n ");
1323         }
1324     }
1325
1326     return ret;
1327 }
1328
1329 struct rk2818fb_info rk2818_fb_info = {
1330     .fb_id   = FB_ID,
1331     .disp_on_pin = FB_DISPLAY_ON_PIN,
1332     .disp_on_value = FB_DISPLAY_ON_VALUE,
1333     .standby_pin = FB_LCD_STANDBY_PIN,
1334     .standby_value = FB_LCD_STANDBY_VALUE,
1335     .mcu_fmk_pin = FB_MCU_FMK_PIN,
1336     .lcd_info = &rk2818_lcd_info,
1337     .io_init   = rk2818_fb_io_init,
1338 };
1339
1340 /*****************************************************************************************
1341  * backlight  devices
1342  * author: nzy@rock-chips.com
1343  *****************************************************************************************/
1344  /*
1345  GPIOF2_APWM0_SEL_NAME,       IOMUXB_PWM0
1346  GPIOF3_APWM1_MMC0DETN_NAME,  IOMUXA_PWM1
1347  GPIOF4_APWM2_MMC0WPT_NAME,   IOMUXA_PWM2
1348  GPIOF5_APWM3_DPWM3_NAME,     IOMUXB_PWM3
1349  */
1350
1351 #define PWM_ID            0
1352 #define PWM_MUX_NAME      GPIOF2_APWM0_SEL_NAME
1353 #define PWM_MUX_MODE      IOMUXB_PWM0
1354 #define PWM_EFFECT_VALUE  0
1355
1356
1357 #define BL_EN_MUX_NAME    GPIOF34_UART3_SEL_NAME
1358 #define BL_EN_MUX_MODE    IOMUXB_GPIO1_B34
1359
1360 #define BL_EN_PIN         RK2818_PIN_PF3
1361 #define BL_EN_VALUE       GPIO_HIGH
1362
1363
1364
1365 static int rk2818_backlight_io_init(void)
1366 {
1367     int ret = 0;
1368
1369     rk2818_mux_api_set(PWM_MUX_NAME, PWM_MUX_MODE);
1370
1371     rk2818_mux_api_set(BL_EN_MUX_NAME, BL_EN_MUX_MODE);
1372
1373     ret = gpio_request(BL_EN_PIN, NULL);
1374     if(ret != 0)
1375     {
1376         gpio_free(BL_EN_PIN);
1377         printk(KERN_ERR ">>>>>> lcd_cs gpio_request err \n ");
1378     }
1379
1380     gpio_direction_output(BL_EN_PIN, 0);
1381     gpio_set_value(BL_EN_PIN, BL_EN_VALUE);
1382
1383     return ret;
1384 }
1385
1386 static int rk2818_backlight_io_deinit(void)
1387 {
1388     int ret = 0;
1389
1390     gpio_free(BL_EN_PIN);
1391
1392     rk2818_mux_api_mode_resume(PWM_MUX_NAME);
1393
1394     rk2818_mux_api_mode_resume(BL_EN_MUX_NAME);
1395
1396     return ret;
1397 }
1398
1399 struct rk2818_bl_info rk2818_bl_info = {
1400     .pwm_id   = PWM_ID,
1401     .bl_ref   = PWM_EFFECT_VALUE,
1402     .io_init   = rk2818_backlight_io_init,
1403     .io_deinit = rk2818_backlight_io_deinit,
1404 };
1405
1406
1407 /*****************************************************************************************
1408  * netcard  devices
1409  * author: lyx@rock-chips.com
1410  *****************************************************************************************/
1411 #ifdef CONFIG_DM9000
1412 /*
1413 GPIOA5_FLASHCS1_SEL_NAME     IOMUXB_FLASH_CS1
1414 GPIOA6_FLASHCS2_SEL_NAME     IOMUXB_FLASH_CS2
1415 GPIOA7_FLASHCS3_SEL_NAME     IOMUXB_FLASH_CS3
1416 GPIOE_SPI1_FLASH_SEL1_NAME   IOMUXA_FLASH_CS45
1417 GPIOE_SPI1_FLASH_SEL_NAME    IOMUXA_FLASH_CS67
1418 */
1419 #define DM9000_USE_NAND_CS 1     //cs can be 1,2,3,4,5,6 or 7
1420 #define DM9000_CS_IOMUX_NAME GPIOA5_FLASHCS1_SEL_NAME
1421 #define DM9000_CS_IOMUX_MODE IOMUXB_FLASH_CS1
1422 #define DM9000_NET_INT_PIN RK2818_PIN_PA1
1423 #define DM9000_INT_IOMUX_NAME GPIOA1_HOSTDATA17_SEL_NAME
1424 #define DM9000_INT_IOMUX_MODE IOMUXB_GPIO0_A1
1425 #define DM9000_INT_INIT_VALUE GPIOPullDown
1426 #define DM9000_IRQ IRQF_TRIGGER_HIGH
1427 #define DM9000_IO_ADDR (RK2818_NANDC_PHYS + 0x800 + DM9000_USE_NAND_CS*0x100 + 0x8)
1428 #define DM9000_DATA_ADDR (RK2818_NANDC_PHYS + 0x800 + DM9000_USE_NAND_CS*0x100 + 0x4)
1429
1430 static int dm9k_gpio_set(void)
1431 {
1432         //cs
1433         rk2818_mux_api_set(DM9000_CS_IOMUX_NAME, DM9000_CS_IOMUX_MODE);
1434         //int
1435         rk2818_mux_api_set(DM9000_INT_IOMUX_NAME, DM9000_INT_IOMUX_MODE);
1436
1437         return 0;
1438 }
1439 static int dm9k_gpio_free(void)
1440 {
1441         rk2818_mux_api_mode_resume(DM9000_INT_IOMUX_NAME);
1442         rk2818_mux_api_mode_resume(DM9000_CS_IOMUX_NAME);
1443         return 0;
1444 }
1445
1446 static struct resource dm9k_resource[] = {
1447         [0] = {
1448                 .start = DM9000_IO_ADDR,
1449                 .end   = DM9000_IO_ADDR + 3,
1450                 .flags = IORESOURCE_MEM,
1451         },
1452         [1] = {
1453                 .start = DM9000_DATA_ADDR,
1454                 .end   = DM9000_DATA_ADDR + 3,
1455                 .flags = IORESOURCE_MEM,
1456         },
1457         [2] = {
1458                 .start = DM9000_NET_INT_PIN,
1459                 .end   = DM9000_NET_INT_PIN,
1460                 .flags = IORESOURCE_IRQ | DM9000_IRQ,
1461         }
1462
1463 };
1464
1465 /* for the moment we limit ourselves to 8bit IO until some
1466  * better IO routines can be written and tested
1467 */
1468 struct dm9000_plat_data dm9k_platdata = {
1469         .flags = DM9000_PLATF_8BITONLY,
1470         .irq_pin = DM9000_NET_INT_PIN,
1471         .irq_pin_value = DM9000_INT_INIT_VALUE,
1472         .io_init = dm9k_gpio_set,
1473         .io_deinit = dm9k_gpio_free,
1474 };
1475
1476 struct platform_device rk2818_device_dm9k = {
1477         .name           = "dm9000",
1478         .id             = 0,
1479         .num_resources  = ARRAY_SIZE(dm9k_resource),
1480         .resource       = dm9k_resource,
1481         .dev            = {
1482                 .platform_data = &dm9k_platdata,
1483         }
1484 };
1485 #endif
1486
1487 #ifdef CONFIG_HEADSET_DET
1488 struct rk2818_headset_data rk2818_headset_info = {
1489         .irq            = FPGA_PIO0_00,
1490         .irq_type       = IRQF_TRIGGER_FALLING,
1491         .headset_in_type= HEADSET_IN_HIGH,
1492 };
1493
1494 struct platform_device rk28_device_headset = {
1495                 .name   = "rk2818_headsetdet",
1496                 .id     = 0,
1497                 .dev    = {
1498                     .platform_data = &rk2818_headset_info,
1499                 }
1500 };
1501 #endif
1502
1503 #ifdef CONFIG_INPUT_LPSENSOR_CM3602
1504 static int capella_cm3602_power(int on)
1505 {       /* TODO eolsen Add Voltage reg control */
1506     if (on) {
1507     //          gpio_direction_output(MAHIMAHI_GPIO_PROXIMITY_EN, 0);
1508     }
1509     else {
1510     //          gpio_direction_output(MAHIMAHI_GPIO_PROXIMITY_EN, 1);
1511     }
1512     return 0;
1513 }
1514
1515 static struct capella_cm3602_platform_data capella_cm3602_pdata = {
1516         .power = capella_cm3602_power,
1517         .irq_pin = SPI_GPIO_P6_04,
1518         .pwd_out_pin = SPI_GPIO_P4_07,
1519         .ps_shutdown_pin = SPI_GPIO_P4_08,
1520         //.p_out = MAHIMAHI_GPIO_PROXIMITY_INT_N
1521         };
1522
1523 struct platform_device rk2818_device_cm3605 = {
1524             .name = CAPELLA_CM3602,
1525                 .id = -1,
1526                 .dev = {
1527                 .platform_data = &capella_cm3602_pdata
1528                         }
1529         };
1530 #endif
1531
1532 /*****************************************************************************************
1533  * nand flash devices
1534  * author: hxy@rock-chips.com
1535  *****************************************************************************************/
1536 /*
1537 GPIOA5_FLASHCS1_SEL_NAME,   IOMUXB_FLASH_CS1
1538 GPIOA6_FLASHCS2_SEL_NAME,   IOMUXB_FLASH_CS2
1539 GPIOA7_FLASHCS3_SEL_NAME,   IOMUXB_FLASH_CS3
1540 GPIOE_SPI1_FLASH_SEL1_NAME, IOMUXA_FLASH_CS45
1541 GPIOE_SPI1_FLASH_SEL_NAME,  IOMUXA_FLASH_CS67
1542 */
1543
1544 #define NAND_CS_MAX_NUM     1  /*form 0 to 8, it is 0 when no nand flash */
1545
1546 int rk2818_nand_io_init(void)
1547 {
1548 #if (NAND_CS_MAX_NUM == 2)
1549     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1550 #elif (NAND_CS_MAX_NUM == 3)
1551     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1552     rk2818_mux_api_set(GPIOA6_FLASHCS2_SEL_NAME, IOMUXB_FLASH_CS2);
1553 #elif (NAND_CS_MAX_NUM == 4)
1554     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1555     rk2818_mux_api_set(GPIOA6_FLASHCS2_SEL_NAME, IOMUXB_FLASH_CS2);
1556     rk2818_mux_api_set(GPIOA7_FLASHCS3_SEL_NAME, IOMUXB_FLASH_CS3);
1557 #elif ((NAND_CS_MAX_NUM == 5) || (NAND_CS_MAX_NUM == 6))
1558     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1559     rk2818_mux_api_set(GPIOA6_FLASHCS2_SEL_NAME, IOMUXB_FLASH_CS2);
1560     rk2818_mux_api_set(GPIOA7_FLASHCS3_SEL_NAME, IOMUXB_FLASH_CS3);
1561     rk2818_mux_api_set(GPIOE_SPI1_FLASH_SEL1_NAME, IOMUXA_FLASH_CS45);
1562 #elif ((NAND_CS_MAX_NUM == 7) || (NAND_CS_MAX_NUM == 8))
1563     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1564     rk2818_mux_api_set(GPIOA6_FLASHCS2_SEL_NAME, IOMUXB_FLASH_CS2);
1565     rk2818_mux_api_set(GPIOA7_FLASHCS3_SEL_NAME, IOMUXB_FLASH_CS3);
1566     rk2818_mux_api_set(GPIOE_SPI1_FLASH_SEL1_NAME, IOMUXA_FLASH_CS45);
1567     rk2818_mux_api_set(GPIOE_SPI1_FLASH_SEL_NAME, IOMUXA_FLASH_CS67);
1568 #endif
1569     return 0;
1570 }
1571
1572 struct rk2818_nand_platform_data rk2818_nand_data = {
1573     .width      = 1,     /* data bus width in bytes */
1574     .hw_ecc     = 1,     /* hw ecc 0: soft ecc */
1575     .num_flash    = 1,
1576     .io_init   = rk2818_nand_io_init,
1577 };
1578
1579
1580 /*****************************************/
1581
1582 static struct platform_device *devices[] __initdata = {
1583 #ifdef CONFIG_BT
1584     &rk2818_device_rfkill,
1585 #endif
1586         &rk2818_device_uart0,
1587         &rk2818_device_uart1,
1588 #ifdef CONFIG_I2C0_RK2818
1589         &rk2818_device_i2c0,
1590 #endif
1591 #ifdef CONFIG_I2C1_RK2818
1592         &rk2818_device_i2c1,
1593 #endif
1594 #ifdef CONFIG_SDMMC0_RK2818
1595         &rk2818_device_sdmmc0,
1596 #endif
1597 #ifdef CONFIG_SDMMC1_RK2818
1598         &rk2818_device_sdmmc1,
1599 #endif
1600         &rk2818_device_spim,
1601         &rk2818_device_i2s,
1602 #if defined(CONFIG_ANDROID_PMEM)
1603         &rk2818_device_pmem,
1604         &rk2818_device_pmem_dsp,
1605 #endif
1606         &rk2818_device_adc,
1607         &rk2818_device_adckey,
1608         &rk2818_device_battery,
1609     &rk2818_device_fb,
1610     &rk2818_device_backlight,
1611         &rk2818_device_dsp,
1612
1613 #ifdef CONFIG_VIDEO_RK2818
1614         &rk2818_device_camera,      /* ddl@rock-chips.com : camera support  */
1615         &rk2818_soc_camera_pdrv,
1616  #endif
1617
1618 #ifdef CONFIG_MTD_NAND_RK2818
1619         &rk2818_nand_device,
1620 #endif
1621 #ifdef CONFIG_DM9000
1622         &rk2818_device_dm9k,
1623 #endif
1624 #ifdef CONFIG_INPUT_LPSENSOR_CM3602
1625     &rk2818_device_cm3605,
1626 #endif
1627 #ifdef CONFIG_HEADSET_DET
1628     &rk28_device_headset,
1629 #endif
1630 #ifdef CONFIG_DWC_OTG
1631         &rk2818_device_dwc_otg,
1632 #endif
1633 #ifdef CONFIG_RK2818_HOST11
1634         &rk2818_device_host11,
1635 #endif
1636 #ifdef CONFIG_USB_ANDROID
1637         &android_usb_device,
1638         &usb_mass_storage_device,
1639 #endif
1640 #ifdef CONFIG_ANDROID_TIMED_GPIO
1641         &rk28_device_vibrator,
1642 #endif
1643 };
1644
1645 extern struct sys_timer rk2818_timer;
1646 #define POWER_PIN       RK2818_PIN_PB1
1647 static void rk2818_power_on(void)
1648 {
1649         int ret;
1650         ret = gpio_request(POWER_PIN, NULL);
1651         if (ret) {
1652                 printk("failed to request power_off gpio\n");
1653                 goto err_free_gpio;
1654         }
1655
1656         gpio_pull_updown(POWER_PIN, GPIOPullUp);
1657         ret = gpio_direction_output(POWER_PIN, GPIO_HIGH);
1658         if (ret) {
1659                 printk("failed to set power_off gpio output\n");
1660                 goto err_free_gpio;
1661         }
1662
1663         gpio_set_value(POWER_PIN, 1);/*power on*/
1664
1665 err_free_gpio:
1666         gpio_free(POWER_PIN);
1667 }
1668
1669 static void rk2818_power_off(void)
1670 {
1671         printk("shut down system now ...\n");
1672         gpio_set_value(POWER_PIN, 0);/*power down*/
1673 }
1674
1675 //      adc      ---> key
1676 #define PLAY_ON_PIN RK2818_PIN_PA3
1677 #define PLAY_ON_LEVEL 1
1678 static  ADC_keyst gAdcValueTab[] =
1679 {
1680         {0x5c,  AD2KEY1},///VOLUME_DOWN
1681         {0xbf,  AD2KEY2},///VOLUME_UP
1682         {0x115, AD2KEY3},///MENU
1683         {0x177, AD2KEY4},///HOME
1684         {0x1d3, AD2KEY5},///BACK
1685         {0x290, AD2KEY6},///CALL
1686         {0x230, AD2KEY7},///SEARCH
1687         {0,     0}///table end
1688 };
1689
1690 static unsigned char gInitKeyCode[] =
1691 {
1692         AD2KEY1,AD2KEY2,AD2KEY3,AD2KEY4,AD2KEY5,AD2KEY6,AD2KEY7,
1693         ENDCALL,KEYSTART,KEY_WAKEUP,
1694 };
1695
1696 struct adc_key_data rk2818_adc_key = {
1697     .pin_playon     = PLAY_ON_PIN,
1698     .playon_level   = PLAY_ON_LEVEL,
1699     .adc_empty      = 900,
1700     .adc_invalid    = 20,
1701     .adc_drift      = 50,
1702     .adc_chn        = 1,
1703     .adc_key_table  = gAdcValueTab,
1704     .initKeyCode    = gInitKeyCode,
1705     .adc_key_cnt    = 10,
1706 };
1707
1708 struct rk2818_adckey_platform_data rk2818_adckey_platdata = {
1709         .adc_key = &rk2818_adc_key,
1710 };
1711
1712 #if CONFIG_ANDROID_TIMED_GPIO
1713 static struct timed_gpio timed_gpios[] = {
1714         {
1715                 .name = "vibrator",
1716                 .gpio = SPI_GPIO_P1_12,
1717                 .max_timeout = 1000,
1718                 .active_low = 1,
1719         },
1720 };
1721
1722 struct timed_gpio_platform_data rk28_vibrator_info = {
1723         .num_gpios = 1,
1724         .gpios = timed_gpios,
1725 };
1726 #endif
1727
1728 static void __init machine_rk2818_init_irq(void)
1729 {
1730         rk2818_init_irq();
1731         rk2818_gpio_init(rk2818_gpioBank, 8);
1732         rk2818_gpio_irq_setup();
1733 }
1734
1735 static void __init machine_rk2818_board_init(void)
1736 {
1737         rk2818_power_on();
1738         pm_power_off = rk2818_power_off;
1739 #ifdef CONFIG_I2C0_RK2818
1740         i2c_register_board_info(default_i2c0_data.bus_num, board_i2c0_devices,
1741                         ARRAY_SIZE(board_i2c0_devices));
1742 #endif
1743 #ifdef CONFIG_I2C1_RK2818
1744         i2c_register_board_info(default_i2c1_data.bus_num, board_i2c1_devices,
1745                         ARRAY_SIZE(board_i2c1_devices));
1746 #endif
1747 #ifdef CONFIG_SPI_FPGA_I2C
1748         i2c_register_board_info(default_i2c2_data.bus_num, board_i2c2_devices,
1749                         ARRAY_SIZE(board_i2c2_devices));
1750         i2c_register_board_info(default_i2c3_data.bus_num, board_i2c3_devices,
1751                         ARRAY_SIZE(board_i2c3_devices));
1752 #endif
1753         platform_add_devices(devices, ARRAY_SIZE(devices));
1754         spi_register_board_info(board_spi_devices, ARRAY_SIZE(board_spi_devices));
1755 }
1756
1757 static void __init machine_rk2818_mapio(void)
1758 {
1759         iotable_init(rk2818_io_desc, ARRAY_SIZE(rk2818_io_desc));
1760         rk2818_clock_init();
1761         rk2818_iomux_init();
1762 }
1763
1764 MACHINE_START(RK2818, "RK28board")
1765
1766 /* UART for LL DEBUG */
1767         .phys_io        = 0x18002000,
1768         .io_pg_offst    = ((0xFF100000) >> 18) & 0xfffc,
1769         .boot_params    = RK2818_SDRAM_PHYS + 0xf8000,
1770         .map_io         = machine_rk2818_mapio,
1771         .init_irq       = machine_rk2818_init_irq,
1772         .init_machine   = machine_rk2818_board_init,
1773         .timer          = &rk2818_timer,
1774 MACHINE_END
1775