arch/arm/mach-rk30/board-rk3168-tb.c

   1 /*
   2  *
   3  * Copyright (C) 2012 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/skbuff.h>
  24 #include <linux/spi/spi.h>
  25 #include <linux/mmc/host.h>
  26 #include <linux/ion.h>
  27 #include <linux/cpufreq.h>
  28 #include <linux/clk.h>
  29 #include <mach/dvfs.h>
  30
  31 #include <asm/setup.h>
  32 #include <asm/mach-types.h>
  33 #include <asm/mach/arch.h>
  34 #include <asm/mach/map.h>
  35 #include <asm/mach/flash.h>
  36 #include <asm/hardware/gic.h>
  37
  38 #include <mach/board.h>
  39 #include <mach/hardware.h>
  40 #include <mach/io.h>
  41 #include <mach/gpio.h>
  42 #include <mach/iomux.h>
  43 #include <linux/rk_fb.h>
  44 #include <linux/regulator/machine.h>
  45 #include <linux/rfkill-rk.h>
  46 #include <linux/sensor-dev.h>
  47 #include <linux/mfd/tps65910.h>
  48 #include <linux/regulator/act8846.h>
  49 #include <linux/mfd/rk808.h>
  50 #include <linux/mfd/ricoh619.h>
  51 #include <linux/regulator/rk29-pwm-regulator.h>
  52 #ifdef CONFIG_MFD_RT5025
  53 #include <linux/mfd/rt5025.h>
  54 #endif
  55 #include <plat/efuse.h>
  56
  57 #ifdef CONFIG_CW2015_BATTERY
  58 #include <linux/power/cw2015_battery.h>
  59 #endif
  60 #if defined(CONFIG_MFD_RK610)
  61 #include <linux/mfd/rk610_core.h>
  62 #endif
  63
  64 #if defined(CONFIG_MFD_RK616)
  65 #include <linux/mfd/rk616.h>
  66 #endif
  67
  68
  69 #if defined(CONFIG_RK_HDMI)
  70         #include "../../../drivers/video/rockchip/hdmi/rk_hdmi.h"
  71 #endif
  72
  73 #if defined(CONFIG_SPIM_RK29)
  74 #include "../../../drivers/spi/rk29_spim.h"
  75 #endif
  76 #if defined(CONFIG_GPS_RK)
  77 #include "../../../drivers/misc/gps/rk_gps/rk_gps.h"
  78 #endif
  79 #if defined(CONFIG_MU509)
  80 #include <linux/mu509.h>
  81 #endif
  82 #if defined(CONFIG_MW100)
  83 #include <linux/mw100.h>
  84 #endif
  85 #if defined(CONFIG_MT6229)
  86 #include <linux/mt6229.h>
  87 #endif
  88 #if defined(CONFIG_ANDROID_TIMED_GPIO)
  89 #include "../../../drivers/staging/android/timed_gpio.h"
  90 #endif
  91
  92 #if defined(CONFIG_MT6620)
  93 #include <linux/gps.h>
  94 #endif
  95 #include "board-rk3168-tb-camera.c"
  96
  97 #if defined(CONFIG_TOUCHSCREEN_GT8XX)
  98 #define TOUCH_RESET_PIN  RK30_PIN0_PB6
  99 #define TOUCH_PWR_PIN    RK30_PIN0_PC5   // need to fly line by hardware engineer
 100
 101 /* Android Parameter */
 102 static int ap_mdm = 0;
 103 module_param(ap_mdm, int, 0644);
 104 static int ap_has_alsa = 0;
 105 module_param(ap_has_alsa, int, 0644);
 106 static int ap_data_only = 2;
 107 module_param(ap_data_only, int, 0644);
 108 static int ap_has_earphone = 0;
 109 module_param(ap_has_earphone, int, 0644);
 110
 111
 112 static int goodix_init_platform_hw(void)
 113 {
 114         int ret;
 115
 116         if (TOUCH_PWR_PIN != INVALID_GPIO) {
 117                 ret = gpio_request(TOUCH_PWR_PIN, "goodix power pin");
 118                 if (ret != 0) {
 119                         gpio_free(TOUCH_PWR_PIN);
 120                         printk("goodix power error\n");
 121                         return -EIO;
 122                 }
 123                 gpio_direction_output(TOUCH_PWR_PIN, 0);
 124                 gpio_set_value(TOUCH_PWR_PIN, GPIO_LOW);
 125                 msleep(100);
 126         }
 127
 128         if (TOUCH_RESET_PIN != INVALID_GPIO) {
 129                 ret = gpio_request(TOUCH_RESET_PIN, "goodix reset pin");
 130                 if (ret != 0) {
 131                         gpio_free(TOUCH_RESET_PIN);
 132                         printk("goodix gpio_request error\n");
 133                         return -EIO;
 134                 }
 135                 gpio_direction_output(TOUCH_RESET_PIN, 1);
 136                 msleep(100);
 137                 //gpio_set_value(TOUCH_RESET_PIN, GPIO_LOW);
 138                 //msleep(100);
 139                 //gpio_set_value(TOUCH_RESET_PIN, GPIO_HIGH);
 140                 //msleep(500);
 141         }
 142         return 0;
 143 }
 144
 145 struct goodix_platform_data goodix_info = {
 146         .model = 8105,
 147         .irq_pin = RK30_PIN1_PB7,
 148         .rest_pin = TOUCH_RESET_PIN,
 149         .init_platform_hw = goodix_init_platform_hw,
 150 };
 151 #endif
 152
 153 static struct spi_board_info board_spi_devices[] = {
 154 };
 155
 156 /***********************************************************
 157 *       rk30  backlight
 158 ************************************************************/
 159 #ifdef CONFIG_BACKLIGHT_RK29_BL
 160 #define PWM_ID            3
 161 #define PWM_MODE          PWM3
 162 #define PWM_EFFECT_VALUE  1
 163
 164 #define LCD_DISP_ON_PIN
 165
 166 #ifdef  LCD_DISP_ON_PIN
 167 #define BL_EN_PIN         RK30_PIN0_PA2
 168 #define BL_EN_VALUE       GPIO_HIGH
 169 #endif
 170 static int rk29_backlight_io_init(void)
 171 {
 172         int ret = 0;
 173
 174         iomux_set(PWM_MODE);
 175 #ifdef  LCD_DISP_ON_PIN
 176         ret = gpio_request(BL_EN_PIN, "bl_en");
 177         if (ret == 0) {
 178                 gpio_direction_output(BL_EN_PIN, BL_EN_VALUE);
 179         }
 180 #endif
 181         return ret;
 182 }
 183
 184 static int rk29_backlight_io_deinit(void)
 185 {
 186         int ret = 0, pwm_gpio;
 187 #ifdef  LCD_DISP_ON_PIN
 188         gpio_free(BL_EN_PIN);
 189 #endif
 190         pwm_gpio = iomux_mode_to_gpio(PWM_MODE);
 191         gpio_request(pwm_gpio, "bl_pwm");
 192         gpio_direction_output(pwm_gpio, GPIO_LOW);
 193         return ret;
 194 }
 195
 196 static int rk29_backlight_pwm_suspend(void)
 197 {
 198         int ret, pwm_gpio = iomux_mode_to_gpio(PWM_MODE);
 199
 200         ret = gpio_request(pwm_gpio, "bl_pwm");
 201         if (ret) {
 202                 printk("func %s, line %d: request gpio fail\n", __FUNCTION__, __LINE__);
 203                 return ret;
 204         }
 205         gpio_direction_output(pwm_gpio, GPIO_LOW);
 206 #ifdef  LCD_DISP_ON_PIN
 207         gpio_direction_output(BL_EN_PIN, !BL_EN_VALUE);
 208 #endif
 209         return ret;
 210 }
 211
 212 static int rk29_backlight_pwm_resume(void)
 213 {
 214         int pwm_gpio = iomux_mode_to_gpio(PWM_MODE);
 215
 216         gpio_free(pwm_gpio);
 217         iomux_set(PWM_MODE);
 218 #ifdef  LCD_DISP_ON_PIN
 219         msleep(30);
 220         gpio_direction_output(BL_EN_PIN, BL_EN_VALUE);
 221 #endif
 222         return 0;
 223 }
 224
 225 static struct rk29_bl_info rk29_bl_info = {
 226         .pwm_id = PWM_ID,
 227         .min_brightness=20,
 228         .max_brightness=255,
 229         .brightness_mode =BRIGHTNESS_MODE_CONIC,
 230         .bl_ref = PWM_EFFECT_VALUE,
 231         .io_init = rk29_backlight_io_init,
 232         .io_deinit = rk29_backlight_io_deinit,
 233         .pwm_suspend = rk29_backlight_pwm_suspend,
 234         .pwm_resume = rk29_backlight_pwm_resume,
 235 };
 236
 237 static struct platform_device rk29_device_backlight = {
 238         .name   = "rk29_backlight",
 239         .id     = -1,
 240         .dev    = {
 241                 .platform_data  = &rk29_bl_info,
 242         }
 243 };
 244
 245 #endif
 246
 247 #ifdef CONFIG_RK29_SUPPORT_MODEM
 248
 249 #define RK30_MODEM_POWER        RK30_PIN0_PC6
 250 #define RK30_MODEM_POWER_IOMUX  iomux_set(GPIO0_C6)
 251
 252 static int rk30_modem_io_init(void)
 253 {
 254     printk("%s\n", __FUNCTION__);
 255     RK30_MODEM_POWER_IOMUX;
 256
 257         return 0;
 258 }
 259
 260 static struct rk29_io_t rk30_modem_io = {
 261     .io_addr    = RK30_MODEM_POWER,
 262     .enable     = GPIO_HIGH,
 263     .disable    = GPIO_LOW,
 264     .io_init    = rk30_modem_io_init,
 265 };
 266
 267 static struct platform_device rk30_device_modem = {
 268         .name   = "rk30_modem",
 269         .id     = -1,
 270         .dev    = {
 271                 .platform_data  = &rk30_modem_io,
 272         }
 273 };
 274 #endif
 275 #if defined(CONFIG_MU509)
 276 static int mu509_io_init(void)
 277 {
 278
 279         iomux_set(GPIO2_D5);
 280         iomux_set(GPIO0_C6);
 281         iomux_set(GPIO2_D4);
 282         iomux_set(GPIO0_C4);
 283         iomux_set(GPIO0_C5);
 284         return 0;
 285 }
 286
 287 static int mu509_io_deinit(void)
 288 {
 289
 290         return 0;
 291 }
 292
 293 struct rk29_mu509_data rk29_mu509_info = {
 294         .io_init = mu509_io_init,
 295         .io_deinit = mu509_io_deinit,
 296         .modem_power_en = RK30_PIN2_PD5,
 297         .bp_power = RK30_PIN0_PC6,
 298         .bp_reset = RK30_PIN2_PD4,
 299         .ap_wakeup_bp = RK30_PIN0_PC4,
 300         .bp_wakeup_ap = RK30_PIN0_PC5,
 301 };
 302 struct platform_device rk29_device_mu509 = {
 303         .name = "mu509",
 304         .id = -1,
 305         .dev            = {
 306                 .platform_data = &rk29_mu509_info,
 307         }
 308     };
 309 #endif
 310 #if defined(CONFIG_MW100)
 311 static int mw100_io_init(void)
 312 {
 313         iomux_set(GPIO2_D5);
 314         iomux_set(GPIO0_C6);
 315         iomux_set(GPIO2_D4);
 316         iomux_set(GPIO0_C4);
 317         iomux_set(GPIO0_C5);
 318         return 0;
 319 }
 320
 321 static int mw100_io_deinit(void)
 322 {
 323
 324         return 0;
 325 }
 326
 327 struct rk29_mw100_data rk29_mw100_info = {
 328         .io_init = mw100_io_init,
 329         .io_deinit = mw100_io_deinit,
 330         .modem_power_en = RK30_PIN2_PD5,
 331         .bp_power = RK30_PIN0_PC6,
 332         .bp_reset = RK30_PIN2_PD4,
 333         .ap_wakeup_bp = RK30_PIN0_PC4,
 334         .bp_wakeup_ap = RK30_PIN0_PC5,
 335 };
 336 struct platform_device rk29_device_mw100 = {
 337         .name = "mw100",
 338         .id = -1,
 339         .dev            = {
 340                 .platform_data = &rk29_mw100_info,
 341         }
 342     };
 343 #endif
 344 #if defined(CONFIG_MT6229)
 345 static int mt6229_io_init(void)
 346 {
 347         iomux_set(GPIO2_D5);
 348         iomux_set(GPIO0_C6);
 349         iomux_set(GPIO2_D4);
 350         iomux_set(GPIO0_C4);
 351         iomux_set(GPIO0_C5);
 352         return 0;
 353 }
 354
 355 static int mt6229_io_deinit(void)
 356 {
 357
 358         return 0;
 359 }
 360
 361 struct rk29_mt6229_data rk29_mt6229_info = {
 362         .io_init = mt6229_io_init,
 363         .io_deinit = mt6229_io_deinit,
 364         .modem_power_en = RK30_PIN2_PD5,
 365         .bp_power = RK30_PIN0_PC6,
 366         .bp_reset = RK30_PIN2_PD4,
 367         .ap_wakeup_bp = RK30_PIN0_PC4,
 368         .bp_wakeup_ap = RK30_PIN0_PC5,
 369 };
 370 struct platform_device rk29_device_mt6229 = {
 371         .name = "mt6229",
 372         .id = -1,
 373         .dev            = {
 374                 .platform_data = &rk29_mt6229_info,
 375         }
 376     };
 377 #endif
 378
 379 /*MMA8452 gsensor*/
 380 #if defined (CONFIG_GS_MMA8452)
 381 #define MMA8452_INT_PIN   RK30_PIN0_PB7
 382
 383 static int mma8452_init_platform_hw(void)
 384 {
 385         return 0;
 386 }
 387
 388 static struct sensor_platform_data mma8452_info = {
 389         .type = SENSOR_TYPE_ACCEL,
 390         .irq_enable = 1,
 391         .poll_delay_ms = 30,
 392         .init_platform_hw = mma8452_init_platform_hw,
 393         .orientation = {-1, 0, 0, 0, -1, 0, 0, 0, 1},
 394 };
 395 #endif
 396 #if defined (CONFIG_GS_LIS3DH)
 397 #define LIS3DH_INT_PIN   RK30_PIN0_PB7
 398
 399 static int lis3dh_init_platform_hw(void)
 400 {
 401
 402         return 0;
 403 }
 404
 405 static struct sensor_platform_data lis3dh_info = {
 406         .type = SENSOR_TYPE_ACCEL,
 407         .irq_enable = 1,
 408         .poll_delay_ms = 30,
 409         .init_platform_hw = lis3dh_init_platform_hw,
 410         .orientation = {-1, 0, 0, 0, -1, 0, 0, 0, 1},
 411 };
 412 #endif
 413 #if defined (CONFIG_COMPASS_AK8975)
 414 static struct sensor_platform_data akm8975_info =
 415 {
 416         .type = SENSOR_TYPE_COMPASS,
 417         .irq_enable = 1,
 418         .poll_delay_ms = 30,
 419         .m_layout =
 420         {
 421                 {
 422                         {1, 0, 0},
 423                         {0, 1, 0},
 424                         {0, 0, 1},
 425                 },
 426
 427                 {
 428                         {1, 0, 0},
 429                         {0, 1, 0},
 430                         {0, 0, 1},
 431                 },
 432
 433                 {
 434                         {1, 0, 0},
 435                         {0, 1, 0},
 436                         {0, 0, 1},
 437                 },
 438
 439                 {
 440                         {1, 0, 0},
 441                         {0, 1, 0},
 442                         {0, 0, 1},
 443                 },
 444         }
 445 };
 446
 447 #endif
 448
 449 #if defined(CONFIG_GYRO_L3G4200D)
 450
 451 #include <linux/l3g4200d.h>
 452 #define L3G4200D_INT_PIN  RK30_PIN0_PB4
 453
 454 static int l3g4200d_init_platform_hw(void)
 455 {
 456         return 0;
 457 }
 458
 459 static struct sensor_platform_data l3g4200d_info = {
 460         .type = SENSOR_TYPE_GYROSCOPE,
 461         .irq_enable = 1,
 462         .poll_delay_ms = 30,
 463         .orientation = {0, 1, 0, -1, 0, 0, 0, 0, 1},
 464         .init_platform_hw = l3g4200d_init_platform_hw,
 465         .x_min = 40,//x_min,y_min,z_min = (0-100) according to hardware
 466         .y_min = 40,
 467         .z_min = 20,
 468 };
 469
 470 #endif
 471
 472 #ifdef CONFIG_LS_CM3217
 473 static struct sensor_platform_data cm3217_info = {
 474         .type = SENSOR_TYPE_LIGHT,
 475         .irq_enable = 0,
 476         .poll_delay_ms = 500,
 477 };
 478
 479 #endif
 480
 481 #ifdef CONFIG_FB_ROCKCHIP
 482
 483 #define LCD_CS_PIN         INVALID_GPIO
 484 #define LCD_CS_VALUE       GPIO_HIGH
 485
 486 #define LCD_EN_PIN         RK30_PIN0_PB0
 487 #define MIPI_LCD_RST_PIN   RK30_PIN0_PC3   //mipi lcd's reset pin, if no reset pin, set's  INVALID_GPIO
 488 #define LCD_EN_VALUE       GPIO_HIGH
 489
 490 static int rk_fb_io_init(struct rk29_fb_setting_info *fb_setting)
 491 {
 492         int ret = 0;
 493
 494         if(LCD_CS_PIN !=INVALID_GPIO)
 495         {
 496                 ret = gpio_request(LCD_CS_PIN, NULL);
 497                 if (ret != 0)
 498                 {
 499                         gpio_free(LCD_CS_PIN);
 500                         printk(KERN_ERR "request lcd cs pin fail!\n");
 501                         return -1;
 502                 }
 503                 else
 504                 {
 505                         gpio_direction_output(LCD_CS_PIN, LCD_CS_VALUE);
 506                 }
 507         }
 508
 509         if(LCD_EN_PIN !=INVALID_GPIO)
 510         {
 511                 ret = gpio_request(LCD_EN_PIN, NULL);
 512                 if (ret != 0)
 513                 {
 514                         gpio_free(LCD_EN_PIN);
 515                         printk(KERN_ERR "request lcd en pin fail!\n");
 516                         return -1;
 517                 }
 518                 else
 519                 {
 520                         gpio_direction_output(LCD_EN_PIN, LCD_EN_VALUE);
 521                 }
 522         }
 523
 524     if(MIPI_LCD_RST_PIN !=INVALID_GPIO)
 525         {
 526                 ret = gpio_request(MIPI_LCD_RST_PIN, NULL);
 527                 if (ret != 0)
 528                 {
 529                         gpio_free(MIPI_LCD_RST_PIN);
 530                         printk(KERN_ERR "request mipi lcd rst pin fail!\n");
 531                         return -1;
 532                 }
 533
 534                 else
 535                 {
 536             gpio_set_value(MIPI_LCD_RST_PIN, !GPIO_LOW);
 537             msleep(20);
 538                 }
 539         }
 540         return 0;
 541 }
 542 static int rk_fb_io_disable(void)
 543 {
 544         if(LCD_CS_PIN !=INVALID_GPIO)
 545         {
 546                 gpio_set_value(LCD_CS_PIN, !LCD_CS_VALUE);
 547         }
 548         if(LCD_EN_PIN !=INVALID_GPIO)
 549         {
 550                 gpio_set_value(LCD_EN_PIN, !LCD_EN_VALUE);
 551         }
 552
 553     if(MIPI_LCD_RST_PIN !=INVALID_GPIO)
 554         {
 555                 gpio_set_value(MIPI_LCD_RST_PIN, GPIO_LOW);
 556         msleep(10);
 557         }
 558         return 0;
 559 }
 560 static int rk_fb_io_enable(void)
 561 {
 562         if(LCD_CS_PIN !=INVALID_GPIO)
 563         {
 564                 gpio_set_value(LCD_CS_PIN, LCD_CS_VALUE);
 565         }
 566         if(LCD_EN_PIN !=INVALID_GPIO)
 567         {
 568                 gpio_set_value(LCD_EN_PIN, LCD_EN_VALUE);
 569         }
 570
 571     if(MIPI_LCD_RST_PIN !=INVALID_GPIO)
 572         {
 573         gpio_set_value(MIPI_LCD_RST_PIN, !GPIO_LOW);
 574         msleep(10);
 575         }
 576         return 0;
 577 }
 578
 579 #if defined(CONFIG_LCDC0_RK3066B) || defined(CONFIG_LCDC0_RK3188)
 580 struct rk29fb_info lcdc0_screen_info = {
 581 #if defined(CONFIG_RK_HDMI) && defined(CONFIG_HDMI_SOURCE_LCDC0) && defined(CONFIG_DUAL_LCDC_DUAL_DISP_IN_KERNEL)
 582         .prop      = EXTEND,    //extend display device
 583         .io_init    = NULL,
 584         .io_disable = NULL,
 585         .io_enable = NULL,
 586         .set_screen_info = hdmi_init_lcdc,
 587 #else
 588         .prop      = PRMRY,             //primary display device
 589         .io_init   = rk_fb_io_init,
 590         .io_disable = rk_fb_io_disable,
 591         .io_enable = rk_fb_io_enable,
 592         .set_screen_info = set_lcd_info,
 593 #endif
 594 };
 595 #endif
 596
 597 #if defined(CONFIG_LCDC1_RK3066B) || defined(CONFIG_LCDC1_RK3188)
 598 struct rk29fb_info lcdc1_screen_info = {
 599 #if defined(CONFIG_RK_HDMI) && defined(CONFIG_HDMI_SOURCE_LCDC1) && defined(CONFIG_DUAL_LCDC_DUAL_DISP_IN_KERNEL)
 600         .prop      = EXTEND,    //extend display device
 601         .io_init    = NULL,
 602         .io_disable = NULL,
 603         .io_enable = NULL,
 604         .set_screen_info = hdmi_init_lcdc,
 605 #else
 606         .prop      = PRMRY,             //primary display device
 607         .io_init   = rk_fb_io_init,
 608         .io_disable = rk_fb_io_disable,
 609         .io_enable = rk_fb_io_enable,
 610         .set_screen_info = set_lcd_info,
 611 #endif
 612 };
 613 #endif
 614
 615 static struct resource resource_fb[] = {
 616         [0] = {
 617                 .name  = "fb0 buf",
 618                 .start = 0,
 619                 .end   = 0,//RK30_FB0_MEM_SIZE - 1,
 620                 .flags = IORESOURCE_MEM,
 621         },
 622         [1] = {
 623                 .name  = "ipp buf",  //for rotate
 624                 .start = 0,
 625                 .end   = 0,//RK30_FB0_MEM_SIZE - 1,
 626                 .flags = IORESOURCE_MEM,
 627         },
 628         [2] = {
 629                 .name  = "fb2 buf",
 630                 .start = 0,
 631                 .end   = 0,//RK30_FB0_MEM_SIZE - 1,
 632                 .flags = IORESOURCE_MEM,
 633         },
 634 };
 635
 636 static struct platform_device device_fb = {
 637         .name           = "rk-fb",
 638         .id             = -1,
 639         .num_resources  = ARRAY_SIZE(resource_fb),
 640         .resource       = resource_fb,
 641 };
 642 #endif
 643 #if defined(CONFIG_ARCH_RK3188)
 644 static struct resource resource_mali[] = {
 645         [0] = {
 646         .name  = "ump buf",
 647         .start = 0,
 648         .end   = 0,
 649         .flags = IORESOURCE_MEM,
 650         },
 651
 652 };
 653
 654 static struct platform_device device_mali= {
 655         .name           = "mali400_ump",
 656         .id             = -1,
 657         .num_resources  = ARRAY_SIZE(resource_mali),
 658         .resource       = resource_mali,
 659 };
 660 #endif
 661
 662 #if defined(CONFIG_LCDC0_RK3066B) || defined(CONFIG_LCDC0_RK3188)
 663 static struct resource resource_lcdc0[] = {
 664         [0] = {
 665                 .name  = "lcdc0 reg",
 666                 .start = RK30_LCDC0_PHYS,
 667                 .end   = RK30_LCDC0_PHYS + RK30_LCDC0_SIZE - 1,
 668                 .flags = IORESOURCE_MEM,
 669         },
 670
 671         [1] = {
 672                 .name  = "lcdc0 irq",
 673                 .start = IRQ_LCDC0,
 674                 .end   = IRQ_LCDC0,
 675                 .flags = IORESOURCE_IRQ,
 676         },
 677 };
 678
 679 static struct platform_device device_lcdc0 = {
 680         .name             = "rk30-lcdc",
 681         .id               = 0,
 682         .num_resources    = ARRAY_SIZE(resource_lcdc0),
 683         .resource         = resource_lcdc0,
 684         .dev            = {
 685                 .platform_data = &lcdc0_screen_info,
 686         },
 687 };
 688 #endif
 689 #if defined(CONFIG_LCDC1_RK3066B) || defined(CONFIG_LCDC1_RK3188)
 690 static struct resource resource_lcdc1[] = {
 691         [0] = {
 692                 .name  = "lcdc1 reg",
 693                 .start = RK30_LCDC1_PHYS,
 694                 .end   = RK30_LCDC1_PHYS + RK30_LCDC1_SIZE - 1,
 695                 .flags = IORESOURCE_MEM,
 696         },
 697         [1] = {
 698                 .name  = "lcdc1 irq",
 699                 .start = IRQ_LCDC1,
 700                 .end   = IRQ_LCDC1,
 701                 .flags = IORESOURCE_IRQ,
 702         },
 703 };
 704
 705 static struct platform_device device_lcdc1 = {
 706         .name             = "rk30-lcdc",
 707         .id               = 1,
 708         .num_resources    = ARRAY_SIZE(resource_lcdc1),
 709         .resource         = resource_lcdc1,
 710         .dev            = {
 711                 .platform_data = &lcdc1_screen_info,
 712         },
 713 };
 714 #endif
 715
 716 #if defined(CONFIG_MFD_RK610)
 717 #define RK610_RST_PIN                   RK30_PIN2_PC5
 718 static int rk610_power_on_init(void)
 719 {
 720         int ret;
 721         if(RK610_RST_PIN != INVALID_GPIO)
 722         {
 723                 ret = gpio_request(RK610_RST_PIN, "rk610 reset");
 724                 if (ret)
 725                 {
 726                         printk(KERN_ERR "rk610_control_probe request gpio fail\n");
 727                 }
 728                 else
 729                 {
 730                         gpio_direction_output(RK610_RST_PIN, GPIO_HIGH);
 731                         msleep(100);
 732                         gpio_direction_output(RK610_RST_PIN, GPIO_LOW);
 733                         msleep(100);
 734                         gpio_set_value(RK610_RST_PIN, GPIO_HIGH);
 735                 }
 736         }
 737
 738         return 0;
 739
 740 }
 741
 742
 743 static struct rk610_ctl_platform_data rk610_ctl_pdata = {
 744         .rk610_power_on_init = rk610_power_on_init,
 745 };
 746 #endif
 747
 748 #if defined(CONFIG_MFD_RK616)
 749 #define RK616_RST_PIN                   RK30_PIN3_PB2
 750 #define RK616_PWREN_PIN                 RK30_PIN0_PA3
 751 #define RK616_SCL_RATE                  (100*1000)   //i2c scl rate
 752 static int rk616_power_on_init(void)
 753 {
 754         int ret;
 755
 756         if(RK616_PWREN_PIN != INVALID_GPIO)
 757         {
 758                 ret = gpio_request(RK616_PWREN_PIN, "rk616 pwren");
 759                 if (ret)
 760                 {
 761                         printk(KERN_ERR "rk616 pwren gpio request fail\n");
 762                 }
 763                 else
 764                 {
 765                         gpio_direction_output(RK616_PWREN_PIN,GPIO_HIGH);
 766                 }
 767         }
 768
 769         if(RK616_RST_PIN != INVALID_GPIO)
 770         {
 771                 ret = gpio_request(RK616_RST_PIN, "rk616 reset");
 772                 if (ret)
 773                 {
 774                         printk(KERN_ERR "rk616 reset gpio request fail\n");
 775                 }
 776                 else
 777                 {
 778                         gpio_direction_output(RK616_RST_PIN, GPIO_HIGH);
 779                         msleep(2);
 780                         gpio_direction_output(RK616_RST_PIN, GPIO_LOW);
 781                         msleep(10);
 782                         gpio_set_value(RK616_RST_PIN, GPIO_HIGH);
 783                 }
 784         }
 785
 786         return 0;
 787
 788 }
 789
 790
 791 static int rk616_power_deinit(void)
 792 {
 793         gpio_set_value(RK616_PWREN_PIN,GPIO_LOW);
 794         gpio_set_value(RK616_RST_PIN,GPIO_LOW);
 795         gpio_free(RK616_PWREN_PIN);
 796         gpio_free(RK616_RST_PIN);
 797
 798         return 0;
 799 }
 800
 801 static struct rk616_platform_data rk616_pdata = {
 802         .power_init = rk616_power_on_init,
 803         .power_deinit = rk616_power_deinit,
 804         .scl_rate   = RK616_SCL_RATE,
 805         .lcd0_func = INPUT,             //port lcd0 as input
 806         .lcd1_func = INPUT,             //port lcd1 as input
 807         .lvds_ch_nr = 1,                //the number of used lvds channel
 808         .hdmi_irq = RK30_PIN2_PD6,
 809         .spk_ctl_gpio = RK30_PIN2_PD7,
 810         .hp_ctl_gpio = RK30_PIN2_PD7,
 811 };
 812 #endif
 813
 814
 815 #ifdef CONFIG_SND_SOC_RK610
 816 static int rk610_codec_io_init(void)
 817 {
 818 //if need iomux.
 819 //Must not gpio_request
 820         return 0;
 821 }
 822
 823 static struct rk610_codec_platform_data rk610_codec_pdata = {
 824         .spk_ctl_io = RK30_PIN2_PD7,
 825         .io_init = rk610_codec_io_init,
 826 };
 827 #endif
 828
 829 #ifdef CONFIG_ANDROID_TIMED_GPIO
 830 static struct timed_gpio timed_gpios[] = {
 831         {
 832                 .name = "vibrator",
 833                 .gpio = INVALID_GPIO,
 834                 .max_timeout = 1000,
 835                 .active_low = 0,
 836                 .adjust_time =20,      //adjust for diff product
 837         },
 838 };
 839
 840 static struct timed_gpio_platform_data rk29_vibrator_info = {
 841         .num_gpios = 1,
 842         .gpios = timed_gpios,
 843 };
 844
 845 static struct platform_device rk29_device_vibrator = {
 846         .name = "timed-gpio",
 847         .id = -1,
 848         .dev = {
 849                 .platform_data = &rk29_vibrator_info,
 850         },
 851
 852 };
 853 #endif
 854
 855 #ifdef CONFIG_LEDS_GPIO_PLATFORM
 856 static struct gpio_led rk29_leds[] = {
 857         {
 858                 .name = "button-backlight",
 859                 .gpio = INVALID_GPIO,
 860                 .default_trigger = "timer",
 861                 .active_low = 0,
 862                 .retain_state_suspended = 0,
 863                 .default_state = LEDS_GPIO_DEFSTATE_OFF,
 864         },
 865 };
 866
 867 static struct gpio_led_platform_data rk29_leds_pdata = {
 868         .leds = rk29_leds,
 869         .num_leds = ARRAY_SIZE(rk29_leds),
 870 };
 871
 872 static struct platform_device rk29_device_gpio_leds = {
 873         .name   = "leds-gpio",
 874         .id     = -1,
 875         .dev    = {
 876                 .platform_data  = &rk29_leds_pdata,
 877         },
 878 };
 879 #endif
 880
 881 #ifdef CONFIG_RK_IRDA
 882 #define IRDA_IRQ_PIN           INVALID_GPIO //RK30_PIN0_PA3
 883
 884 static int irda_iomux_init(void)
 885 {
 886         int ret = 0;
 887
 888         //irda irq pin
 889         ret = gpio_request(IRDA_IRQ_PIN, NULL);
 890         if (ret != 0) {
 891                 gpio_free(IRDA_IRQ_PIN);
 892                 printk(">>>>>> IRDA_IRQ_PIN gpio_request err \n ");
 893         }
 894         gpio_pull_updown(IRDA_IRQ_PIN, PullDisable);
 895         gpio_direction_input(IRDA_IRQ_PIN);
 896
 897         return 0;
 898 }
 899
 900 static int irda_iomux_deinit(void)
 901 {
 902         gpio_free(IRDA_IRQ_PIN);
 903         return 0;
 904 }
 905
 906 static struct irda_info rk29_irda_info = {
 907         .intr_pin = IRDA_IRQ_PIN,
 908         .iomux_init = irda_iomux_init,
 909         .iomux_deinit = irda_iomux_deinit,
 910         //.irda_pwr_ctl = bu92747guw_power_ctl,
 911 };
 912
 913 static struct platform_device irda_device = {
 914 #ifdef CONFIG_RK_IRDA_NET
 915         .name = "rk_irda",
 916 #else
 917         .name = "bu92747_irda",
 918 #endif
 919         .id = -1,
 920         .dev = {
 921                 .platform_data = &rk29_irda_info,
 922         }
 923 };
 924 #endif
 925
 926 #ifdef CONFIG_ION
 927 #define ION_RESERVE_SIZE        (80 * SZ_1M)
 928 static struct ion_platform_data rk30_ion_pdata = {
 929         .nr = 1,
 930         .heaps = {
 931                 {
 932                         .type = ION_HEAP_TYPE_CARVEOUT,
 933                         .id = ION_NOR_HEAP_ID,
 934                         .name = "norheap",
 935                         .size = ION_RESERVE_SIZE,
 936                 }
 937         },
 938 };
 939
 940 static struct platform_device device_ion = {
 941         .name = "ion-rockchip",
 942         .id = 0,
 943         .dev = {
 944                 .platform_data = &rk30_ion_pdata,
 945         },
 946 };
 947 #endif
 948
 949 /**************************************************************************************************
 950  * SDMMC devices,  include the module of SD,MMC,and sdio.noted by xbw at 2012-03-05
 951 **************************************************************************************************/
 952 #ifdef CONFIG_SDMMC_RK29
 953 #include "board-rk3168-tb-sdmmc-conifg.c"
 954 #include "../plat-rk/rk-sdmmc-ops.c"
 955 #include "../plat-rk/rk-sdmmc-wifi.c"
 956 #endif //endif ---#ifdef CONFIG_SDMMC_RK29
 957
 958 #ifdef CONFIG_SDMMC0_RK29
 959 static int rk29_sdmmc0_cfg_gpio(void)
 960 {
 961 #ifdef CONFIG_SDMMC_RK29_OLD
 962         iomux_set(MMC0_CMD);
 963         iomux_set(MMC0_CLKOUT);
 964         iomux_set(MMC0_D0);
 965         iomux_set(MMC0_D1);
 966         iomux_set(MMC0_D2);
 967         iomux_set(MMC0_D3);
 968
 969         iomux_set_gpio_mode(iomux_mode_to_gpio(MMC0_DETN));
 970
 971         gpio_request(RK30_PIN3_PA7, "sdmmc-power");
 972         gpio_direction_output(RK30_PIN3_PA7, GPIO_LOW);
 973
 974 #else
 975         rk29_sdmmc_set_iomux(0, 0xFFFF);
 976
 977     #if defined(CONFIG_SDMMC0_RK29_SDCARD_DET_FROM_GPIO)
 978         #if SDMMC_USE_NEW_IOMUX_API
 979         iomux_set_gpio_mode(iomux_gpio_to_mode(RK29SDK_SD_CARD_DETECT_N));
 980         #else
 981         rk30_mux_api_set(RK29SDK_SD_CARD_DETECT_PIN_NAME, RK29SDK_SD_CARD_DETECT_IOMUX_FGPIO);
 982         #endif
 983     #else
 984         #if SDMMC_USE_NEW_IOMUX_API
 985         iomux_set(MMC0_DETN);
 986         #else
 987         rk30_mux_api_set(RK29SDK_SD_CARD_DETECT_PIN_NAME, RK29SDK_SD_CARD_DETECT_IOMUX_FMUX);
 988         #endif
 989     #endif
 990
 991 #if defined(CONFIG_SDMMC0_RK29_WRITE_PROTECT)
 992         gpio_request(SDMMC0_WRITE_PROTECT_PIN, "sdmmc-wp");
 993         gpio_direction_input(SDMMC0_WRITE_PROTECT_PIN);
 994 #endif
 995
 996 #endif
 997
 998         return 0;
 999 }
1000
1001 #define CONFIG_SDMMC0_USE_DMA
1002 struct rk29_sdmmc_platform_data default_sdmmc0_data = {
1003         .host_ocr_avail =
1004             (MMC_VDD_25_26 | MMC_VDD_26_27 | MMC_VDD_27_28 | MMC_VDD_28_29 |
1005              MMC_VDD_29_30 | MMC_VDD_30_31 | MMC_VDD_31_32 | MMC_VDD_32_33 |
1006              MMC_VDD_33_34 | MMC_VDD_34_35 | MMC_VDD_35_36),
1007         .host_caps =
1008             (MMC_CAP_4_BIT_DATA | MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED),
1009         .io_init = rk29_sdmmc0_cfg_gpio,
1010
1011 #if !defined(CONFIG_SDMMC_RK29_OLD)
1012         .set_iomux = rk29_sdmmc_set_iomux,
1013 #endif
1014
1015         .dma_name = "sd_mmc",
1016 #ifdef CONFIG_SDMMC0_USE_DMA
1017         .use_dma = 1,
1018 #else
1019         .use_dma = 0,
1020 #endif
1021
1022 #if defined(CONFIG_WIFI_COMBO_MODULE_CONTROL_FUNC) && defined(CONFIG_USE_SDMMC0_FOR_WIFI_DEVELOP_BOARD)
1023     .status = rk29sdk_wifi_mmc0_status,
1024     .register_status_notify = rk29sdk_wifi_mmc0_status_register,
1025 #endif
1026
1027 #if defined(RK29SDK_SD_CARD_PWR_EN) || (INVALID_GPIO != RK29SDK_SD_CARD_PWR_EN)
1028     .power_en = RK29SDK_SD_CARD_PWR_EN,
1029     .power_en_level = RK29SDK_SD_CARD_PWR_EN_LEVEL,
1030 #else
1031     .power_en = INVALID_GPIO,
1032     .power_en_level = GPIO_LOW,
1033 #endif
1034         .enable_sd_wakeup = 0,
1035
1036 #if defined(CONFIG_SDMMC0_RK29_WRITE_PROTECT)
1037         .write_prt = SDMMC0_WRITE_PROTECT_PIN,
1038         .write_prt_enalbe_level = SDMMC0_WRITE_PROTECT_ENABLE_VALUE;
1039 #else
1040         .write_prt = INVALID_GPIO,
1041 #endif
1042
1043     .det_pin_info = {
1044     #if defined(RK29SDK_SD_CARD_DETECT_N) || (INVALID_GPIO != RK29SDK_SD_CARD_DETECT_N)
1045         .io             = RK29SDK_SD_CARD_DETECT_N, //INVALID_GPIO,
1046         .enable         = RK29SDK_SD_CARD_INSERT_LEVEL,
1047         #ifdef RK29SDK_SD_CARD_DETECT_PIN_NAME
1048         .iomux          = {
1049             .name       = RK29SDK_SD_CARD_DETECT_PIN_NAME,
1050             #ifdef RK29SDK_SD_CARD_DETECT_IOMUX_FGPIO
1051             .fgpio      = RK29SDK_SD_CARD_DETECT_IOMUX_FGPIO,
1052             #endif
1053             #ifdef RK29SDK_SD_CARD_DETECT_IOMUX_FMUX
1054             .fmux       = RK29SDK_SD_CARD_DETECT_IOMUX_FMUX,
1055             #endif
1056         },
1057         #endif
1058     #else
1059         .io             = INVALID_GPIO,
1060         .enable         = GPIO_LOW,
1061     #endif
1062     },
1063
1064 };
1065 #endif // CONFIG_SDMMC0_RK29
1066
1067 #ifdef CONFIG_SDMMC1_RK29
1068 #define CONFIG_SDMMC1_USE_DMA
1069 static int rk29_sdmmc1_cfg_gpio(void)
1070 {
1071 #if defined(CONFIG_SDMMC_RK29_OLD)
1072         iomux_set(MMC1_CMD);
1073         iomux_set(MMC1_CLKOUT);
1074         iomux_set(MMC1_D0);
1075         iomux_set(MMC1_D1);
1076         iomux_set(MMC1_D2);
1077         iomux_set(MMC1_D3);
1078 #else
1079
1080 #if defined(CONFIG_SDMMC1_RK29_WRITE_PROTECT)
1081         gpio_request(SDMMC1_WRITE_PROTECT_PIN, "sdio-wp");
1082         gpio_direction_input(SDMMC1_WRITE_PROTECT_PIN);
1083 #endif
1084
1085 #endif
1086
1087         return 0;
1088 }
1089
1090 struct rk29_sdmmc_platform_data default_sdmmc1_data = {
1091         .host_ocr_avail =
1092             (MMC_VDD_25_26 | MMC_VDD_26_27 | MMC_VDD_27_28 | MMC_VDD_28_29 |
1093              MMC_VDD_29_30 | MMC_VDD_30_31 | MMC_VDD_31_32 | MMC_VDD_32_33 |
1094              MMC_VDD_33_34),
1095
1096 #if !defined(CONFIG_USE_SDMMC1_FOR_WIFI_DEVELOP_BOARD)
1097         .host_caps = (MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ |
1098                       MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED),
1099 #else
1100         .host_caps =
1101             (MMC_CAP_4_BIT_DATA | MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED),
1102 #endif
1103
1104         .io_init = rk29_sdmmc1_cfg_gpio,
1105
1106 #if !defined(CONFIG_SDMMC_RK29_OLD)
1107         .set_iomux = rk29_sdmmc_set_iomux,
1108 #endif
1109
1110         .dma_name = "sdio",
1111 #ifdef CONFIG_SDMMC1_USE_DMA
1112         .use_dma = 1,
1113 #else
1114         .use_dma = 0,
1115 #endif
1116
1117 #if defined(CONFIG_WIFI_CONTROL_FUNC) || defined(CONFIG_WIFI_COMBO_MODULE_CONTROL_FUNC)
1118     .status = rk29sdk_wifi_status,
1119     .register_status_notify = rk29sdk_wifi_status_register,
1120 #endif
1121
1122 #if defined(CONFIG_SDMMC1_RK29_WRITE_PROTECT)
1123         .write_prt = SDMMC1_WRITE_PROTECT_PIN,
1124             .write_prt_enalbe_level = SDMMC1_WRITE_PROTECT_ENABLE_VALUE;
1125 #else
1126         .write_prt = INVALID_GPIO,
1127 #endif
1128
1129     #if defined(CONFIG_RK29_SDIO_IRQ_FROM_GPIO)
1130         .sdio_INT_gpio = RK29SDK_WIFI_SDIO_CARD_INT,
1131     #endif
1132
1133     .det_pin_info = {
1134 #if defined(CONFIG_USE_SDMMC1_FOR_WIFI_DEVELOP_BOARD)
1135      #if defined(RK29SDK_SD_CARD_DETECT_N) || (INVALID_GPIO != RK29SDK_SD_CARD_DETECT_N)
1136         .io             = RK29SDK_SD_CARD_DETECT_N,
1137      #else
1138          .io             = INVALID_GPIO,
1139      #endif
1140
1141         .enable         = RK29SDK_SD_CARD_INSERT_LEVEL,
1142         #ifdef RK29SDK_SD_CARD_DETECT_PIN_NAME
1143         .iomux          = {
1144             .name       = RK29SDK_SD_CARD_DETECT_PIN_NAME,
1145             #ifdef RK29SDK_SD_CARD_DETECT_IOMUX_FGPIO
1146             .fgpio      = RK29SDK_SD_CARD_DETECT_IOMUX_FGPIO,
1147             #endif
1148             #ifdef RK29SDK_SD_CARD_DETECT_IOMUX_FMUX
1149             .fmux       = RK29SDK_SD_CARD_DETECT_IOMUX_FMUX,
1150             #endif
1151         },
1152         #endif
1153  #else
1154         .io             = INVALID_GPIO,
1155         .enable         = GPIO_LOW,
1156 #endif
1157     },
1158
1159         .enable_sd_wakeup = 0,
1160 };
1161 #endif //endif--#ifdef CONFIG_SDMMC1_RK29
1162
1163 /**************************************************************************************************
1164  * the end of setting for SDMMC devices
1165 **************************************************************************************************/
1166
1167 #ifdef CONFIG_BATTERY_RK30_ADC
1168 static struct rk30_adc_battery_platform_data rk30_adc_battery_platdata = {
1169         .dc_det_pin      = RK30_PIN0_PB2,
1170         .batt_low_pin    = RK30_PIN0_PB1,
1171         .charge_set_pin  = INVALID_GPIO,
1172         .charge_ok_pin   = RK30_PIN0_PA6,
1173         .dc_det_level    = GPIO_LOW,
1174         .charge_ok_level = GPIO_HIGH,
1175 };
1176
1177 static struct platform_device rk30_device_adc_battery = {
1178         .name   = "rk30-battery",
1179         .id     = -1,
1180         .dev = {
1181                 .platform_data = &rk30_adc_battery_platdata,
1182         },
1183 };
1184 #endif
1185 #ifdef CONFIG_CW2015_BATTERY
1186 /*
1187    note the follow array must set depend on the battery that you use
1188    you must send the battery to cellwise-semi the contact information:
1189    name: chen gan; tel:13416876079; E-mail: ben.chen@cellwise-semi.com
1190  */
1191 static u8 config_info[SIZE_BATINFO] = {
1192         0x15, 0x42, 0x60, 0x59, 0x52,
1193         0x58, 0x4D, 0x48, 0x48, 0x44,
1194         0x44, 0x46, 0x49, 0x48, 0x32,
1195         0x24, 0x20, 0x17, 0x13, 0x0F,
1196         0x19, 0x3E, 0x51, 0x45, 0x08,
1197         0x76, 0x0B, 0x85, 0x0E, 0x1C,
1198         0x2E, 0x3E, 0x4D, 0x52, 0x52,
1199         0x57, 0x3D, 0x1B, 0x6A, 0x2D,
1200         0x25, 0x43, 0x52, 0x87, 0x8F,
1201         0x91, 0x94, 0x52, 0x82, 0x8C,
1202         0x92, 0x96, 0xFF, 0x7B, 0xBB,
1203         0xCB, 0x2F, 0x7D, 0x72, 0xA5,
1204         0xB5, 0xC1, 0x46, 0xAE
1205 };
1206
1207 static struct cw_bat_platform_data cw_bat_platdata = {
1208         .dc_det_pin      = RK30_PIN0_PB2,
1209         .dc_det_level    = GPIO_LOW,
1210
1211         .bat_low_pin    = RK30_PIN0_PB1,
1212         .bat_low_level  = GPIO_LOW,
1213         .chg_ok_pin   = INVALID_GPIO,
1214         .chg_ok_level = GPIO_HIGH,
1215
1216         .is_usb_charge = 0,
1217         .chg_mode_sel_pin = INVALID_GPIO,
1218         .chg_mode_sel_level = GPIO_HIGH,
1219
1220         .cw_bat_config_info     = config_info,
1221
1222 };
1223
1224 #endif
1225 #ifdef CONFIG_RK30_PWM_REGULATOR
1226 static int pwm_voltage_map[] = {
1227         800000,825000,850000, 875000,900000, 925000 ,950000, 975000,1000000, 1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000, 1325000, 1350000,1375000
1228 };
1229 static struct regulator_consumer_supply pwm_dcdc1_consumers[] = {
1230         {
1231                 .supply = "vdd_cpu",
1232         }
1233 };
1234
1235 struct regulator_init_data pwm_regulator_init_dcdc[1] =
1236 {
1237         {
1238                 .constraints = {
1239                         .name = "PWM_DCDC1",
1240                         .min_uV = 600000,
1241                         .max_uV = 1800000,      //0.6-1.8V
1242                         .apply_uV = true,
1243                         .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE,
1244                 },
1245                 .num_consumer_supplies = ARRAY_SIZE(pwm_dcdc1_consumers),
1246                 .consumer_supplies = pwm_dcdc1_consumers,
1247         },
1248 };
1249
1250 static struct pwm_platform_data pwm_regulator_info[1] = {
1251         {
1252                 .pwm_id = 1,
1253                 .pwm_gpio = RK30_PIN3_PD4,
1254                 .pwm_iomux_pwm = PWM1,
1255                 .pwm_iomux_gpio = GPIO3_D4,
1256                 .pwm_voltage = 1100000,
1257                 .suspend_voltage = 1000000,
1258                 .min_uV = 800000,
1259                 .max_uV = 1375000,
1260                 .coefficient = 575,     //57.5%
1261                 .pwm_voltage_map = pwm_voltage_map,
1262                 .init_data      = &pwm_regulator_init_dcdc[0],
1263         },
1264 };
1265
1266 struct platform_device pwm_regulator_device[1] = {
1267         {
1268                 .name = "pwm-voltage-regulator",
1269                 .id = 0,
1270                 .dev            = {
1271                         .platform_data = &pwm_regulator_info[0],
1272                 }
1273         },
1274 };
1275 #endif
1276
1277 #ifdef CONFIG_RK29_VMAC
1278 #define PHY_PWR_EN_GPIO RK30_PIN1_PD6
1279 #include "board-rk30-sdk-vmac.c"
1280 #endif
1281
1282 #ifdef CONFIG_RFKILL_RK
1283 // bluetooth rfkill device, its driver in net/rfkill/rfkill-rk.c
1284 static struct rfkill_rk_platform_data rfkill_rk_platdata = {
1285     .type               = RFKILL_TYPE_BLUETOOTH,
1286
1287     .poweron_gpio       = { // BT_REG_ON
1288         .io             = INVALID_GPIO, //RK30_PIN3_PC7,
1289         .enable         = GPIO_HIGH,
1290         .iomux          = {
1291             .name       = "bt_poweron",
1292             .fgpio      = GPIO3_C7,
1293         },
1294     },
1295
1296     .reset_gpio         = { // BT_RST
1297         .io             = RK30_PIN3_PC7, // set io to INVALID_GPIO for disable it
1298         .enable         = GPIO_LOW,
1299         .iomux          = {
1300             .name       = "bt_reset",
1301             .fgpio      = GPIO3_C7,
1302        },
1303    },
1304
1305     .wake_gpio          = { // BT_WAKE, use to control bt's sleep and wakeup
1306         .io             = RK30_PIN3_PC6, // set io to INVALID_GPIO for disable it
1307         .enable         = GPIO_HIGH,
1308         .iomux          = {
1309             .name       = "bt_wake",
1310             .fgpio      = GPIO3_C6,
1311         },
1312     },
1313
1314     .wake_host_irq      = { // BT_HOST_WAKE, for bt wakeup host when it is in deep sleep
1315         .gpio           = {
1316             .io         = RK30_PIN0_PA5, // set io to INVALID_GPIO for disable it
1317             .enable     = GPIO_LOW,      // set GPIO_LOW for falling, set 0 for rising
1318             .iomux      = {
1319                 .name   = NULL,
1320             },
1321         },
1322     },
1323
1324     .rts_gpio           = { // UART_RTS, enable or disable BT's data coming
1325         .io             = RK30_PIN1_PA3, // set io to INVALID_GPIO for disable it
1326         .enable         = GPIO_LOW,
1327         .iomux          = {
1328             .name       = "bt_rts",
1329             .fgpio      = GPIO1_A3,
1330             .fmux       = UART0_RTSN,
1331         },
1332     },
1333 };
1334
1335 static struct platform_device device_rfkill_rk = {
1336     .name   = "rfkill_rk",
1337     .id     = -1,
1338     .dev    = {
1339         .platform_data = &rfkill_rk_platdata,
1340     },
1341 };
1342 #endif
1343
1344 #if defined(CONFIG_GPS_RK)
1345 int rk_gps_io_init(void)
1346 {
1347         printk("%s \n", __FUNCTION__);
1348
1349         gpio_request(RK30_PIN1_PB5, NULL);
1350         gpio_direction_output(RK30_PIN1_PB5, GPIO_LOW);
1351
1352         iomux_set(GPS_RFCLK);//GPS_CLK
1353         iomux_set(GPS_MAG);//GPS_MAG
1354         iomux_set(GPS_SIG);//GPS_SIGN
1355
1356         gpio_request(RK30_PIN1_PA6, NULL);
1357         gpio_direction_output(RK30_PIN1_PA6, GPIO_LOW);
1358
1359         gpio_request(RK30_PIN1_PA5, NULL);
1360         gpio_direction_output(RK30_PIN1_PA5, GPIO_LOW);
1361
1362         gpio_request(RK30_PIN1_PA7, NULL);
1363         gpio_direction_output(RK30_PIN1_PA7, GPIO_LOW);
1364         return 0;
1365 }
1366 int rk_gps_power_up(void)
1367 {
1368         printk("%s \n", __FUNCTION__);
1369
1370         return 0;
1371 }
1372
1373 int rk_gps_power_down(void)
1374 {
1375         printk("%s \n", __FUNCTION__);
1376
1377         return 0;
1378 }
1379
1380 int rk_gps_reset_set(int level)
1381 {
1382         return 0;
1383 }
1384 int rk_enable_hclk_gps(void)
1385 {
1386         struct clk *gps_aclk = NULL;
1387         gps_aclk = clk_get(NULL, "aclk_gps");
1388         if(gps_aclk) {
1389                 clk_enable(gps_aclk);
1390                 clk_put(gps_aclk);
1391                 printk("%s \n", __FUNCTION__);
1392         }
1393         else
1394                 printk("get gps aclk fail\n");
1395         return 0;
1396 }
1397 int rk_disable_hclk_gps(void)
1398 {
1399         struct clk *gps_aclk = NULL;
1400         gps_aclk = clk_get(NULL, "aclk_gps");
1401         if(gps_aclk) {
1402                 //TO wait long enough until GPS ISR is finished.
1403                 msleep(5);
1404                 clk_disable(gps_aclk);
1405                 clk_put(gps_aclk);
1406                 printk("%s \n", __FUNCTION__);
1407         }
1408         else
1409                 printk("get gps aclk fail\n");
1410         return 0;
1411 }
1412 struct rk_gps_data rk_gps_info = {
1413         .io_init = rk_gps_io_init,
1414         .power_up = rk_gps_power_up,
1415         .power_down = rk_gps_power_down,
1416         .reset = rk_gps_reset_set,
1417         .enable_hclk_gps = rk_enable_hclk_gps,
1418         .disable_hclk_gps = rk_disable_hclk_gps,
1419         .GpsSign = RK30_PIN1_PB3,
1420         .GpsMag = RK30_PIN1_PB2,        //GPIO index
1421         .GpsClk = RK30_PIN1_PB4,        //GPIO index
1422         .GpsVCCEn = RK30_PIN1_PB5,     //GPIO index
1423         .GpsSpi_CSO = RK30_PIN1_PA4,    //GPIO index
1424         .GpsSpiClk = RK30_PIN1_PA5,     //GPIO index
1425         .GpsSpiMOSI = RK30_PIN1_PA7,      //GPIO index
1426         .GpsIrq = IRQ_GPS,
1427         .GpsSpiEn = 0,
1428         .GpsAdcCh = 2,
1429         .u32GpsPhyAddr = RK30_GPS_PHYS,
1430         .u32GpsPhySize = RK30_GPS_SIZE,
1431 };
1432
1433 struct platform_device rk_device_gps = {
1434         .name = "gps_hv5820b",
1435         .id = -1,
1436         .dev            = {
1437         .platform_data = &rk_gps_info,
1438                 }
1439         };
1440 #endif
1441
1442 #if defined(CONFIG_MT5931_MT6622)
1443 static struct mt6622_platform_data mt6622_platdata = {
1444                     .power_gpio         = { // BT_REG_ON
1445                         .io             = RK30_PIN3_PD5, // set io to INVALID_GPIO for disable it
1446                             .enable         = GPIO_HIGH,
1447                             .iomux          = {
1448                                     .name       = NULL,
1449                                 },
1450                     },
1451
1452                     .reset_gpio         = { // BT_RST
1453                         .io             = RK30_PIN0_PD7,
1454                         .enable         = GPIO_HIGH,
1455                         .iomux          = {
1456                             .name       = NULL,
1457                         },
1458                     },
1459
1460                     .irq_gpio           = {
1461                             .io             = RK30_PIN3_PD2,
1462                             .enable         = GPIO_HIGH,
1463                             .iomux          = {
1464                                     .name       = NULL,
1465                                 },
1466                     },
1467
1468                     .rts_gpio           = { // UART_RTS
1469                             .io             = RK30_PIN1_PA3,
1470                             .enable         = GPIO_LOW,
1471                                     .iomux          = {
1472                                     .name       = "bt_rts",
1473                                     .fgpio      = GPIO1_A3,
1474                                     .fmux       = UART0_RTSN,
1475                             },
1476                     },
1477 };
1478
1479 static struct platform_device device_mt6622 = {
1480                     .name   = "mt6622",
1481                         .id     = -1,
1482                         .dev    = {
1483                                .platform_data = &mt6622_platdata,
1484                         },
1485 };
1486 #endif
1487
1488 static struct platform_device *devices[] __initdata = {
1489 #ifdef CONFIG_ION
1490         &device_ion,
1491 #endif
1492 #ifdef CONFIG_ANDROID_TIMED_GPIO
1493         &rk29_device_vibrator,
1494 #endif
1495 #ifdef CONFIG_LEDS_GPIO_PLATFORM
1496         &rk29_device_gpio_leds,
1497 #endif
1498 #ifdef CONFIG_RK_IRDA
1499         &irda_device,
1500 #endif
1501 #if defined(CONFIG_WIFI_CONTROL_FUNC)||defined(CONFIG_WIFI_COMBO_MODULE_CONTROL_FUNC)
1502         &rk29sdk_wifi_device,
1503 #endif
1504
1505 #if defined(CONFIG_MT6620)
1506     &mt3326_device_gps,
1507 #endif
1508
1509 #ifdef CONFIG_RK29_SUPPORT_MODEM
1510         &rk30_device_modem,
1511 #endif
1512 #if defined(CONFIG_MU509)
1513         &rk29_device_mu509,
1514 #endif
1515 #if defined(CONFIG_MW100)
1516         &rk29_device_mw100,
1517 #endif
1518 #if defined(CONFIG_MT6229)
1519         &rk29_device_mt6229,
1520 #endif
1521 #ifdef CONFIG_BATTERY_RK30_ADC
1522         &rk30_device_adc_battery,
1523 #endif
1524 #ifdef CONFIG_RFKILL_RK
1525         &device_rfkill_rk,
1526 #endif
1527 #ifdef CONFIG_GPS_RK
1528         &rk_device_gps,
1529 #endif
1530 #if defined(CONFIG_ARCH_RK3188)
1531         &device_mali,
1532 #endif
1533 #ifdef CONFIG_MT5931_MT6622
1534         &device_mt6622,
1535 #endif
1536 };
1537
1538 static int rk_platform_add_display_devices(void)
1539 {
1540         struct platform_device *fb = NULL;  //fb
1541         struct platform_device *lcdc0 = NULL; //lcdc0
1542         struct platform_device *lcdc1 = NULL; //lcdc1
1543         struct platform_device *bl = NULL; //backlight
1544 #ifdef CONFIG_FB_ROCKCHIP
1545         fb = &device_fb;
1546 #endif
1547
1548 #if defined(CONFIG_LCDC0_RK3066B) || defined(CONFIG_LCDC0_RK3188)
1549         lcdc0 = &device_lcdc0,
1550 #endif
1551
1552 #if defined(CONFIG_LCDC1_RK3066B) || defined(CONFIG_LCDC1_RK3188)
1553         lcdc1 = &device_lcdc1,
1554 #endif
1555
1556 #ifdef CONFIG_BACKLIGHT_RK29_BL
1557         bl = &rk29_device_backlight,
1558 #endif
1559         __rk_platform_add_display_devices(fb,lcdc0,lcdc1,bl);
1560
1561         return 0;
1562
1563 }
1564
1565 // i2c
1566 #ifdef CONFIG_I2C0_RK30
1567 static struct i2c_board_info __initdata i2c0_info[] = {
1568 #if defined (CONFIG_GS_MMA8452)
1569         {
1570                 .type           = "gs_mma8452",
1571                 .addr           = 0x1d,
1572                 .flags          = 0,
1573                 .irq            = MMA8452_INT_PIN,
1574                 .platform_data = &mma8452_info,
1575         },
1576 #endif
1577 #if defined (CONFIG_GS_LIS3DH)
1578         {
1579                 .type           = "gs_lis3dh",
1580                 .addr           = 0x19,   //0x19(SA0-->VCC), 0x18(SA0-->GND)
1581                 .flags          = 0,
1582                 .irq            = LIS3DH_INT_PIN,
1583                 .platform_data = &lis3dh_info,
1584         },
1585 #endif
1586 #if defined (CONFIG_COMPASS_AK8975)
1587         {
1588                 .type          = "ak8975",
1589                 .addr          = 0x0d,
1590                 .flags         = 0,
1591                 .irq           = RK30_PIN3_PD7,
1592                 .platform_data = &akm8975_info,
1593         },
1594 #endif
1595 #if defined (CONFIG_GYRO_L3G4200D)
1596         {
1597                 .type          = "l3g4200d_gryo",
1598                 .addr          = 0x69,
1599                 .flags         = 0,
1600                 .irq           = L3G4200D_INT_PIN,
1601                 .platform_data = &l3g4200d_info,
1602         },
1603 #endif
1604 #if defined (CONFIG_SND_SOC_RK1000)
1605         {
1606                 .type          = "rk1000_i2c_codec",
1607                 .addr          = 0x60,
1608                 .flags         = 0,
1609         },
1610         {
1611                 .type          = "rk1000_control",
1612                 .addr          = 0x40,
1613                 .flags         = 0,
1614         },
1615 #endif
1616
1617 #if defined (CONFIG_SND_SOC_RT5631)
1618         {
1619                 .type                   = "rt5631",
1620                 .addr                   = 0x1a,
1621                 .flags                  = 0,
1622         },
1623 #endif
1624
1625 #if defined (CONFIG_SND_SOC_RT5512)
1626         {
1627                 .type                   = "rt5512",
1628                 .addr                   = 0x18,
1629                 .flags                  = 0,
1630         },
1631 #endif
1632
1633
1634 #if defined (CONFIG_SND_SOC_RT5640)
1635             {
1636                         .type                   = "rt5640",
1637                         .addr                   = 0x1c,
1638                         .flags                  = 0,
1639                 },
1640 #endif
1641
1642 #ifdef CONFIG_MFD_RK610
1643                 {
1644                         .type                   = "rk610_ctl",
1645                         .addr                   = 0x40,
1646                         .flags                  = 0,
1647                         .platform_data          = &rk610_ctl_pdata,
1648                 },
1649 #ifdef CONFIG_RK610_TVOUT
1650                 {
1651                         .type                   = "rk610_tvout",
1652                         .addr                   = 0x42,
1653                         .flags                  = 0,
1654                 },
1655 #endif
1656 #ifdef CONFIG_HDMI_RK610
1657                 {
1658                         .type                   = "rk610_hdmi",
1659                         .addr                   = 0x46,
1660                         .flags                  = 0,
1661                         .irq                    = INVALID_GPIO,
1662                 },
1663 #endif
1664 #ifdef CONFIG_SND_SOC_RK610
1665                 {//RK610_CODEC addr  from 0x60 to 0x80 (0x60~0x80)
1666                         .type                   = "rk610_i2c_codec",
1667                         .addr                   = 0x60,
1668                         .flags                  = 0,
1669                         .platform_data          = &rk610_codec_pdata,
1670                 },
1671 #endif
1672 #endif
1673
1674 };
1675 #endif
1676
1677 int __sramdata g_pmic_type =  0;
1678 #ifdef CONFIG_I2C1_RK30
1679 #ifdef CONFIG_MFD_WM831X_I2C
1680 #define PMU_POWER_SLEEP                 RK30_PIN0_PA1
1681
1682 static struct pmu_info  wm8326_dcdc_info[] = {
1683         {
1684                 .name          = "vdd_core",   //logic
1685                 .min_uv          = 1000000,
1686                 .max_uv         = 1000000,
1687                 .suspend_vol  =  950000,
1688         },
1689         {
1690                 .name          = "vdd_cpu",    //arm
1691                 .min_uv          = 1000000,
1692                 .max_uv         = 1000000,
1693                 .suspend_vol  =  950000,
1694         },
1695         {
1696                 .name          = "dcdc3",   //ddr
1697                 .min_uv          = 1150000,
1698                 .max_uv         = 1150000,
1699                 .suspend_vol  =  1150000,
1700         },
1701         #ifdef CONFIG_MACH_RK3066_SDK
1702         {
1703                 .name          = "dcdc4",   //vcc_io
1704                 .min_uv          = 3300000,
1705                 .max_uv         = 3300000,
1706                 .suspend_vol  =  3000000,
1707         },
1708         #else
1709         {
1710                 .name          = "dcdc4",   //vcc_io
1711                 .min_uv          = 3000000,
1712                 .max_uv         = 3000000,
1713                 .suspend_vol  =  2800000,
1714         },
1715         #endif
1716 };
1717
1718 static struct pmu_info  wm8326_ldo_info[] = {
1719         {
1720                 .name          = "ldo1",   //vcc18_cif
1721                 .min_uv          = 1800000,
1722                 .max_uv         = 1800000,
1723                 .suspend_vol  =  1800000,
1724         },
1725         {
1726                 .name          = "ldo2",    //vccio_wl
1727                 .min_uv          = 1800000,
1728                 .max_uv         = 1800000,
1729                 .suspend_vol  =  1800000,
1730         },
1731         {
1732                 .name          = "ldo3",   //
1733                 .min_uv          = 1100000,
1734                 .max_uv         = 1100000,
1735                 .suspend_vol  =  1100000,
1736         },
1737         {
1738                 .name          = "ldo4",   //vdd11
1739                 .min_uv          = 1000000,
1740                 .max_uv         = 1000000,
1741                 .suspend_vol  =  1000000,
1742         },
1743         {
1744                 .name          = "ldo5",   //vcc25
1745                 .min_uv          = 1800000,
1746                 .max_uv         = 1800000,
1747                 .suspend_vol  =  1800000,
1748         },
1749         {
1750                 .name          = "ldo6",   //vcc33
1751                 .min_uv          = 3300000,
1752                 .max_uv         = 3300000,
1753                 .suspend_vol  =  3300000,
1754         },
1755         {
1756                 .name          = "ldo7",   //vcc28_cif
1757                 .min_uv          = 2800000,
1758                 .max_uv         = 2800000,
1759                 .suspend_vol  =  2800000,
1760         },
1761         {
1762                 .name          = "ldo8",   //vcca33
1763                 .min_uv          = 3300000,
1764                 .max_uv         = 3300000,
1765                 .suspend_vol  =  3300000,
1766         },
1767         {
1768                 .name          = "ldo9",   //vcc_tp
1769                 .min_uv          = 3300000,
1770                 .max_uv         = 3300000,
1771                 .suspend_vol  =  3300000,
1772         },
1773         {
1774                 .name          = "ldo10",   //flash_io
1775                 .min_uv          = 1800000,
1776                 .max_uv         = 1800000,
1777                 .suspend_vol  =  1800000,
1778         },
1779 };
1780
1781 #include "board-pmu-wm8326.c"
1782 #endif
1783
1784 #ifdef CONFIG_MFD_TPS65910
1785 #define TPS65910_HOST_IRQ        RK30_PIN0_PB3
1786
1787 #define PMU_POWER_SLEEP RK30_PIN0_PA1
1788
1789 static struct pmu_info  tps65910_dcdc_info[] = {
1790         {
1791                 .name          = "vdd_core",   //logic
1792                 .min_uv          = 1200000,
1793                 .max_uv         = 1200000,
1794         },
1795         {
1796                 .name          = "vdd2",    //ddr
1797                 .min_uv          = 1200000,
1798                 .max_uv         = 1200000,
1799         },
1800         {
1801                 .name          = "vio",   //vcc_io
1802                 .min_uv          = 2500000,
1803                 .max_uv         = 2500000,
1804         },
1805
1806 };
1807 static  struct pmu_info  tps65910_ldo_info[] = {
1808         {
1809                 .name          = "vpll",   //vdd10
1810                 .min_uv          = 1000000,
1811                 .max_uv         = 1000000,
1812         },
1813         {
1814                 .name          = "vdig1",    //vcc18_cif
1815                 .min_uv          = 1800000,
1816                 .max_uv         = 1800000,
1817         },
1818         {
1819                 .name          = "vdig2",   //vdd_jetta
1820                 .min_uv          = 1200000,
1821                 .max_uv         = 1200000,
1822         },
1823         {
1824                 .name          = "vaux1",   //vcc28_cif
1825                 .min_uv          = 2800000,
1826                 .max_uv         = 2800000,
1827         },
1828         {
1829                 .name          = "vaux2",   //vcca33
1830                 .min_uv          = 3300000,
1831                 .max_uv         = 3300000,
1832         },
1833         {
1834                 .name          = "vaux33",   //vcc_tp
1835                 .min_uv          = 3300000,
1836                 .max_uv         = 3300000,
1837         },
1838         {
1839                 .name          = "vmmc",   //vcc30
1840                 .min_uv          = 3000000,
1841                 .max_uv         = 3000000,
1842         },
1843         {
1844                 .name          = "vdac",   //vcc18
1845                 .min_uv          = 1800000,
1846                 .max_uv         = 1800000,
1847         },
1848  };
1849
1850 #include "board-pmu-tps65910.c"
1851 #endif
1852
1853 #ifdef CONFIG_REGULATOR_ACT8846
1854 #define PMU_POWER_SLEEP RK30_PIN0_PA1
1855 #define PMU_VSEL RK30_PIN3_PD3
1856 static struct pmu_info  act8846_dcdc_info[] = {
1857         {
1858                 .name          = "act_dcdc1",   //ddr
1859                 .min_uv          = 1200000,
1860                 .max_uv         = 1200000,
1861                 .suspend_vol  =  1200000,
1862         },
1863         {
1864                 .name          = "vdd_core",    //logic
1865                 .min_uv          = 1000000,
1866                 .max_uv         = 1000000,
1867                 #ifdef CONFIG_ACT8846_SUPPORT_RESET
1868                 .suspend_vol  =  1200000,
1869                 #else
1870                 .suspend_vol  =  900000,
1871                 #endif
1872
1873         },
1874         {
1875                 .name          = "vdd_cpu",   //arm
1876                 .min_uv          = 1000000,
1877                 .max_uv         = 1000000,
1878                 #ifdef CONFIG_ACT8846_SUPPORT_RESET
1879                 .suspend_vol  =  1200000,
1880                 #else
1881                 .suspend_vol  =  900000,
1882                 #endif
1883
1884         },
1885         {
1886                 .name          = "act_dcdc4",   //vccio
1887                 .min_uv          = 3000000,
1888                 .max_uv         = 3000000,
1889                 #ifdef CONFIG_ACT8846_SUPPORT_RESET
1890                 .suspend_vol  =  3000000,
1891                 #else
1892                 .suspend_vol  =  2800000,
1893                 #endif
1894
1895         },
1896
1897 };
1898 static  struct pmu_info  act8846_ldo_info[] = {
1899         {
1900                 .name          = "act_ldo1",   //vdd11
1901                 .min_uv          = 1000000,
1902                 .max_uv         = 1000000,
1903         },
1904         {
1905                 .name          = "act_ldo2",    //vdd12
1906                 .min_uv          = 1200000,
1907                 .max_uv         = 1200000,
1908         },
1909         {
1910                 .name          = "act_ldo3",   //vcc18_cif
1911                 .min_uv          = 1800000,
1912                 .max_uv         = 1800000,
1913         },
1914         {
1915                 .name          = "act_ldo4",   //vcca33
1916                 .min_uv          = 3300000,
1917                 .max_uv         = 3300000,
1918         },
1919         {
1920                 .name          = "act_ldo5",   //vcctp
1921                 .min_uv          = 3300000,
1922                 .max_uv         = 3300000,
1923         },
1924         {
1925                 .name          = "act_ldo6",   //vcc33
1926                 .min_uv          = 3300000,
1927                 .max_uv         = 3300000,
1928         },
1929         {
1930                 .name          = "act_ldo7",   //vccio_wl
1931                 .min_uv          = 1800000,
1932                 .max_uv         = 1800000,
1933         },
1934         {
1935                 .name          = "act_ldo8",   //vcc28_cif
1936                 .min_uv          = 2800000,
1937                 .max_uv         = 2800000,
1938         },
1939  };
1940
1941 #include "board-pmu-act8846.c"
1942 #endif
1943
1944 #ifdef CONFIG_MFD_RK808
1945 #define PMU_POWER_SLEEP RK30_PIN0_PA1
1946 #define RK808_HOST_IRQ        RK30_PIN0_PB3
1947
1948 static struct pmu_info  rk808_dcdc_info[] = {
1949         {
1950                 .name          = "vdd_cpu",   //arm
1951                 .min_uv          = 1000000,
1952                 .max_uv         = 1000000,
1953                 .suspend_vol  =  900000,
1954         },
1955         {
1956                 .name          = "vdd_core",    //logic
1957                 .min_uv          = 1000000,
1958                 .max_uv         = 1000000,
1959                 .suspend_vol  =  900000,
1960         },
1961         {
1962                 .name          = "rk_dcdc3",   //ddr
1963                 .min_uv          = 1200000,
1964                 .max_uv         = 1200000,
1965                 .suspend_vol  =  1200000,
1966         },
1967         {
1968                 .name          = "rk_dcdc4",   //vccio
1969                 .min_uv          = 3300000,
1970                 .max_uv         = 3300000,
1971                 .suspend_vol  =  3000000,
1972         },
1973
1974 };
1975 static  struct pmu_info  rk808_ldo_info[] = {
1976         {
1977                 .name          = "rk_ldo1",   //vcc33
1978                 .min_uv          = 3300000,
1979                 .max_uv         = 3300000,
1980                 .suspend_vol   = 3300000,
1981         },
1982         {
1983                 .name          = "rk_ldo2",    //vcctp
1984                 .min_uv          = 3300000,
1985                 .max_uv         = 3300000,
1986                  .suspend_vol   = 3300000,
1987
1988         },
1989         {
1990                 .name          = "rk_ldo3",   //vdd10
1991                 .min_uv          = 1000000,
1992                 .max_uv         = 1000000,
1993                  .suspend_vol   = 1000000,
1994         },
1995         {
1996                 .name          = "rk_ldo4",   //vcc18
1997                 .min_uv          = 1800000,
1998                 .max_uv         = 1800000,
1999                  .suspend_vol   = 1800000,
2000         },
2001         {
2002                 .name          = "rk_ldo5",   //vcc28_cif
2003                 .min_uv          = 2800000,
2004                 .max_uv         = 2800000,
2005                  .suspend_vol   = 2800000,
2006         },
2007         {
2008                 .name          = "rk_ldo6",   //vdd12
2009                 .min_uv          = 1200000,
2010                 .max_uv         = 1200000,
2011                  .suspend_vol   = 1200000,
2012         },
2013         {
2014                 .name          = "rk_ldo7",   //vcc18_cif
2015                 .min_uv          = 1800000,
2016                 .max_uv         = 1800000,
2017                  .suspend_vol   = 1800000,
2018         },
2019         {
2020                 .name          = "rk_ldo8",   //vcca_33
2021                 .min_uv          = 3300000,
2022                 .max_uv         = 3300000,
2023                  .suspend_vol   = 3300000,
2024         },
2025  };
2026
2027 #include "board-pmu-rk808.c"
2028 #endif
2029 #ifdef CONFIG_MFD_RICOH619
2030 #define PMU_POWER_SLEEP RK30_PIN0_PA1
2031 #define RICOH619_HOST_IRQ        RK30_PIN0_PB3
2032
2033 static struct pmu_info  ricoh619_dcdc_info[] = {
2034         {
2035                 .name          = "vdd_cpu",   //arm
2036                 .min_uv          = 1000000,
2037                 .max_uv         = 1000000,
2038                 .suspend_vol  =  900000,
2039         },
2040         {
2041                 .name          = "vdd_core",    //logic
2042                 .min_uv          = 1000000,
2043                 .max_uv         = 1000000,
2044                 .suspend_vol  =  900000,
2045         },
2046
2047         {
2048                 .name          = "ricoh_dc3",   //vcc18
2049                 .min_uv          = 1800000,
2050                 .max_uv         = 1800000,
2051                 .suspend_vol  =  1800000,
2052         },
2053
2054         {
2055                 .name          = "ricoh_dc4",   //vccio
2056                 .min_uv          = 3300000,
2057                 .max_uv         = 3300000,
2058                 .suspend_vol  =  3300000,
2059         },
2060
2061         {
2062                 .name          = "ricoh_dc5",   //ddr
2063                 .min_uv          = 1200000,
2064                 .max_uv         = 1200000,
2065                 .suspend_vol  =  1200000,
2066         },
2067
2068 };
2069 static  struct pmu_info  ricoh619_ldo_info[] = {
2070         {
2071                 .name          = "ricoh_ldo1",   //vcc30
2072                 .min_uv          = 3000000,
2073                 .max_uv         = 3000000,
2074         },
2075         {
2076                 .name          = "ricoh_ldo2",    //vcca33
2077                 .min_uv          = 3300000,
2078                 .max_uv         = 3300000,
2079         },
2080         {
2081                 .name          = "ricoh_ldo3",   //vcctp
2082                 .min_uv          = 3300000,
2083                 .max_uv         = 3300000,
2084         },
2085         {
2086                 .name          = "ricoh_ldo4",   //vccsd
2087                 .min_uv          = 3300000,
2088                 .max_uv         = 3300000,
2089         },
2090         {
2091                 .name          = "ricoh_ldo5",   //vcc18_cif
2092                 .min_uv          = 1800000,
2093                 .max_uv         = 1800000,
2094         },
2095         {
2096                 .name          = "ricoh_ldo6",   //vdd12
2097                 .min_uv          = 1200000,
2098                 .max_uv         = 1200000,
2099         },
2100         {
2101                 .name          = "ricoh_ldo7",   //vcc28_cif
2102                 .min_uv          = 2800000,
2103                 .max_uv         = 2800000,
2104         },
2105         {
2106                 .name          = "ricoh_ldo8",   //vcc25
2107                 .min_uv          = 2500000,
2108                 .max_uv         = 2500000,
2109         },
2110         {
2111                 .name          = "ricoh_ldo9",   //vdd10
2112                 .min_uv          = 1000000,
2113                 .max_uv         = 1000000,
2114         },
2115         {
2116                 .name          = "ricoh_ldo10",   //vcca18
2117                 .min_uv          = 1800000,
2118                 .max_uv         = 1800000,
2119         },
2120
2121  };
2122
2123 #include "board-pmu-ricoh619.c"
2124 #endif
2125
2126 #ifdef CONFIG_MFD_RT5025
2127 #define RT5025_HOST_IRQ        RK30_PIN0_PB3
2128
2129 static struct pmu_info  rt5025_dcdc_info[] = {
2130         {
2131                 .name          = "vdd_cpu",   //arm
2132                 .min_uv          = 1000000,
2133                 .max_uv         = 1000000,
2134         },
2135         {
2136                 .name          = "vdd_core",    //logic
2137                 .min_uv          = 1000000,
2138                 .max_uv         = 1000000,
2139         },
2140
2141         {
2142                 .name          = "rt5025-dcdc3",   //vccio
2143                 .min_uv          = 3300000,
2144                 .max_uv         = 3300000,
2145         },
2146
2147         {
2148                 .name          = "rt5025-dcdc4",   //vccio
2149                 .min_uv         = 5000000,
2150                 .max_uv         = 5000000,
2151         },
2152
2153 };
2154 static  struct pmu_info  rt5025_ldo_info[] = {
2155         {
2156                 .name          = "rt5025-ldo1",   //vcc18
2157                 .min_uv          = 1800000,
2158                 .max_uv         = 1800000,
2159         },
2160         {
2161                 .name          = "rt5025-ldo2",    //vddjetta
2162                 .min_uv          = 1200000,
2163                 .max_uv         = 1200000,
2164         },
2165         {
2166                 .name          = "rt5025-ldo3",   //vdd10
2167                 .min_uv          = 1000000,
2168                 .max_uv         = 1000000,
2169         },
2170         {
2171                 .name          = "rt5025-ldo4",   //vccjetta
2172                 .min_uv          = 3300000,
2173                 .max_uv         = 3300000,
2174         },
2175         {
2176                 .name          = "rt5025-ldo5",   //vccio_wl
2177                 .min_uv          = 1800000,
2178                 .max_uv         = 1800000,
2179         },
2180         {
2181                 .name          = "rt5025-ldo6",   //vcc_tp
2182                 .min_uv          = 3300000,
2183                 .max_uv         = 3300000,
2184         },
2185
2186  };
2187
2188 #include "board-pmu-rt5025.c"
2189 #endif
2190
2191
2192
2193 static struct i2c_board_info __initdata i2c1_info[] = {
2194 #if defined (CONFIG_MFD_WM831X_I2C)
2195         {
2196                 .type          = "wm8326",
2197                 .addr          = 0x34,
2198                 .flags         = 0,
2199                 .irq           = RK30_PIN0_PB3,
2200                 .platform_data = &wm831x_platdata,
2201         },
2202 #endif
2203 #if defined (CONFIG_MFD_TPS65910)
2204         {
2205         .type           = "tps65910",
2206         .addr           = TPS65910_I2C_ID0,
2207         .flags          = 0,
2208         .irq            = TPS65910_HOST_IRQ,
2209         .platform_data = &tps65910_data,
2210         },
2211 #endif
2212
2213 #if defined (CONFIG_REGULATOR_ACT8846)
2214         {
2215                 .type                   = "act8846",
2216                 .addr           = 0x5a,
2217                 .flags                  = 0,
2218         //      .irq            = ACT8846_HOST_IRQ,
2219                 .platform_data=&act8846_data,
2220         },
2221 #endif
2222 #if defined (CONFIG_MFD_RK808)
2223         {
2224                 .type                   = "rk808",
2225                 .addr           = 0x1b,
2226                 .flags                  = 0,
2227         //      .irq            = ACT8846_HOST_IRQ,
2228                 .platform_data=&rk808_data,
2229         },
2230 #endif
2231
2232 #if defined (CONFIG_MFD_RICOH619)
2233         {
2234                 .type                   = "ricoh619",
2235                 .addr           = 0x32,
2236                 .flags                  = 0,
2237                .irq            = RICOH619_HOST_IRQ,
2238                .platform_data=&ricoh619_data,
2239         },
2240 #endif
2241
2242 #if defined (CONFIG_MFD_RT5025)
2243         {
2244                 .type                   = "RT5025",
2245                 .addr           = 0x35,
2246                 .flags                  = 0,
2247                .irq            = RT5025_HOST_IRQ,
2248                .platform_data=&rt5025_data,
2249         },
2250 #endif
2251
2252 #if defined (CONFIG_RTC_HYM8563)
2253         {
2254                 .type                   = "rtc_hym8563",
2255                 .addr           = 0x51,
2256                 .flags                  = 0,
2257                 .irq            = RK30_PIN1_PA4,
2258         },
2259 #if defined (CONFIG_CW2015_BATTERY)
2260         {
2261                 .type           = "cw201x",
2262                 .addr           = 0x62,
2263                 .flags          = 0,
2264                 .platform_data  = &cw_bat_platdata,
2265         },
2266 #endif
2267 #endif
2268
2269 };
2270 #endif
2271
2272 void __sramfunc board_pmu_suspend(void)
2273 {
2274 #if defined (CONFIG_MFD_WM831X_I2C)
2275         if(pmic_is_wm8326())
2276         board_pmu_wm8326_suspend();
2277 #endif
2278 #if defined (CONFIG_MFD_TPS65910)
2279         if(pmic_is_tps65910())
2280         board_pmu_tps65910_suspend();
2281 #endif
2282 #if defined (CONFIG_REGULATOR_ACT8846)
2283         if(pmic_is_act8846())
2284         board_pmu_act8846_suspend();
2285 #endif
2286 #if defined (CONFIG_MFD_RK808)
2287         if(pmic_is_rk808())
2288         board_pmu_rk808_suspend();
2289 #endif
2290 #if defined (CONFIG_MFD_RICOH619)
2291         if(pmic_is_ricoh619())
2292         board_pmu_ricoh619_suspend();
2293 #endif
2294
2295 }
2296
2297 void __sramfunc board_pmu_resume(void)
2298 {
2299 #if defined (CONFIG_MFD_WM831X_I2C)
2300         if(pmic_is_wm8326())
2301         board_pmu_wm8326_resume();
2302 #endif
2303 #if defined (CONFIG_MFD_TPS65910)
2304         if(pmic_is_tps65910())
2305         board_pmu_tps65910_resume();
2306 #endif
2307 #if defined (CONFIG_REGULATOR_ACT8846)
2308         if(pmic_is_act8846())
2309         board_pmu_act8846_resume();
2310 #endif
2311 #if defined (CONFIG_MFD_RK808)
2312         if(pmic_is_rk808())
2313         board_pmu_rk808_resume();
2314 #endif
2315 #if defined (CONFIG_MFD_RICOH619)
2316         if(pmic_is_ricoh619())
2317         board_pmu_ricoh619_resume();
2318 #endif
2319
2320 }
2321
2322  int __sramdata gpio3d6_iomux,gpio3d6_do,gpio3d6_dir,gpio3d6_en;
2323
2324 #define grf_readl(offset)       readl_relaxed(RK30_GRF_BASE + offset)
2325 #define grf_writel(v, offset)   do { writel_relaxed(v, RK30_GRF_BASE + offset); dsb(); } while (0)
2326
2327 void __sramfunc rk30_pwm_logic_suspend_voltage(void)
2328 {
2329 #ifdef CONFIG_RK30_PWM_REGULATOR
2330
2331 //      int gpio0d7_iomux,gpio0d7_do,gpio0d7_dir,gpio0d7_en;
2332         sram_udelay(10000);
2333         gpio3d6_iomux = grf_readl(GRF_GPIO3D_IOMUX);
2334         gpio3d6_do = grf_readl(GRF_GPIO3H_DO);
2335         gpio3d6_dir = grf_readl(GRF_GPIO3H_DIR);
2336         gpio3d6_en = grf_readl(GRF_GPIO3H_EN);
2337
2338         grf_writel((0x03000300), GRF_GPIO3D_IOMUX);
2339         grf_writel((1<<28)|(1<<12), GRF_GPIO3H_DIR);
2340         grf_writel((1<<28)|(1<<12), GRF_GPIO3H_DO);
2341         grf_writel((1<<28)|(1<<12), GRF_GPIO3H_EN);
2342 #endif
2343 }
2344 void __sramfunc rk30_pwm_logic_resume_voltage(void)
2345 {
2346 #ifdef CONFIG_RK30_PWM_REGULATOR
2347         grf_writel((1<<28)|gpio3d6_iomux, GRF_GPIO3D_IOMUX);
2348         grf_writel((1<<30)|gpio3d6_en, GRF_GPIO3H_EN);
2349         grf_writel((1<<30)|gpio3d6_dir, GRF_GPIO3H_DIR);
2350         grf_writel((1<<30)|gpio3d6_do, GRF_GPIO3H_DO);
2351         sram_udelay(10000);
2352
2353 #endif
2354
2355 }
2356 extern void pwm_suspend_voltage(void);
2357 extern void pwm_resume_voltage(void);
2358 void  rk30_pwm_suspend_voltage_set(void)
2359 {
2360 #ifdef CONFIG_RK30_PWM_REGULATOR
2361         pwm_suspend_voltage();
2362 #endif
2363 }
2364 void  rk30_pwm_resume_voltage_set(void)
2365 {
2366 #ifdef CONFIG_RK30_PWM_REGULATOR
2367         pwm_resume_voltage();
2368 #endif
2369 }
2370
2371
2372 #ifdef CONFIG_I2C2_RK30
2373 static struct i2c_board_info __initdata i2c2_info[] = {
2374 #if defined (CONFIG_TOUCHSCREEN_GT8XX)
2375         {
2376                 .type          = "Goodix-TS",
2377                 .addr          = 0x55,
2378                 .flags         = 0,
2379                 .irq           = RK30_PIN1_PB7,
2380                 .platform_data = &goodix_info,
2381         },
2382 #endif
2383 #if defined (CONFIG_LS_CM3217)
2384         {
2385                 .type          = "lightsensor",
2386                 .addr          = 0x10,
2387                 .flags         = 0,
2388                 .platform_data = &cm3217_info,
2389         },
2390 #endif
2391 };
2392 #endif
2393
2394 #ifdef CONFIG_I2C3_RK30
2395 static struct i2c_board_info __initdata i2c3_info[] = {
2396 };
2397 #endif
2398
2399 #ifdef CONFIG_I2C4_RK30
2400 static struct i2c_board_info __initdata i2c4_info[] = {
2401 #if defined (CONFIG_MFD_RK616)
2402         {
2403                 .type          = "rk616",
2404                 .addr          = 0x50,
2405                 .flags         = 0,
2406                 .platform_data = &rk616_pdata,
2407         },
2408 #endif
2409
2410 };
2411 #endif
2412
2413 #ifdef CONFIG_I2C_GPIO_RK30
2414 #define I2C_SDA_PIN     INVALID_GPIO// RK30_PIN2_PD6   //set sda_pin here
2415 #define I2C_SCL_PIN     INVALID_GPIO//RK30_PIN2_PD7   //set scl_pin here
2416 static int rk30_i2c_io_init(void)
2417 {
2418         //set iomux (gpio) here
2419         //rk30_mux_api_set(GPIO2D7_I2C1SCL_NAME, GPIO2D_GPIO2D7);
2420         //rk30_mux_api_set(GPIO2D6_I2C1SDA_NAME, GPIO2D_GPIO2D6);
2421
2422         return 0;
2423 }
2424 struct i2c_gpio_platform_data default_i2c_gpio_data = {
2425        .sda_pin = I2C_SDA_PIN,
2426        .scl_pin = I2C_SCL_PIN,
2427        .udelay = 5, // clk = 500/udelay = 100Khz
2428        .timeout = 100,//msecs_to_jiffies(100),
2429        .bus_num    = 5,
2430        .io_init = rk30_i2c_io_init,
2431 };
2432 static struct i2c_board_info __initdata i2c_gpio_info[] = {
2433 };
2434 #endif
2435
2436 static void __init rk30_i2c_register_board_info(void)
2437 {
2438 #ifdef CONFIG_I2C0_RK30
2439         i2c_register_board_info(0, i2c0_info, ARRAY_SIZE(i2c0_info));
2440 #endif
2441 #ifdef CONFIG_I2C1_RK30
2442         i2c_register_board_info(1, i2c1_info, ARRAY_SIZE(i2c1_info));
2443 #endif
2444 #ifdef CONFIG_I2C2_RK30
2445         i2c_register_board_info(2, i2c2_info, ARRAY_SIZE(i2c2_info));
2446 #endif
2447 #ifdef CONFIG_I2C3_RK30
2448         i2c_register_board_info(3, i2c3_info, ARRAY_SIZE(i2c3_info));
2449 #endif
2450 #ifdef CONFIG_I2C4_RK30
2451         i2c_register_board_info(4, i2c4_info, ARRAY_SIZE(i2c4_info));
2452 #endif
2453 #ifdef CONFIG_I2C_GPIO_RK30
2454         i2c_register_board_info(5, i2c_gpio_info, ARRAY_SIZE(i2c_gpio_info));
2455 #endif
2456 }
2457 //end of i2c
2458
2459 // ========== Begin of rk3168 top board keypad defination ============
2460
2461 #include <plat/key.h>
2462
2463 static struct rk29_keys_button key_button[] = {
2464         {
2465                 .desc   = "vol-",
2466                 .code   = KEY_VOLUMEDOWN,
2467                 .adc_value      = 900,
2468                 .gpio   = INVALID_GPIO,
2469                 .active_low = PRESS_LEV_LOW,
2470         },
2471         {
2472                 .desc   = "play",
2473                 .code   = KEY_POWER,
2474                 .gpio   = RK30_PIN0_PA4,
2475                 .active_low = PRESS_LEV_LOW,
2476                 .wakeup = 1,
2477         },
2478         {
2479                 .desc   = "vol+",
2480                 .code   = KEY_VOLUMEUP,
2481                 .adc_value      = 1,
2482                 .gpio = INVALID_GPIO,
2483                 .active_low = PRESS_LEV_LOW,
2484         },
2485         {
2486                 .desc   = "menu",
2487                 .code   = EV_MENU,
2488                 .adc_value      = 133,
2489                 .gpio = INVALID_GPIO,
2490                 .active_low = PRESS_LEV_LOW,
2491         },
2492         {
2493                 .desc   = "home",
2494                 .code   = KEY_HOME,
2495                 .adc_value      = 550,
2496                 .gpio = INVALID_GPIO,
2497                 .active_low = PRESS_LEV_LOW,
2498         },
2499         {
2500                 .desc   = "esc",
2501                 .code   = KEY_BACK,
2502                 .adc_value      = 333,
2503                 .gpio = INVALID_GPIO,
2504                 .active_low = PRESS_LEV_LOW,
2505         },
2506         {
2507                 .desc   = "camera",
2508                 .code   = KEY_CAMERA,
2509                 .adc_value      = 742,
2510                 .gpio = INVALID_GPIO,
2511                 .active_low = PRESS_LEV_LOW,
2512         },
2513 };
2514 struct rk29_keys_platform_data rk29_keys_pdata = {
2515         .buttons        = key_button,
2516         .nbuttons       = ARRAY_SIZE(key_button),
2517         .chn    = 1,  //chn: 0-7, if do not use ADC,set 'chn' -1
2518 };
2519
2520 // =========== End of rk3168 top board keypad defination  =============
2521
2522
2523 #define POWER_ON_PIN RK30_PIN0_PA0   //power_hold
2524 static void rk30_pm_power_off(void)
2525 {
2526         printk(KERN_ERR "rk30_pm_power_off start...\n");
2527         #if defined(CONFIG_MFD_WM831X)
2528         if(pmic_is_wm8326()){
2529                 wm831x_set_bits(Wm831x,WM831X_GPIO_LEVEL,0x0001,0x0000);  //set sys_pwr 0
2530                 wm831x_device_shutdown(Wm831x);//wm8326 shutdown
2531          }
2532         #endif
2533
2534         #if defined(CONFIG_REGULATOR_ACT8846)
2535         if(pmic_is_act8846())
2536         {
2537                act8846_device_shutdown();
2538         }
2539         #endif
2540
2541         #if defined(CONFIG_MFD_TPS65910)
2542         if(pmic_is_tps65910())
2543         {
2544                 tps65910_device_shutdown();//tps65910 shutdown
2545         }
2546         #endif
2547
2548          #if defined(CONFIG_MFD_RK808)
2549         if(pmic_is_rk808())
2550        {
2551                 rk808_device_shutdown();//rk808 shutdown
2552         }
2553         #endif
2554          #if defined(CONFIG_MFD_RICOH619)
2555          if(pmic_is_ricoh619()){
2556         ricoh619_power_off();    //ricoh619 shutdown
2557         }
2558         #endif
2559
2560         #if defined(CONFIG_MFD_RT5025)
2561         if(pmic_is_rt5025()){
2562         rt5025_power_off();    //rt5025 shutdown
2563         }
2564         #endif
2565
2566         gpio_direction_output(POWER_ON_PIN, GPIO_LOW);
2567         while (1);
2568 }
2569
2570 static void __init machine_rk30_board_init(void)
2571 {
2572         avs_init();
2573         gpio_request(POWER_ON_PIN, "poweronpin");
2574         gpio_direction_output(POWER_ON_PIN, GPIO_HIGH);
2575
2576         pm_power_off = rk30_pm_power_off;
2577
2578         gpio_direction_output(POWER_ON_PIN, GPIO_HIGH);
2579
2580
2581         rk30_i2c_register_board_info();
2582         spi_register_board_info(board_spi_devices, ARRAY_SIZE(board_spi_devices));
2583         platform_add_devices(devices, ARRAY_SIZE(devices));
2584         rk_platform_add_display_devices();
2585         board_usb_detect_init(RK30_PIN0_PA7);
2586
2587 #if defined(CONFIG_WIFI_CONTROL_FUNC)
2588         rk29sdk_wifi_bt_gpio_control_init();
2589 #elif defined(CONFIG_WIFI_COMBO_MODULE_CONTROL_FUNC)
2590     rk29sdk_wifi_combo_module_gpio_init();
2591 #endif
2592
2593 #if defined(CONFIG_MT6620)
2594     clk_set_rate(clk_get_sys("rk_serial.0", "uart"), 48*1000000);
2595 #endif
2596
2597 #if defined(CONFIG_MT5931_MT6622)
2598                 clk_set_rate(clk_get_sys("rk_serial.0", "uart"), 24*1000000);
2599 #endif
2600 }
2601 #define HD_SCREEN_SIZE 1920UL*1200UL*4*3
2602 static void __init rk30_reserve(void)
2603 {
2604 #if defined(CONFIG_ARCH_RK3188)
2605         /*if lcd resolution great than or equal to 1920*1200,reserve the ump memory */
2606         if(!(get_fb_size() < ALIGN(HD_SCREEN_SIZE,SZ_1M)))
2607         {
2608                 int ump_mem_phy_size=512UL*1024UL*1024UL;
2609                 resource_mali[0].start = board_mem_reserve_add("ump buf", ump_mem_phy_size);
2610                 resource_mali[0].end = resource_mali[0].start + ump_mem_phy_size -1;
2611         }
2612 #endif
2613 #ifdef CONFIG_ION
2614         rk30_ion_pdata.heaps[0].base = board_mem_reserve_add("ion", ION_RESERVE_SIZE);
2615 #endif
2616 #ifdef CONFIG_FB_ROCKCHIP
2617         resource_fb[0].start = board_mem_reserve_add("fb0 buf", get_fb_size());
2618         resource_fb[0].end = resource_fb[0].start + get_fb_size()- 1;
2619 #if 0
2620         resource_fb[1].start = board_mem_reserve_add("ipp buf", RK30_FB0_MEM_SIZE);
2621         resource_fb[1].end = resource_fb[1].start + RK30_FB0_MEM_SIZE - 1;
2622 #endif
2623
2624 #if defined(CONFIG_FB_ROTATE) || !defined(CONFIG_THREE_FB_BUFFER)
2625         resource_fb[2].start = board_mem_reserve_add("fb2 buf",get_fb_size());
2626         resource_fb[2].end = resource_fb[2].start + get_fb_size() - 1;
2627 #endif
2628 #endif
2629
2630 #ifdef CONFIG_VIDEO_RK29
2631         rk30_camera_request_reserve_mem();
2632 #endif
2633
2634 #ifdef CONFIG_GPS_RK
2635         //it must be more than 8MB
2636         rk_gps_info.u32MemoryPhyAddr = board_mem_reserve_add("gps", SZ_8M);
2637 #endif
2638         board_mem_reserved();
2639 }
2640 /******************************** arm dvfs frequency volt table **********************************/
2641 /**
2642  * dvfs_cpu_logic_table: table for arm and logic dvfs
2643  * @frequency   : arm frequency
2644  * @cpu_volt    : arm voltage depend on frequency
2645  */
2646
2647 #if defined(CONFIG_ARCH_RK3188)
2648 //sdk
2649 static struct cpufreq_frequency_table dvfs_arm_table_volt_level0[] = {
2650         {.frequency = 312 * 1000,       .index = 850 * 1000},
2651         {.frequency = 504 * 1000,       .index = 900 * 1000},
2652         {.frequency = 816 * 1000,       .index = 950 * 1000},
2653         {.frequency = 1008 * 1000,      .index = 1025 * 1000},
2654         {.frequency = 1200 * 1000,      .index = 1100 * 1000},
2655         {.frequency = 1416 * 1000,      .index = 1200 * 1000},
2656         {.frequency = 1608 * 1000,      .index = 1300 * 1000},
2657         {.frequency = CPUFREQ_TABLE_END},
2658 };
2659 //default
2660 static struct cpufreq_frequency_table dvfs_arm_table_volt_level1[] = {
2661         {.frequency = 312 * 1000,       .index = 875 * 1000},
2662         {.frequency = 504 * 1000,       .index = 925 * 1000},
2663         {.frequency = 816 * 1000,       .index = 975 * 1000},
2664         {.frequency = 1008 * 1000,      .index = 1075 * 1000},
2665         {.frequency = 1200 * 1000,      .index = 1150 * 1000},
2666         {.frequency = 1416 * 1000,      .index = 1250 * 1000},
2667         {.frequency = 1608 * 1000,      .index = 1350 * 1000},
2668         {.frequency = CPUFREQ_TABLE_END},
2669 };
2670 // cube 10'
2671 static struct cpufreq_frequency_table dvfs_arm_table_volt_level2[] = {
2672         {.frequency = 312 * 1000,       .index = 900 * 1000},
2673         {.frequency = 504 * 1000,       .index = 925 * 1000},
2674         {.frequency = 816 * 1000,       .index = 1000 * 1000},
2675         {.frequency = 1008 * 1000,      .index = 1075 * 1000},
2676         {.frequency = 1200 * 1000,      .index = 1200 * 1000},
2677         {.frequency = 1416 * 1000,      .index = 1250 * 1000},
2678         {.frequency = 1608 * 1000,      .index = 1350 * 1000},
2679         {.frequency = CPUFREQ_TABLE_END},
2680 };
2681
2682 /******************************** gpu dvfs frequency volt table **********************************/
2683 //sdk
2684 static struct cpufreq_frequency_table dvfs_gpu_table_volt_level0[] = {
2685         {.frequency = 133 * 1000,       .index = 975 * 1000},//the mininum rate is limited 133M for rk3188
2686         {.frequency = 200 * 1000,       .index = 975 * 1000},
2687         {.frequency = 266 * 1000,       .index = 1000 * 1000},
2688         {.frequency = 300 * 1000,       .index = 1050 * 1000},
2689         {.frequency = 400 * 1000,       .index = 1100 * 1000},
2690         {.frequency = 600 * 1000,       .index = 1200 * 1000},
2691         {.frequency = CPUFREQ_TABLE_END},
2692 };
2693 //cube 10'
2694 static struct cpufreq_frequency_table dvfs_gpu_table_volt_level1[] = {
2695         {.frequency = 133 * 1000,       .index = 975 * 1000},//the mininum rate is limited 133M for rk3188
2696         {.frequency = 200 * 1000,       .index = 1000 * 1000},
2697         {.frequency = 266 * 1000,       .index = 1025 * 1000},
2698         {.frequency = 300 * 1000,       .index = 1050 * 1000},
2699         {.frequency = 400 * 1000,       .index = 1100 * 1000},
2700         {.frequency = 600 * 1000,       .index = 1250 * 1000},
2701         {.frequency = CPUFREQ_TABLE_END},
2702 };
2703
2704 /******************************** ddr dvfs frequency volt table **********************************/
2705 static struct cpufreq_frequency_table dvfs_ddr_table_volt_level0[] = {
2706         {.frequency = 200 * 1000 + DDR_FREQ_SUSPEND,    .index = 950 * 1000},
2707         {.frequency = 300 * 1000 + DDR_FREQ_VIDEO,      .index = 1000 * 1000},
2708         {.frequency = 396 * 1000 + DDR_FREQ_NORMAL,     .index = 1100 * 1000},
2709         {.frequency = 460 * 1000 + DDR_FREQ_DUALVIEW,     .index = 1150 * 1000},
2710         //{.frequency = 528 * 1000 + DDR_FREQ_NORMAL,     .index = 1200 * 1000},
2711         {.frequency = CPUFREQ_TABLE_END},
2712 };
2713
2714 static struct cpufreq_frequency_table dvfs_ddr_table_t[] = {
2715         {.frequency = 200 * 1000 + DDR_FREQ_SUSPEND,    .index = 950 * 1000},
2716         {.frequency = 460 * 1000 + DDR_FREQ_NORMAL,     .index = 1150 * 1000},
2717         {.frequency = CPUFREQ_TABLE_END},
2718 };
2719
2720 //if you board is good for volt quality,select dvfs_arm_table_volt_level0
2721 #define dvfs_arm_table dvfs_arm_table_volt_level1
2722 #define dvfs_gpu_table dvfs_gpu_table_volt_level1
2723 #define dvfs_ddr_table dvfs_ddr_table_volt_level0
2724
2725 #else
2726 //for RK3168 && RK3066B
2727 static struct cpufreq_frequency_table dvfs_arm_table[] = {
2728         {.frequency = 312 * 1000,       .index = 950 * 1000},
2729         {.frequency = 504 * 1000,       .index = 1000 * 1000},
2730         {.frequency = 816 * 1000,       .index = 1050 * 1000},
2731         {.frequency = 1008 * 1000,      .index = 1125 * 1000},
2732         {.frequency = 1200 * 1000,      .index = 1200 * 1000},
2733         //{.frequency = 1416 * 1000,      .index = 1250 * 1000},
2734         //{.frequency = 1608 * 1000,      .index = 1300 * 1000},
2735         {.frequency = CPUFREQ_TABLE_END},
2736 };
2737
2738 static struct cpufreq_frequency_table dvfs_gpu_table[] = {
2739         {.frequency = 100 * 1000,       .index = 1000 * 1000},
2740         {.frequency = 200 * 1000,       .index = 1000 * 1000},
2741         {.frequency = 266 * 1000,       .index = 1050 * 1000},
2742         //{.frequency = 300 * 1000,       .index = 1050 * 1000},
2743         {.frequency = 400 * 1000,       .index = 1125 * 1000},
2744         {.frequency = CPUFREQ_TABLE_END},
2745 };
2746
2747 static struct cpufreq_frequency_table dvfs_ddr_table[] = {
2748         {.frequency = 200 * 1000 + DDR_FREQ_SUSPEND,    .index = 1000 * 1000},
2749         {.frequency = 300 * 1000 + DDR_FREQ_VIDEO,      .index = 1050 * 1000},
2750         {.frequency = 400 * 1000 + DDR_FREQ_NORMAL,     .index = 1100 * 1000},
2751         {.frequency = 450 * 1000,                       .index = 1150 * 1000},
2752         {.frequency = CPUFREQ_TABLE_END},
2753 };
2754 #endif
2755 /******************************** arm dvfs frequency volt table end **********************************/
2756 //#define DVFS_CPU_TABLE_SIZE   (ARRAY_SIZE(dvfs_cpu_logic_table))
2757 //static struct cpufreq_frequency_table cpu_dvfs_table[DVFS_CPU_TABLE_SIZE];
2758 //static struct cpufreq_frequency_table dep_cpu2core_table[DVFS_CPU_TABLE_SIZE];
2759 int get_max_freq(struct cpufreq_frequency_table *table)
2760 {
2761         int i,temp=0;
2762
2763         for(i=0;table[i].frequency!= CPUFREQ_TABLE_END;i++)
2764         {
2765                 if(temp<table[i].frequency)
2766                         temp=table[i].frequency;
2767         }
2768         printk("get_max_freq=%d\n",temp);
2769         return temp;
2770 }
2771
2772 void __init board_clock_init(void)
2773 {
2774         u32 flags=RK30_CLOCKS_DEFAULT_FLAGS;
2775 #if !defined(CONFIG_ARCH_RK3188)
2776         if(get_max_freq(dvfs_gpu_table)<=(400*1000))
2777         {
2778                 flags=RK30_CLOCKS_DEFAULT_FLAGS|CLK_GPU_GPLL;
2779         }
2780         else
2781                 flags=RK30_CLOCKS_DEFAULT_FLAGS|CLK_GPU_CPLL;
2782 #endif
2783         rk30_clock_data_init(periph_pll_default, codec_pll_default, flags);
2784         //dvfs_set_arm_logic_volt(dvfs_cpu_logic_table, cpu_dvfs_table, dep_cpu2core_table);
2785         dvfs_set_freq_volt_table(clk_get(NULL, "cpu"), dvfs_arm_table);
2786         dvfs_set_freq_volt_table(clk_get(NULL, "gpu"), dvfs_gpu_table);
2787 #if defined(CONFIG_ARCH_RK3188)
2788         if (rk_pll_flag() == 0)
2789                 dvfs_set_freq_volt_table(clk_get(NULL, "ddr"), dvfs_ddr_table);
2790         else
2791                 dvfs_set_freq_volt_table(clk_get(NULL, "ddr"), dvfs_ddr_table_t);
2792 #else
2793         dvfs_set_freq_volt_table(clk_get(NULL, "ddr"), dvfs_ddr_table);
2794 #endif
2795 }
2796
2797 MACHINE_START(RK30, "RK30board")
2798         .boot_params    = PLAT_PHYS_OFFSET + 0x800,
2799         .fixup          = rk30_fixup,
2800         .reserve        = &rk30_reserve,
2801         .map_io         = rk30_map_io,
2802         .init_irq       = rk30_init_irq,
2803         .timer          = &rk30_timer,
2804         .init_machine   = machine_rk30_board_init,
2805 MACHINE_END