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 #include <linux/usb/android_composite.h>
  28
  29 #include <mach/hardware.h>
  30 #include <asm/mach-types.h>
  31 #include <asm/mach/arch.h>
  32 #include <asm/mach/map.h>
  33 #include <asm/mach/flash.h>
  34
  35 #include <mach/irqs.h>
  36 #include <mach/board.h>
  37 #include <mach/rk2818_iomap.h>
  38 #include <mach/iomux.h>
  39 #include <mach/gpio.h>
  40 #include <mach/spi_fpga.h>
  41 #include <mach/rk2818_camera.h>                          /* ddl@rock-chips.com : camera support */
  42 #include <linux/pda_power.h>
  43 #include <linux/regulator/charge-regulator.h>
  44 #include <linux/regulator/machine.h>
  45 #include <linux/usb/gpio_vbus.h>
  46 #include <mach/rk2818_nand.h>
  47
  48 #include <linux/mtd/nand.h>
  49 #include <linux/mtd/partitions.h>
  50 #include <linux/dm9000.h>
  51 #include <linux/capella_cm3602.h>
  52
  53 #include <media/soc_camera.h>                               /* ddl@rock-chips.com : camera support */
  54
  55
  56 #include "devices.h"
  57
  58 #include "../../../drivers/spi/rk2818_spim.h"
  59 #include <linux/regulator/rk2818_lp8725.h>
  60 #include "../../../drivers/input/touchscreen/xpt2046_ts.h"
  61 #include "../../../drivers/staging/android/timed_gpio.h"
  62 #include "../../../sound/soc/codecs/wm8994.h"
  63 #include "../../../drivers/headset_observe/rk2818_headset.h"
  64 #include <mach/rk2818-socpm.h>
  65 #include <asm/tcm.h>
  66
  67 /* --------------------------------------------------------------------
  68  *  ÉùÃ÷ÁËrk2818_gpioBankÊý×é£¬²¢¶¨ÒåÁËGPIO¼Ä´æÆ÷×éIDºÍ¼Ä´æÆ÷»ùµØÖ·¡£
  69  * -------------------------------------------------------------------- */
  70
  71 static struct rk2818_gpio_bank rk2818_gpioBank[] = {
  72                 {
  73                 .id             = RK2818_ID_PIOA,
  74                 .offset         = RK2818_GPIO0_BASE,
  75                 .clock          = NULL,
  76         },
  77                 {
  78                 .id             = RK2818_ID_PIOB,
  79                 .offset         = RK2818_GPIO0_BASE,
  80                 .clock          = NULL,
  81         },
  82                 {
  83                 .id             = RK2818_ID_PIOC,
  84                 .offset         = RK2818_GPIO0_BASE,
  85                 .clock          = NULL,
  86         },
  87                 {
  88                 .id             = RK2818_ID_PIOD,
  89                 .offset         = RK2818_GPIO0_BASE,
  90                 .clock          = NULL,
  91         },
  92                 {
  93                 .id             = RK2818_ID_PIOE,
  94                 .offset         = RK2818_GPIO1_BASE,
  95                 .clock          = NULL,
  96         },
  97                 {
  98                 .id             = RK2818_ID_PIOF,
  99                 .offset         = RK2818_GPIO1_BASE,
 100                 .clock          = NULL,
 101         },
 102                 {
 103                 .id             = RK2818_ID_PIOG,
 104                 .offset         = RK2818_GPIO1_BASE,
 105                 .clock          = NULL,
 106         },
 107                 {
 108                 .id             = RK2818_ID_PIOH,
 109                 .offset         = RK2818_GPIO1_BASE,
 110                 .clock          = NULL,
 111         }
 112 };
 113
 114 //IOÓ³Éä·½Ê½ÃèÊö £¬Ã¿¸öÎªÒ»¶ÎÏßÐÔÁ¬ÐøÓ³Éä
 115 static struct map_desc rk2818_io_desc[] __initdata = {
 116
 117         {
 118                 .virtual        = RK2818_MCDMA_BASE,                                    //ÐéÄâµØÖ·
 119                 .pfn            = __phys_to_pfn(RK2818_MCDMA_PHYS),    //ÎïÀíµØÖ·£¬ÐëÓëÒ³±í¶ÔÆë
 120                 .length         = RK2818_MCDMA_SIZE,                                                    //³¤¶È
 121                 .type           = MT_DEVICE                                                     //Ó³Éä·½Ê½
 122         },
 123
 124         {
 125                 .virtual        = RK2818_DWDMA_BASE,
 126                 .pfn            = __phys_to_pfn(RK2818_DWDMA_PHYS),
 127                 .length         = RK2818_DWDMA_SIZE,
 128                 .type           = MT_DEVICE
 129         },
 130
 131         {
 132                 .virtual        = RK2818_INTC_BASE,
 133                 .pfn            = __phys_to_pfn(RK2818_INTC_PHYS),
 134                 .length         = RK2818_INTC_SIZE,
 135                 .type           = MT_DEVICE
 136         },
 137
 138         {
 139                 .virtual        = RK2818_NANDC_BASE,
 140                 .pfn            = __phys_to_pfn(RK2818_NANDC_PHYS),
 141                 .length         = RK2818_NANDC_SIZE,
 142                 .type           = MT_DEVICE
 143         },
 144
 145         {
 146                 .virtual        = RK2818_SDRAMC_BASE,
 147                 .pfn            = __phys_to_pfn(RK2818_SDRAMC_PHYS),
 148                 .length         = RK2818_SDRAMC_SIZE,
 149                 .type           = MT_DEVICE
 150         },
 151
 152         {
 153                 .virtual        = RK2818_ARMDARBITER_BASE,
 154                 .pfn            = __phys_to_pfn(RK2818_ARMDARBITER_PHYS),
 155                 .length         = RK2818_ARMDARBITER_SIZE,
 156                 .type           = MT_DEVICE
 157         },
 158
 159         {
 160                 .virtual        = RK2818_APB_BASE,
 161                 .pfn            = __phys_to_pfn(RK2818_APB_PHYS),
 162                 .length         = 0xa0000,
 163                 .type           = MT_DEVICE
 164         },
 165
 166         {
 167                 .virtual        = RK2818_WDT_BASE,
 168                 .pfn            = __phys_to_pfn(RK2818_WDT_PHYS),
 169                 .length         = 0xa0000,                      ///apb bus i2s i2c spi no map in this
 170                 .type           = MT_DEVICE
 171         },
 172 };
 173
 174 /*****************************************************************************************
 175  * sd/mmc devices
 176  * author: kfx@rock-chips.com
 177 *****************************************************************************************/
 178 static int rk2818_sdmmc0_io_init(void)
 179 {
 180     rk2818_mux_api_set(GPIOH_MMC0D_SEL_NAME, IOMUXA_SDMMC0_DATA123);
 181         rk2818_mux_api_set(GPIOH_MMC0_SEL_NAME, IOMUXA_SDMMC0_CMD_DATA0_CLKOUT);
 182
 183     return 0;
 184 }
 185
 186 static int rk2818_sdmmc1_io_init(void)
 187 {
 188         rk2818_mux_api_set(GPIOG_MMC1_SEL_NAME, IOMUXA_SDMMC1_CMD_DATA0_CLKOUT);
 189         rk2818_mux_api_set(GPIOG_MMC1D_SEL_NAME, IOMUXA_SDMMC1_DATA123);
 190
 191     return 0;
 192 }
 193 #define CONFIG_SDMMC0_USE_DMA
 194 #define CONFIG_SDMMC1_USE_DMA
 195 struct rk2818_sdmmc_platform_data default_sdmmc0_data = {
 196         .host_ocr_avail = (MMC_VDD_27_28|MMC_VDD_28_29|MMC_VDD_29_30|
 197                                            MMC_VDD_30_31|MMC_VDD_31_32|MMC_VDD_32_33|
 198                                            MMC_VDD_33_34|MMC_VDD_34_35| MMC_VDD_35_36),
 199         .host_caps      = (MMC_CAP_4_BIT_DATA|MMC_CAP_MMC_HIGHSPEED|MMC_CAP_SD_HIGHSPEED),
 200         .io_init = rk2818_sdmmc0_io_init,
 201         .no_detect = 0,
 202         .dma_name = "sd_mmc",
 203 #ifdef CONFIG_SDMMC0_USE_DMA
 204         .use_dma  = 1,
 205 #else
 206         .use_dma = 0,
 207 #endif
 208 };
 209
 210 static int raho_wifi_status(struct device *dev);
 211 static int raho_wifi_status_register(void (*callback)(int card_presend, void *dev_id), void *dev_id);
 212 struct rk2818_sdmmc_platform_data default_sdmmc1_data = {
 213         .host_ocr_avail = (MMC_VDD_26_27|MMC_VDD_27_28|MMC_VDD_28_29|
 214                                            MMC_VDD_29_30|MMC_VDD_30_31|MMC_VDD_31_32|
 215                                            MMC_VDD_32_33|MMC_VDD_33_34),
 216         .host_caps      = (MMC_CAP_4_BIT_DATA|MMC_CAP_SDIO_IRQ|
 217                                    MMC_CAP_MMC_HIGHSPEED|MMC_CAP_SD_HIGHSPEED),
 218         .io_init = rk2818_sdmmc1_io_init,
 219         .no_detect = 1,
 220         .dma_name = "sdio",
 221 #ifdef CONFIG_SDMMC1_USE_DMA
 222         .use_dma  = 1,
 223 #else
 224         .use_dma = 0,
 225 #endif
 226         .status = raho_wifi_status,
 227         .register_status_notify = raho_wifi_status_register,
 228 };
 229
 230 static int raho_wifi_cd;   /* wifi virtual 'card detect' status */
 231 static void (*wifi_status_cb)(int card_present, void *dev_id);
 232 static void *wifi_status_cb_devid;
 233
 234 static int raho_wifi_status(struct device *dev)
 235 {
 236         return raho_wifi_cd;
 237 }
 238
 239 static int raho_wifi_status_register(void (*callback)(int card_present, void *dev_id), void *dev_id)
 240 {
 241         if(wifi_status_cb)
 242                 return -EAGAIN;
 243         wifi_status_cb = callback;
 244         wifi_status_cb_devid = dev_id;
 245         return 0;
 246 }
 247
 248 #define RAHO_WIFI_GPIO_POWER_N  FPGA_PIO1_06
 249 #define RAHO_WIFI_GPIO_RESET_N  FPGA_PIO1_03
 250
 251 int raho_wifi_power_state = 0;
 252 int raho_bt_power_state = 0;
 253
 254 static int raho_wifi_power(int on)
 255 {
 256         pr_info("%s: %d\n", __func__, on);
 257         if (on){
 258                 gpio_set_value(RAHO_WIFI_GPIO_POWER_N, on);
 259                 mdelay(100);
 260                 pr_info("wifi turn on power\n");
 261         }else{
 262                 if (!raho_bt_power_state){
 263                         gpio_set_value(RAHO_WIFI_GPIO_POWER_N, on);
 264                         mdelay(100);
 265                         pr_info("wifi shut off power\n");
 266                 }else
 267                 {
 268                         pr_info("wifi shouldn't shut off power, bt is using it!\n");
 269                 }
 270
 271         }
 272
 273         raho_wifi_power_state = on;
 274         return 0;
 275 }
 276
 277 static int raho_wifi_reset_state;
 278 static int raho_wifi_reset(int on)
 279 {
 280         pr_info("%s: %d\n", __func__, on);
 281         gpio_set_value(RAHO_WIFI_GPIO_RESET_N, on);
 282         mdelay(100);
 283         raho_wifi_reset_state = on;
 284         return 0;
 285 }
 286
 287 static int raho_wifi_set_carddetect(int val)
 288 {
 289         pr_info("%s:%d\n", __func__, val);
 290         raho_wifi_cd = val;
 291         if (wifi_status_cb){
 292                 wifi_status_cb(val, wifi_status_cb_devid);
 293         }else {
 294                 pr_warning("%s, nobody to notify\n", __func__);
 295         }
 296         return 0;
 297 }
 298
 299 static struct wifi_platform_data raho_wifi_control = {
 300         .set_power = raho_wifi_power,
 301         .set_reset = raho_wifi_reset,
 302         .set_carddetect = raho_wifi_set_carddetect,
 303 };
 304 static struct platform_device raho_wifi_device = {
 305         .name = "bcm4329_wlan",
 306         .id = 1,
 307         .dev = {
 308                 .platform_data = &raho_wifi_control,
 309          },
 310 };
 311
 312 /* bluetooth rfkill device */
 313 static struct platform_device raho_rfkill = {
 314         .name = "raho_rfkill",
 315         .id = -1,
 316 };
 317
 318 /*****************************************************************************************
 319  * extern gpio devices
 320  * author: xxx@rock-chips.com
 321  *****************************************************************************************/
 322 #if defined (CONFIG_GPIO_PCA9554)
 323 struct rk2818_gpio_expander_info  extern_gpio_settinginfo[] = {
 324         {
 325                 .gpio_num               =RK2818_PIN_PI0,
 326                 .pin_type           = GPIO_IN,
 327                 //.pin_value                    =GPIO_HIGH,
 328          },
 329
 330         {
 331                 .gpio_num               =RK2818_PIN_PI4,// tp3
 332                 .pin_type           = GPIO_IN,
 333                 //.pin_value                    =GPIO_HIGH,
 334          },
 335
 336          {
 337                 .gpio_num               =RK2818_PIN_PI5,//tp4
 338                 .pin_type           = GPIO_IN,
 339                 //.pin_value                    =GPIO_HIGH,
 340          },
 341          {
 342                 .gpio_num               =RK2818_PIN_PI6,//tp2
 343                 .pin_type           = GPIO_OUT,
 344                 //.pin_value                    =GPIO_HIGH,
 345          },
 346          {
 347                 .gpio_num               =RK2818_PIN_PI7,//tp1
 348                 .pin_type           = GPIO_OUT,
 349                 .pin_value                      =GPIO_HIGH,
 350          },
 351
 352
 353
 354 };
 355
 356 struct pca9554_platform_data rk2818_pca9554_data={
 357         .gpio_base=GPIO_EXPANDER_BASE,
 358         .gpio_pin_num=CONFIG_EXPANDED_GPIO_NUM,
 359         .gpio_irq_start=NR_AIC_IRQS + 2*NUM_GROUP,
 360         .irq_pin_num=CONFIG_EXPANDED_GPIO_IRQ_NUM,
 361         .pca9954_irq_pin=RK2818_PIN_PE2,
 362         .settinginfo=extern_gpio_settinginfo,
 363         .settinginfolen=ARRAY_SIZE(extern_gpio_settinginfo),
 364 };
 365 #endif
 366
 367 /*****************************************************************************************
 368  *regulator devices  drivers/regulator/rk2818_lp8725.c  linux/regulator/rk2818_lp8725.h
 369  *author: cym
 370 *****************************************************************************************/
 371 #if defined (CONFIG_RK2818_REGULATOR_LP8725)
 372 /*ldo1 2V8OUT USB2.5V LCD_VCC*/
 373 static struct regulator_consumer_supply ldo1_consumers[] = {
 374         {
 375                 .supply = "ldo1",
 376         }
 377 };
 378
 379 static struct regulator_init_data rk2818_lp8725_ldo1_data = {
 380         .constraints = {
 381                 .name = "LDO1",
 382                 .min_uV = 1200000,
 383                 .max_uV = 3300000,
 384                 .apply_uV = 1,
 385                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 386         },
 387         .num_consumer_supplies = ARRAY_SIZE(ldo1_consumers),
 388         .consumer_supplies = ldo1_consumers,
 389 };
 390
 391 /*ldo2 CAMERA_1V8 SD_CARD*/
 392 static struct regulator_consumer_supply ldo2_consumers[] = {
 393         {
 394                 .supply = "ldo2",
 395         }
 396 };
 397
 398 static struct regulator_init_data rk2818_lp8725_ldo2_data = {
 399         .constraints = {
 400                 .name = "LDO2",
 401                 .min_uV = 1200000,
 402                 .max_uV = 3300000,
 403                 .apply_uV = 1,
 404                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 405         },
 406         .num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
 407         .consumer_supplies = ldo2_consumers,
 408 };
 409
 410 /*ldo3 VCC_NAND WIFI/BT/FM_BCM4325*/
 411 static struct regulator_consumer_supply ldo3_consumers[] = {
 412         {
 413                 .supply = "ldo3",
 414         }
 415 };
 416
 417 static struct regulator_init_data rk2818_lp8725_ldo3_data = {
 418         .constraints = {
 419                 .name = "LDO3",
 420                 .min_uV = 1200000,
 421                 .max_uV = 3300000,
 422                 .apply_uV = 1,
 423                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 424         },
 425         .num_consumer_supplies = ARRAY_SIZE(ldo3_consumers),
 426         .consumer_supplies = ldo3_consumers,
 427 };
 428
 429 /*ldo4 VCCA CODEC_WM8994*/
 430 static struct regulator_consumer_supply ldo4_consumers[] = {
 431         {
 432                 .supply = "ldo4",
 433         }
 434 };
 435
 436 static struct regulator_init_data rk2818_lp8725_ldo4_data = {
 437         .constraints = {
 438                 .name = "LDO4",
 439                 .min_uV = 1200000,
 440                 .max_uV = 3300000,
 441                 .apply_uV = 1,
 442                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 443         },
 444         .num_consumer_supplies = ARRAY_SIZE(ldo4_consumers),
 445         .consumer_supplies = ldo4_consumers,
 446 };
 447
 448 /*ldo5 AVDD18 CODEC_WM8994*/
 449 static struct regulator_consumer_supply ldo5_consumers[] = {
 450         {
 451                 .supply = "ldo5",
 452         }
 453 };
 454
 455 static struct regulator_init_data rk2818_lp8725_ldo5_data = {
 456         .constraints = {
 457                 .name = "LDO5",
 458                 .min_uV = 1200000,
 459                 .max_uV = 3300000,
 460                 .apply_uV = 1,
 461                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 462         },
 463         .num_consumer_supplies = ARRAY_SIZE(ldo5_consumers),
 464         .consumer_supplies = ldo5_consumers,
 465 };
 466
 467 /*lilo1 VCCIO Sensor£¨3M£©*/
 468 static struct regulator_consumer_supply lilo1_consumers[] = {
 469         {
 470                 .supply = "lilo1",
 471         }
 472 };
 473
 474 static struct regulator_init_data rk2818_lp8725_lilo1_data = {
 475         .constraints = {
 476                 .name = "LILO1",
 477                 .min_uV = 800000,
 478                 .max_uV = 3300000,
 479                 .apply_uV = 1,
 480                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 481         },
 482         .num_consumer_supplies = ARRAY_SIZE(lilo1_consumers),
 483         .consumer_supplies = lilo1_consumers
 484 };
 485
 486 /*lilo2 VCC33_SD Sensor£¨3M£©*/
 487 static struct regulator_consumer_supply lilo2_consumers[] = {
 488         {
 489                 .supply = "lilo2",
 490         }
 491 };
 492
 493 static struct regulator_init_data rk2818_lp8725_lilo2_data = {
 494         .constraints = {
 495                 .name = "LILO2",
 496                 .min_uV = 800000,
 497                 .max_uV = 3300000,
 498                 .apply_uV = 1,
 499                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 500         },
 501         .num_consumer_supplies = ARRAY_SIZE(lilo2_consumers),
 502         .consumer_supplies = lilo2_consumers
 503 };
 504
 505 /*buck1 VDD12 Core*/
 506 static struct regulator_consumer_supply buck1_consumers[] = {
 507         {
 508                 .supply = "vdd12",
 509         }
 510 };
 511
 512 static struct regulator_init_data rk2818_lp8725_buck1_data = {
 513         .constraints = {
 514                 .name = "VDD12",
 515                 .min_uV = 800000,
 516                 .max_uV = 1500000,
 517                 .apply_uV = 1,
 518                 .always_on = 1,
 519                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE | REGULATOR_CHANGE_MODE,
 520                 .valid_modes_mask = REGULATOR_MODE_IDLE | REGULATOR_MODE_NORMAL,
 521         },
 522         .num_consumer_supplies = ARRAY_SIZE(buck1_consumers),
 523         .consumer_supplies = buck1_consumers
 524 };
 525
 526 /*buck2 VDDDR MobileDDR VCC*/
 527 static struct regulator_consumer_supply buck2_consumers[] = {
 528         {
 529                 .supply = "vccdr",
 530         }
 531 };
 532
 533 static struct regulator_init_data rk2818_lp8725_buck2_data = {
 534         .constraints = {
 535                 .name = "VCCDR",
 536                 .min_uV = 1800000,
 537                 .max_uV = 1800000,
 538                 .apply_uV = 1,
 539                 .always_on = 1,
 540                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 541         },
 542         .num_consumer_supplies = ARRAY_SIZE(buck2_consumers),
 543         .consumer_supplies = buck2_consumers
 544 };
 545
 546 /*buck1_v2 VDD12 Core*/
 547 static struct regulator_consumer_supply buck1_v2_consumers[] = {
 548         {
 549                 .supply = "vdd12_v2",
 550         }
 551 };
 552
 553 static struct regulator_init_data rk2818_lp8725_buck1_v2_data = {
 554         .constraints = {
 555                 .name = "VDD12_V2",
 556                 .min_uV = 800000,
 557                 .max_uV = 1500000,
 558                 .apply_uV = 1,
 559                 //.always_on = 1,
 560                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE | REGULATOR_CHANGE_MODE,
 561         },
 562         .num_consumer_supplies = ARRAY_SIZE(buck1_v2_consumers),
 563         .consumer_supplies = buck1_v2_consumers
 564 };
 565
 566 /*buck2_v2 VDDDR MobileDDR VCC*/
 567 static struct regulator_consumer_supply buck2_v2_consumers[] = {
 568         {
 569                 .supply = "vccdr_v2",
 570         }
 571 };
 572
 573 static struct regulator_init_data rk2818_lp8725_buck2_v2_data = {
 574         .constraints = {
 575                 .name = "VCCDR_V2",
 576                 .min_uV = 1800000,
 577                 .max_uV = 1800000,
 578                 .apply_uV = 1,
 579                 //.always_on = 1,
 580                 .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
 581         },
 582         .num_consumer_supplies = ARRAY_SIZE(buck2_v2_consumers),
 583         .consumer_supplies = buck2_v2_consumers
 584 };
 585
 586 struct lp8725_regulator_subdev rk2818_lp8725_regulator_subdev[] = {
 587         {
 588                 .id=LP8725_LDO1,
 589                 .initdata=&rk2818_lp8725_ldo1_data,
 590          },
 591
 592         {
 593                 .id=LP8725_LDO2,
 594                 .initdata=&rk2818_lp8725_ldo2_data,
 595          },
 596
 597         {
 598                 .id=LP8725_LDO3,
 599                 .initdata=&rk2818_lp8725_ldo3_data,
 600          },
 601
 602         {
 603                 .id=LP8725_LDO4,
 604                 .initdata=&rk2818_lp8725_ldo4_data,
 605          },
 606
 607         {
 608                 .id=LP8725_LDO5,
 609                 .initdata=&rk2818_lp8725_ldo5_data,
 610          },
 611
 612         {
 613                 .id=LP8725_LILO1,
 614                 .initdata=&rk2818_lp8725_lilo1_data,
 615          },
 616
 617         {
 618                 .id=LP8725_LILO2,
 619                 .initdata=&rk2818_lp8725_lilo2_data,
 620          },
 621
 622         {
 623                 .id=LP8725_DCDC1,
 624                 .initdata=&rk2818_lp8725_buck1_data,
 625          },
 626
 627         {
 628                 .id=LP8725_DCDC2,
 629                 .initdata=&rk2818_lp8725_buck2_data,
 630          },
 631         {
 632                 .id=LP8725_DCDC1_V2,
 633                 .initdata=&rk2818_lp8725_buck1_v2_data,
 634          },
 635
 636         {
 637                 .id=LP8725_DCDC2_V2,
 638                 .initdata=&rk2818_lp8725_buck2_v2_data,
 639          },
 640 };
 641
 642 struct lp8725_platform_data rk2818_lp8725_data={
 643         .num_regulators=LP8725_NUM_REGULATORS,
 644         .regulators=rk2818_lp8725_regulator_subdev,
 645 };
 646 #endif
 647
 648 /*****************************************************************************************
 649  * gsensor devices
 650 *****************************************************************************************/
 651 #define GS_IRQ_PIN RK2818_PIN_PE3
 652
 653 struct rk2818_gs_platform_data rk2818_gs_platdata = {
 654         .gsensor_irq_pin = GS_IRQ_PIN,
 655         .swap_xy           = 0,
 656 };
 657
 658 /*****************************************************************************************
 659  * wm8994  codec
 660  * author: cjq@rock-chips.com
 661  *****************************************************************************************/
 662 static struct wm8994_platform_data wm8994_data = {
 663     .mic_input = 0,
 664     .micBase_vcc = 0,
 665     .bb_input = 0,
 666     .bb_output = 0,
 667     .frequence = 0,
 668     .enable_pin = 0,
 669     .headset_pin = 0,
 670     .headset_call_vol = 0,
 671     .speaker_call_vol = 0,
 672     .earpiece_call_vol = 0,
 673     .bt_call_vol = 0,
 674 };// must initialize
 675
 676 /*****************************************************************************************
 677  * i2c devices
 678  * author: kfx@rock-chips.com
 679 *****************************************************************************************/
 680 static int rk2818_i2c0_io_init(void)
 681 {
 682         rk2818_mux_api_set(GPIOE_I2C0_SEL_NAME, IOMUXA_I2C0);
 683         return 0;
 684 }
 685
 686 static int rk2818_i2c1_io_init(void)
 687 {
 688         rk2818_mux_api_set(GPIOE_U1IR_I2C1_NAME, IOMUXA_I2C1);
 689         return 0;
 690 }
 691
 692 struct rk2818_i2c_platform_data default_i2c0_data = {
 693         .bus_num    = 0,
 694         .flags      = 0,
 695         .slave_addr = 0xff,
 696         .scl_rate  = 400*1000,
 697         .mode       = I2C_MODE_IRQ, //I2C_MODE_POLL
 698         .io_init = rk2818_i2c0_io_init,
 699 };
 700 struct rk2818_i2c_platform_data default_i2c1_data = {
 701 #ifdef CONFIG_I2C0_RK2818
 702         .bus_num    = 1,
 703 #else
 704         .bus_num        = 0,
 705 #endif
 706         .flags      = 0,
 707         .slave_addr = 0xff,
 708         .scl_rate  = 400*1000,
 709         .mode       = I2C_MODE_POLL, //I2C_MODE_POLL
 710         .io_init = rk2818_i2c1_io_init,
 711 };
 712
 713 struct rk2818_i2c_spi_data default_i2c2_data = {
 714         .bus_num    = 2,
 715         .flags      = 0,
 716         .slave_addr = 0xff,
 717         .scl_rate  = 400*1000,
 718
 719 };
 720 struct rk2818_i2c_spi_data default_i2c3_data = {
 721
 722         .bus_num    = 3,
 723         .flags      = 0,
 724         .slave_addr = 0xff,
 725         .scl_rate  = 400*1000,
 726
 727 };
 728 static struct i2c_board_info __initdata board_i2c0_devices[] = {
 729 #if defined (CONFIG_RK1000_CONTROL)
 730         {
 731                 .type                   = "rk1000_control",
 732                 .addr           = 0x40,
 733                 .flags                  = 0,
 734         },
 735 #endif
 736
 737 #if defined (CONFIG_RK1000_TVOUT)
 738         {
 739                 .type                   = "rk1000_tvout",
 740                 .addr           = 0x42,
 741                 .flags                  = 0,
 742         },
 743 #endif
 744 #if defined (CONFIG_SND_SOC_RK1000)
 745         {
 746                 .type                   = "rk1000_i2c_codec",
 747                 .addr           = 0x60,
 748                 .flags                  = 0,
 749         },
 750 #endif
 751 #if defined (CONFIG_SND_SOC_WM8988)
 752         {
 753                 .type                   = "wm8988",
 754                 .addr           = 0x1a,
 755                 .flags                  = 0,
 756         }
 757 #endif
 758 #if defined (CONFIG_TOUCHSCREEN_IT7250)  //add by robert for ctp_it7250
 759     {
 760         .type           = "Ctp_it7250",
 761         .addr           = 0x46,
 762         .flags          = 0,
 763         .irq            = RK2818_PIN_PE1,
 764     },
 765 #endif  //end add
 766 };
 767 static struct i2c_board_info __initdata board_i2c1_devices[] = {
 768 #if defined (CONFIG_RTC_HYM8563)
 769         {
 770                 .type                   = "rtc_hym8563",
 771                 .addr           = 0x51,
 772                 .flags                  = 0,
 773         },
 774 #endif
 775 #if defined (CONFIG_RTC_DRV_S35392A)
 776         {
 777                 .type                   = "rtc-s35392a",
 778                 .addr           = 0x30,
 779                 .flags                  = 0,
 780                 .irq            = RK2818_PIN_PE2,
 781         },
 782 #endif
 783 #if defined (CONFIG_FM_QN8006)
 784         {
 785                 .type                   = "fm_qn8006",
 786                 .addr           = 0x2b,
 787                 .flags                  = 0,
 788         },
 789 #endif
 790 #if defined (CONFIG_GPIO_PCA9554)
 791         {
 792                 .type                   = "extend_gpio_pca9554",
 793                 .addr           = 0x3c,
 794                 .flags                  = 0,
 795                 .platform_data=&rk2818_pca9554_data.gpio_base,
 796         },
 797 #endif
 798 #if defined (CONFIG_RK2818_REGULATOR_LP8725)
 799         {
 800                 .type                   = "lp8725",
 801                 .addr           = 0x79,
 802                 .flags                  = 0,
 803                 .platform_data=&rk2818_lp8725_data,
 804         },
 805 #endif
 806 #if defined (CONFIG_GS_MMA7660)
 807     {
 808         .type           = "gs_mma7660",
 809         .addr           = 0x4c,
 810         .flags          = 0,
 811         .irq            = GS_IRQ_PIN,
 812                 .platform_data = &rk2818_gs_platdata,
 813     },
 814 #endif
 815
 816 };
 817
 818 static struct i2c_board_info __initdata board_i2c2_devices[] = {
 819
 820 };
 821
 822 static struct i2c_board_info __initdata board_i2c3_devices[] = {
 823 #if defined (CONFIG_SND_SOC_WM8994)
 824         {
 825                 .type                   = "wm8994",
 826                 .addr           = 0x1a,
 827                 .flags                  = 0,
 828                 .platform_data  = &wm8994_data,
 829         },
 830 #endif
 831 };
 832
 833 /*
 834  * External power
 835  */
 836
 837 static int power_supply_init(struct device *dev)
 838 {
 839         return gpio_request(FPGA_PIO2_08, "AC charger detect");
 840 }
 841
 842 static int rk2818_is_ac_online(void)
 843 {
 844         return !gpio_get_value(FPGA_PIO2_08);
 845 }
 846
 847 static void power_supply_exit(struct device *dev)
 848 {
 849         gpio_free(FPGA_PIO2_08);
 850 }
 851
 852 static char *rk2818_supplicant[] = {
 853         "rk2818-battery"
 854 };
 855
 856 static struct pda_power_pdata power_supply_info = {
 857         .init            = power_supply_init,
 858         .is_ac_online    = rk2818_is_ac_online,
 859         .exit            = power_supply_exit,
 860         .supplied_to     = rk2818_supplicant,
 861         .num_supplicants = ARRAY_SIZE(rk2818_supplicant),
 862 };
 863
 864 static struct resource power_supply_resources[] = {
 865         [0] = {
 866                 .name  = "ac",
 867                 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE |
 868                          IORESOURCE_IRQ_LOWEDGE,
 869         },
 870         [1] = {
 871                 .name  = "usb",
 872                 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE |
 873                          IORESOURCE_IRQ_LOWEDGE,
 874         },
 875 };
 876
 877 static struct platform_device power_supply = {
 878         .name = "pda-power",
 879         .id   = -1,
 880         .dev  = {
 881                 .platform_data = &power_supply_info,
 882         },
 883         .resource      = power_supply_resources,
 884         .num_resources = ARRAY_SIZE(power_supply_resources),
 885 };
 886
 887 /*
 888  * USB "Transceiver"
 889  */
 890
 891 static struct resource gpio_vbus_resource = {
 892         .flags = IORESOURCE_IRQ,
 893         .start =  IRQ_NR_OTG,
 894         .end   = IRQ_NR_OTG,
 895 };
 896
 897 static struct gpio_vbus_mach_info gpio_vbus_info = {
 898         .gpio_vbus   = FPGA_PIO4_06,
 899 };
 900
 901 static struct platform_device gpio_vbus = {
 902         .name          = "gpio-vbus",
 903         .id            = -1,
 904         .num_resources = 1,
 905         .resource      = &gpio_vbus_resource,
 906         .dev = {
 907                 .platform_data = &gpio_vbus_info,
 908         },
 909 };
 910
 911 /*
 912  * Battery charger
 913  */
 914
 915 static struct regulator_consumer_supply rk2818_consumers[] = {
 916         {
 917                 .dev=&rk2818_device_battery.dev,
 918                 .supply = "battery",
 919         },
 920         {
 921                 .dev = &gpio_vbus.dev,
 922                 .supply = "vbus_draw",
 923         },
 924         {
 925                 .dev = &power_supply.dev,
 926                 .supply = "ac_draw",
 927         },
 928 };
 929
 930 static struct regulator_init_data charge_init_data = {
 931         .constraints = {
 932                 .max_uA         = 1200000,
 933                 .valid_ops_mask = REGULATOR_CHANGE_CURRENT,
 934         },
 935         .num_consumer_supplies  = ARRAY_SIZE(rk2818_consumers),
 936         .consumer_supplies      = rk2818_consumers,
 937 };
 938
 939 static struct charge_platform_data charge_current_info = {
 940         .gpio_charge = FPGA_PIO2_08,
 941         .init_data  = &charge_init_data,
 942 };
 943
 944 static struct platform_device charge_current = {
 945         .name = "charge-regulator",
 946         .id   = -1,
 947         .dev  = {
 948                 .platform_data = &charge_current_info,
 949         },
 950 };
 951
 952 /*****************************************************************************************
 953  * camera  devices
 954  * author: ddl@rock-chips.com
 955  *****************************************************************************************/
 956 #ifdef CONFIG_VIDEO_RK2818
 957 /* Board-raho camera configuration */
 958 #define SENSOR_NAME_0 RK28_CAM_SENSOR_NAME_OV2655
 959 #define SENSOR_IIC_ADDR_0           0x60
 960 #define SENSOR_IIC_ADAPTER_ID_0    2
 961 #define SENSOR_POWER_PIN_0         FPGA_PIO1_05
 962 #define SENSOR_RESET_PIN_0         FPGA_PIO1_14
 963 #define SENSOR_POWERACTIVE_LEVEL_0 RK28_CAM_POWERACTIVE_L
 964 #define SENSOR_RESETACTIVE_LEVEL_0 RK28_CAM_RESETACTIVE_L
 965
 966
 967 #define SENSOR_NAME_1 NULL
 968 #define SENSOR_IIC_ADDR_1           0x00
 969 #define SENSOR_IIC_ADAPTER_ID_1    0xff
 970 #define SENSOR_POWER_PIN_1         INVALID_GPIO
 971 #define SENSOR_RESET_PIN_1         INVALID_GPIO
 972 #define SENSOR_POWERACTIVE_LEVEL_1 RK28_CAM_POWERACTIVE_L
 973 #define SENSOR_RESETACTIVE_LEVEL_1 RK28_CAM_RESETACTIVE_L
 974
 975 static int rk28_sensor_io_init(void);
 976 static int rk28_sensor_io_deinit(void);
 977
 978 struct rk28camera_platform_data rk28_camera_platform_data = {
 979     .io_init = rk28_sensor_io_init,
 980     .io_deinit = rk28_sensor_io_deinit,
 981     .gpio_res = {
 982         {
 983             .gpio_reset = SENSOR_RESET_PIN_0,
 984             .gpio_power = SENSOR_POWER_PIN_0,
 985             .gpio_flag = (SENSOR_POWERACTIVE_LEVEL_0|SENSOR_RESETACTIVE_LEVEL_0),
 986             .dev_name = SENSOR_NAME_0,
 987         }, {
 988             .gpio_reset = SENSOR_RESET_PIN_1,
 989             .gpio_power = SENSOR_POWER_PIN_1,
 990             .gpio_flag = (SENSOR_POWERACTIVE_LEVEL_1|SENSOR_RESETACTIVE_LEVEL_1),
 991             .dev_name = SENSOR_NAME_1,
 992         }
 993     }
 994 };
 995
 996 static int rk28_sensor_io_init(void)
 997 {
 998     int ret = 0, i;
 999     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
1000         unsigned int camera_ioflag;
1001     //printk("\n%s....%d    ******** ddl *********\n",__FUNCTION__,__LINE__);
1002
1003     for (i=0; i<2; i++) {
1004         camera_reset = rk28_camera_platform_data.gpio_res[i].gpio_reset;
1005         camera_power = rk28_camera_platform_data.gpio_res[i].gpio_power;
1006                 camera_ioflag = rk28_camera_platform_data.gpio_res[i].gpio_flag;
1007
1008         if (camera_power != INVALID_GPIO) {
1009             ret = gpio_request(camera_power, "camera power");
1010             if (ret)
1011                 continue;
1012
1013             gpio_set_value(camera_reset, (((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
1014             gpio_direction_output(camera_power, (((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
1015
1016                         //printk("\n%s....%d  %x   ******** ddl *********\n",__FUNCTION__,__LINE__,(((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
1017
1018         }
1019
1020         if (camera_reset != INVALID_GPIO) {
1021             ret = gpio_request(camera_reset, "camera reset");
1022             if (ret) {
1023                 if (camera_power != INVALID_GPIO)
1024                     gpio_free(camera_power);
1025
1026                 continue;
1027             }
1028
1029             gpio_set_value(camera_reset, ((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
1030             gpio_direction_output(camera_reset, ((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
1031
1032                         //printk("\n%s....%d  %x   ******** ddl *********\n",__FUNCTION__,__LINE__,((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
1033
1034         }
1035     }
1036
1037     return 0;
1038 }
1039
1040 static int rk28_sensor_io_deinit(void)
1041 {
1042     unsigned int i;
1043     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
1044
1045     //printk("\n%s....%d    ******** ddl *********\n",__FUNCTION__,__LINE__);
1046
1047     for (i=0; i<2; i++) {
1048         camera_reset = rk28_camera_platform_data.gpio_res[i].gpio_reset;
1049         camera_power = rk28_camera_platform_data.gpio_res[i].gpio_power;
1050
1051         if (camera_power != INVALID_GPIO){
1052             gpio_direction_input(camera_power);
1053             gpio_free(camera_power);
1054         }
1055
1056         if (camera_reset != INVALID_GPIO)  {
1057             gpio_direction_input(camera_reset);
1058             gpio_free(camera_reset);
1059         }
1060     }
1061
1062     return 0;
1063 }
1064
1065
1066 static int rk28_sensor_power(struct device *dev, int on)
1067 {
1068     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
1069         unsigned int camera_ioflag;
1070
1071     if(rk28_camera_platform_data.gpio_res[0].dev_name &&  (strcmp(rk28_camera_platform_data.gpio_res[0].dev_name, dev_name(dev)) == 0)) {
1072         camera_reset = rk28_camera_platform_data.gpio_res[0].gpio_reset;
1073         camera_power = rk28_camera_platform_data.gpio_res[0].gpio_power;
1074                 camera_ioflag = rk28_camera_platform_data.gpio_res[0].gpio_flag;
1075     } 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)) {
1076         camera_reset = rk28_camera_platform_data.gpio_res[1].gpio_reset;
1077         camera_power = rk28_camera_platform_data.gpio_res[1].gpio_power;
1078                 camera_ioflag = rk28_camera_platform_data.gpio_res[1].gpio_flag;
1079     }
1080
1081     if (camera_reset != INVALID_GPIO) {
1082         gpio_set_value(camera_reset, ((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
1083         //printk("\n%s..%s..ResetPin=%d ..PinLevel = %x \n",__FUNCTION__,dev_name(dev),camera_reset, ((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
1084     }
1085     if (camera_power != INVALID_GPIO)  {
1086         if (on) {
1087                 gpio_set_value(camera_power, ((camera_ioflag&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
1088                         //printk("\n%s..%s..PowerPin=%d ..PinLevel = %x   \n",__FUNCTION__,dev_name(dev), camera_power, ((camera_ioflag&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
1089                 } else {
1090                         gpio_set_value(camera_power, (((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
1091                         //printk("\n%s..%s..PowerPin=%d ..PinLevel = %x   \n",__FUNCTION__,dev_name(dev), camera_power, (((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
1092                 }
1093         }
1094     if (camera_reset != INVALID_GPIO) {
1095         msleep(3);          /* delay 3 ms */
1096         gpio_set_value(camera_reset,(((~camera_ioflag)&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
1097         //printk("\n%s..%s..ResetPin= %d..PinLevel = %x   \n",__FUNCTION__,dev_name(dev), camera_reset, (((~camera_ioflag)&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
1098     }
1099     return 0;
1100 }
1101
1102 static struct i2c_board_info rk2818_i2c_cam_info[] = {
1103         {
1104                 I2C_BOARD_INFO(SENSOR_NAME_0, SENSOR_IIC_ADDR_0>>1)
1105         },
1106 };
1107
1108 struct soc_camera_link rk2818_iclink = {
1109         .bus_id         = RK28_CAM_PLATFORM_DEV_ID,
1110         .power          = rk28_sensor_power,
1111         .board_info     = &rk2818_i2c_cam_info[0],
1112         .i2c_adapter_id = SENSOR_IIC_ADAPTER_ID_0,
1113         .module_name    = SENSOR_NAME_0,
1114 };
1115
1116 /*platform_device : soc-camera need  */
1117 struct platform_device rk2818_soc_camera_pdrv = {
1118         .name   = "soc-camera-pdrv",
1119         .id     = -1,
1120         .dev    = {
1121                 .init_name = SENSOR_NAME_0,
1122                 .platform_data = &rk2818_iclink,
1123         },
1124 };
1125 #endif
1126 /*****************************************************************************************
1127  * battery  devices
1128  * author: lw@rock-chips.com
1129  *****************************************************************************************/
1130 #define CHARGEOK_PIN    FPGA_PIO0_06
1131 struct rk2818_battery_platform_data rk2818_battery_platdata = {
1132         .charge_ok_pin = CHARGEOK_PIN,
1133         .charge_ok_level = 0,
1134 };
1135
1136
1137 /*****************************************************************************************
1138  * serial devices
1139  * author: lhh@rock-chips.com
1140  *****************************************************************************************/
1141 static int serial_io_init(void)
1142 {
1143         int ret;
1144 #if 1
1145         //cz@rock-chips.com
1146         //20100808
1147         //UART0µÄËÄ¸ö¹Ü½ÅÏÈIOMUX³ÉGPIO
1148         //È»ºó·Ö±ðÉèÖÃÊäÈëÊä³ö/À¸ßÀµÍ´¦Àí
1149         //×îºóÔÙIOMUX³ÉUART
1150         //·ÀÖ¹Ö±½ÓIOMUX³ÉUARTºóËÄ¸ö¹Ü½ÅµÄ×´Ì¬²»¶ÔÊ±
1151         //²Ù×÷UARTµ¼ÖÂUART_USR_BUSYÊ¼ÖÕÎª1Ôì³ÉÈçÏÂËÀÑ»·
1152         //while(rk2818_uart_read(port,UART_USR)&UART_USR_BUSY)
1153         //UARTËÄ¸ö¹Ü½ÅÔÚÎ´´«ÊäÊ±Õý³£×´Ì¬Ó¦¸ÃÎª£º
1154         //RX/TX£ºHIGH
1155         //CTS/RTS£ºLOW
1156         //×¢Òâ£ºCTS/RTSÎªµÍÓÐÐ§£¬Ó²¼þÉÏ²»Ó¦¸ÃÇ¿ÐÐ×öÉÏÀ
1157                 rk2818_mux_api_set(GPIOG1_UART0_MMC1WPT_NAME, IOMUXA_GPIO1_C1 /*IOMUXA_UART0_SOUT*/);
1158                 rk2818_mux_api_set(GPIOG0_UART0_MMC1DET_NAME, IOMUXA_GPIO1_C0 /*IOMUXA_UART0_SIN*/);
1159
1160                 ret = gpio_request(RK2818_PIN_PG0, NULL);
1161                 if(ret != 0)
1162                 {
1163                   gpio_free(RK2818_PIN_PG0);
1164                 }
1165                 gpio_direction_output(RK2818_PIN_PG0,GPIO_HIGH);
1166
1167
1168                 ret = gpio_request(RK2818_PIN_PG1, NULL);
1169                 if(ret != 0)
1170                 {
1171                   gpio_free(RK2818_PIN_PG1);
1172                 }
1173                 gpio_direction_output(RK2818_PIN_PG1,GPIO_HIGH);
1174
1175                 gpio_pull_updown(RK2818_PIN_PG1,GPIOPullUp);
1176                 gpio_pull_updown(RK2818_PIN_PG0,GPIOPullUp);
1177
1178                 rk2818_mux_api_set(GPIOG1_UART0_MMC1WPT_NAME, IOMUXA_UART0_SOUT);
1179                 rk2818_mux_api_set(GPIOG0_UART0_MMC1DET_NAME, IOMUXA_UART0_SIN);
1180
1181                 rk2818_mux_api_set(GPIOB2_U0CTSN_SEL_NAME, IOMUXB_GPIO0_B2/*IOMUXB_UART0_CTS_N*/);
1182                 rk2818_mux_api_set(GPIOB3_U0RTSN_SEL_NAME, IOMUXB_GPIO0_B3/*IOMUXB_UART0_RTS_N*/);
1183
1184                 ret = gpio_request(RK2818_PIN_PB2, NULL);
1185                 if(ret != 0)
1186                 {
1187                   gpio_free(RK2818_PIN_PB2);
1188                 }
1189                 gpio_direction_input(RK2818_PIN_PB2);
1190         //        gpio_direction_output(RK2818_PIN_PB2,GPIO_LOW);
1191
1192                 ret = gpio_request(RK2818_PIN_PB3, NULL);
1193                 if(ret != 0)
1194                 {
1195                   gpio_free(RK2818_PIN_PB3);
1196                 }
1197                 gpio_direction_output(RK2818_PIN_PB3,GPIO_LOW);
1198 #endif
1199
1200         rk2818_mux_api_set(GPIOB2_U0CTSN_SEL_NAME, IOMUXB_UART0_CTS_N);
1201         rk2818_mux_api_set(GPIOB3_U0RTSN_SEL_NAME, IOMUXB_UART0_RTS_N);
1202
1203         return 0;
1204 }
1205
1206 struct rk2818_serial_platform_data rk2818_serial0_platdata = {
1207         .io_init = serial_io_init,
1208 };
1209
1210 /*****************************************************************************************
1211  * i2s devices
1212  * author: lhhrock-chips.com
1213  *****************************************************************************************/
1214 static int i2s_io_init(void)
1215 {
1216     /* Configure the I2S pins in correct mode */
1217     rk2818_mux_api_set(CXGPIO_I2S_SEL_NAME,IOMUXB_I2S_INTERFACE);
1218         return 0;
1219 }
1220
1221 struct rk2818_i2s_platform_data rk2818_i2s_platdata = {
1222         .io_init = i2s_io_init,
1223 };
1224
1225
1226 /*****************************************************************************************
1227  * spi devices
1228  * author: lhhrock-chips.com
1229  *****************************************************************************************/
1230 #define SPI_CHIPSELECT_NUM 3
1231 struct spi_cs_gpio rk2818_spi_cs_gpios[SPI_CHIPSELECT_NUM] = {
1232         {
1233                 .name = "spi cs0",
1234                 .cs_gpio = RK2818_PIN_PB4,
1235                 .cs_iomux_name = GPIOB4_SPI0CS0_MMC0D4_NAME,//if no iomux,set it NULL
1236                 .cs_iomux_mode = IOMUXA_GPIO0_B4,
1237         },
1238         {
1239                 .name = "spi cs1",
1240                 .cs_gpio = RK2818_PIN_PB0,
1241                 .cs_iomux_name = GPIOB0_SPI0CSN1_MMC1PCA_NAME,
1242                 .cs_iomux_mode = IOMUXA_GPIO0_B0,
1243         },
1244         {
1245                 .name = "spi cs2",
1246                 .cs_gpio = RK2818_PIN_PF5,
1247                 .cs_iomux_name = GPIOF5_APWM3_DPWM3_NAME,
1248                 .cs_iomux_mode = IOMUXB_GPIO1_B5,
1249         }
1250 };
1251
1252 static int spi_io_init(struct spi_cs_gpio *cs_gpios, int cs_num)
1253 {
1254         int i,j,ret;
1255         //clk
1256         rk2818_mux_api_set(GPIOB_SPI0_MMC0_NAME, IOMUXA_SPI0);
1257         //cs
1258         if (cs_gpios) {
1259                 for (i=0; i<cs_num; i++) {
1260                         rk2818_mux_api_set(cs_gpios[i].cs_iomux_name, cs_gpios[i].cs_iomux_mode);
1261                         ret = gpio_request(cs_gpios[i].cs_gpio, cs_gpios[i].name);
1262                         if (ret) {
1263                                 for (j=0;j<i;j++) {
1264                                         gpio_free(cs_gpios[j].cs_gpio);
1265                                         rk2818_mux_api_mode_resume(cs_gpios[j].cs_iomux_name);
1266                                 }
1267                                 printk("[fun:%s, line:%d], gpio request err\n", __func__, __LINE__);
1268                                 return -1;
1269                         }
1270                         gpio_direction_output(cs_gpios[i].cs_gpio, GPIO_HIGH);
1271                 }
1272         }
1273         return 0;
1274 }
1275
1276 static int spi_io_deinit(struct spi_cs_gpio *cs_gpios, int cs_num)
1277 {
1278         int i;
1279         rk2818_mux_api_mode_resume(GPIOB_SPI0_MMC0_NAME);
1280
1281         if (cs_gpios) {
1282                 for (i=0; i<cs_num; i++) {
1283                         gpio_free(cs_gpios[i].cs_gpio);
1284                         rk2818_mux_api_mode_resume(cs_gpios[i].cs_iomux_name);
1285                 }
1286         }
1287
1288         return 0;
1289 }
1290
1291 struct rk2818_spi_platform_data rk2818_spi_platdata = {
1292         .num_chipselect = SPI_CHIPSELECT_NUM,//raho ´ó°åÐèÒªÖ§³Ö3¸öÆ¬Ñ¡ dxj
1293         .chipselect_gpios = rk2818_spi_cs_gpios,
1294         .io_init = spi_io_init,
1295         .io_deinit = spi_io_deinit,
1296 };
1297
1298
1299 /*****************************************************************************************
1300  * xpt2046 touch panel
1301  * author: dxjrock-chips.com
1302  *****************************************************************************************/
1303 #define XPT2046_GPIO_INT           RK2818_PIN_PE1
1304 #define DEBOUNCE_REPTIME  3
1305
1306 #if defined(CONFIG_TOUCHSCREEN_XPT2046_320X480_SPI)
1307 static struct xpt2046_platform_data xpt2046_info = {
1308         .model                  = 2046,
1309         .keep_vref_on   = 1,
1310         .swap_xy                = 0,
1311         .x_min                  = 0,
1312         .x_max                  = 320,
1313         .y_min                  = 0,
1314         .y_max                  = 480,
1315         .debounce_max           = 7,
1316         .debounce_rep           = DEBOUNCE_REPTIME,
1317         .debounce_tol           = 20,
1318         .gpio_pendown           = XPT2046_GPIO_INT,
1319         .penirq_recheck_delay_usecs = 1,
1320 };
1321 #elif defined(CONFIG_TOUCHSCREEN_XPT2046_320X480_CBN_SPI)
1322 static struct xpt2046_platform_data xpt2046_info = {
1323         .model                  = 2046,
1324         .keep_vref_on   = 1,
1325         .swap_xy                = 0,
1326         .x_min                  = 0,
1327         .x_max                  = 320,
1328         .y_min                  = 0,
1329         .y_max                  = 480,
1330         .debounce_max           = 7,
1331         .debounce_rep           = DEBOUNCE_REPTIME,
1332         .debounce_tol           = 20,
1333         .gpio_pendown           = XPT2046_GPIO_INT,
1334         .penirq_recheck_delay_usecs = 1,
1335 };
1336 #elif defined(CONFIG_TOUCHSCREEN_XPT2046_SPI)
1337 static struct xpt2046_platform_data xpt2046_info = {
1338         .model                  = 2046,
1339         .keep_vref_on   = 1,
1340         .swap_xy                = 1,
1341         .x_min                  = 0,
1342         .x_max                  = 800,
1343         .y_min                  = 0,
1344         .y_max                  = 480,
1345         .debounce_max           = 7,
1346         .debounce_rep           = DEBOUNCE_REPTIME,
1347         .debounce_tol           = 20,
1348         .gpio_pendown           = XPT2046_GPIO_INT,
1349
1350         .penirq_recheck_delay_usecs = 1,
1351 };
1352 #elif defined(CONFIG_TOUCHSCREEN_XPT2046_CBN_SPI)
1353 static struct xpt2046_platform_data xpt2046_info = {
1354         .model                  = 2046,
1355         .keep_vref_on   = 1,
1356         .swap_xy                = 1,
1357         .x_min                  = 0,
1358         .x_max                  = 800,
1359         .y_min                  = 0,
1360         .y_max                  = 480,
1361         .debounce_max           = 7,
1362         .debounce_rep           = DEBOUNCE_REPTIME,
1363         .debounce_tol           = 20,
1364         .gpio_pendown           = XPT2046_GPIO_INT,
1365
1366         .penirq_recheck_delay_usecs = 1,
1367 };
1368 #endif
1369
1370 static struct rk2818_spi_chip cmb_spi_chip = {
1371         .transfer_mode = RK2818_SPI_FULL_DUPLEX,
1372 };
1373
1374 static struct spi_board_info board_spi_devices[] = {
1375 #if defined(CONFIG_SPI_FPGA)
1376         {       /* fpga ice65l08xx */
1377                 .modalias       = "spi_fpga",
1378                 .chip_select    = 1,
1379                 .max_speed_hz   = 12 * 1000 * 1000,
1380                 .bus_num        = 0,
1381                 .mode   = SPI_MODE_0,
1382                 //.platform_data = &rk2818_spi_platdata,
1383         },
1384 #endif
1385 #if defined(CONFIG_ENC28J60)
1386         {       /* net chip */
1387                 .modalias       = "enc28j60",
1388                 .chip_select    = 1,
1389                 .max_speed_hz   = 12 * 1000 * 1000,
1390                 .bus_num        = 0,
1391                 .mode   = SPI_MODE_0,
1392         },
1393 #endif
1394 #if defined(CONFIG_TOUCHSCREEN_XPT2046_320X480_SPI) || defined(CONFIG_TOUCHSCREEN_XPT2046_320X480_CBN_SPI)\
1395     ||defined(CONFIG_TOUCHSCREEN_XPT2046_SPI) || defined(CONFIG_TOUCHSCREEN_XPT2046_CBN_SPI)
1396         {
1397                 .modalias       = "xpt2046_ts",
1398                 .chip_select    = 2,
1399                 .max_speed_hz   = 125 * 1000 * 26,/* (max sample rate @ 3V) * (cmd + data + overhead) */
1400                 .bus_num        = 0,
1401                 .irq = XPT2046_GPIO_INT,
1402                 .platform_data = &xpt2046_info,
1403         },
1404 #endif
1405 #if defined(CONFIG_SMS_SPI_ROCKCHIP)
1406         {
1407                 .modalias       = "siano1186",
1408                 .chip_select    = 0,
1409                 .max_speed_hz   = 12*1000*1000,
1410                 .bus_num        = 0,
1411                 .irq            = RK2818_PIN_PA6,
1412                 .controller_data = &cmb_spi_chip,
1413         },
1414 #endif
1415 };
1416
1417 /*****************************************************************************************
1418  * lcd  devices
1419  * author: zyw@rock-chips.com
1420  *****************************************************************************************/
1421 //#ifdef  CONFIG_LCD_TD043MGEA1
1422 #define LCD_TXD_PIN          RK2818_PIN_PE4
1423 #define LCD_CLK_PIN          RK2818_PIN_PE5
1424 #define LCD_CS_PIN           RK2818_PIN_PH6
1425 #define LCD_TXD_MUX_NAME     GPIOE_I2C0_SEL_NAME
1426 #define LCD_CLK_MUX_NAME     NULL
1427 #define LCD_CS_MUX_NAME      GPIOH6_IQ_SEL_NAME
1428 #define LCD_TXD_MUX_MODE     1
1429 #define LCD_CLK_MUX_MODE     1
1430 #define LCD_CS_MUX_MODE      0
1431 //#endif
1432 static int rk2818_lcd_io_init(void)
1433 {
1434     int ret = 0;
1435
1436     rk2818_mux_api_set(LCD_CS_MUX_NAME, LCD_CS_MUX_MODE);
1437     if (LCD_CS_PIN != INVALID_GPIO) {
1438         ret = gpio_request(LCD_CS_PIN, NULL);
1439         if(ret != 0)
1440         {
1441             goto err1;
1442             printk(">>>>>> lcd cs gpio_request err \n ");
1443         }
1444     }
1445
1446     rk2818_mux_api_set(LCD_CLK_MUX_NAME, LCD_CLK_MUX_MODE);
1447     if (LCD_CLK_PIN != INVALID_GPIO) {
1448         ret = gpio_request(LCD_CLK_PIN, NULL);
1449         if(ret != 0)
1450         {
1451             goto err2;
1452             printk(">>>>>> lcd clk gpio_request err \n ");
1453         }
1454     }
1455
1456     rk2818_mux_api_set(LCD_TXD_MUX_NAME, LCD_TXD_MUX_MODE);
1457     if (LCD_TXD_PIN != INVALID_GPIO) {
1458         ret = gpio_request(LCD_TXD_PIN, NULL);
1459         if(ret != 0)
1460         {
1461             goto err3;
1462             printk(">>>>>> lcd txd gpio_request err \n ");
1463         }
1464     }
1465
1466     return 0;
1467
1468 err3:
1469     if (LCD_CLK_PIN != INVALID_GPIO) {
1470         gpio_free(LCD_CLK_PIN);
1471     }
1472 err2:
1473     if (LCD_CS_PIN != INVALID_GPIO) {
1474         gpio_free(LCD_CS_PIN);
1475     }
1476 err1:
1477     return ret;
1478 }
1479
1480 static int rk2818_lcd_io_deinit(void)
1481 {
1482     int ret = 0;
1483     gpio_free(LCD_CS_PIN);
1484     rk2818_mux_api_mode_resume(LCD_CS_MUX_NAME);
1485     gpio_free(LCD_CLK_PIN);
1486     gpio_free(LCD_TXD_PIN);
1487     rk2818_mux_api_mode_resume(LCD_TXD_MUX_NAME);
1488     rk2818_mux_api_mode_resume(LCD_CLK_MUX_NAME);
1489
1490     return ret;
1491 }
1492
1493 struct rk2818lcd_info rk2818_lcd_info = {
1494     .txd_pin  = LCD_TXD_PIN,
1495     .clk_pin = LCD_CLK_PIN,
1496     .cs_pin = LCD_CS_PIN,
1497     .io_init   = rk2818_lcd_io_init,
1498     .io_deinit = rk2818_lcd_io_deinit,
1499 };
1500
1501
1502 /*****************************************************************************************
1503  * frame buffe  devices
1504  * author: zyw@rock-chips.com
1505  *****************************************************************************************/
1506 #define FB_ID                       0
1507 #define FB_DISPLAY_ON_PIN           INVALID_GPIO
1508 #define FB_LCD_STANDBY_PIN          INVALID_GPIO
1509 #define FB_MCU_FMK_PIN              INVALID_GPIO
1510
1511 #define FB_DISPLAY_ON_VALUE         GPIO_LOW
1512 #define FB_LCD_STANDBY_VALUE        0
1513
1514 #define FB_DISPLAY_ON_MUX_NAME      NULL
1515 #define FB_DISPLAY_ON_MUX_MODE      0
1516
1517 #define FB_LCD_STANDBY_MUX_NAME     NULL
1518 #define FB_LCD_STANDBY_MUX_MODE     1
1519
1520 #define FB_MCU_FMK_PIN_MUX_NAME     NULL
1521 #define FB_MCU_FMK_MUX_MODE         0
1522
1523 #define FB_DATA0_16_MUX_NAME       GPIOC_LCDC16BIT_SEL_NAME
1524 #define FB_DATA0_16_MUX_MODE        1
1525
1526 #define FB_DATA17_18_MUX_NAME      GPIOC_LCDC18BIT_SEL_NAME
1527 #define FB_DATA17_18_MUX_MODE       1
1528
1529 #define FB_DATA19_24_MUX_NAME      GPIOC_LCDC24BIT_SEL_NAME
1530 #define FB_DATA19_24_MUX_MODE       1
1531
1532 #define FB_DEN_MUX_NAME            CXGPIO_LCDDEN_SEL_NAME
1533 #define FB_DEN_MUX_MODE             1
1534
1535 #define FB_VSYNC_MUX_NAME          CXGPIO_LCDVSYNC_SEL_NAME
1536 #define FB_VSYNC_MUX_MODE           1
1537
1538 #define FB_MCU_FMK_MUX_NAME        NULL
1539 #define FB_MCU_FMK_MUX_MODE         0
1540
1541 static int rk2818_fb_io_init(struct rk2818_fb_setting_info *fb_setting)
1542 {
1543     int ret = 0;
1544     if(fb_setting->data_num <=16)
1545         rk2818_mux_api_set(FB_DATA0_16_MUX_NAME, FB_DATA0_16_MUX_MODE);
1546     if(fb_setting->data_num >16 && fb_setting->data_num<=18)
1547         rk2818_mux_api_set(FB_DATA17_18_MUX_NAME, FB_DATA17_18_MUX_MODE);
1548     if(fb_setting->data_num >18)
1549         rk2818_mux_api_set(FB_DATA19_24_MUX_NAME, FB_DATA19_24_MUX_MODE);
1550
1551     if(fb_setting->vsync_en)
1552         rk2818_mux_api_set(FB_VSYNC_MUX_NAME, FB_VSYNC_MUX_MODE);
1553
1554     if(fb_setting->den_en)
1555         rk2818_mux_api_set(FB_DEN_MUX_NAME, FB_DEN_MUX_MODE);
1556
1557     if(fb_setting->mcu_fmk_en && FB_MCU_FMK_MUX_NAME && (FB_MCU_FMK_PIN != INVALID_GPIO))
1558     {
1559         rk2818_mux_api_set(FB_MCU_FMK_MUX_NAME, FB_MCU_FMK_MUX_MODE);
1560         ret = gpio_request(FB_MCU_FMK_PIN, NULL);
1561         if(ret != 0)
1562         {
1563             gpio_free(FB_MCU_FMK_PIN);
1564             printk(">>>>>> FB_MCU_FMK_PIN gpio_request err \n ");
1565         }
1566         gpio_direction_input(FB_MCU_FMK_PIN);
1567     }
1568
1569     if(fb_setting->disp_on_en && FB_DISPLAY_ON_MUX_NAME && (FB_DISPLAY_ON_PIN != INVALID_GPIO))
1570     {
1571         rk2818_mux_api_set(FB_DISPLAY_ON_MUX_NAME, FB_DISPLAY_ON_MUX_MODE);
1572         ret = gpio_request(FB_DISPLAY_ON_PIN, NULL);
1573         if(ret != 0)
1574         {
1575             gpio_free(FB_DISPLAY_ON_PIN);
1576             printk(">>>>>> FB_DISPLAY_ON_PIN gpio_request err \n ");
1577         }
1578     }
1579
1580     if(fb_setting->disp_on_en && FB_LCD_STANDBY_MUX_NAME && (FB_LCD_STANDBY_PIN != INVALID_GPIO))
1581     {
1582         rk2818_mux_api_set(FB_LCD_STANDBY_MUX_NAME, FB_LCD_STANDBY_MUX_MODE);
1583         ret = gpio_request(FB_LCD_STANDBY_PIN, NULL);
1584         if(ret != 0)
1585         {
1586             gpio_free(FB_LCD_STANDBY_PIN);
1587             printk(">>>>>> FB_LCD_STANDBY_PIN gpio_request err \n ");
1588         }
1589     }
1590
1591     return ret;
1592 }
1593
1594 struct rk2818fb_info rk2818_fb_info = {
1595     .fb_id   = FB_ID,
1596     .disp_on_pin = FB_DISPLAY_ON_PIN,
1597     .disp_on_value = FB_DISPLAY_ON_VALUE,
1598     .standby_pin = FB_LCD_STANDBY_PIN,
1599     .standby_value = FB_LCD_STANDBY_VALUE,
1600     .mcu_fmk_pin = FB_MCU_FMK_PIN,
1601     .lcd_info = &rk2818_lcd_info,
1602     .io_init   = rk2818_fb_io_init,
1603 };
1604
1605 /*****************************************************************************************
1606  * backlight  devices
1607  * author: nzy@rock-chips.com
1608  *****************************************************************************************/
1609  /*
1610  GPIOF2_APWM0_SEL_NAME,       IOMUXB_PWM0
1611  GPIOF3_APWM1_MMC0DETN_NAME,  IOMUXA_PWM1
1612  GPIOF4_APWM2_MMC0WPT_NAME,   IOMUXA_PWM2
1613  GPIOF5_APWM3_DPWM3_NAME,     IOMUXB_PWM3
1614  */
1615
1616 #define PWM_ID            0
1617 #define PWM_MUX_NAME      GPIOF2_APWM0_SEL_NAME
1618 #define PWM_MUX_MODE      IOMUXB_PWM0
1619 #define PWM_EFFECT_VALUE  0
1620
1621
1622 #define BL_EN_MUX_NAME    GPIOF34_UART3_SEL_NAME
1623 #define BL_EN_MUX_MODE    IOMUXB_GPIO1_B34
1624
1625 #define BL_EN_PIN         RK2818_PIN_PF3
1626 #define BL_EN_VALUE       GPIO_HIGH
1627
1628
1629
1630 static int rk2818_backlight_io_init(void)
1631 {
1632     int ret = 0;
1633
1634     rk2818_mux_api_set(PWM_MUX_NAME, PWM_MUX_MODE);
1635
1636     rk2818_mux_api_set(BL_EN_MUX_NAME, BL_EN_MUX_MODE);
1637
1638     ret = gpio_request(BL_EN_PIN, NULL);
1639     if(ret != 0)
1640     {
1641         gpio_free(BL_EN_PIN);
1642         printk(KERN_ERR ">>>>>> lcd_cs gpio_request err \n ");
1643     }
1644
1645     gpio_direction_output(BL_EN_PIN, 0);
1646     gpio_set_value(BL_EN_PIN, BL_EN_VALUE);
1647
1648     return ret;
1649 }
1650
1651 static int rk2818_backlight_io_deinit(void)
1652 {
1653     int ret = 0;
1654
1655     gpio_free(BL_EN_PIN);
1656
1657     rk2818_mux_api_mode_resume(PWM_MUX_NAME);
1658
1659     rk2818_mux_api_mode_resume(BL_EN_MUX_NAME);
1660
1661     return ret;
1662 }
1663
1664 struct rk2818_bl_info rk2818_bl_info = {
1665     .pwm_id   = PWM_ID,
1666     .bl_ref   = PWM_EFFECT_VALUE,
1667     .io_init   = rk2818_backlight_io_init,
1668     .io_deinit = rk2818_backlight_io_deinit,
1669 };
1670
1671
1672 /*****************************************************************************************
1673  * netcard  devices
1674  * author: lyx@rock-chips.com
1675  *****************************************************************************************/
1676 #ifdef CONFIG_DM9000
1677 /*
1678 GPIOA5_FLASHCS1_SEL_NAME     IOMUXB_FLASH_CS1
1679 GPIOA6_FLASHCS2_SEL_NAME     IOMUXB_FLASH_CS2
1680 GPIOA7_FLASHCS3_SEL_NAME     IOMUXB_FLASH_CS3
1681 GPIOE_SPI1_FLASH_SEL1_NAME   IOMUXA_FLASH_CS45
1682 GPIOE_SPI1_FLASH_SEL_NAME    IOMUXA_FLASH_CS67
1683 */
1684 #define DM9000_USE_NAND_CS 1     //cs can be 1,2,3,4,5,6 or 7
1685 #define DM9000_CS_IOMUX_NAME GPIOA5_FLASHCS1_SEL_NAME
1686 #define DM9000_CS_IOMUX_MODE IOMUXB_FLASH_CS1
1687 #define DM9000_NET_INT_PIN RK2818_PIN_PA1
1688 #define DM9000_INT_IOMUX_NAME GPIOA1_HOSTDATA17_SEL_NAME
1689 #define DM9000_INT_IOMUX_MODE IOMUXB_GPIO0_A1
1690 #define DM9000_INT_INIT_VALUE GPIOPullDown
1691 #define DM9000_IRQ IRQF_TRIGGER_HIGH
1692 #define DM9000_IO_ADDR (RK2818_NANDC_PHYS + 0x800 + DM9000_USE_NAND_CS*0x100 + 0x8)
1693 #define DM9000_DATA_ADDR (RK2818_NANDC_PHYS + 0x800 + DM9000_USE_NAND_CS*0x100 + 0x4)
1694
1695 static int dm9k_gpio_set(void)
1696 {
1697         //cs
1698         rk2818_mux_api_set(DM9000_CS_IOMUX_NAME, DM9000_CS_IOMUX_MODE);
1699         //int
1700         rk2818_mux_api_set(DM9000_INT_IOMUX_NAME, DM9000_INT_IOMUX_MODE);
1701
1702         return 0;
1703 }
1704 static int dm9k_gpio_free(void)
1705 {
1706         rk2818_mux_api_mode_resume(DM9000_INT_IOMUX_NAME);
1707         rk2818_mux_api_mode_resume(DM9000_CS_IOMUX_NAME);
1708         return 0;
1709 }
1710
1711 static struct resource dm9k_resource[] = {
1712         [0] = {
1713                 .start = DM9000_IO_ADDR,
1714                 .end   = DM9000_IO_ADDR + 3,
1715                 .flags = IORESOURCE_MEM,
1716         },
1717         [1] = {
1718                 .start = DM9000_DATA_ADDR,
1719                 .end   = DM9000_DATA_ADDR + 3,
1720                 .flags = IORESOURCE_MEM,
1721         },
1722         [2] = {
1723                 .start = DM9000_NET_INT_PIN,
1724                 .end   = DM9000_NET_INT_PIN,
1725                 .flags = IORESOURCE_IRQ | DM9000_IRQ,
1726         }
1727
1728 };
1729
1730 /* for the moment we limit ourselves to 8bit IO until some
1731  * better IO routines can be written and tested
1732 */
1733 struct dm9000_plat_data dm9k_platdata = {
1734         .flags = DM9000_PLATF_8BITONLY,
1735         .irq_pin = DM9000_NET_INT_PIN,
1736         .irq_pin_value = DM9000_INT_INIT_VALUE,
1737         .io_init = dm9k_gpio_set,
1738         .io_deinit = dm9k_gpio_free,
1739 };
1740
1741 struct platform_device rk2818_device_dm9k = {
1742         .name           = "dm9000",
1743         .id             = 0,
1744         .num_resources  = ARRAY_SIZE(dm9k_resource),
1745         .resource       = dm9k_resource,
1746         .dev            = {
1747                 .platform_data = &dm9k_platdata,
1748         }
1749 };
1750 #endif
1751
1752 #ifdef CONFIG_HEADSET_DET
1753 struct rk2818_headset_data rk2818_headset_info = {
1754         .irq            = FPGA_PIO0_00,
1755         .irq_type       = IRQF_TRIGGER_FALLING,
1756         .headset_in_type= HEADSET_IN_HIGH,
1757 };
1758
1759 struct platform_device rk28_device_headset = {
1760                 .name   = "rk2818_headsetdet",
1761                 .id     = 0,
1762                 .dev    = {
1763                     .platform_data = &rk2818_headset_info,
1764                 }
1765 };
1766 #endif
1767
1768 #ifdef CONFIG_INPUT_LPSENSOR_CM3602
1769 static int capella_cm3602_power(int on);
1770
1771 static struct capella_cm3602_platform_data capella_cm3602_pdata = {
1772         .power = capella_cm3602_power,
1773         .irq_pin = FPGA_PIO0_04,
1774         .pwd_out_pin = FPGA_PIO4_07,
1775         .ps_shutdown_pin = FPGA_PIO5_00,
1776         //.p_out = MAHIMAHI_GPIO_PROXIMITY_INT_N
1777         };
1778
1779 static int capella_cm3602_power(int on)
1780 {       /* TODO eolsen Add Voltage reg control */
1781     if (on) {
1782         printk("[%s]:on---\n",__FUNCTION__);
1783        gpio_direction_output(capella_cm3602_pdata.pwd_out_pin, SPI_GPIO_LOW);
1784         gpio_direction_output(capella_cm3602_pdata.ps_shutdown_pin, SPI_GPIO_LOW);
1785     }
1786     else {
1787             printk("[%s]:off---\n",__FUNCTION__);
1788        gpio_direction_output(capella_cm3602_pdata.pwd_out_pin, SPI_GPIO_HIGH);
1789         gpio_direction_output(capella_cm3602_pdata.ps_shutdown_pin, SPI_GPIO_HIGH);
1790     }
1791     return 0;
1792 }
1793
1794 struct platform_device rk2818_device_cm3605 = {
1795             .name = CAPELLA_CM3602,
1796                 .id = -1,
1797                 .dev = {
1798                 .platform_data = &capella_cm3602_pdata
1799                         }
1800         };
1801 #endif
1802
1803 /*****************************************************************************************
1804  * nand flash devices
1805  * author: hxy@rock-chips.com
1806  *****************************************************************************************/
1807 /*
1808 GPIOA5_FLASHCS1_SEL_NAME,   IOMUXB_FLASH_CS1
1809 GPIOA6_FLASHCS2_SEL_NAME,   IOMUXB_FLASH_CS2
1810 GPIOA7_FLASHCS3_SEL_NAME,   IOMUXB_FLASH_CS3
1811 GPIOE_SPI1_FLASH_SEL1_NAME, IOMUXA_FLASH_CS45
1812 GPIOE_SPI1_FLASH_SEL_NAME,  IOMUXA_FLASH_CS67
1813 */
1814
1815 #define NAND_CS_MAX_NUM     1  /*form 0 to 8, it is 0 when no nand flash */
1816
1817 int rk2818_nand_io_init(void)
1818 {
1819 #if (NAND_CS_MAX_NUM == 2)
1820     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1821 #elif (NAND_CS_MAX_NUM == 3)
1822     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1823     rk2818_mux_api_set(GPIOA6_FLASHCS2_SEL_NAME, IOMUXB_FLASH_CS2);
1824 #elif (NAND_CS_MAX_NUM == 4)
1825     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1826     rk2818_mux_api_set(GPIOA6_FLASHCS2_SEL_NAME, IOMUXB_FLASH_CS2);
1827     rk2818_mux_api_set(GPIOA7_FLASHCS3_SEL_NAME, IOMUXB_FLASH_CS3);
1828 #elif ((NAND_CS_MAX_NUM == 5) || (NAND_CS_MAX_NUM == 6))
1829     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1830     rk2818_mux_api_set(GPIOA6_FLASHCS2_SEL_NAME, IOMUXB_FLASH_CS2);
1831     rk2818_mux_api_set(GPIOA7_FLASHCS3_SEL_NAME, IOMUXB_FLASH_CS3);
1832     rk2818_mux_api_set(GPIOE_SPI1_FLASH_SEL1_NAME, IOMUXA_FLASH_CS45);
1833 #elif ((NAND_CS_MAX_NUM == 7) || (NAND_CS_MAX_NUM == 8))
1834     rk2818_mux_api_set(GPIOA5_FLASHCS1_SEL_NAME, IOMUXB_FLASH_CS1);
1835     rk2818_mux_api_set(GPIOA6_FLASHCS2_SEL_NAME, IOMUXB_FLASH_CS2);
1836     rk2818_mux_api_set(GPIOA7_FLASHCS3_SEL_NAME, IOMUXB_FLASH_CS3);
1837     rk2818_mux_api_set(GPIOE_SPI1_FLASH_SEL1_NAME, IOMUXA_FLASH_CS45);
1838     rk2818_mux_api_set(GPIOE_SPI1_FLASH_SEL_NAME, IOMUXA_FLASH_CS67);
1839 #endif
1840     return 0;
1841 }
1842
1843 struct rk2818_nand_platform_data rk2818_nand_data = {
1844     .width      = 1,     /* data bus width in bytes */
1845     .hw_ecc     = 1,     /* hw ecc 0: soft ecc */
1846     .num_flash    = 1,
1847     .io_init   = rk2818_nand_io_init,
1848 };
1849
1850
1851 /********************usb*********************/
1852 struct usb_mass_storage_platform_data mass_storage_pdata = {
1853         .nluns          = 1,
1854         .vendor         = "RockChip",
1855         .product        = "rk2818 sdk",
1856         .release        = 0x0100,
1857 };
1858
1859
1860 static struct platform_device *devices[] __initdata = {
1861 #ifdef CONFIG_BT
1862         &raho_rfkill,
1863 #endif
1864 #ifdef CONFIG_UART0_RK2818
1865         &rk2818_device_uart0,
1866 #endif
1867 #ifdef CONFIG_UART1_RK2818
1868         &rk2818_device_uart1,
1869 #endif
1870 #ifdef CONFIG_I2C0_RK2818
1871         &rk2818_device_i2c0,
1872 #endif
1873 #ifdef CONFIG_I2C1_RK2818
1874         &rk2818_device_i2c1,
1875 #endif
1876 #ifdef CONFIG_SDMMC0_RK2818
1877         &rk2818_device_sdmmc0,
1878 #endif
1879 #ifdef CONFIG_SDMMC1_RK2818
1880         &rk2818_device_sdmmc1,
1881 #endif
1882         &raho_wifi_device,
1883         &rk2818_device_spim,
1884         &rk2818_device_i2s,
1885 #if defined(CONFIG_ANDROID_PMEM)
1886         &rk2818_device_pmem,
1887         &rk2818_device_pmem_dsp,
1888 #endif
1889         &rk2818_device_adc,
1890         &rk2818_device_adckey,
1891 #if defined(CONFIG_RK2818_REGULATOR_CHARGE)
1892         &power_supply,
1893         &charge_current,
1894 #endif
1895         &rk2818_device_battery,
1896     &rk2818_device_fb,
1897     &rk2818_device_backlight,
1898         &rk2818_device_dsp,
1899
1900 #ifdef CONFIG_VIDEO_RK2818
1901         &rk2818_device_camera,      /* ddl@rock-chips.com : camera support  */
1902         &rk2818_soc_camera_pdrv,
1903  #endif
1904
1905 #ifdef CONFIG_MTD_NAND_RK2818
1906         &rk2818_nand_device,
1907 #endif
1908 #ifdef CONFIG_DM9000
1909         &rk2818_device_dm9k,
1910 #endif
1911 #ifdef CONFIG_INPUT_LPSENSOR_CM3602
1912     &rk2818_device_cm3605,
1913 #endif
1914 #ifdef CONFIG_HEADSET_DET
1915     &rk28_device_headset,
1916 #endif
1917 #ifdef CONFIG_DWC_OTG
1918         &rk2818_device_dwc_otg,
1919 #endif
1920 #ifdef CONFIG_RK2818_HOST11
1921         &rk2818_device_host11,
1922 #endif
1923 #ifdef CONFIG_USB_ANDROID
1924         &android_usb_device,
1925         &usb_mass_storage_device,
1926 #endif
1927 #ifdef CONFIG_ANDROID_TIMED_GPIO
1928         &rk28_device_vibrator,
1929 #endif
1930 };
1931
1932 extern struct sys_timer rk2818_timer;
1933 #define POWER_PIN       RK2818_PIN_PB1
1934 static void rk2818_power_on(void)
1935 {
1936         int ret;
1937         ret = gpio_request(POWER_PIN, NULL);
1938         if (ret) {
1939                 printk("failed to request power_off gpio\n");
1940                 goto err_free_gpio;
1941         }
1942
1943         gpio_pull_updown(POWER_PIN, GPIOPullUp);
1944         ret = gpio_direction_output(POWER_PIN, GPIO_HIGH);
1945         if (ret) {
1946                 printk("failed to set power_off gpio output\n");
1947                 goto err_free_gpio;
1948         }
1949
1950         gpio_set_value(POWER_PIN, 1);/*power on*/
1951
1952 err_free_gpio:
1953         gpio_free(POWER_PIN);
1954 }
1955
1956 static void rk2818_power_off(void)
1957 {
1958         printk("shut down system now ...\n");
1959         gpio_set_value(POWER_PIN, 0);/*power down*/
1960 }
1961
1962 //      adc      ---> key
1963 #define PLAY_ON_PIN RK2818_PIN_PA3
1964 #define PLAY_ON_LEVEL 1
1965 static  ADC_keyst gAdcValueTab[] =
1966 {
1967         {0x65,  AD2KEY1},///VOLUME_DOWN
1968         {0xd3,  AD2KEY2},///VOLUME_UP
1969         {0x130, AD2KEY3},///MENU
1970         {0x19d, AD2KEY4},///HOME
1971         {0x202, AD2KEY5},///BACK
1972         {0x2d0, AD2KEY6},///CALL
1973         {0x267, AD2KEY7},///SEARCH
1974         {0,     0}///table end
1975 };
1976
1977 static unsigned char gInitKeyCode[] =
1978 {
1979         AD2KEY1,AD2KEY2,AD2KEY3,AD2KEY4,AD2KEY5,AD2KEY6,AD2KEY7,
1980         ENDCALL,KEYSTART,KEY_WAKEUP,
1981 };
1982
1983 struct adc_key_data rk2818_adc_key = {
1984     .pin_playon     = PLAY_ON_PIN,
1985     .playon_level   = PLAY_ON_LEVEL,
1986     .adc_empty      = 1000,
1987     .adc_invalid    = 20,
1988     .adc_drift      = 50,
1989     .adc_chn        = 1,
1990     .adc_key_table  = gAdcValueTab,
1991     .initKeyCode    = gInitKeyCode,
1992     .adc_key_cnt    = 10,
1993 };
1994
1995 struct rk2818_adckey_platform_data rk2818_adckey_platdata = {
1996         .adc_key = &rk2818_adc_key,
1997 };
1998
1999 #if CONFIG_ANDROID_TIMED_GPIO
2000 static struct timed_gpio timed_gpios[] = {
2001         {
2002                 .name = "vibrator",
2003                 .gpio = SPI_GPIO_P1_12,
2004                 .max_timeout = 1000,
2005                 .active_low = 1,
2006         },
2007 };
2008
2009 struct timed_gpio_platform_data rk28_vibrator_info = {
2010         .num_gpios = 1,
2011         .gpios = timed_gpios,
2012 };
2013 #endif
2014 #if defined (CONFIG_RK2818_SOC_PM)
2015 void __tcmfunc rk2818_pm_scu_suspend(unsigned int *reg,int regoff)
2016 {
2017
2018         switch(regoff)
2019         {
2020                 case PM_SCU_CLKGATE0_CON:
2021                         {
2022                         }
2023
2024
2025         }
2026
2027 }
2028
2029
2030
2031 void __tcmfunc rk2818_soc_general_reg_suspend(void)
2032 {
2033         struct rk2818_pm_soc_st *general=rk2818_soc_pm.general;
2034
2035         unsigned int *general_reg_addr=general->reg_base_addr;
2036         #if 1
2037         general->reg_ctrbit|=(0x1<<PM_GPIO0_AB_PU_CON);
2038         general_reg_addr[PM_GPIO0_AB_PU_CON] =GPIO0_AB_NORMAL;
2039
2040         general->reg_ctrbit|=(0x1<<PM_GPIO0_CD_PU_CON);
2041         general_reg_addr[PM_GPIO0_CD_PU_CON] = GPIO0_CD_NORMAL;
2042
2043         general->reg_ctrbit|=(0x1<<PM_GPIO1_AB_PU_CON);
2044         general_reg_addr[PM_GPIO1_AB_PU_CON] = GPIO1_AB_NORMAL;
2045
2046         general->reg_ctrbit|=(0x1<<PM_GPIO1_CD_PU_CON);
2047         general_reg_addr[PM_GPIO1_CD_PU_CON] = GPIO1_CD_NORMAL;
2048         #endif
2049
2050         general->reg_ctrbit|=(0x1<<PM_IOMUX_A_CON);
2051         general->reg_ctrbit|=(0x1<<PM_IOMUX_B_CON);
2052
2053         rk2818_socpm_gpio_pullupdown(RK2818_PIN_PA3,GPIOPullDown);// ´¦Àí°´¼ü
2054
2055         #if 1  //set uart0 pin
2056
2057                 general_reg_addr[PM_IOMUX_A_CON] &=(~(0x3<<PM_UART0_OUT))&(~(0x3<<PM_UART0_IN));// 00 gpio 01uart
2058                 general_reg_addr[PM_IOMUX_B_CON] &=(~(0x1<<PM_UART0_RTS))&(~(0x1<<PM_UART0_CTS));//
2059                 rk2818_socpm_set_gpio(RK2818_PIN_PG0,0,0);//uart0 sin pin
2060                 rk2818_socpm_set_gpio(RK2818_PIN_PG1,0,0);//uart0 sout pin
2061
2062                 rk2818_socpm_set_gpio(RK2818_PIN_PG0,0,0);//uart0 sin pin
2063                 rk2818_socpm_set_gpio(RK2818_PIN_PG1,0,0);//uart0 sout pin
2064
2065                 rk2818_socpm_set_gpio(RK2818_PIN_PB2,0,0);//uart0 cts pin
2066                 rk2818_socpm_set_gpio(RK2818_PIN_PB3,0,0);//uart0 rts pin
2067
2068                 rk2818_socpm_set_gpio(RK2818_PIN_PF7,0,0);//uart0 dtr pin
2069                 rk2818_socpm_set_gpio(RK2818_PIN_PE0,0,0);//uart0 dsr pin
2070
2071
2072         #endif
2073
2074         #if 1  //set uart1 pin
2075
2076                 general_reg_addr[PM_IOMUX_A_CON] &=(~(0x3<<PM_UART1_OUT))&(~(0x3<<PM_UART1_IN));// 00 gpio 01uart
2077                 rk2818_socpm_set_gpio(RK2818_PIN_PF0,0,0);//uart0 sin pin
2078                 rk2818_socpm_set_gpio(RK2818_PIN_PG1,0,0);//uart0 sout pin
2079         #endif
2080
2081
2082         #if 1  //set i2c0 pin
2083                 general_reg_addr[PM_IOMUX_A_CON] |=(0x1<<PM_I2C0);// 1 gpio;0 i2c
2084                 rk2818_socpm_set_gpio(RK2818_PIN_PE4,0,0);//sda pin
2085                 rk2818_socpm_set_gpio(RK2818_PIN_PE5,0,0);//scl dsr pin
2086         #endif
2087
2088         #if 1  //set i2c1 pin
2089                 general_reg_addr[PM_IOMUX_A_CON] &=(~(0x3<<PM_I2C1));// 0 gpio;1 i2c
2090                 rk2818_socpm_set_gpio(RK2818_PIN_PE6,0,0);//sda pin
2091                 rk2818_socpm_set_gpio(RK2818_PIN_PE7,0,0);//scl dsr pin
2092         #endif
2093         #if 1  // sdio0
2094
2095                 general_reg_addr[PM_IOMUX_A_CON] &=(~(0x1<<PM_SDIO0_CMD))&(~(0x1<<PM_SDIO0_DATA));// 1 gpio;0 i2c
2096                 rk2818_socpm_set_gpio(RK2818_PIN_PH0,0,0);
2097                 rk2818_socpm_set_gpio(RK2818_PIN_PH1,0,0);
2098                 rk2818_socpm_set_gpio(RK2818_PIN_PH2,0,0);
2099                 rk2818_socpm_set_gpio(RK2818_PIN_PH3,0,0);
2100                 rk2818_socpm_set_gpio(RK2818_PIN_PH4,0,0);
2101                 rk2818_socpm_set_gpio(RK2818_PIN_PH5,0,0);
2102
2103                 //rk2818_socpm_set_gpio(RK2818_PIN_PF3,0,0);
2104
2105
2106         #endif
2107         #if 1 // sdio1
2108                 general_reg_addr[PM_IOMUX_A_CON] &=(~(0x1<<PM_SDIO1_CMD))&(~(0x1<<PM_SDIO1_DATA));// 1 gpio;0 i2c
2109                 rk2818_socpm_set_gpio(RK2818_PIN_PG2,0,0);
2110                 rk2818_socpm_set_gpio(RK2818_PIN_PG3,0,0);
2111                 rk2818_socpm_set_gpio(RK2818_PIN_PG4,0,0);
2112                 rk2818_socpm_set_gpio(RK2818_PIN_PG5,0,0);
2113                 rk2818_socpm_set_gpio(RK2818_PIN_PG6,0,0);
2114                 rk2818_socpm_set_gpio(RK2818_PIN_PG7,0,0);
2115         #endif
2116 }
2117 void __tcmfunc rk2818_pm_set_vol(void)
2118 {
2119         rk2818_socpm_set_gpio(RK2818_PIN_PC2,1,0);
2120 }
2121 void __tcmfunc rk2818_pm_resume_vol(void)
2122 {
2123         rk2818_socpm_set_gpio(RK2818_PIN_PC2,1,1);
2124 }
2125 #else
2126 #define pm_set_general_cpu_reg(a)
2127 #define rk2818_pm_set_vol()
2128 #define rk2818_pm_resume_vol()
2129 #endif
2130 static void __init machine_rk2818_init_irq(void)
2131 {
2132         rk2818_init_irq();
2133         rk2818_gpio_init(rk2818_gpioBank, 8);
2134         rk2818_gpio_irq_setup();
2135 }
2136
2137 static void __init machine_rk2818_board_init(void)
2138 {
2139         printk("3x machine_rk2818_board_init\n");
2140
2141         rk2818_socpm_int( (pm_scu_suspend) rk2818_pm_scu_suspend,(pm_general_reg_suspend) rk2818_soc_general_reg_suspend,
2142         (pm_set_suspendvol) rk2818_pm_set_vol,(pm_resume_vol) rk2818_pm_resume_vol);
2143         rk2818_power_on();
2144         pm_power_off = rk2818_power_off;
2145
2146 #ifdef CONFIG_SPI_FPGA_FW
2147         fpga_dl_fw();
2148 #endif
2149
2150 #ifdef CONFIG_I2C0_RK2818
2151         i2c_register_board_info(default_i2c0_data.bus_num, board_i2c0_devices,
2152                         ARRAY_SIZE(board_i2c0_devices));
2153 #endif
2154 #ifdef CONFIG_I2C1_RK2818
2155         i2c_register_board_info(default_i2c1_data.bus_num, board_i2c1_devices,
2156                         ARRAY_SIZE(board_i2c1_devices));
2157 #endif
2158 #ifdef CONFIG_SPI_FPGA_I2C
2159         i2c_register_board_info(default_i2c2_data.bus_num, board_i2c2_devices,
2160                         ARRAY_SIZE(board_i2c2_devices));
2161         i2c_register_board_info(default_i2c3_data.bus_num, board_i2c3_devices,
2162                         ARRAY_SIZE(board_i2c3_devices));
2163 #endif
2164         platform_add_devices(devices, ARRAY_SIZE(devices));
2165         spi_register_board_info(board_spi_devices, ARRAY_SIZE(board_spi_devices));
2166 }
2167
2168 static void __init machine_rk2818_mapio(void)
2169 {
2170         iotable_init(rk2818_io_desc, ARRAY_SIZE(rk2818_io_desc));
2171         rk2818_clock_init();
2172         rk2818_iomux_init();
2173 }
2174
2175 MACHINE_START(RK2818, "RK28board")
2176
2177 /* UART for LL DEBUG */
2178         .phys_io        = 0x18002000,
2179         .io_pg_offst    = ((0xFF100000) >> 18) & 0xfffc,
2180         .boot_params    = RK2818_SDRAM_PHYS + 0xf8000,
2181         .map_io         = machine_rk2818_mapio,
2182         .init_irq       = machine_rk2818_init_irq,
2183         .init_machine   = machine_rk2818_board_init,
2184         .timer          = &rk2818_timer,
2185 MACHINE_END
2186