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