API tools faq
paste
Advertisement
Pteridium

Board roamer kernel 2.6

Pteridium
Feb 23rd, 2015
343
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 108.10 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * Copyright (C) 2007 Google, Inc.
  3.  * Copyright (c) 2008-2010, Code Aurora Forum. All rights reserved.
  4.  * Author: Brian Swetland <swetland@google.com>
  5.  *
  6.  * This software is licensed under the terms of the GNU General Public
  7.  * License version 2, as published by the Free Software Foundation, and
  8.  * may be copied, distributed, and modified under those terms.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  */
  16.  
  17. /* ========================================================================================
  18. when         who        what, where, why                             comment tag
  19. ---------     -------       -------------------------------------------------------     --------------------------
  20.  
  21. ==========================================================================================*/
  22. #include <linux/kernel.h>
  23. #include <linux/init.h>
  24. #include <linux/platform_device.h>
  25. #include <linux/input.h>
  26. #include <linux/io.h>
  27. #include <linux/delay.h>
  28. #include <linux/bootmem.h>
  29. //#include <linux/usb/mass_storage_function.h>
  30. #include <linux/power_supply.h>
  31.  
  32.  
  33. #include <mach/hardware.h>
  34. #include <asm/mach-types.h>
  35. #include <asm/mach/arch.h>
  36. #include <asm/mach/map.h>
  37. #include <asm/mach/flash.h>
  38. #include <asm/setup.h>
  39. #ifdef CONFIG_CACHE_L2X0
  40. #include <asm/hardware/cache-l2x0.h>
  41. #endif
  42.  
  43. #include <asm/mach/mmc.h>
  44. #include <mach/vreg.h>
  45. #include <mach/mpp.h>
  46. #include <mach/gpio.h>
  47. #include <mach/board.h>
  48. #include <mach/msm_iomap.h>
  49. #include <mach/msm_rpcrouter.h>
  50. #include <mach/msm_hsusb.h>
  51. #include <mach/rpc_hsusb.h>
  52. #include <mach/rpc_pmapp.h>
  53. #include <mach/msm_serial_hs.h>
  54. #include <mach/memory.h>
  55. #include <mach/msm_battery.h>
  56. #include <mach/rpc_server_handset.h>
  57.  
  58.  
  59. #include <linux/mtd/nand.h>
  60. #include <linux/mtd/partitions.h>
  61. #include <linux/i2c.h>
  62. #include <linux/i2c-gpio.h>
  63. #include <linux/android_pmem.h>
  64. #include <mach/camera.h>
  65. #include <linux/proc_fs.h>
  66. #include <mach/zte_memlog.h>
  67. #include "devices.h"
  68. #include "socinfo.h"
  69. #include "clock.h"
  70. #include "msm-keypad-devices.h"
  71. #ifdef CONFIG_USB_ANDROID
  72. #include <linux/usb/android_composite.h>
  73. #endif
  74. #include "pm.h"
  75. #ifdef CONFIG_ARCH_MSM7X27
  76. #include <linux/msm_kgsl.h>
  77. #endif
  78.  
  79. #ifdef CONFIG_ZTE_PLATFORM
  80. //#include "msm_usb_config.h" //USB-HML-001
  81. #endif
  82. #include <linux/lis302dl.h>
  83. #if defined( CONFIG_TOUCHSCREEN_MSM_LEGACY)
  84. #include <mach/msm_touch.h>
  85. #elif defined( CONFIG_TOUCHSCREEN_MSM)
  86. #include <mach/msm_ts.h>
  87. #endif
  88. #ifdef CONFIG_TOUCHSCREEN_SYNAPTICS_3K
  89. #include <linux/input/synaptics_i2c_rmi.h>
  90. #endif
  91. /*ZTE_TS_ZFJ_20110509 begin*/
  92. #ifdef CONFIG_TOUCHSCREEN_MXT224
  93. #include <linux/atmel_qt602240.h>
  94. extern struct atmel_i2c_platform_data atmel_data;
  95. #endif
  96.  
  97. //ZTE_TS_XYM_20110715 begin
  98. #ifdef CONFIG_TOUCHSCREEN_CY8CTST241
  99. #include <linux/cyttsp.h>
  100.  
  101. #define CY_USE_MT       /* define if using Single-Touch */
  102. //#define CY_USE_SPI        /* define if using SPI interface */
  103. #define CY_USE_I2C      /* define if using I2C interface  */
  104.  
  105. #ifdef CY_USE_SPI
  106. #define CY_SPI_IRQ_GPIO 139 /* xxx board GPIO */
  107. /* optional init function; set up IRQ GPIO;
  108.  * call reference in platform data structure
  109.  */
  110. static int cyttsp_spi_init(int on)
  111. {
  112.     int ret;
  113.  
  114.  
  115.     /* add any special code to initialize any required system hw
  116.      * such as regulators or gpio pins
  117.      */
  118.  
  119.  
  120.     if (on) {
  121.         gpio_direction_input(CY_SPI_IRQ_GPIO);
  122.         /* for MSM systems the call to gpio_direction_input can be
  123.          * replaced with the more explicit call:
  124.          gpio_tlmm_config(GPIO_CFG(CY_SPI_IRQ_GPIO, 0, GPIO_INPUT,
  125.             GPIO_PULL_UP, GPIO_6MA), GPIO_ENABLE);
  126.          */
  127.         ret = gpio_request(CY_SPI_IRQ_GPIO, "CYTTSP IRQ GPIO");
  128.         if (ret) {
  129.             printk(KERN_ERR "%s: Failed to request GPIO %d\n",
  130.                    __func__, CY_SPI_IRQ_GPIO);
  131.             return ret;
  132.         }
  133.     } else {
  134.         gpio_free(CY_SPI_IRQ_GPIO);
  135.     }
  136.     return 0;
  137. }
  138.  
  139. static int cyttsp_spi_wakeup(void)
  140. {
  141.     return 0;
  142. }
  143.  
  144. static struct cyttsp_platform_data cypress_spi_ttsp_platform_data = {
  145.     .wakeup = cyttsp_spi_wakeup,
  146.     .init = cyttsp_spi_init,
  147. #ifdef CY_USE_MT
  148.     .mt_sync = input_mt_sync,
  149. #endif
  150.     .maxx = 240,
  151.     .maxy = 320,
  152.     .flags = 0,
  153.     .gen = CY_GEN3,
  154.     .use_st = 0,
  155.     .use_mt = 1,
  156.     .use_trk_id = 0,
  157.     .use_hndshk = 1,
  158.     .use_timer = 0,
  159.     .use_sleep = 1,
  160.     .use_gestures = 0,
  161.     .use_load_file = 1,
  162.     .use_force_fw_update = 1,
  163.     .use_virtual_keys = 0,
  164.     /* activate up to 4 groups
  165.      * and set active distance
  166.      */
  167.     .gest_set = CY_GEST_GRP_NONE | CY_ACT_DIST,
  168.     /* change act_intrvl to customize the Active power state
  169.      * scanning/processing refresh interval for Operating mode
  170.      */
  171.     .act_intrvl = CY_ACT_INTRVL_DFLT,
  172.     /* change tch_tmout to customize the touch timeout for the
  173.      * Active power state for Operating mode
  174.      */
  175.     .tch_tmout = CY_TCH_TMOUT_DFLT,
  176.     /* change lp_intrvl to customize the Low Power power state
  177.      * scanning/processing refresh interval for Operating mode
  178.      */
  179.     .lp_intrvl = CY_LP_INTRVL_DFLT,
  180.     .name = CY_SPI_NAME,
  181.     .irq_gpio = CY_SPI_IRQ_GPIO,
  182. };
  183.  
  184. static struct spi_board_info xxx_cyttsp_spi_board_info[] __initdata = {
  185.     {
  186.         .modalias = CY_SPI_NAME,
  187.         .platform_data  = &cypress_spi_ttsp_platform_data,
  188.         .irq = INT_34XX_SPI4_IRQ,
  189.         .max_speed_hz   = 1000000,
  190.         .bus_num = 4,
  191.         .chip_select = 0,
  192.         .mode = SPI_MODE_0,
  193.     },
  194. };
  195.  
  196. static void __init xxx_spi_cyttsp_init(void)
  197. {
  198.     printk(KERN_INFO "irq = %d\n",
  199.         xxx_cyttsp_spi_board_info[0].irq);
  200.     spi_register_board_info(xxx_cyttsp_spi_board_info,
  201.         ARRAY_SIZE(xxx_cyttsp_spi_board_info));
  202. }
  203. #endif /* CY_USE_SPI */
  204.  
  205. #ifdef CY_USE_I2C
  206. #define CY_I2C_IRQ_GPIO 29  /* xxx board GPIO */
  207.  
  208. /* optional init function; set up IRQ GPIO;
  209.  * call reference in platform data structure
  210.  */
  211. static int cyttsp_i2c_init(int on)
  212. {
  213.     int ret;
  214.  
  215.  
  216.     /* add any special code to initialize any required system hw
  217.      * such as regulators or gpio pins
  218.      */
  219.  
  220.  
  221.     if (on) {
  222.         gpio_direction_input(CY_I2C_IRQ_GPIO);
  223.         /* for MSM systems the call to gpio_direction_input can be
  224.          * replaced with the more explicit call:
  225.          gpio_tlmm_config(GPIO_CFG(CY_I2C_IRQ_GPIO, 0, GPIO_INPUT,
  226.             GPIO_PULL_UP, GPIO_6MA), GPIO_ENABLE);
  227.          */
  228.         ret = gpio_request(CY_I2C_IRQ_GPIO, "CYTTSP IRQ GPIO");
  229.         if (ret) {
  230.             printk(KERN_ERR "%s: Failed to request GPIO %d\n",
  231.                    __func__, CY_I2C_IRQ_GPIO);
  232.             return ret;
  233.         }
  234.     } else {
  235.         gpio_free(CY_I2C_IRQ_GPIO);
  236.     }
  237.     return 0;
  238. }
  239.  
  240. static int cyttsp_i2c_wakeup(void)
  241. {
  242.         gpio_direction_output(CY_I2C_IRQ_GPIO, 1);
  243.     usleep(10);
  244.     gpio_set_value(CY_I2C_IRQ_GPIO,0);
  245.     usleep(10);
  246.     gpio_set_value(CY_I2C_IRQ_GPIO,1);
  247.     usleep(10);
  248.     gpio_set_value(CY_I2C_IRQ_GPIO,0);
  249.     usleep(10);
  250.     gpio_set_value(CY_I2C_IRQ_GPIO,1);
  251.    
  252.     usleep(10);
  253.     gpio_direction_input(CY_I2C_IRQ_GPIO);
  254.  
  255.     return 0;
  256. }
  257.  
  258. static struct cyttsp_platform_data cypress_i2c_ttsp_platform_data = {
  259.     .wakeup = cyttsp_i2c_wakeup,
  260.     //.wakeup = NULL,
  261.     .init = cyttsp_i2c_init,
  262. #ifdef CY_USE_MT
  263.     .mt_sync = input_mt_sync,
  264. #endif
  265.     .maxx = 320,
  266.     .maxy = 480,
  267.     .flags = 0,
  268.     .gen = CY_GEN2,
  269.     .use_st = 0,
  270.     .use_mt = 1,
  271.     .use_trk_id = 0,
  272.     .use_hndshk = 1,
  273.     .use_timer = 0,
  274.     .use_sleep = 1,
  275.     .use_gestures = 0,
  276.     .use_load_file = 0,
  277.     .use_force_fw_update = 0,
  278.     .use_virtual_keys = 0,
  279.     /* activate up to 4 groups
  280.      * and set active distance
  281.      */
  282.     .gest_set = CY_GEST_GRP_NONE | CY_ACT_DIST,
  283.     /* change act_intrvl to customize the Active power state
  284.      * scanning/processing refresh interval for Operating mode
  285.      */
  286.     .act_intrvl = CY_ACT_INTRVL_DFLT,
  287.     /* change tch_tmout to customize the touch timeout for the
  288.      * Active power state for Operating mode
  289.      */
  290.     .tch_tmout = CY_TCH_TMOUT_DFLT,
  291.     /* change lp_intrvl to customize the Low Power power state
  292.      * scanning/processing refresh interval for Operating mode
  293.      */
  294.     .lp_intrvl = CY_LP_INTRVL_DFLT,
  295.     .name = CY_I2C_NAME,
  296.     .irq_gpio = CY_I2C_IRQ_GPIO,
  297. };
  298.  
  299.  
  300. #endif /* CY_USE_I2C */
  301. #endif // CONFIG_TOUCHSCREEN_CY8CTST241
  302. //ZTE_TS_XYM_20110715 end
  303.  
  304. #ifdef CONFIG_ARCH_MSM7X25
  305. #define MSM_PMEM_MDP_SIZE   0xb21000
  306. #define MSM_PMEM_ADSP_SIZE  0x97b000
  307. #define MSM_PMEM_AUDIO_SIZE 0x121000
  308. #define MSM_FB_SIZE     0x200000
  309. #define PMEM_KERNEL_EBI1_SIZE   0x64000
  310. #endif
  311.  
  312. #ifdef CONFIG_ARCH_MSM7X27
  313. #define MSM_PMEM_MDP_SIZE   0x1B76000
  314. #define MSM_PMEM_ADSP_SIZE  0xB71000
  315. #define MSM_PMEM_AUDIO_SIZE 0x5B000
  316. #define MSM_FB_SIZE     0x177000
  317. #define MSM_GPU_PHYS_SIZE   SZ_2M
  318. #define PMEM_KERNEL_EBI1_SIZE   0x1C000
  319. /* Using lower 1MB of OEMSBL memory for GPU_PHYS */
  320. #define MSM_GPU_PHYS_START_ADDR  0xD600000ul
  321. #endif
  322.  
  323. #ifdef CONFIG_ANDROID_RAM_CONSOLE
  324. #define MSM_RAM_CONSOLE_PHYS  0x02500000 //ZTE_BOOT_HUANGYANJUN_20100903_01
  325. #define MSM_RAM_CONSOLE_SIZE  SZ_1M
  326. #endif
  327.  
  328. static smem_global *global;
  329.  
  330. //ZTE_BOOT_JIANGFENG_20100223_01, start
  331. #ifdef CONFIG_ZTE_PLATFORM
  332. static int g_zte_ftm_flag_fixup;
  333. static int lcd_first_reset = false;//ZTE_DRIVE_LCD_LKEJ_20110620
  334. #endif
  335. //ZTE_BOOT_JIANGFENG_20100223_01, end
  336.  
  337. /* Using upper 1/2MB of Apps Bootloader memory*/
  338. #define MSM_PMEM_AUDIO_START_ADDR   0x80000ul
  339.  
  340. static struct resource smc91x_resources[] = {
  341.     [0] = {
  342.         .start  = 0x9C004300,
  343.         .end    = 0x9C0043ff,
  344.         .flags  = IORESOURCE_MEM,
  345.     },
  346.     [1] = {
  347.         .start  = MSM_GPIO_TO_INT(132),
  348.         .end    = MSM_GPIO_TO_INT(132),
  349.         .flags  = IORESOURCE_IRQ,
  350.     },
  351. };
  352.  
  353. #ifdef CONFIG_USB_FUNCTION
  354. #ifndef CONFIG_ZTE_PLATFORM
  355. static struct usb_mass_storage_platform_data usb_mass_storage_pdata = {
  356.     .nluns          = 0x02,
  357.     .buf_size       = 16384,
  358.     .vendor         = "GOOGLE",
  359.     .product        = "Mass storage",
  360.     .release        = 0xffff,
  361. };
  362. #endif
  363.  
  364. static struct platform_device mass_storage_device = {
  365.     .name           = "usb_mass_storage",
  366.     .id             = -1,
  367.     .dev            = {
  368.         .platform_data          = &usb_mass_storage_pdata,
  369.     },
  370. };
  371. #endif
  372.  
  373. #if 0
  374. #ifdef CONFIG_USB_ANDROID
  375. //ruanmeisi 20100713 zte pid
  376. #define PRODUCT_ID_ALL_INTERFACE          0x1350
  377. #define PRODUCT_ID_MS_ADB                      0x1351
  378. #define PRODUCT_ID_ADB                             0x1352
  379. #define PRODUCT_ID_MS                               0x1353
  380. #define PRODUCT_ID_DIAG                           0x0112
  381. #define PRODUCT_ID_DIAG_NMEA_MODEM   0x0111
  382. #define PRODUCT_ID_MODEM_MS_ADB         0x1354
  383. #define PRODUCT_ID_MODEM_MS                 0x1355
  384. #define PRODUCT_ID_MS_CDROM                 0x0083
  385. #define PRODUCT_ID_RNDIS_MS                 0x1364
  386. #define PRODUCT_ID_RNDIS_MS_ADB             0x1364
  387. #define PRODUCT_ID_RNDIS             0x1365
  388. /*ZTE_USB_WZY_101021 start*/
  389. #define PRODUCT_ID_DIAG_MODEM_NEMA_MS_AT             0x1367
  390. #define PRODUCT_ID_DIAG_MODEM_NEMA_MS_ADB_AT             0x1366
  391. #define PRODUCT_ID_RNDIS_ADB             0x1373
  392. /* dynamic composition */
  393. static struct usb_composition usb_func_composition[] = {
  394. #ifdef  CONFIG_ZTE_PLATFORM
  395.     {
  396.         /* MSC */
  397.         .product_id         = PRODUCT_ID_MS,
  398.         .functions      = 0x02,
  399.         .adb_product_id     = PRODUCT_ID_MS_ADB,
  400.         .adb_functions      = 0x12
  401.     },
  402.     {
  403.         /* ADB*/
  404.         .product_id         = PRODUCT_ID_ADB,  /*ZTE_USB_WZY_101021*/
  405.         .functions      = 0x01,
  406.         .adb_product_id     = PRODUCT_ID_ADB,
  407.         .adb_functions      = 0x01
  408.     },
  409.     {
  410.         /* diag + modem + nmea + ms + adb*/
  411.         .product_id         = PRODUCT_ID_ALL_INTERFACE,
  412.         .functions      = 0x12764,
  413.         .adb_product_id     = PRODUCT_ID_ALL_INTERFACE,
  414.         .adb_functions      = 0x12764
  415.     },
  416.     {
  417.         /* diag + nmea + modem */
  418.         .product_id         = PRODUCT_ID_DIAG_NMEA_MODEM,
  419.         .functions      = 0x674,
  420.         .adb_product_id     = PRODUCT_ID_DIAG_NMEA_MODEM,
  421.         .adb_functions      = 0x674
  422.     },
  423.     {
  424.         /* diag */
  425.         .product_id         = PRODUCT_ID_DIAG,
  426.         .functions      = 0x4,
  427.         .adb_product_id     = PRODUCT_ID_DIAG,
  428.         .adb_functions      = 0x4
  429.     },
  430.     {
  431.         /* modem + ms + adb */
  432.         .product_id         = PRODUCT_ID_MODEM_MS,
  433.         .functions      = 0x26,
  434.         .adb_product_id     = PRODUCT_ID_MODEM_MS_ADB,
  435.         .adb_functions      = 0x126
  436.     },
  437.     {
  438.         /* ms + CDROM */
  439.         .product_id         = PRODUCT_ID_MS_CDROM,
  440.         .functions      = 0x2,
  441.         .adb_product_id     = PRODUCT_ID_MS_CDROM,
  442.         .adb_functions      = 0x2
  443.     },
  444.     {
  445.         /* rndis + ms + adb */
  446.         .product_id         = PRODUCT_ID_RNDIS_MS,
  447.         .functions      = 0x2A,
  448.         .adb_product_id     = PRODUCT_ID_RNDIS_MS_ADB,
  449.         .adb_functions      = 0x12A
  450.     },
  451.     {
  452.         /* rndis */
  453.         .product_id         = PRODUCT_ID_RNDIS,
  454.         .functions      = 0xA,
  455.         .adb_product_id     = PRODUCT_ID_RNDIS,
  456.         .adb_functions      = 0xA
  457.     },
  458.     {
  459.         /* rndis + adb*/
  460.         .product_id         = PRODUCT_ID_RNDIS_ADB,
  461.         .functions      = 0xA,
  462.         .adb_product_id     = PRODUCT_ID_RNDIS_ADB,
  463.         .adb_functions      = 0x1A
  464.     },
  465.     /*ZTE_USB_WZY_101021 start*/
  466.     {
  467.         /* diag+modm+nema+ms+at*/
  468.         .product_id         = PRODUCT_ID_DIAG_MODEM_NEMA_MS_AT,
  469.         .functions      = 0xB2764,
  470.         .adb_product_id     = PRODUCT_ID_DIAG_MODEM_NEMA_MS_ADB_AT,
  471.         .adb_functions      = 0xB12764
  472.     },
  473.     {
  474.         /* diag+modm+nema+ms+adb+at*/
  475.         .product_id         = PRODUCT_ID_DIAG_MODEM_NEMA_MS_ADB_AT,
  476.         .functions      = 0xB12764,
  477.         .adb_product_id     = PRODUCT_ID_DIAG_MODEM_NEMA_MS_ADB_AT,
  478.         .adb_functions      = 0xB12764
  479.     },/*ZTE_USB_WZY_101021 end*/
  480.  
  481. #else
  482.     {
  483.         /* MSC */
  484.         .product_id         = 0xF000,
  485.         .functions      = 0x02,
  486.         .adb_product_id     = 0x9015,
  487.         .adb_functions      = 0x12
  488.     },
  489. #ifdef CONFIG_USB_F_SERIAL
  490.     {
  491.         /* MODEM */
  492.         .product_id         = 0xF00B,
  493.         .functions      = 0x06,
  494.         .adb_product_id     = 0x901E,
  495.         .adb_functions      = 0x16,
  496.     },
  497. #endif
  498. #ifdef CONFIG_USB_ANDROID_DIAG
  499.     {
  500.         /* DIAG */
  501.         .product_id         = 0x900E,
  502.         .functions      = 0x04,
  503.         .adb_product_id     = 0x901D,
  504.         .adb_functions      = 0x14,
  505.     },
  506. #endif
  507. #if defined(CONFIG_USB_ANDROID_DIAG) && defined(CONFIG_USB_F_SERIAL)
  508.     {
  509.         /* DIAG + MODEM */
  510.         .product_id         = 0x9004,
  511.         .functions      = 0x64,
  512.         .adb_product_id     = 0x901F,
  513.         .adb_functions      = 0x0614,
  514.     },
  515.     {
  516.         /* DIAG + MODEM + NMEA*/
  517.         .product_id         = 0x9016,
  518.         .functions      = 0x764,
  519.         .adb_product_id     = 0x9020,
  520.         .adb_functions      = 0x7614,
  521.     },
  522.     {
  523.         /* DIAG + MODEM + NMEA + MSC */
  524.         .product_id         = 0x9017,
  525.         .functions      = 0x2764,
  526.         .adb_product_id     = 0x9018,
  527.         .adb_functions      = 0x27614,
  528.     },
  529. #endif
  530. #ifdef CONFIG_USB_ANDROID_CDC_ECM
  531.     {
  532.         /* MSC + CDC-ECM */
  533.         .product_id         = 0x9014,
  534.         .functions      = 0x82,
  535.         .adb_product_id     = 0x9023,
  536.         .adb_functions      = 0x812,
  537.     },
  538. #endif
  539. #ifdef CONFIG_USB_ANDROID_RMNET
  540.     {
  541.         /* DIAG + RMNET */
  542.         .product_id         = 0x9021,
  543.         .functions      = 0x94,
  544.         .adb_product_id     = 0x9022,
  545.         .adb_functions      = 0x914,
  546.     },
  547. #endif
  548. #ifdef CONFIG_USB_ANDROID_RNDIS
  549.     {
  550.         /* RNDIS */
  551.         .product_id         = 0xF00E,
  552.         .functions      = 0xA,
  553.         .adb_product_id     = 0x9024,
  554.         .adb_functions      = 0x1A,
  555.     },
  556. #endif
  557. #endif
  558. };
  559. static struct android_usb_platform_data android_usb_pdata = {
  560. #ifdef CONFIG_ZTE_PLATFORM
  561.     .vendor_id  = 0x19d2,
  562.     .version    = 0x0100,
  563.     .compositions   = usb_func_composition,
  564.     .num_compositions = ARRAY_SIZE(usb_func_composition),
  565.     .product_name   = "ZTE HSUSB Device",
  566.     .manufacturer_name = "ZTE Incorporated",
  567.     .nluns = 1,
  568.     #else
  569.     .vendor_id  = 0x05C6,
  570.     .version    = 0x0100,
  571.     .compositions   = usb_func_composition,
  572.     .num_compositions = ARRAY_SIZE(usb_func_composition),
  573.     .product_name   = "Qualcomm HSUSB Device",
  574.     .manufacturer_name = "Qualcomm Incorporated",
  575.     .nluns = 1,
  576.     #endif
  577. };
  578. static struct platform_device android_usb_device = {
  579.     .name   = "android_usb",
  580.     .id     = -1,
  581.     .dev        = {
  582.         .platform_data = &android_usb_pdata,
  583.     },
  584. };
  585. #endif
  586. static struct platform_device smc91x_device = {
  587.     .name       = "smc91x",
  588.     .id     = 0,
  589.     .num_resources  = ARRAY_SIZE(smc91x_resources),
  590.     .resource   = smc91x_resources,
  591. };
  592.  
  593.  
  594. #ifndef CONFIG_ZTE_PLATFORM
  595. #ifdef CONFIG_USB_FUNCTION
  596. static struct usb_function_map usb_functions_map[] = {
  597.     {"diag", 0},
  598.     {"adb", 1},
  599.     {"modem", 2},
  600.     {"nmea", 3},
  601.     {"mass_storage", 4},
  602.     {"ethernet", 5},
  603.     {"rmnet", 6},
  604. };
  605.  
  606. /* dynamic composition */
  607. static struct usb_composition usb_func_composition[] = {
  608.     {
  609.         .product_id         = 0x9012,
  610.         .functions      = 0x5, /* 0101 */
  611.     },
  612.  
  613.     {
  614.         .product_id         = 0x9013,
  615.         .functions      = 0x15, /* 10101 */
  616.     },
  617.  
  618.     {
  619.         .product_id         = 0x9014,
  620.         .functions      = 0x30, /* 110000 */
  621.     },
  622.  
  623.     {
  624.         .product_id         = 0x9016,
  625.         .functions      = 0xD, /* 01101 */
  626.     },
  627.  
  628.     {
  629.         .product_id         = 0x9017,
  630.         .functions      = 0x1D, /* 11101 */
  631.     },
  632.  
  633.     {
  634.         .product_id         = 0xF000,
  635.         .functions      = 0x10, /* 10000 */
  636.     },
  637.  
  638.     {
  639.         .product_id         = 0xF009,
  640.         .functions      = 0x20, /* 100000 */
  641.     },
  642.  
  643.     {
  644.         .product_id         = 0x9018,
  645.         .functions      = 0x1F, /* 011111 */
  646.     },
  647. #ifdef CONFIG_USB_FUNCTION_RMNET
  648.     {
  649.         .product_id         = 0x9021,
  650.         /* DIAG + RMNET */
  651.         .functions      = 0x41,
  652.     },
  653.     {
  654.         .product_id         = 0x9022,
  655.         /* DIAG + ADB + RMNET */
  656.         .functions      = 0x43,
  657.     },
  658. #endif
  659.  
  660. };
  661.  
  662. static struct msm_hsusb_platform_data msm_hsusb_pdata = {
  663.     .version    = 0x0100,
  664.     .phy_info   = (USB_PHY_INTEGRATED | USB_PHY_MODEL_65NM),
  665.     .vendor_id          = 0x5c6,
  666.     .product_name       = "Qualcomm HSUSB Device",
  667.     .serial_number      = "1234567890ABCDEF",
  668.     .manufacturer_name  = "Qualcomm Incorporated",
  669.     .compositions   = usb_func_composition,
  670.     .num_compositions = ARRAY_SIZE(usb_func_composition),
  671.     .function_map   = usb_functions_map,
  672.     .num_functions  = ARRAY_SIZE(usb_functions_map),
  673.     .config_gpio    = NULL,
  674. };
  675. #endif
  676.  
  677. #endif
  678. #endif
  679.  
  680. static struct platform_device smc91x_device = {
  681.     .name       = "smc91x",
  682.     .id     = 0,
  683.     .num_resources  = ARRAY_SIZE(smc91x_resources),
  684.     .resource   = smc91x_resources,
  685. };
  686.  
  687. #ifdef CONFIG_USB_ANDROID
  688. #if 0
  689. static char *usb_functions_default[] = {
  690.     "diag",
  691.     "modem",
  692.     "nmea",
  693.     "rmnet",
  694.     "usb_mass_storage",
  695. };
  696.  
  697. static char *usb_functions_default_adb[] = {
  698.     "diag",
  699.     "adb",
  700.     "modem",
  701.     "nmea",
  702.     "rmnet",
  703.     "usb_mass_storage",
  704. };
  705.  
  706. static char *usb_functions_rndis_diag[] = {
  707.     "rndis",
  708.     "diag",
  709. };
  710.  
  711. static char *usb_functions_rndis_adb_diag[] = {
  712.     "rndis",
  713.     "adb",
  714.     "diag",
  715. };
  716. #endif
  717.  
  718. static char *usb_functions_all[] = {
  719. #ifdef CONFIG_USB_ANDROID_RNDIS
  720.     "rndis",
  721. #endif
  722. #ifdef CONFIG_USB_ANDROID_DIAG
  723.     "diag",
  724. #endif
  725.     "adb",
  726. #ifdef CONFIG_USB_F_SERIAL
  727.     "modem",
  728.     "nmea",
  729. #endif
  730. #ifdef CONFIG_USB_ANDROID_RMNET
  731.     "rmnet",
  732. #endif
  733.     "usb_mass_storage",
  734. #ifdef CONFIG_USB_ANDROID_ACM
  735.     "acm",
  736. #endif
  737. #ifdef CONFIG_USB_ANDROID_AT
  738.     "at"
  739. #endif
  740. };
  741.  
  742.  
  743. #if 0
  744. static struct android_usb_product usb_products[] = {
  745.     {
  746.         .product_id = 0x9026,
  747.         .num_functions  = ARRAY_SIZE(usb_functions_default),
  748.         .functions  = usb_functions_default,
  749.     },
  750.     {
  751.         .product_id = 0x9025,
  752.         .num_functions  = ARRAY_SIZE(usb_functions_default_adb),
  753.         .functions  = usb_functions_default_adb,
  754.     },
  755.     {
  756.         .product_id = 0x902C,
  757.         .num_functions  = ARRAY_SIZE(usb_functions_rndis_diag),
  758.         .functions  = usb_functions_rndis_diag,
  759.     },
  760.     {
  761.         .product_id = 0x902D,
  762.         .num_functions  = ARRAY_SIZE(usb_functions_rndis_adb_diag),
  763.         .functions  = usb_functions_rndis_adb_diag,
  764.     },
  765. };
  766. #else
  767.  
  768. #include "zte_usb_config.c"
  769.  
  770. #endif
  771.  
  772. static struct usb_mass_storage_platform_data mass_storage_pdata = {
  773.     .nluns      = 1,
  774.     .vendor     = "ZTE Incorporated",
  775.     .product        = "Mass storage",
  776.     .release    = 0x0100,
  777. };
  778.  
  779. static struct platform_device usb_mass_storage_device = {
  780.     .name   = "usb_mass_storage",
  781.     .id = -1,
  782.     .dev    = {
  783.         .platform_data = &mass_storage_pdata,
  784.     },
  785. };
  786.  
  787. #if 0
  788. static struct usb_ether_platform_data rndis_pdata = {
  789.     /* ethaddr is filled by board_serialno_setup */
  790.     .vendorID   = 0x05C6,
  791.     .vendorDescr    = "Qualcomm Incorporated",
  792. };
  793. #endif
  794. static struct platform_device rndis_device = {
  795.     .name   = "rndis",
  796.     .id = -1,
  797.     .dev    = {
  798.         .platform_data = &rndis_pdata,
  799.     },
  800. };
  801.  
  802. #if 0
  803. static struct android_usb_platform_data android_usb_pdata = {
  804.     .vendor_id  = 0x05C6,
  805.     .product_id = 0x9026,
  806.     .version    = 0x0100,
  807.     .product_name       = "Qualcomm HSUSB Device",
  808.     .manufacturer_name  = "Qualcomm Incorporated",
  809.     .num_products = ARRAY_SIZE(usb_products),
  810.     .products = usb_products,
  811.     .num_functions = ARRAY_SIZE(usb_functions_all),
  812.     .functions = usb_functions_all,
  813.     .serial_number = "1234567890ABCDEF",
  814. };
  815. #endif
  816. static struct platform_device android_usb_device = {
  817.     .name   = "android_usb",
  818.     .id     = -1,
  819.     .dev        = {
  820.         .platform_data = &android_usb_pdata,
  821.     },
  822. };
  823. #endif
  824.  
  825. #ifdef CONFIG_USB_MSM_OTG_72K
  826. static int hsusb_rpc_connect(int connect)
  827. {
  828.     if (connect)
  829.         return msm_hsusb_rpc_connect();
  830.     else
  831.         return msm_hsusb_rpc_close();
  832. }
  833. #endif
  834.  
  835. #ifdef CONFIG_USB_MSM_OTG_72K
  836. struct vreg *vreg_3p3;
  837. static int msm_hsusb_ldo_init(int init)
  838. {
  839.     if (init) {
  840.         vreg_3p3 = vreg_get(NULL, "usb");
  841.         if (IS_ERR(vreg_3p3))
  842.             return PTR_ERR(vreg_3p3);
  843.         vreg_set_level(vreg_3p3, 3300);
  844.     } else
  845.         vreg_put(vreg_3p3);
  846.  
  847.     return 0;
  848. }
  849.  
  850. static int msm_hsusb_ldo_enable(int enable)
  851. {
  852.     static int ldo_status;
  853.  
  854.     if (!vreg_3p3 || IS_ERR(vreg_3p3))
  855.         return -ENODEV;
  856.  
  857.     if (ldo_status == enable)
  858.         return 0;
  859.  
  860.     ldo_status = enable;
  861.  
  862.     pr_info("%s: %d", __func__, enable);
  863.  
  864.     if (enable)
  865.         return vreg_enable(vreg_3p3);
  866.  
  867.     return vreg_disable(vreg_3p3);
  868. }
  869.  
  870. static int msm_hsusb_pmic_notif_init(void (*callback)(int online), int init)
  871. {
  872.     int ret;
  873.  
  874.     if (init) {
  875.         ret = msm_pm_app_rpc_init(callback);
  876.     } else {
  877.         msm_pm_app_rpc_deinit(callback);
  878.         ret = 0;
  879.     }
  880.     return ret;
  881. }
  882.  
  883. //ruanmeisi_20100713 reset phy from arm9
  884. #ifdef  CONFIG_ZTE_PLATFORM
  885. static int msm_hsusb_rpc_phy_reset(void __iomem *addr)
  886. {
  887.         return msm_hsusb_phy_reset();
  888. }
  889. #endif
  890. static struct msm_otg_platform_data msm_otg_pdata = {
  891.     .rpc_connect    = hsusb_rpc_connect,
  892.     #ifdef CONFIG_ZTE_PLATFORM
  893.     .phy_reset      = msm_hsusb_rpc_phy_reset,
  894.     #endif
  895.     .pmic_vbus_notif_init         = msm_hsusb_pmic_notif_init,
  896.     .chg_vbus_draw       = hsusb_chg_vbus_draw,
  897.     .chg_connected       = hsusb_chg_connected,
  898.     .chg_init        = hsusb_chg_init,
  899. #ifdef CONFIG_USB_EHCI_MSM
  900.     .vbus_power = msm_hsusb_vbus_power,
  901. #endif
  902.     .ldo_init       = msm_hsusb_ldo_init,
  903.     .ldo_enable     = msm_hsusb_ldo_enable,
  904.     .pclk_required_during_lpm = 1
  905.  
  906. };
  907.  
  908. #ifdef CONFIG_USB_GADGET
  909. //static struct msm_hsusb_gadget_platform_data msm_gadget_pdata;
  910. #endif
  911. #endif
  912.  
  913. /* ZTE_Audio_CJ_100304, chenjun, 2010-3-4, start */
  914. #define SND(desc, num) { .name = #desc, .id = num }
  915. static struct snd_endpoint snd_endpoints_list[] = {
  916.     SND(HANDSET, 0),
  917.     SND(MONO_HEADSET, 2),
  918.     SND(HEADSET, 3),
  919. /* ZTE_Audio_CJ_101227, chenjun, 2010-12-27, start */
  920.     SND(HAC, 4),
  921. /* ZTE_Audio_CJ_101227, chenjun, 2010-12-27, end */
  922.     SND(SPEAKER, 6),
  923.     SND(TTY_HEADSET, 8),
  924.     SND(TTY_VCO, 9),
  925.     SND(TTY_HCO, 10),
  926.     SND(BT, 12),
  927.     SND(IN_S_SADC_OUT_HANDSET, 16),
  928.     SND(IN_S_SADC_OUT_SPEAKER_PHONE, 25),
  929.     SND(HEADSET_AND_SPEAKER, 26),
  930.     SND(CURRENT, 28),
  931. };
  932. #undef SND
  933. /* ZTE_Audio_CJ_100304, chenjun, 2010-3-4, end */
  934.  
  935. static struct msm_snd_endpoints msm_device_snd_endpoints = {
  936.     .endpoints = snd_endpoints_list,
  937.     .num = sizeof(snd_endpoints_list) / sizeof(struct snd_endpoint)
  938. };
  939.  
  940. static struct platform_device msm_device_snd = {
  941.     .name = "msm_snd",
  942.     .id = -1,
  943.     .dev    = {
  944.         .platform_data = &msm_device_snd_endpoints
  945.     },
  946. };
  947.  
  948. #define DEC0_FORMAT ((1<<MSM_ADSP_CODEC_MP3)| \
  949.     (1<<MSM_ADSP_CODEC_AAC)|(1<<MSM_ADSP_CODEC_WMA)| \
  950.     (1<<MSM_ADSP_CODEC_WMAPRO)|(1<<MSM_ADSP_CODEC_AMRWB)| \
  951.     (1<<MSM_ADSP_CODEC_AMRNB)|(1<<MSM_ADSP_CODEC_WAV)| \
  952.     (1<<MSM_ADSP_CODEC_ADPCM)|(1<<MSM_ADSP_CODEC_YADPCM)| \
  953.     (1<<MSM_ADSP_CODEC_EVRC)|(1<<MSM_ADSP_CODEC_QCELP))
  954. #define DEC1_FORMAT ((1<<MSM_ADSP_CODEC_WAV)|(1<<MSM_ADSP_CODEC_ADPCM)| \
  955.     (1<<MSM_ADSP_CODEC_YADPCM)|(1<<MSM_ADSP_CODEC_QCELP)| \
  956.     (1<<MSM_ADSP_CODEC_MP3))
  957. #define DEC2_FORMAT ((1<<MSM_ADSP_CODEC_WAV)|(1<<MSM_ADSP_CODEC_ADPCM)| \
  958.     (1<<MSM_ADSP_CODEC_YADPCM)|(1<<MSM_ADSP_CODEC_QCELP)| \
  959.     (1<<MSM_ADSP_CODEC_MP3))
  960.  
  961. #ifdef CONFIG_ARCH_MSM7X25
  962. #define DEC3_FORMAT 0
  963. #define DEC4_FORMAT 0
  964. #else
  965. #define DEC3_FORMAT ((1<<MSM_ADSP_CODEC_WAV)|(1<<MSM_ADSP_CODEC_ADPCM)| \
  966.     (1<<MSM_ADSP_CODEC_YADPCM)|(1<<MSM_ADSP_CODEC_QCELP))
  967. #define DEC4_FORMAT (1<<MSM_ADSP_CODEC_MIDI)
  968. #endif
  969.  
  970. static unsigned int dec_concurrency_table[] = {
  971.     /* Audio LP */
  972.     (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DMA)), 0,
  973.     0, 0, 0,
  974.  
  975.     /* Concurrency 1 */
  976.     (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  977.     (DEC1_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  978.     (DEC2_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  979.     (DEC3_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  980.     (DEC4_FORMAT),
  981.  
  982.      /* Concurrency 2 */
  983.     (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  984.     (DEC1_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  985.     (DEC2_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  986.     (DEC3_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  987.     (DEC4_FORMAT),
  988.  
  989.     /* Concurrency 3 */
  990.     (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  991.     (DEC1_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  992.     (DEC2_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  993.     (DEC3_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  994.     (DEC4_FORMAT),
  995.  
  996.     /* Concurrency 4 */
  997.     (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  998.     (DEC1_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  999.     (DEC2_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1000.     (DEC3_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1001.     (DEC4_FORMAT),
  1002.  
  1003.     /* Concurrency 5 */
  1004.     (DEC0_FORMAT|(1<<MSM_ADSP_MODE_TUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1005.     (DEC1_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1006.     (DEC2_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1007.     (DEC3_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1008.     (DEC4_FORMAT),
  1009.  
  1010.     /* Concurrency 6 */
  1011.     (DEC0_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1012.     (DEC1_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1013.     (DEC2_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1014.     (DEC3_FORMAT|(1<<MSM_ADSP_MODE_NONTUNNEL)|(1<<MSM_ADSP_OP_DM)),
  1015.     (DEC4_FORMAT),
  1016. };
  1017.  
  1018. #define DEC_INFO(name, queueid, decid, nr_codec) { .module_name = name, \
  1019.     .module_queueid = queueid, .module_decid = decid, \
  1020.     .nr_codec_support = nr_codec}
  1021.  
  1022. static struct msm_adspdec_info dec_info_list[] = {
  1023.     DEC_INFO("AUDPLAY0TASK", 13, 0, 11), /* AudPlay0BitStreamCtrlQueue */
  1024.     DEC_INFO("AUDPLAY1TASK", 14, 1, 5),  /* AudPlay1BitStreamCtrlQueue */
  1025.     DEC_INFO("AUDPLAY2TASK", 15, 2, 5),  /* AudPlay2BitStreamCtrlQueue */
  1026. #ifdef CONFIG_ARCH_MSM7X25
  1027.     DEC_INFO("AUDPLAY3TASK", 16, 3, 0),  /* AudPlay3BitStreamCtrlQueue */
  1028.     DEC_INFO("AUDPLAY4TASK", 17, 4, 0),  /* AudPlay4BitStreamCtrlQueue */
  1029. #else
  1030.     DEC_INFO("AUDPLAY3TASK", 16, 3, 4),  /* AudPlay3BitStreamCtrlQueue */
  1031.     DEC_INFO("AUDPLAY4TASK", 17, 4, 1),  /* AudPlay4BitStreamCtrlQueue */
  1032. #endif
  1033. };
  1034.  
  1035. static struct msm_adspdec_database msm_device_adspdec_database = {
  1036.     .num_dec = ARRAY_SIZE(dec_info_list),
  1037.     .num_concurrency_support = (ARRAY_SIZE(dec_concurrency_table) / \
  1038.                     ARRAY_SIZE(dec_info_list)),
  1039.     .dec_concurrency_table = dec_concurrency_table,
  1040.     .dec_info_list = dec_info_list,
  1041. };
  1042.  
  1043. static struct platform_device msm_device_adspdec = {
  1044.     .name = "msm_adspdec",
  1045.     .id = -1,
  1046.     .dev    = {
  1047.         .platform_data = &msm_device_adspdec_database
  1048.     },
  1049. };
  1050.  
  1051. static struct android_pmem_platform_data android_pmem_kernel_ebi1_pdata = {
  1052.     .name = PMEM_KERNEL_EBI1_DATA_NAME,
  1053.     /* if no allocator_type, defaults to PMEM_ALLOCATORTYPE_BITMAP,
  1054.      * the only valid choice at this time. The board structure is
  1055.      * set to all zeros by the C runtime initialization and that is now
  1056.      * the enum value of PMEM_ALLOCATORTYPE_BITMAP, now forced to 0 in
  1057.      * include/linux/android_pmem.h.
  1058.      */
  1059.     .cached = 0,
  1060. };
  1061.  
  1062. static struct android_pmem_platform_data android_pmem_pdata = {
  1063.     .name = "pmem",
  1064.     .allocator_type = PMEM_ALLOCATORTYPE_BITMAP,
  1065.     .cached = 1,
  1066. };
  1067.  
  1068. static struct android_pmem_platform_data android_pmem_adsp_pdata = {
  1069.     .name = "pmem_adsp",
  1070.     .allocator_type = PMEM_ALLOCATORTYPE_BITMAP,
  1071.     .cached = 0,
  1072. };
  1073.  
  1074. static struct android_pmem_platform_data android_pmem_audio_pdata = {
  1075.     .name = "pmem_audio",
  1076.     .allocator_type = PMEM_ALLOCATORTYPE_BITMAP,
  1077.     .cached = 0,
  1078. };
  1079.  
  1080. static struct platform_device android_pmem_device = {
  1081.     .name = "android_pmem",
  1082.     .id = 0,
  1083.     .dev = { .platform_data = &android_pmem_pdata },
  1084. };
  1085.  
  1086. static struct platform_device android_pmem_adsp_device = {
  1087.     .name = "android_pmem",
  1088.     .id = 1,
  1089.     .dev = { .platform_data = &android_pmem_adsp_pdata },
  1090. };
  1091.  
  1092. static struct platform_device android_pmem_audio_device = {
  1093.     .name = "android_pmem",
  1094.     .id = 2,
  1095.     .dev = { .platform_data = &android_pmem_audio_pdata },
  1096. };
  1097.  
  1098. static struct platform_device android_pmem_kernel_ebi1_device = {
  1099.     .name = "android_pmem",
  1100.     .id = 4,
  1101.     .dev = { .platform_data = &android_pmem_kernel_ebi1_pdata },
  1102. };
  1103.  
  1104. static struct msm_handset_platform_data hs_platform_data = {
  1105.     .hs_name = "7k_handset",
  1106.     .pwr_key_delay_ms = 500, /* 0 will disable end key */
  1107. };
  1108.  
  1109. static struct platform_device hs_device = {
  1110.     .name   = "msm-handset",
  1111.     .id     = -1,
  1112.     .dev    = {
  1113.         .platform_data = &hs_platform_data,
  1114.     },
  1115. };
  1116.  
  1117.  
  1118. #define LCDC_CONFIG_PROC          21
  1119. #define LCDC_UN_CONFIG_PROC       22
  1120. #define LCDC_API_PROG             0x30000066
  1121. #define LCDC_API_VERS             0x00010001
  1122.  
  1123. //ZTE_BOOT_HUANGYJ_20100816_01 add mooncake boot config
  1124. #ifdef CONFIG_ZTE_PLATFORM
  1125. //lcd reset & spi
  1126. #define GPIO_LCD_RESET_OUT      91
  1127. #define GPIO_LCD_SPI_CS_OUT     122
  1128. #define GPIO_LCD_SPI_SDO_OUT    123
  1129. #define GPIO_LCD_SPI_SCLK_OUT   124
  1130. #define GPIO_LCD_SPI_SDI_IN     132
  1131. #define GPIO_LCD_ID_DETECT      34//ZTE_LCD_LKEJ_20110225_001
  1132.  
  1133. #else
  1134. #define GPIO_OUT_132    132
  1135. #define GPIO_OUT_131    131
  1136. #define GPIO_OUT_103    103
  1137. #define GPIO_OUT_102    102
  1138. #define GPIO_OUT_88     88
  1139. #endif
  1140.  
  1141. static struct msm_rpc_endpoint *lcdc_ep;
  1142.  
  1143. static int msm_fb_lcdc_config(int on)
  1144. {
  1145.     int rc = 0;
  1146.     struct rpc_request_hdr hdr;
  1147.  
  1148.     if (on)
  1149.         pr_info("lcdc config\n");
  1150.     else
  1151.         pr_info("lcdc un-config\n");
  1152.  
  1153.     lcdc_ep = msm_rpc_connect_compatible(LCDC_API_PROG, LCDC_API_VERS, 0);
  1154.     if (IS_ERR(lcdc_ep)) {
  1155.         printk(KERN_ERR "%s: msm_rpc_connect failed! rc = %ld\n",
  1156.             __func__, PTR_ERR(lcdc_ep));
  1157.         return -EINVAL;
  1158.     }
  1159.  
  1160.     rc = msm_rpc_call(lcdc_ep,
  1161.                 (on) ? LCDC_CONFIG_PROC : LCDC_UN_CONFIG_PROC,
  1162.                 &hdr, sizeof(hdr),
  1163.                 5 * HZ);
  1164.     if (rc)
  1165.         printk(KERN_ERR
  1166.             "%s: msm_rpc_call failed! rc = %d\n", __func__, rc);
  1167.  
  1168.     msm_rpc_close(lcdc_ep);
  1169.     return rc;
  1170. }
  1171.  
  1172. //ZTE_BOOT_HUANGYJ_20100816_01 add mooncake boot config
  1173. #ifdef CONFIG_ZTE_PLATFORM
  1174. static int gpio_array_num[] = {
  1175.                 GPIO_LCD_SPI_SCLK_OUT, /* spi_clk */
  1176.                 GPIO_LCD_SPI_CS_OUT, /* spi_cs  */
  1177.                 GPIO_LCD_SPI_SDI_IN, /* spi_sdi */
  1178.                 GPIO_LCD_SPI_SDO_OUT, /* spi_sdoi */
  1179.                 GPIO_LCD_RESET_OUT,
  1180.                 GPIO_LCD_ID_DETECT,//ZTE_LCD_LKEJ_20110225_001
  1181.                 };
  1182.  
  1183. static void lcdc_lead_gpio_init(void)
  1184. {
  1185.     if (gpio_request(GPIO_LCD_SPI_SCLK_OUT, "spi_clk"))
  1186.         pr_err("failed to request gpio spi_clk\n");
  1187.     if (gpio_request(GPIO_LCD_SPI_CS_OUT, "spi_cs"))
  1188.         pr_err("failed to request gpio spi_cs\n");
  1189.     if (gpio_request(GPIO_LCD_SPI_SDI_IN, "spi_sdi"))
  1190.         pr_err("failed to request gpio spi_sdi\n");
  1191.     if (gpio_request(GPIO_LCD_SPI_SDO_OUT, "spi_sdoi"))
  1192.         pr_err("failed to request gpio spi_sdoi\n");
  1193.     if (gpio_request(GPIO_LCD_RESET_OUT, "gpio_dac"))
  1194.         pr_err("failed to request gpio_dac\n");
  1195.     if (gpio_request(GPIO_LCD_ID_DETECT, "gpio_id_detect"))//ZTE_LCD_LKEJ_20110225_001
  1196.         pr_err("failed to request gpio_id_detect\n");
  1197. }
  1198.  
  1199. static uint32_t lcdc_gpio_table[] = {
  1200.     GPIO_CFG(GPIO_LCD_SPI_SCLK_OUT, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
  1201.     GPIO_CFG(GPIO_LCD_SPI_CS_OUT, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
  1202.     GPIO_CFG(GPIO_LCD_SPI_SDI_IN, 0, GPIO_INPUT, GPIO_PULL_UP, GPIO_2MA),
  1203.     GPIO_CFG(GPIO_LCD_SPI_SDO_OUT, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
  1204.     GPIO_CFG(GPIO_LCD_RESET_OUT,  0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
  1205.     GPIO_CFG(GPIO_LCD_ID_DETECT, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),};//ZTE_LCD_LKEJ_20110225_001
  1206. #else
  1207. static int gpio_array_num[] = {
  1208.                 GPIO_OUT_132, /* spi_clk */
  1209.                 GPIO_OUT_131, /* spi_cs  */
  1210.                 GPIO_OUT_103, /* spi_sdi */
  1211.                 GPIO_OUT_102, /* spi_sdoi */
  1212.                 GPIO_OUT_88
  1213.                 };
  1214.  
  1215. static void lcdc_gordon_gpio_init(void)
  1216. {
  1217.     if (gpio_request(GPIO_OUT_132, "spi_clk"))
  1218.         pr_err("failed to request gpio spi_clk\n");
  1219.     if (gpio_request(GPIO_OUT_131, "spi_cs"))
  1220.         pr_err("failed to request gpio spi_cs\n");
  1221.     if (gpio_request(GPIO_OUT_103, "spi_sdi"))
  1222.         pr_err("failed to request gpio spi_sdi\n");
  1223.     if (gpio_request(GPIO_OUT_102, "spi_sdoi"))
  1224.         pr_err("failed to request gpio spi_sdoi\n");
  1225.     if (gpio_request(GPIO_OUT_88, "gpio_dac"))
  1226.         pr_err("failed to request gpio_dac\n");
  1227. }
  1228.  
  1229. static uint32_t lcdc_gpio_table[] = {
  1230.     GPIO_CFG(GPIO_OUT_132, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
  1231.     GPIO_CFG(GPIO_OUT_131, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
  1232.     GPIO_CFG(GPIO_OUT_103, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
  1233.     GPIO_CFG(GPIO_OUT_102, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
  1234.     GPIO_CFG(GPIO_OUT_88,  0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
  1235. };
  1236. #endif
  1237.  
  1238. static void config_lcdc_gpio_table(uint32_t *table, int len, unsigned enable)
  1239. {
  1240.     int n, rc;
  1241.     for (n = 0; n < len; n++) {
  1242.         rc = gpio_tlmm_config(table[n],
  1243.             enable ? GPIO_ENABLE : GPIO_DISABLE);
  1244.         if (rc) {
  1245.             printk(KERN_ERR "%s: gpio_tlmm_config(%#x)=%d\n",
  1246.                 __func__, table[n], rc);
  1247.             break;
  1248.         }
  1249.     }
  1250. }
  1251.  
  1252. //ZTE_BOOT_HUANGYJ_20100816_01 add mooncake boot config
  1253. #ifdef CONFIG_ZTE_PLATFORM
  1254. static void lcdc_lead_config_gpios(int enable)
  1255. #else
  1256. static void lcdc_gordon_config_gpios(int enable)
  1257. #endif
  1258. {
  1259.     config_lcdc_gpio_table(lcdc_gpio_table,
  1260.         ARRAY_SIZE(lcdc_gpio_table), enable);
  1261. }
  1262.  
  1263. static char *msm_fb_lcdc_vreg[] = {
  1264.     "gp5"
  1265. };
  1266.  
  1267. static int msm_fb_lcdc_power_save(int on)
  1268. {
  1269.     struct vreg *vreg[ARRAY_SIZE(msm_fb_lcdc_vreg)];
  1270.     int i, rc = 0;
  1271.  
  1272.     for (i = 0; i < ARRAY_SIZE(msm_fb_lcdc_vreg); i++) {
  1273.         if (on) {
  1274.             vreg[i] = vreg_get(0, msm_fb_lcdc_vreg[i]);
  1275.             rc = vreg_enable(vreg[i]);
  1276.             if (rc) {
  1277.                 printk(KERN_ERR "vreg_enable: %s vreg"
  1278.                         "operation failed \n",
  1279.                         msm_fb_lcdc_vreg[i]);
  1280.                 goto bail;
  1281.             }
  1282.            if(lcd_first_reset)//ZTE_DRIVE_LCD_LKEJ_20110620
  1283.             {
  1284.              lcdc_lead_config_gpios(1);
  1285.              msleep(10);
  1286.              gpio_direction_output(GPIO_LCD_RESET_OUT, 1);
  1287.              msleep(10);                        ////ZTE_LCD_LUYA_20100629_001
  1288.              gpio_direction_output(GPIO_LCD_RESET_OUT, 0);
  1289.              msleep(20);                        ////ZTE_LCD_LUYA_20100629_001
  1290.              gpio_direction_output(GPIO_LCD_RESET_OUT, 1);
  1291.              msleep(120);
  1292.             }
  1293.            else
  1294.             {
  1295.               lcd_first_reset = true;
  1296.             }
  1297.         } else {
  1298.             int tmp;
  1299.             vreg[i] = vreg_get(0, msm_fb_lcdc_vreg[i]);
  1300.             tmp = vreg_disable(vreg[i]);
  1301.             if (tmp) {
  1302.                 printk(KERN_ERR "vreg_disable: %s vreg "
  1303.                         "operation failed \n",
  1304.                         msm_fb_lcdc_vreg[i]);
  1305.                 if (!rc)
  1306.                     rc = tmp;
  1307.             }
  1308.             /*
  1309.             tmp = gpio_tlmm_config(GPIO_CFG(GPIO_LCD_RESET_OUT, 0,
  1310.                         GPIO_OUTPUT, GPIO_NO_PULL,
  1311.                         GPIO_2MA), GPIO_ENABLE);
  1312.             if (tmp) {
  1313.                 printk(KERN_ERR "gpio_tlmm_config failed\n");
  1314.                 if (!rc)
  1315.                     rc = tmp;
  1316.             }
  1317.             gpio_set_value(91, 0);
  1318.             mdelay(15);
  1319.             gpio_set_value(91, 1);
  1320.             mdelay(15);
  1321.             */
  1322.         }
  1323.     }
  1324.  
  1325.     return rc;
  1326.  
  1327. bail:
  1328.     if (on) {
  1329.         for (; i > 0; i--)
  1330.             vreg_disable(vreg[i - 1]);
  1331.     }
  1332.  
  1333.     return rc;
  1334. }
  1335. static struct lcdc_platform_data lcdc_pdata = {
  1336.     .lcdc_gpio_config = msm_fb_lcdc_config,
  1337.     .lcdc_power_save   = msm_fb_lcdc_power_save,
  1338. };
  1339.  
  1340. //ZTE_BOOT_HUANGYJ_20100816_01 add mooncake boot config
  1341. #ifdef CONFIG_ZTE_PLATFORM
  1342. static struct msm_panel_common_pdata lcdc_qvga_panel_data = {
  1343.     .panel_config_gpio = lcdc_lead_config_gpios,
  1344.     .gpio_num          = gpio_array_num,
  1345. };
  1346.  
  1347. static struct platform_device lcdc_qvga_panel_device = {
  1348.     .name   = "lcdc_panel_qvga",
  1349.     .id     = 0,
  1350.     .dev    = {
  1351.         .platform_data = &lcdc_qvga_panel_data,
  1352.     }
  1353. };
  1354. #else
  1355. static struct msm_panel_common_pdata lcdc_gordon_panel_data = {
  1356.     .panel_config_gpio = lcdc_gordon_config_gpios,
  1357.     .gpio_num          = gpio_array_num,
  1358. };
  1359.  
  1360. static struct platform_device lcdc_gordon_panel_device = {
  1361.     .name   = "lcdc_gordon_vga",
  1362.     .id     = 0,
  1363.     .dev    = {
  1364.         .platform_data = &lcdc_gordon_panel_data,
  1365.     }
  1366. };
  1367. #endif
  1368.  
  1369. static struct resource msm_fb_resources[] = {
  1370.     {
  1371.         .flags  = IORESOURCE_DMA,
  1372.     }
  1373. };
  1374.  
  1375. static int msm_fb_detect_panel(const char *name)
  1376. {
  1377.     int ret = -EPERM;
  1378.  
  1379.     if (machine_is_msm7x25_ffa() || machine_is_msm7x27_ffa()) {
  1380.         if (!strcmp(name, "lcdc_gordon_vga"))
  1381.             ret = 0;
  1382.         else
  1383.             ret = -ENODEV;
  1384.     }
  1385.  
  1386.     return ret;
  1387. }
  1388.  
  1389. static struct msm_fb_platform_data msm_fb_pdata = {
  1390.     .detect_client = msm_fb_detect_panel,
  1391.     .mddi_prescan = 1,
  1392. };
  1393.  
  1394. static struct platform_device msm_fb_device = {
  1395.     .name   = "msm_fb",
  1396.     .id     = 0,
  1397.     .num_resources  = ARRAY_SIZE(msm_fb_resources),
  1398.     .resource       = msm_fb_resources,
  1399.     .dev    = {
  1400.         .platform_data = &msm_fb_pdata,
  1401.     }
  1402. };
  1403.  
  1404. #ifdef CONFIG_BT
  1405. static struct platform_device msm_bt_power_device = {
  1406.     .name = "bt_power",
  1407. };
  1408.  
  1409.  
  1410. static struct platform_device msm_bcm_power_device = {
  1411.     .name = "bcm_power",
  1412. };
  1413.  
  1414.  
  1415. enum {
  1416.     BT_WAKE,
  1417.     BT_RFR,
  1418.     BT_CTS,
  1419.     BT_RX,
  1420.     BT_TX,
  1421.     BT_PCM_DOUT,
  1422.     BT_PCM_DIN,
  1423.     BT_PCM_SYNC,
  1424.     BT_PCM_CLK,
  1425.     BT_HOST_WAKE,
  1426. };
  1427.  
  1428. static unsigned bt_config_power_on[] = {
  1429.     GPIO_CFG(90, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),   /* WAKE ZTE_BT_QXX_20100709*/
  1430.     GPIO_CFG(43, 2, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),   /* RFR */
  1431.     GPIO_CFG(44, 2, GPIO_INPUT,  GPIO_NO_PULL, GPIO_2MA),   /* CTS */
  1432.     GPIO_CFG(45, 2, GPIO_INPUT,  GPIO_NO_PULL, GPIO_2MA),   /* Rx */
  1433.     GPIO_CFG(46, 3, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),   /* Tx */
  1434.     GPIO_CFG(68, 1, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),   /* PCM_DOUT */
  1435.     GPIO_CFG(69, 1, GPIO_INPUT,  GPIO_NO_PULL, GPIO_2MA),   /* PCM_DIN */
  1436.     GPIO_CFG(70, 2, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),   /* PCM_SYNC */
  1437.     GPIO_CFG(71, 2, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),   /* PCM_CLK */
  1438.     GPIO_CFG(83, 0, GPIO_INPUT,  GPIO_NO_PULL, GPIO_2MA),   /* HOST_WAKE */
  1439. };
  1440. static unsigned bt_config_power_off[] = {
  1441.     GPIO_CFG(90, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* WAKE */
  1442.     GPIO_CFG(43, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* RFR */
  1443.     GPIO_CFG(44, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* CTS */
  1444.     GPIO_CFG(45, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* Rx */
  1445.     GPIO_CFG(46, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* Tx */
  1446.     GPIO_CFG(68, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* PCM_DOUT */
  1447.     GPIO_CFG(69, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* PCM_DIN */
  1448.     GPIO_CFG(70, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* PCM_SYNC */
  1449.     GPIO_CFG(71, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* PCM_CLK */
  1450.     GPIO_CFG(83, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* HOST_WAKE */
  1451. };
  1452.  
  1453. static int bluetooth_power(int on)
  1454. {
  1455.     struct vreg *vreg_bt;
  1456.     int pin, rc;
  1457.  
  1458.     printk(KERN_DEBUG "%s\n", __func__);
  1459.  
  1460.     /* do not have vreg bt defined, gp6 is the same */
  1461.     /* vreg_get parameter 1 (struct device *) is ignored */
  1462.     vreg_bt = vreg_get(NULL, "gp6");
  1463.  
  1464.     if (IS_ERR(vreg_bt)) {
  1465.         printk(KERN_ERR "%s: vreg get failed (%ld)\n",
  1466.                __func__, PTR_ERR(vreg_bt));
  1467.         return PTR_ERR(vreg_bt);
  1468.     }
  1469.  
  1470.     if (on) {
  1471.         for (pin = 0; pin < ARRAY_SIZE(bt_config_power_on); pin++) {
  1472.             rc = gpio_tlmm_config(bt_config_power_on[pin],
  1473.                           GPIO_ENABLE);
  1474.             if (rc) {
  1475.                 printk(KERN_ERR
  1476.                        "%s: gpio_tlmm_config(%#x)=%d\n",
  1477.                        __func__, bt_config_power_on[pin], rc);
  1478.                 return -EIO;
  1479.             }
  1480.         }
  1481.  
  1482.         /* units of mV, steps of 50 mV */
  1483.         rc = vreg_set_level(vreg_bt, 1800);
  1484.         if (rc) {
  1485.             printk(KERN_ERR "%s: vreg set level failed (%d)\n",
  1486.                    __func__, rc);
  1487.             return -EIO;
  1488.         }
  1489.         rc = vreg_enable(vreg_bt);
  1490.         if (rc) {
  1491.             printk(KERN_ERR "%s: vreg enable failed (%d)\n",
  1492.                    __func__, rc);
  1493.             return -EIO;
  1494.         }
  1495.        
  1496.         rc = gpio_request(20, "bt_reset");
  1497.         if(!rc)
  1498.         {
  1499.             gpio_direction_output(20, 1);
  1500.         }
  1501.         else
  1502.         {
  1503.             printk(KERN_ERR "gpio_request: %d failed!\n", 20);
  1504.         }
  1505.         gpio_free(20);     
  1506.        
  1507.     } else {
  1508.         rc = vreg_disable(vreg_bt);
  1509.         if (rc) {
  1510.             printk(KERN_ERR "%s: vreg disable failed (%d)\n",
  1511.                    __func__, rc);
  1512.             return -EIO;
  1513.         }
  1514.         for (pin = 0; pin < ARRAY_SIZE(bt_config_power_off); pin++) {
  1515.             rc = gpio_tlmm_config(bt_config_power_off[pin],
  1516.                           GPIO_ENABLE);
  1517.             if (rc) {
  1518.                 printk(KERN_ERR
  1519.                        "%s: gpio_tlmm_config(%#x)=%d\n",
  1520.                        __func__, bt_config_power_off[pin], rc);
  1521.                 return -EIO;
  1522.             }
  1523.         }
  1524.        
  1525.     rc = gpio_request(20, "bt_reset");
  1526.     if(!rc)
  1527.     {
  1528.         gpio_direction_output(20, 0);
  1529.     }
  1530.     else
  1531.     {
  1532.         printk(KERN_ERR "gpio_request: %d failed!\n", 20);
  1533.     }
  1534.     gpio_free(20);
  1535.        
  1536.     }
  1537.     return 0;
  1538. }
  1539.  
  1540.  
  1541. static int bcm_power(int on)
  1542. {
  1543. //  struct vreg *vreg_bt;  
  1544.     int pin, rc;
  1545.  
  1546.     printk(KERN_DEBUG "%s\n", __func__);
  1547.  
  1548.     if (on) {
  1549.         for (pin = 0; pin < ARRAY_SIZE(bt_config_power_on); pin++) {
  1550.             rc = gpio_tlmm_config(bt_config_power_on[pin],
  1551.                           GPIO_ENABLE);
  1552.             if (rc) {
  1553.                 printk(KERN_ERR
  1554.                        "%s: gpio_tlmm_config(%#x)=%d\n",
  1555.                        __func__, bt_config_power_on[pin], rc);
  1556.                 return -EIO;
  1557.             }
  1558.         }
  1559.  
  1560.        
  1561.         rc = gpio_request(20, "bt_reset");
  1562.         if(!rc)
  1563.         {
  1564.        gpio_direction_output(20, 0);
  1565.            mdelay(1);
  1566.            gpio_direction_output(20, 1);
  1567.    
  1568.         }
  1569.         else
  1570.         {
  1571.             printk(KERN_ERR "gpio_request: %d failed!\n", 20);
  1572.         }
  1573.         gpio_free(20);     
  1574.        
  1575.     } else {
  1576.    
  1577.         for (pin = 0; pin < ARRAY_SIZE(bt_config_power_off); pin++) {
  1578.             rc = gpio_tlmm_config(bt_config_power_off[pin],
  1579.                           GPIO_ENABLE);
  1580.             if (rc) {
  1581.                 printk(KERN_ERR
  1582.                        "%s: gpio_tlmm_config(%#x)=%d\n",
  1583.                        __func__, bt_config_power_off[pin], rc);
  1584.                 return -EIO;
  1585.             }
  1586.         }
  1587.        
  1588.     rc = gpio_request(20, "bt_reset");
  1589.     if(!rc)
  1590.     {
  1591.         gpio_direction_output(20, 0);
  1592.     }
  1593.     else
  1594.     {
  1595.        printk(KERN_ERR "gpio_request: %d failed!\n", 20);
  1596.     }
  1597.     gpio_free(20);
  1598.        
  1599.     }
  1600.     return 0;
  1601. }
  1602.  
  1603.  
  1604. static void __init bt_power_init(void)
  1605. {
  1606.     msm_bt_power_device.dev.platform_data = &bluetooth_power;
  1607.     msm_bcm_power_device.dev.platform_data = &bcm_power;  
  1608. }
  1609. #else
  1610. #define bt_power_init(x) do {} while (0)
  1611. #endif
  1612.  
  1613. #ifdef CONFIG_ARCH_MSM7X27
  1614. static struct resource kgsl_resources[] = {
  1615.     {
  1616.         .name = "kgsl_reg_memory",
  1617.         .start = 0xA0000000,
  1618.         .end = 0xA001ffff,
  1619.         .flags = IORESOURCE_MEM,
  1620.     },
  1621.     {
  1622.         .name = "kgsl_yamato_irq",
  1623.         .start = INT_GRAPHICS,
  1624.         .end = INT_GRAPHICS,
  1625.         .flags = IORESOURCE_IRQ,
  1626.     },
  1627. };
  1628.  
  1629. static struct kgsl_platform_data kgsl_pdata;
  1630.  
  1631. static struct platform_device msm_device_kgsl = {
  1632.     .name = "kgsl",
  1633.     .id = -1,
  1634.     .num_resources = ARRAY_SIZE(kgsl_resources),
  1635.     .resource = kgsl_resources,
  1636.     .dev = {
  1637.         .platform_data = &kgsl_pdata,
  1638.     },
  1639. };
  1640. #endif
  1641.  
  1642. static struct platform_device msm_device_pmic_leds = {
  1643.     .name   = "pmic-leds-status",
  1644.     .id = -1,
  1645. };
  1646.  
  1647. /*ZTE_BUTTON_BACKLIGHT_WLY_005, @2009-11-1,change gpio89 to gpio32,begin*/
  1648. static struct gpio_led android_led_list[] = {
  1649.     {
  1650.         .name = "button-backlight",
  1651.         .gpio = 35,
  1652.     },
  1653. };
  1654.  
  1655. static struct gpio_led_platform_data android_leds_data = {
  1656.     .num_leds   = ARRAY_SIZE(android_led_list),
  1657.     .leds       = android_led_list,
  1658. };
  1659.  
  1660. static struct platform_device android_leds = {
  1661.     .name       = "leds-gpio",
  1662.     .id     = -1,
  1663.     .dev        = {
  1664.         .platform_data = &android_leds_data,
  1665.     },
  1666. };
  1667. /*ZTE_BUTTON_BACKLIGHT_WLY_005, @2009-11-1,change gpio89 to gpio32,end*/
  1668.  
  1669. static struct resource bluesleep_resources[] = {
  1670.     {
  1671.         .name   = "gpio_host_wake",
  1672.         .start  = 83,
  1673.         .end    = 83,
  1674.         .flags  = IORESOURCE_IO,
  1675.     },
  1676.     {
  1677.         .name   = "gpio_ext_wake",
  1678.         .start  = 90,  
  1679.         .end    = 90,    
  1680.         .flags  = IORESOURCE_IO,
  1681.     },
  1682.     {
  1683.         .name   = "host_wake",
  1684.         .start  = MSM_GPIO_TO_INT(83),
  1685.         .end    = MSM_GPIO_TO_INT(83),
  1686.         .flags  = IORESOURCE_IRQ,
  1687.     },
  1688. };
  1689.  
  1690. static struct platform_device msm_bluesleep_device = {
  1691.     .name = "bluesleep",
  1692.     .id     = -1,
  1693.     .num_resources  = ARRAY_SIZE(bluesleep_resources),
  1694.     .resource   = bluesleep_resources,
  1695. };
  1696.  
  1697.  
  1698. static struct platform_device msm_bcmsleep_device = {
  1699.     .name = "bcmsleep",
  1700.     .id     = -1,
  1701.     .num_resources  = ARRAY_SIZE(bluesleep_resources),
  1702.     .resource   = bluesleep_resources,
  1703. };
  1704.  
  1705. #ifdef CONFIG_TOUCHSCREEN_SYNAPTICS_3K
  1706. #define SYNAPTICS_I2C_RMI4_NAME "synaptics-rmi4-ts"
  1707. #define TS_I2C_ADDR     0x22
  1708. #define GPIO_TS_IRQ     29
  1709. #define GPIO_TOUCH_EN   31
  1710.  
  1711. static int touchscreen_power(int on)
  1712. {
  1713.     int ret=0;
  1714.     ret = gpio_request(GPIO_TOUCH_EN, "touch voltage");
  1715.     if (!ret){
  1716.         if (on==1){
  1717.             gpio_direction_output(GPIO_TOUCH_EN, 1);
  1718.         }else if (on==0){
  1719.             gpio_direction_output(GPIO_TOUCH_EN,0);
  1720.     }
  1721.     }else{
  1722.         pr_err("touchscreen_power,gpio request error!\n");
  1723.         ret=-EIO;
  1724.     }
  1725.  
  1726.     gpio_free(GPIO_TOUCH_EN);
  1727.  
  1728.     return ret;
  1729. }
  1730.  
  1731. static struct synaptics_rmi4_data synaptics_ts_data = {
  1732.     .orientation    = 0,    // ROTATION_0 = 0,ROTATION_90 = 1, ROTATION_180 = 2, ROTATION_270 = 3
  1733.     .power  = touchscreen_power,
  1734.     .gpio_irq = 29,
  1735. };
  1736.  
  1737. #endif
  1738.  
  1739. static struct lis302dl_platform_data gsensor = {
  1740.     .gpio_intr1 =  84,
  1741.     .gpio_intr2 =  85,
  1742.     .scale      =  2 ,
  1743.     .int_active_low = 1,
  1744. };
  1745.  
  1746. static struct i2c_board_info i2c_devices[] = {
  1747. //add the following devices to i2c-bus     ZTE_SENSORS_FYA_20110223 begin
  1748. #ifdef CONFIG_SENSORS_AKM8962
  1749.     {
  1750.         I2C_BOARD_INFO("akm8962", 0x0c),
  1751.     },
  1752. #endif
  1753. #ifdef CONFIG_SENSOR_LIS302DL
  1754.     {
  1755.         .type = "lis302dl",
  1756.         .addr = 0x1c,
  1757.         .platform_data = &gsensor,
  1758.     },
  1759. #endif
  1760. #ifdef CONFIG_SENSOR_ADXL34X   
  1761.     {  
  1762.         .type = "adxl34x",  
  1763.         .addr = 0x53,  
  1764.     },
  1765. #endif
  1766. //add the following devices to i2c-bus     ZTE_SENSORS_FYA_20110223 end
  1767. #ifdef CONFIG_MT9D112
  1768.     {
  1769.         I2C_BOARD_INFO("mt9d112", 0x78 >> 1),
  1770.     },
  1771. #endif
  1772. #ifdef CONFIG_S5K3E2FX
  1773.     {
  1774.         I2C_BOARD_INFO("s5k3e2fx", 0x20 >> 1),
  1775.     },
  1776. #endif
  1777. #ifdef CONFIG_MT9P012
  1778.     {
  1779.         I2C_BOARD_INFO("mt9p012", 0x6C >> 1),
  1780.     },
  1781. #endif
  1782. #ifdef CONFIG_MT9P012_KM
  1783.     {
  1784.         I2C_BOARD_INFO("mt9p012_km", 0x6C >> 2),
  1785.     },
  1786. #endif
  1787. #if defined(CONFIG_MT9T013) || defined(CONFIG_SENSORS_MT9T013)
  1788.     {
  1789.         I2C_BOARD_INFO("mt9t013", 0x6C),
  1790.     },
  1791. #endif
  1792. #ifdef CONFIG_VB6801
  1793.     {
  1794.         I2C_BOARD_INFO("vb6801", 0x20),
  1795.     },
  1796. #endif
  1797.  
  1798. #ifdef CONFIG_MT9P111
  1799.     /*
  1800.      * Commented by zhang.shengjie
  1801.      *
  1802.      * Refer to drivers/media/video/msm/mt9p111.c
  1803.      * For MT9P111: 5.0Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  1804.      *
  1805.      * Attention: I2C device is initialized in sensor's driver if "CONFIG_SENSOR_ADAPTER"
  1806.      *            is defined
  1807.      */
  1808. #if !defined(CONFIG_SENSOR_ADAPTER)
  1809.     {
  1810.         I2C_BOARD_INFO("mt9p111", 0x7A >> 1),
  1811.     },
  1812. #else
  1813.     //Do nothing
  1814. #endif
  1815. #endif
  1816.  
  1817. #ifdef CONFIG_MT9T11X
  1818.     /*
  1819.      * Commented by zhang.shengjie, ZTE_MSM_CAMERA_ZHSHJ_001
  1820.      *
  1821.      * Refer to drivers/media/video/msm/mt9t11x.c
  1822.      * For MT9T111: 3.1Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  1823.      * For MT9T112: 3.1Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  1824.      *
  1825.      * Attention: I2C device is initialized in sensor's driver if "CONFIG_SENSOR_ADAPTER"
  1826.      *            is defined
  1827.      */
  1828. #if !defined(CONFIG_SENSOR_ADAPTER)
  1829.     {
  1830.         I2C_BOARD_INFO("mt9t11x", 0x7A >> 1),
  1831.     },
  1832. #else
  1833.     //Do nothing
  1834. #endif
  1835. #endif
  1836.  
  1837. #ifdef CONFIG_MT9D115
  1838.  
  1839.  #if !defined(CONFIG_SENSOR_ADAPTER)
  1840.     {
  1841.         I2C_BOARD_INFO("mt9d115", 0x78 >> 1),
  1842.     },
  1843. #else
  1844.     //Do nothing
  1845. #endif
  1846. #endif
  1847.  
  1848. #ifdef CONFIG_MT9V113
  1849.     /*
  1850.      * Commented by zhang.shengjie
  1851.      *
  1852.      * Refer to drivers/media/video/msm/mt9v113.c
  1853.      * For MT9V113: 0.3Mp, 1/11-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  1854.      */
  1855.     {
  1856.         I2C_BOARD_INFO("mt9v113", 0x78 >> 1),
  1857.     },
  1858. #endif
  1859.  
  1860. #ifdef CONFIG_OV5642
  1861.     /*
  1862.      * Commented by zhang.shengjie
  1863.      *
  1864.      * Refer to drivers/media/video/msm/ov5642.c
  1865.      * For OV5642: 5.0Mp, 1/11-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  1866.      *
  1867.      * Attention: I2C device is initialized in sensor's driver if "CONFIG_SENSOR_ADAPTER"
  1868.      *            is defined
  1869.      */
  1870. #if !defined(CONFIG_SENSOR_ADAPTER)
  1871.     {
  1872.         I2C_BOARD_INFO("ov5642", 0x78 >> 1),
  1873.     },
  1874. #else
  1875.     //Do nothing
  1876. #endif
  1877. #endif
  1878.  
  1879.  
  1880. #ifdef CONFIG_OV5640
  1881.  
  1882. #if !defined(CONFIG_SENSOR_ADAPTER)
  1883.     {
  1884.         I2C_BOARD_INFO("ov5640", 0x78 >> 1),
  1885.     },
  1886. #else
  1887.     //Do nothing
  1888. #endif
  1889. #endif
  1890.  
  1891. //ZTE_TSSC_WLY_002,2010-05-10
  1892. #ifdef CONFIG_TOUCHSCREEN_SYNAPTICS_3K
  1893. {
  1894.         I2C_BOARD_INFO(SYNAPTICS_I2C_RMI4_NAME, TS_I2C_ADDR ),
  1895.         .irq = MSM_GPIO_TO_INT(GPIO_TS_IRQ),
  1896.         //.platform_data = touchscreen_power,
  1897.         .platform_data = &synaptics_ts_data,
  1898.     },
  1899. #endif
  1900. #ifdef CONFIG_TOUCHSCREEN_CYPRESS_I2C_RMI
  1901.     {
  1902.         .type         = "cypress_touch",
  1903.         /*.flags        = ,*/
  1904.         .addr         = 0x0a,
  1905.         .irq          = MSM_GPIO_TO_INT(29),
  1906.     },
  1907. #endif
  1908. //ZTE_TSSC_WLY_002,2010-05-10
  1909. //ZTE_TS_ZFJ_20110124 begin
  1910. #ifdef CONFIG_TOUCHSCREEN_FOCALTECH
  1911.     {
  1912.         .type         = "ft5x0x_ts",
  1913.         /*.flags        = ,*/
  1914.         .addr         = 0x3E,//0x38 ZTE_TS_ZFJ_20110125
  1915.         .irq          = MSM_GPIO_TO_INT(29),
  1916.     },
  1917. #endif
  1918. #ifdef CONFIG_TOUCHSCREEN_FOCALTECH_NEW//ZTE_TS_XYM_20110711
  1919.     {
  1920.         .type         = "ft5x0x_ts",
  1921.         /*.flags        = ,*/
  1922.         .addr         = 0x3E,
  1923.         .irq          = MSM_GPIO_TO_INT(29),
  1924.     },
  1925. #endif
  1926. //ZTE_TS_ZFJ_20110412 end
  1927. /*ZTE_TS_ZFJ_20110509 begin*/
  1928. #ifdef CONFIG_TOUCHSCREEN_MXT224
  1929.     {    
  1930.         I2C_BOARD_INFO(ATMEL_QT602240_NAME, 0x4a ),
  1931.         .platform_data = &atmel_data,
  1932.         .irq = MSM_GPIO_TO_INT(29),
  1933.     },  
  1934. #endif
  1935. /*ZTE_TS_ZFJ_20110509 end*/
  1936. //ZTE_TS_XYM_20110715 begin
  1937. #ifdef CONFIG_TOUCHSCREEN_CY8CTST241
  1938.     {    
  1939.         I2C_BOARD_INFO(CY_I2C_NAME, 0x24),
  1940.         .platform_data = &cypress_i2c_ttsp_platform_data,
  1941.     },  
  1942. #endif
  1943. //ZTE_TS_XYM_20110715 end
  1944.  
  1945. };
  1946.  
  1947. /*ZTE_AUX_FYA_001,@2010-02-06,BEGIN*/
  1948. static struct i2c_gpio_platform_data aux_i2c_gpio_data = {
  1949.     .sda_pin        = 93,
  1950.     .scl_pin        = 92,
  1951.     .sda_is_open_drain  = 1,
  1952.     .scl_is_open_drain  = 1,
  1953.     .udelay         = 40,
  1954. };
  1955.  
  1956. static struct platform_device aux_i2c_gpio_device = {
  1957.     .name       = "i2c-gpio",
  1958.     .id     = 1,
  1959.     .dev        = {
  1960.         .platform_data  = &aux_i2c_gpio_data
  1961.     },
  1962. };
  1963. /*ZTE_AUX_FYA_001,@2010-02-06,END*/
  1964.  
  1965. /*ZTE_AUX2_FYA_001,@2010-02-06,BEGIN*/
  1966. static struct i2c_gpio_platform_data aux2_i2c_gpio_data = {
  1967.     .sda_pin        = 109,
  1968.     .scl_pin        = 107,
  1969.     .sda_is_open_drain  = 0,
  1970.     .scl_is_open_drain  = 1,
  1971.     .udelay         = 2,
  1972. };
  1973.  
  1974. static struct platform_device aux2_i2c_gpio_device = {
  1975.     .name       = "i2c-gpio",
  1976.     .id     = 2,
  1977.     .dev        = {
  1978.         .platform_data  = &aux2_i2c_gpio_data
  1979.     },
  1980. };
  1981. /*ZTE_AUX2_FYA_001,@2010-02-06,BEGIN*/
  1982. #ifdef CONFIG_MSM_CAMERA
  1983. static uint32_t camera_off_gpio_table[] = {
  1984.     /* parallel CAMERA interfaces */
  1985.     /*
  1986.      * Commented by zh.shj
  1987.      *
  1988.      * Refer to drivers/media/video/msm/mt9v113.c
  1989.      * For MT9V113: 0.3Mp, 1/11-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  1990.      *
  1991.      * Refer to drivers/media/video/msm/mt9p111.c
  1992.      * For MT9P111: 5.0Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  1993.      *
  1994.      * GPIO: 0, 1, 2, and 3 are configured as "CAM30_PWRDN", "CAM500_PWRDN", "CAM500_RST", and "FM_RST"
  1995.      */  
  1996. #if 0
  1997.     GPIO_CFG(0,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT0 */
  1998.     GPIO_CFG(1,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT1 */
  1999.     GPIO_CFG(2,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT2 */
  2000.     GPIO_CFG(3,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT3 */
  2001.     GPIO_CFG(4,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT4 */
  2002.     GPIO_CFG(5,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT5 */
  2003.     GPIO_CFG(6,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT6 */
  2004.     GPIO_CFG(7,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT7 */
  2005.     GPIO_CFG(8,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT8 */
  2006.     GPIO_CFG(9,  0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT9 */
  2007.     GPIO_CFG(10, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT10 */
  2008.     GPIO_CFG(11, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT11 */
  2009.     GPIO_CFG(12, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* PCLK */
  2010.     GPIO_CFG(13, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* HSYNC_IN */
  2011.     GPIO_CFG(14, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* VSYNC_IN */
  2012.     GPIO_CFG(15, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA), /* MCLK */
  2013. #else
  2014.     GPIO_CFG(4,  0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_DATA <0> */
  2015.     GPIO_CFG(5,  0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_DATA <1> */
  2016.     GPIO_CFG(6,  0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_DATA <2> */
  2017.     GPIO_CFG(7,  0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_DATA <3> */
  2018.     GPIO_CFG(8,  0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_DATA <4> */
  2019.     GPIO_CFG(9,  0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_DATA <5> */
  2020.     GPIO_CFG(10, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_DATA <6> */
  2021.     GPIO_CFG(11, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_DATA <7> */
  2022.     GPIO_CFG(12, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_PCLK */
  2023.     GPIO_CFG(13, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_HSYNC */
  2024.     GPIO_CFG(14, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA), /* CIF_VSYNC */
  2025.     GPIO_CFG(15, 0, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_2MA),  /* CIF_MCLK */
  2026. #endif
  2027. };
  2028.  
  2029. static uint32_t camera_on_gpio_table[] = {
  2030.     /* parallel CAMERA interfaces */
  2031.     /*
  2032.      * Commented by zh.shj
  2033.      *
  2034.      * Refer to drivers/media/video/msm/mt9v113.c
  2035.      * For MT9V113: 0.3Mp, 1/11-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2036.      *
  2037.      * Refer to drivers/media/video/msm/mt9p111.c
  2038.      * For MT9P111: 5.0Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2039.      *
  2040.      * GPIO: 0, 1, 2, and 3 are configured as "CAM30_PWRDN", "CAM500_PWRDN", "CAM500_RST", and "FM_RST"
  2041.      */  
  2042. #if 0
  2043.     GPIO_CFG(0,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT0 */
  2044.     GPIO_CFG(1,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT1 */
  2045.     GPIO_CFG(2,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT2 */
  2046.     GPIO_CFG(3,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT3 */
  2047. #endif
  2048.     GPIO_CFG(4,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT4 */
  2049.     GPIO_CFG(5,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT5 */
  2050.     GPIO_CFG(6,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT6 */
  2051.     GPIO_CFG(7,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT7 */
  2052.     GPIO_CFG(8,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT8 */
  2053.     GPIO_CFG(9,  1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT9 */
  2054.     GPIO_CFG(10, 1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT10 */
  2055.     GPIO_CFG(11, 1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* DAT11 */
  2056.     GPIO_CFG(12, 1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_16MA), /* PCLK */
  2057.     GPIO_CFG(13, 1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* HSYNC_IN */
  2058.     GPIO_CFG(14, 1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), /* VSYNC_IN */
  2059.     GPIO_CFG(15, 1, GPIO_OUTPUT, GPIO_PULL_DOWN, GPIO_16MA), /* MCLK */
  2060. };
  2061.  
  2062. static void config_gpio_table(uint32_t *table, int len)
  2063. {
  2064.     int n, rc;
  2065.     for (n = 0; n < len; n++) {
  2066.         rc = gpio_tlmm_config(table[n], GPIO_ENABLE);
  2067.         if (rc) {
  2068.             printk(KERN_ERR "%s: gpio_tlmm_config(%#x)=%d\n",
  2069.                 __func__, table[n], rc);
  2070.             break;
  2071.         }
  2072.     }
  2073. }
  2074.  
  2075. static struct vreg *vreg_gp2;
  2076. static struct vreg *vreg_gp3;
  2077.  
  2078. static void msm_camera_vreg_config(int vreg_en)
  2079. {
  2080.     int rc;
  2081.  
  2082.     if (vreg_gp2 == NULL) {
  2083.         vreg_gp2 = vreg_get(NULL, "gp2");
  2084.         if (IS_ERR(vreg_gp2)) {
  2085.             printk(KERN_ERR "%s: vreg_get(%s) failed (%ld)\n",
  2086.                 __func__, "gp2", PTR_ERR(vreg_gp2));
  2087.             return;
  2088.         }
  2089.  
  2090.         rc = vreg_set_level(vreg_gp2, 1800);
  2091.         if (rc) {
  2092.             printk(KERN_ERR "%s: GP2 set_level failed (%d)\n",
  2093.                 __func__, rc);
  2094.         }
  2095.     }
  2096.  
  2097.     if (vreg_gp3 == NULL) {
  2098.         vreg_gp3 = vreg_get(NULL, "gp3");
  2099.         if (IS_ERR(vreg_gp3)) {
  2100.             printk(KERN_ERR "%s: vreg_get(%s) failed (%ld)\n",
  2101.                 __func__, "gp3", PTR_ERR(vreg_gp3));
  2102.             return;
  2103.         }
  2104.  
  2105.         rc = vreg_set_level(vreg_gp3, 2850);
  2106.         if (rc) {
  2107.             printk(KERN_ERR "%s: GP3 set level failed (%d)\n",
  2108.                 __func__, rc);
  2109.         }
  2110.     }
  2111.  
  2112.     if (vreg_en) {
  2113.         rc = vreg_enable(vreg_gp2);
  2114.         if (rc) {
  2115.             printk(KERN_ERR "%s: GP2 enable failed (%d)\n",
  2116.                  __func__, rc);
  2117.         }
  2118.  
  2119.         rc = vreg_enable(vreg_gp3);
  2120.         if (rc) {
  2121.             printk(KERN_ERR "%s: GP3 enable failed (%d)\n",
  2122.                 __func__, rc);
  2123.         }
  2124.     } else {
  2125.         rc = vreg_disable(vreg_gp2);
  2126.         if (rc) {
  2127.             printk(KERN_ERR "%s: GP2 disable failed (%d)\n",
  2128.                  __func__, rc);
  2129.         }
  2130.  
  2131.         rc = vreg_disable(vreg_gp3);
  2132.         if (rc) {
  2133.             printk(KERN_ERR "%s: GP3 disable failed (%d)\n",
  2134.                 __func__, rc);
  2135.         }
  2136.     }
  2137. }
  2138.  
  2139. static void config_camera_on_gpios(void)
  2140. {
  2141.     int vreg_en = 1;
  2142.  
  2143.     if (machine_is_msm7x25_ffa() ||
  2144.         machine_is_msm7x27_ffa())
  2145.         msm_camera_vreg_config(vreg_en);
  2146.  
  2147.     config_gpio_table(camera_on_gpio_table,
  2148.         ARRAY_SIZE(camera_on_gpio_table));
  2149.     //return 0;
  2150. }
  2151.  
  2152. static void config_camera_off_gpios(void)
  2153. {
  2154.     int vreg_en = 0;
  2155.  
  2156.     if (machine_is_msm7x25_ffa() ||
  2157.         machine_is_msm7x27_ffa())
  2158.         msm_camera_vreg_config(vreg_en);
  2159.  
  2160.     config_gpio_table(camera_off_gpio_table,
  2161.         ARRAY_SIZE(camera_off_gpio_table));
  2162. }
  2163.  
  2164. /*
  2165.  * Commented by zh.shj, ZTE_MSM_CAMERA_ZHSHJ_001
  2166.  *
  2167.  * Camera power setting for backend sensor, i.e., MT9T111/MT9T112/OV5642/ov5640
  2168.  * For MT9T111: 3.1Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2169.  * For MT9T112: 3.1Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2170.  */
  2171. #define MSM_CAMERA_POWER_BACKEND_DVDD_VAL       (1800)
  2172. #define MSM_CAMERA_POWER_BACKEND_IOVDD_VAL      (2600)
  2173. #define MSM_CAMERA_POWER_BACKEND_AVDD_VAL       (2800)
  2174. int32_t msm_camera_power_backend(enum msm_camera_pwr_mode_t pwr_mode)
  2175. {
  2176.     struct vreg *vreg_cam_dvdd  = NULL;
  2177.     struct vreg *vreg_cam_avdd  = NULL;
  2178.     struct vreg *vreg_cam_iovdd = NULL;
  2179.     int32_t rc_cam_dvdd, rc_cam_avdd, rc_cam_iovdd;
  2180.  
  2181.     CDBG("%s: entry\n", __func__);
  2182.  
  2183.     /*
  2184.       * Power-up Sequence according to datasheet of sensor:
  2185.       *
  2186.       * VREG_CAM_DVDD1V8  = VREG_GP2
  2187.       * VREG_CAM_IOVDD2V8 = VREG_MSMP
  2188.       * VREG_CAM_AVDD2V6  = VREG_GP3
  2189.       */
  2190.     vreg_cam_dvdd  = vreg_get(0, "gp2");
  2191.     vreg_cam_iovdd = vreg_get(0, "msmp");
  2192.     vreg_cam_avdd  = vreg_get(0, "gp3");
  2193.     if ((!vreg_cam_dvdd) || (!vreg_cam_iovdd) || (!vreg_cam_avdd))
  2194.     {
  2195.         CCRT("%s: vreg_get failed!\n", __func__);
  2196.         return -EIO;
  2197.     }
  2198.  
  2199.     switch (pwr_mode)
  2200.     {
  2201.         case MSM_CAMERA_PWRUP_MODE:
  2202.         {
  2203.             /* DVDD for both 5.0Mp and 3.0Mp camera on board-blade */
  2204.             rc_cam_dvdd = vreg_set_level(vreg_cam_dvdd, MSM_CAMERA_POWER_BACKEND_DVDD_VAL);
  2205.             if (rc_cam_dvdd)
  2206.             {
  2207.                 CCRT("%s: vreg_set_level failed!\n", __func__);
  2208.                 return -EIO;
  2209.             }
  2210.  
  2211.             rc_cam_dvdd = vreg_enable(vreg_cam_dvdd);
  2212.             if (rc_cam_dvdd)
  2213.             {
  2214.                 CCRT("%s: vreg_enable failed!\n", __func__);
  2215.                 return -EIO;
  2216.             }
  2217.  
  2218.             mdelay(1);
  2219.  
  2220.             rc_cam_iovdd = vreg_set_level(vreg_cam_iovdd, MSM_CAMERA_POWER_BACKEND_IOVDD_VAL);
  2221.             if (rc_cam_iovdd)
  2222.             {
  2223.                 CCRT("%s: vreg_set_level failed!\n", __func__);
  2224.                 return -EIO;
  2225.             }
  2226.  
  2227.             rc_cam_iovdd = vreg_enable(vreg_cam_iovdd);
  2228.             if (rc_cam_iovdd)
  2229.             {
  2230.                 CCRT("%s: vreg_enable failed!\n", __func__);
  2231.                 return -EIO;
  2232.             }
  2233.  
  2234.             mdelay(2);
  2235.  
  2236.             /*
  2237.                * AVDD for both 5.0Mp and 3.0Mp camera on board-blade
  2238.                * AVDD and VCM are connected together on board-blade
  2239.                */
  2240.             rc_cam_avdd = vreg_set_level(vreg_cam_avdd, MSM_CAMERA_POWER_BACKEND_AVDD_VAL);
  2241.             if (rc_cam_avdd)
  2242.             {
  2243.                 CCRT("%s: vreg_set_level failed!\n", __func__);
  2244.                 return -EIO;
  2245.             }
  2246.  
  2247.             rc_cam_avdd = vreg_enable(vreg_cam_avdd);
  2248.             if (rc_cam_avdd)
  2249.             {
  2250.                 CCRT("%s: vreg_enable failed!\n", __func__);
  2251.                 return -EIO;
  2252.             }
  2253.  
  2254.             mdelay(500);
  2255.  
  2256.             break;
  2257.         }
  2258.         case MSM_CAMERA_STANDBY_MODE:
  2259.         {
  2260.             rc_cam_avdd  = vreg_disable(vreg_cam_avdd);
  2261.             if (rc_cam_avdd)
  2262.             {
  2263.                 CCRT("%s: vreg_disable failed!\n", __func__);
  2264.                 return -EIO;
  2265.             }
  2266.  
  2267.             break;
  2268.         }
  2269.         case MSM_CAMERA_NORMAL_MODE:
  2270.         {
  2271.             /*
  2272.                * AVDD and VCM are connected together on board-blade
  2273.                */
  2274.             rc_cam_avdd = vreg_set_level(vreg_cam_avdd, MSM_CAMERA_POWER_BACKEND_AVDD_VAL);
  2275.             if (rc_cam_avdd)
  2276.             {
  2277.                 CCRT("%s: vreg_set_level failed!\n", __func__);
  2278.                 return -EIO;
  2279.             }
  2280.  
  2281.             rc_cam_avdd = vreg_enable(vreg_cam_avdd);
  2282.             if (rc_cam_avdd)
  2283.             {
  2284.                 CCRT("%s: vreg_enable failed!\n", __func__);
  2285.                 return -EIO;
  2286.             }
  2287.  
  2288.             mdelay(100);
  2289.  
  2290.             break;
  2291.         }
  2292.         case MSM_CAMERA_PWRDWN_MODE:
  2293.         {
  2294.             /*
  2295.                * Attention: DVDD, AVDD, or MOTORVDD may be used by other devices
  2296.                */
  2297.             rc_cam_dvdd  = vreg_disable(vreg_cam_dvdd);
  2298.             rc_cam_avdd  = vreg_disable(vreg_cam_avdd);
  2299.             if ((rc_cam_dvdd) || (rc_cam_avdd))
  2300.             {
  2301.                 CCRT("%s: vreg_disable failed!\n", __func__);
  2302.                 return -EIO;
  2303.             }
  2304.  
  2305.             break;
  2306.         }
  2307.         default:
  2308.         {
  2309.             CCRT("%s: parameter not supported!\n", __func__);
  2310.             return -EIO;
  2311.         }
  2312.     }
  2313.  
  2314.     return 0;
  2315. }
  2316.  
  2317. /*
  2318.  * Commented by zh.shj
  2319.  *
  2320.  * Camera power setting for frontend sensor, i.e., MT9V113
  2321.  * For MT9V113: 0.3Mp, 1/11-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2322.  */
  2323. #define MSM_CAMERA_POWER_FRONTEND_DVDD_VAL       (1800)
  2324. #define MSM_CAMERA_POWER_FRONTEND_IOVDD_VAL      (2800)
  2325. #define MSM_CAMERA_POWER_FRONTEND_AVDD_VAL       (2600)
  2326. int32_t msm_camera_power_frontend(enum msm_camera_pwr_mode_t pwr_mode)
  2327. {
  2328.     struct vreg *vreg_cam_dvdd  = NULL;
  2329.     struct vreg *vreg_cam_avdd  = NULL;
  2330.     struct vreg *vreg_cam_iovdd = NULL;
  2331.     int32_t rc_cam_dvdd, rc_cam_avdd, rc_cam_iovdd;
  2332.  
  2333.     CDBG("%s: entry\n", __func__);
  2334.  
  2335.     /*
  2336.       * Power-up Sequence according to datasheet of sensor:
  2337.       *
  2338.       * VREG_CAM_DVDD1V8 = VREG_GP2
  2339.       * VREG_CAM30_2V8   = VREG_GP4
  2340.       * VREG_CAM_AVDD2V6 = VREG_GP3
  2341.       */
  2342.     vreg_cam_dvdd  = vreg_get(0, "gp2");
  2343.     vreg_cam_iovdd = vreg_get(0, "gp4");
  2344.     vreg_cam_avdd  = vreg_get(0, "gp3");
  2345.     if ((!vreg_cam_dvdd) || (!vreg_cam_iovdd) || (!vreg_cam_avdd))
  2346.     {
  2347.         CCRT("%s: vreg_get failed!\n", __func__);
  2348.         return -EIO;
  2349.     }
  2350.  
  2351.     switch (pwr_mode)
  2352.     {
  2353.         case MSM_CAMERA_PWRUP_MODE:
  2354.         {
  2355.             rc_cam_dvdd = vreg_set_level(vreg_cam_dvdd, MSM_CAMERA_POWER_FRONTEND_DVDD_VAL);
  2356.             if (rc_cam_dvdd)
  2357.             {
  2358.                 CCRT("%s: vreg_set_level failed!\n", __func__);
  2359.                 return -EIO;
  2360.             }
  2361.  
  2362.             rc_cam_dvdd = vreg_enable(vreg_cam_dvdd);
  2363.             if (rc_cam_dvdd)
  2364.             {
  2365.                 CCRT("%s: vreg_enable failed!\n", __func__);
  2366.                 return -EIO;
  2367.             }
  2368.  
  2369.             mdelay(1);
  2370.  
  2371.             rc_cam_iovdd = vreg_set_level(vreg_cam_iovdd, MSM_CAMERA_POWER_FRONTEND_IOVDD_VAL);
  2372.             if (rc_cam_iovdd)
  2373.             {
  2374.                 CCRT("%s: vreg_set_level failed!\n", __func__);
  2375.                 return -EIO;
  2376.             }
  2377.  
  2378.             rc_cam_iovdd = vreg_enable(vreg_cam_iovdd);
  2379.             if (rc_cam_iovdd)
  2380.             {
  2381.                 CCRT("%s: vreg_enable failed!\n", __func__);
  2382.                 return -EIO;
  2383.             }
  2384.  
  2385.             mdelay(2);
  2386.  
  2387.             rc_cam_avdd = vreg_set_level(vreg_cam_avdd, MSM_CAMERA_POWER_FRONTEND_AVDD_VAL);
  2388.             if (rc_cam_avdd)
  2389.             {
  2390.                 CCRT("%s: vreg_set_level failed!\n", __func__);
  2391.                 return -EIO;
  2392.             }
  2393.  
  2394.             rc_cam_avdd = vreg_enable(vreg_cam_avdd);
  2395.             if (rc_cam_avdd)
  2396.             {
  2397.                 CCRT("%s: vreg_enable failed!\n", __func__);
  2398.                 return -EIO;
  2399.             }
  2400.  
  2401.             mdelay(500);
  2402.  
  2403.             break;
  2404.         }
  2405.         case MSM_CAMERA_STANDBY_MODE:
  2406.         {
  2407.             CCRT("%s: MSM_CAMERA_STANDBY_MODE not supported!\n", __func__);
  2408.             return -EIO;
  2409.         }
  2410.         case MSM_CAMERA_NORMAL_MODE:
  2411.         {
  2412.             CCRT("%s: MSM_CAMERA_NORMAL_MODE not supported!\n", __func__);
  2413.             return -EIO;
  2414.         }
  2415.         case MSM_CAMERA_PWRDWN_MODE:
  2416.         {
  2417.             rc_cam_dvdd  = vreg_disable(vreg_cam_dvdd);
  2418.             rc_cam_iovdd = vreg_disable(vreg_cam_iovdd);
  2419.             rc_cam_avdd  = vreg_disable(vreg_cam_avdd);
  2420.             if ((rc_cam_dvdd) || (rc_cam_iovdd) || (rc_cam_avdd))
  2421.             {
  2422.                 CCRT("%s: vreg_disable failed!\n", __func__);
  2423.                 return -EIO;
  2424.             }
  2425.  
  2426.             break;
  2427.         }
  2428.         default:
  2429.         {
  2430.             CCRT("%s: parameter not supported!\n", __func__);
  2431.             return -EIO;
  2432.         }
  2433.     }
  2434.  
  2435.     return 0;
  2436. }
  2437.  
  2438. /*
  2439.  * Commented by zh.shj
  2440.  *
  2441.  * Camera clock switch for both frontend and backend sensors, i.e., MT9V113 and MT9P111
  2442.  *
  2443.  * For MT9V113: 0.3Mp, 1/11-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2444.  * For MT9P111: 5.0Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2445.  *
  2446.  * switch_val: 0, to switch clock to frontend sensor, i.e., MT9V113, or
  2447.  *             1, to switch clock to backend sensor, i.e., MT9P111
  2448.  */
  2449. int msm_camera_clk_switch(const struct msm_camera_sensor_info *data,
  2450.                                   uint32_t gpio_switch,
  2451.                                   uint32_t switch_val)
  2452. {
  2453.     int rc;
  2454.  
  2455.     CDBG("%s: entry\n", __func__);
  2456.  
  2457.     rc = gpio_request(gpio_switch, data->sensor_name);
  2458.     if (0 == rc)
  2459.     {
  2460.         /* ignore "rc" */
  2461.         rc = gpio_direction_output(gpio_switch, switch_val);
  2462.  
  2463.         /* time delay */
  2464.         mdelay(1);
  2465.     }
  2466.  
  2467.     gpio_free(gpio_switch);
  2468.  
  2469.     return rc;
  2470. }
  2471.  
  2472. static struct msm_camera_device_platform_data msm_camera_device_data = {
  2473.     .camera_gpio_on  = config_camera_on_gpios,
  2474.     .camera_gpio_off = config_camera_off_gpios,
  2475.     .ioext.mdcphy = MSM_MDC_PHYS,
  2476.     .ioext.mdcsz  = MSM_MDC_SIZE,
  2477.     .ioext.appphy = MSM_CLK_CTL_PHYS,
  2478.     .ioext.appsz  = MSM_CLK_CTL_SIZE,
  2479. };
  2480.  
  2481. static struct msm_camera_sensor_flash_src msm_flash_src = {
  2482.     .flash_sr_type = MSM_CAMERA_FLASH_SRC_PMIC,
  2483.     ._fsrc.pmic_src.low_current  = 30,
  2484.     ._fsrc.pmic_src.high_current = 100,
  2485. };
  2486.  
  2487. #ifdef CONFIG_MT9D112
  2488. static struct msm_camera_sensor_flash_data flash_mt9d112 = {
  2489.     .flash_type = MSM_CAMERA_FLASH_LED,
  2490.     .flash_src  = &msm_flash_src
  2491. };
  2492.  
  2493. static struct msm_camera_sensor_info msm_camera_sensor_mt9d112_data = {
  2494.     .sensor_name    = "mt9d112",
  2495.     .sensor_reset   = 89,
  2496.     .sensor_pwd     = 85,
  2497.     .vcm_pwd        = 0,
  2498.     .vcm_enable     = 0,
  2499.     .pdata          = &msm_camera_device_data,
  2500.     .flash_data     = &flash_mt9d112
  2501. };
  2502.  
  2503. static struct platform_device msm_camera_sensor_mt9d112 = {
  2504.     .name      = "msm_camera_mt9d112",
  2505.     .dev       = {
  2506.         .platform_data = &msm_camera_sensor_mt9d112_data,
  2507.     },
  2508. };
  2509. #endif
  2510.  
  2511. #ifdef CONFIG_S5K3E2FX
  2512. static struct msm_camera_sensor_flash_data flash_s5k3e2fx = {
  2513.     .flash_type = MSM_CAMERA_FLASH_LED,
  2514.     .flash_src  = &msm_flash_src
  2515. };
  2516.  
  2517. static struct msm_camera_sensor_info msm_camera_sensor_s5k3e2fx_data = {
  2518.     .sensor_name    = "s5k3e2fx",
  2519.     .sensor_reset   = 89,
  2520.     .sensor_pwd     = 85,
  2521.     .vcm_pwd        = 0,
  2522.     .vcm_enable     = 0,
  2523.     .pdata          = &msm_camera_device_data,
  2524.     .flash_data     = &flash_s5k3e2fx
  2525. };
  2526.  
  2527. static struct platform_device msm_camera_sensor_s5k3e2fx = {
  2528.     .name      = "msm_camera_s5k3e2fx",
  2529.     .dev       = {
  2530.         .platform_data = &msm_camera_sensor_s5k3e2fx_data,
  2531.     },
  2532. };
  2533. #endif
  2534.  
  2535. #ifdef CONFIG_MT9P012
  2536. static struct msm_camera_sensor_flash_data flash_mt9p012 = {
  2537.     .flash_type = MSM_CAMERA_FLASH_LED,
  2538.     .flash_src  = &msm_flash_src
  2539. };
  2540.  
  2541. static struct msm_camera_sensor_info msm_camera_sensor_mt9p012_data = {
  2542.     .sensor_name    = "mt9p012",
  2543.     .sensor_reset   = 89,
  2544.     .sensor_pwd     = 85,
  2545.     .vcm_pwd        = 88,
  2546.     .vcm_enable     = 0,
  2547.     .pdata          = &msm_camera_device_data,
  2548.     .flash_data     = &flash_mt9p012
  2549. };
  2550.  
  2551. static struct platform_device msm_camera_sensor_mt9p012 = {
  2552.     .name      = "msm_camera_mt9p012",
  2553.     .dev       = {
  2554.         .platform_data = &msm_camera_sensor_mt9p012_data,
  2555.     },
  2556. };
  2557. #endif
  2558.  
  2559. #ifdef CONFIG_MT9P012_KM
  2560. static struct msm_camera_sensor_flash_data flash_mt9p012_km = {
  2561.     .flash_type = MSM_CAMERA_FLASH_LED,
  2562.     .flash_src  = &msm_flash_src
  2563. };
  2564.  
  2565. static struct msm_camera_sensor_info msm_camera_sensor_mt9p012_km_data = {
  2566.     .sensor_name    = "mt9p012_km",
  2567.     .sensor_reset   = 89,
  2568.     .sensor_pwd     = 85,
  2569.     .vcm_pwd        = 88,
  2570.     .vcm_enable     = 0,
  2571.     .pdata          = &msm_camera_device_data,
  2572.     .flash_data     = &flash_mt9p012_km
  2573. };
  2574.  
  2575. static struct platform_device msm_camera_sensor_mt9p012_km = {
  2576.     .name      = "msm_camera_mt9p012_km",
  2577.     .dev       = {
  2578.         .platform_data = &msm_camera_sensor_mt9p012_km_data,
  2579.     },
  2580. };
  2581. #endif
  2582.  
  2583. #ifdef CONFIG_MT9T013
  2584. static struct msm_camera_sensor_flash_data flash_mt9t013 = {
  2585.     .flash_type = MSM_CAMERA_FLASH_LED,
  2586.     .flash_src  = &msm_flash_src
  2587. };
  2588.  
  2589. static struct msm_camera_sensor_info msm_camera_sensor_mt9t013_data = {
  2590.     .sensor_name    = "mt9t013",
  2591.     .sensor_reset   = 89,
  2592.     .sensor_pwd     = 85,
  2593.     .vcm_pwd        = 0,
  2594.     .vcm_enable     = 0,
  2595.     .pdata          = &msm_camera_device_data,
  2596.     .flash_data     = &flash_mt9t013
  2597. };
  2598.  
  2599. static struct platform_device msm_camera_sensor_mt9t013 = {
  2600.     .name      = "msm_camera_mt9t013",
  2601.     .dev       = {
  2602.         .platform_data = &msm_camera_sensor_mt9t013_data,
  2603.     },
  2604. };
  2605. #endif
  2606.  
  2607. #ifdef CONFIG_VB6801
  2608. static struct msm_camera_sensor_flash_data flash_vb6801 = {
  2609.     .flash_type = MSM_CAMERA_FLASH_LED,
  2610.     .flash_src  = &msm_flash_src
  2611. };
  2612.  
  2613. static struct msm_camera_sensor_info msm_camera_sensor_vb6801_data = {
  2614.     .sensor_name    = "vb6801",
  2615.     .sensor_reset   = 89,
  2616.     .sensor_pwd     = 88,
  2617.     .vcm_pwd        = 0,
  2618.     .vcm_enable     = 0,
  2619.     .pdata          = &msm_camera_device_data,
  2620.     .flash_data     = &flash_vb6801
  2621. };
  2622.  
  2623. static struct platform_device msm_camera_sensor_vb6801 = {
  2624.     .name      = "msm_camera_vb6801",
  2625.     .dev       = {
  2626.         .platform_data = &msm_camera_sensor_vb6801_data,
  2627.     },
  2628. };
  2629. #endif
  2630. #ifdef CONFIG_MT9P111
  2631. /*
  2632.  * Commented by zhang.shengjie
  2633.  *
  2634.  * Refer to drivers/media/video/msm/mt9p111.c
  2635.  * For MT9P111: 5.0Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2636.  *
  2637.  * ".vcm_pwd" are DISUSED
  2638.  */
  2639.  
  2640. /* CHG_CAM_20100401
  2641.  * Commented by chg
  2642.  * merge 5320 for camera flash.
  2643.  */
  2644. static struct msm_camera_sensor_flash_data flash_mt9p111 = {
  2645.     .flash_type = MSM_CAMERA_FLASH_NONE,
  2646.     .flash_src  = &msm_flash_src
  2647. };
  2648.  
  2649. static struct msm_camera_sensor_info msm_camera_sensor_mt9p111_data = {
  2650.     .sensor_name    = "mt9p111",
  2651.     .sensor_reset   = 2,
  2652.     .sensor_pwd     = 1,
  2653.     .vcm_pwd        = 0,
  2654.     .vcm_enable     = 0,
  2655.     .pdata          = &msm_camera_device_data,
  2656.     .flash_data     = &flash_mt9p111
  2657. };
  2658.  
  2659. static struct platform_device msm_camera_sensor_mt9p111 = {
  2660.     .name      = "msm_camera_mt9p111",
  2661.     .dev       = {
  2662.         .platform_data = &msm_camera_sensor_mt9p111_data,
  2663.     },
  2664. };
  2665. #endif
  2666.  
  2667. #ifdef CONFIG_MT9T11X
  2668. /*
  2669.  * Commented by zhang.shengjie, ZTE_MSM_CAMERA_ZHSHJ_001
  2670.  *
  2671.  * Refer to drivers/media/video/msm/mt9t11x.c
  2672.  * For MT9T111: 3.1Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2673.  * For MT9T112: 3.1Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2674.  *
  2675.  * ".vcm_pwd" are DISUSED
  2676.  */
  2677.  
  2678. /* CHG_CAM_20100401
  2679.  * Commented by chg
  2680.  * merge 5320 for camera flash.
  2681.  */
  2682. static struct msm_camera_sensor_flash_data flash_mt9t11x = {
  2683.     .flash_type = MSM_CAMERA_FLASH_NONE,
  2684.     .flash_src  = &msm_flash_src
  2685. };
  2686.  
  2687. static struct msm_camera_sensor_info msm_camera_sensor_mt9t11x_data = {
  2688.     .sensor_name    = "mt9t11x",
  2689.     .sensor_reset   = 2,
  2690.     .sensor_pwd     = 1,
  2691.     .vcm_pwd        = 0,
  2692.     .vcm_enable     = 0,
  2693.     .pdata          = &msm_camera_device_data,
  2694.     .flash_data     = &flash_mt9t11x
  2695. };
  2696.  
  2697. static struct platform_device msm_camera_sensor_mt9t11x = {
  2698.     .name      = "msm_camera_mt9t11x",
  2699.     .dev       = {
  2700.         .platform_data = &msm_camera_sensor_mt9t11x_data,
  2701.     },
  2702. };
  2703. #endif
  2704.  
  2705. #ifdef CONFIG_MT9D115
  2706. /*
  2707.  * add by ZTE_CAMERA_LIJING_20100629 for MT9D115-2.0Mp-FF-Socket
  2708.  */
  2709. static struct msm_camera_sensor_flash_data flash_mt9d115 = {
  2710.     .flash_type = MSM_CAMERA_FLASH_NONE,
  2711.     .flash_src  = &msm_flash_src
  2712. };
  2713.  
  2714. static struct msm_camera_sensor_info msm_camera_sensor_mt9d115_data = {
  2715.     .sensor_name    = "mt9d115",
  2716.     .sensor_reset   = 2,
  2717.     .sensor_pwd     = 1,
  2718.     .vcm_pwd        = 0,
  2719.     .vcm_enable     = 0,
  2720.     .pdata          = &msm_camera_device_data,
  2721.     .flash_data     = &flash_mt9d115
  2722. };
  2723.  
  2724. static struct platform_device msm_camera_sensor_mt9d115 = {
  2725.     .name      = "msm_camera_mt9d115",
  2726.     .dev       = {
  2727.         .platform_data = &msm_camera_sensor_mt9d115_data,
  2728.     },
  2729. };
  2730. #endif
  2731.  
  2732. #ifdef CONFIG_MT9V113
  2733. /*
  2734.  * Commented by zhang.shengjie
  2735.  *
  2736.  * Refer to drivers/media/video/msm/mt9v113.c
  2737.  * For MT9V113: 0.3Mp, 1/11-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2738.  */
  2739.  
  2740. /* CHG_CAM_20100401
  2741.  * Commented by chg
  2742.  * merge 5320 for camera flash.
  2743.  */
  2744. static struct msm_camera_sensor_flash_data flash_mt9v113 = {
  2745.     .flash_type = MSM_CAMERA_FLASH_NONE,
  2746.     .flash_src  = &msm_flash_src
  2747. };
  2748.  
  2749. static struct msm_camera_sensor_info msm_camera_sensor_mt9v113_data = {
  2750.     .sensor_name    = "mt9v113",
  2751.     .sensor_reset   = 0,
  2752.     .sensor_pwd     = 0,
  2753.     .vcm_pwd        = 0,
  2754.     .vcm_enable     = 0,
  2755.     .pdata          = &msm_camera_device_data,
  2756.     .flash_data     = &flash_mt9v113
  2757. };
  2758.  
  2759. static struct platform_device msm_camera_sensor_mt9v113 = {
  2760.     .name      = "msm_camera_mt9v113",
  2761.     .dev       = {
  2762.         .platform_data = &msm_camera_sensor_mt9v113_data,
  2763.     },
  2764. };
  2765. #endif
  2766.  
  2767. #ifdef CONFIG_OV5642
  2768. /*
  2769.  * Commented by zhang.shengjie
  2770.  *
  2771.  * Refer to drivers/media/video/msm/ov5642.c
  2772.  * For OV5642: 5.0Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  2773.  *
  2774.  * ".vcm_pwd" are DISUSED
  2775.  */
  2776.  
  2777. /* CHG_CAM_20100401
  2778.  * Commented by chg
  2779.  * merge 5320 for camera flash.
  2780.  */
  2781. static struct msm_camera_sensor_flash_data flash_ov5642 = {
  2782.     .flash_type = MSM_CAMERA_FLASH_NONE,
  2783.     .flash_src  = &msm_flash_src
  2784. };
  2785.  
  2786. static struct msm_camera_sensor_info msm_camera_sensor_ov5642_data = {
  2787.     .sensor_name    = "ov5642",
  2788.     .sensor_reset   = 2,
  2789.     .sensor_pwd     = 1,
  2790.     .vcm_pwd        = 0,
  2791.     .vcm_enable     = 0,
  2792.     .pdata          = &msm_camera_device_data,
  2793.     .flash_data     = &flash_ov5642
  2794. };
  2795.  
  2796. static struct platform_device msm_camera_sensor_ov5642 = {
  2797.     .name      = "msm_camera_ov5642",
  2798.     .dev       = {
  2799.         .platform_data = &msm_camera_sensor_ov5642_data,
  2800.     },
  2801. };
  2802. #endif
  2803.  
  2804. #ifdef CONFIG_OV5640
  2805.  
  2806.  
  2807.  
  2808. static struct msm_camera_sensor_flash_data flash_ov5640 = {
  2809.     .flash_type = MSM_CAMERA_FLASH_NONE,
  2810.     .flash_src  = &msm_flash_src
  2811. };
  2812.  
  2813. static struct msm_camera_sensor_info msm_camera_sensor_ov5640_data = {
  2814.     .sensor_name    = "ov5640",
  2815.     .sensor_reset   = 2,
  2816.     .sensor_pwd     = 1,
  2817.     .vcm_pwd        = 0,
  2818.     .vcm_enable     = 0,
  2819.     .pdata          = &msm_camera_device_data,
  2820.     .flash_data     = &flash_ov5640
  2821. };
  2822.  
  2823. static struct platform_device msm_camera_sensor_ov5640 = {
  2824.     .name      = "msm_camera_ov5640",
  2825.     .dev       = {
  2826.         .platform_data = &msm_camera_sensor_ov5640_data,
  2827.     },
  2828. };
  2829. #endif
  2830.  
  2831.  
  2832. #endif
  2833.  
  2834. /*ZTE_TSSC_ZT_004,@2010-01-27,BEGIN*/
  2835. /*ZTE_TSSC_WLY_001, @2010-04-13,BEGIN*/
  2836. /*add touchsreen size definition for mooncake.  QVGA*/
  2837. #if defined( CONFIG_TOUCHSCREEN_MSM_LEGACY)
  2838. struct msm_ts_platform_data msm_tssc_pdata ={
  2839.     .x_max = 239,
  2840.     .y_max = 319,
  2841.     .pressure_max =255,
  2842. };
  2843. #elif defined( CONFIG_TOUCHSCREEN_MSM)
  2844. struct msm_ts_platform_data msm_tssc_pdata = {
  2845.     .min_x = 0,
  2846.     .max_x = 239,
  2847.     .min_y = 0,
  2848.     .max_y = 319,
  2849.     .min_press =0,
  2850.     .max_press =255,
  2851.     .inv_y = 955,
  2852. };
  2853. #endif
  2854. /*ZTE_TSSC_WLY_001, @2010-04-13,END*/
  2855. /*ZTE_TSSC_ZT_004,@2010-01-27,END*/
  2856.  
  2857.  
  2858. #if 0
  2859. static u32 msm_calculate_batt_capacity(u32 current_voltage);
  2860.  
  2861. static struct msm_psy_batt_pdata msm_psy_batt_data = {
  2862.     .voltage_min_design     = 2800,
  2863.     .voltage_max_design = 4300,
  2864.     .avail_chg_sources      = AC_CHG | USB_CHG ,
  2865.     .batt_technology        = POWER_SUPPLY_TECHNOLOGY_LION,
  2866.     .calculate_capacity = &msm_calculate_batt_capacity,
  2867. };
  2868.  
  2869. static u32 msm_calculate_batt_capacity(u32 current_voltage)
  2870. {
  2871.     u32 low_voltage   = msm_psy_batt_data.voltage_min_design;
  2872.     u32 high_voltage  = msm_psy_batt_data.voltage_max_design;
  2873.  
  2874.     return (current_voltage - low_voltage) * 100
  2875.         / (high_voltage - low_voltage);
  2876. }
  2877.  
  2878. static struct platform_device msm_batt_device = {
  2879.     .name           = "msm-battery",
  2880.     .id         = -1,
  2881.     .dev.platform_data  = &msm_psy_batt_data,
  2882. };
  2883. #else
  2884. static u32 msm_calculate_batt_capacity(u32 current_voltage);
  2885.  
  2886. typedef struct
  2887. {
  2888.     u32 voltage;
  2889.     u32 capacity;
  2890. } BattFuelCapacity;
  2891.  
  2892. static const BattFuelCapacity fuelCapacity[] = {
  2893.    {3388, 0},                      /*   0% */
  2894.    {3500, 10},                     /*  10%,3580 is 15% when 3660 is 20 */
  2895.    {3660, 20},                     /*  20% */
  2896.    {3710, 30},                     /*  30% */
  2897.    {3761, 40},                     /*  40% */
  2898.    {3801, 50},                     /*  50% */
  2899.    {3842, 60},                     /*  60% */
  2900.    {3909, 70},                     /*  70% */
  2901.    {3977, 80},                     /*  80% */
  2902.    {4066, 90},                     /*  90% */
  2903.    {4150, 100}                     /* 100% */
  2904. };
  2905.  
  2906. static struct msm_psy_batt_pdata msm_psy_batt_data = {
  2907.     .voltage_min_design     = 2800,
  2908.     .voltage_max_design = 4300,
  2909.     .avail_chg_sources      = AC_CHG | USB_CHG ,
  2910.     .batt_technology        = POWER_SUPPLY_TECHNOLOGY_LION,
  2911.     .calculate_capacity = &msm_calculate_batt_capacity,
  2912. };
  2913.  
  2914. static u32 msm_calculate_batt_capacity(u32 current_voltage)
  2915. {
  2916.     u8 step = sizeof(fuelCapacity)/sizeof(BattFuelCapacity);
  2917.     u8 table_count;
  2918.  
  2919.     if (current_voltage <= fuelCapacity[0].voltage)
  2920.     {
  2921.         return 0;
  2922.     }
  2923.     else if (current_voltage >= fuelCapacity[step-1].voltage)
  2924.     {
  2925.         return 100;
  2926.     }
  2927.     else
  2928.     {    
  2929.         for (table_count = 1; table_count< step; table_count++)
  2930.         {
  2931.             if (current_voltage <= fuelCapacity[table_count].voltage)
  2932.             {
  2933.                 return (fuelCapacity[table_count-1].capacity
  2934.                     + ((current_voltage - fuelCapacity[table_count-1].voltage)*10
  2935.                     /(fuelCapacity[table_count].voltage -
  2936.                     fuelCapacity[table_count-1].voltage)));
  2937.             }
  2938.         }
  2939.     }
  2940.  
  2941.     printk("%s: error\n", __func__);
  2942.     return 0;
  2943. }
  2944.  
  2945. static struct platform_device msm_batt_device = {
  2946.     .name           = "msm-battery",
  2947.     .id         = -1,
  2948.     .dev.platform_data  = &msm_psy_batt_data,
  2949. };
  2950.  
  2951. #endif
  2952.  
  2953. #ifdef CONFIG_ANDROID_RAM_CONSOLE
  2954. static struct resource ram_console_resource[] = {
  2955.     {
  2956.         .start  = MSM_RAM_CONSOLE_PHYS,
  2957.         .end    = MSM_RAM_CONSOLE_PHYS + MSM_RAM_CONSOLE_SIZE - 1,
  2958.         .flags  = IORESOURCE_MEM,
  2959.     },
  2960. };
  2961.  
  2962. static struct platform_device ram_console_device = {
  2963.     .name = "ram_console",
  2964.     .id = -1,
  2965.     .num_resources  = ARRAY_SIZE(ram_console_resource),
  2966.     .resource       = ram_console_resource,
  2967. };
  2968. #endif
  2969. //ZTE_WIFI_OYHQ_20100714 wifi froyo upgrade begin
  2970. /* ATHENV */
  2971. static struct platform_device msm_wlan_ar6000_pm_device = {
  2972.     .name       = "wlan_ar6000_pm_dev",
  2973.     .id     = 1,
  2974.     .num_resources  = 0,
  2975.     .resource   = NULL,
  2976. };
  2977. /* ATHENV */
  2978. //ZTE_WIFI_OYHQ_20100714 wifi froyo upgrade end
  2979. static struct platform_device *early_devices[] __initdata = {
  2980. #ifdef CONFIG_GPIOLIB
  2981.     &msm_gpio_devices[0],
  2982.     &msm_gpio_devices[1],
  2983.     &msm_gpio_devices[2],
  2984.     &msm_gpio_devices[3],
  2985.     &msm_gpio_devices[4],
  2986.     &msm_gpio_devices[5],
  2987. #endif
  2988. };
  2989.  
  2990. static struct platform_device *devices[] __initdata = {
  2991. //ZTE_WIFI_OYHQ_20100714 wifi froyo upgrade begin
  2992.     /* ATHENV */
  2993.     /*
  2994.      * It is necessary to put here in order to support WoW.
  2995.      * Put it before MMC host controller in worst case
  2996.      */
  2997.     &msm_wlan_ar6000_pm_device,
  2998. /* ATHENV */
  2999. //ZTE_WIFI_OYHQ_20100714 wifi froyo upgrade end
  3000. #if !defined(CONFIG_MSM_SERIAL_DEBUGGER)
  3001.     &msm_device_uart3,
  3002. #endif
  3003.     &msm_device_smd,
  3004.     &msm_device_dmov,
  3005.     &msm_device_nand,
  3006.  
  3007. #ifdef CONFIG_USB_MSM_OTG_72K
  3008.     &msm_device_otg,
  3009. #ifdef CONFIG_USB_GADGET
  3010.     &msm_device_gadget_peripheral,
  3011. #endif
  3012. #endif
  3013.  
  3014. #ifdef CONFIG_USB_FUNCTION
  3015.     &msm_device_hsusb_peripheral,
  3016.     &mass_storage_device,
  3017. #endif
  3018.  
  3019. #ifdef CONFIG_USB_ANDROID
  3020.     &usb_mass_storage_device,
  3021.     &rndis_device,
  3022. #ifdef CONFIG_USB_ANDROID_DIAG
  3023.     &usb_diag_device,
  3024. #endif
  3025.     &android_usb_device,
  3026. #endif
  3027.  
  3028.     &msm_device_i2c,
  3029. /*ZTE_AUX_FYA_001,@2010-02-06,BEGIN*/
  3030.     &aux_i2c_gpio_device,  
  3031. /*ZTE_AUX_FYA_001,@2010-02-06,END*/
  3032. /*ZTE_AUX2_FYA_001,@2010-02-06,BEGIN*/
  3033.     &aux2_i2c_gpio_device,  
  3034. /*ZTE_AUX2_FYA_001,@2010-02-06,END*/
  3035.     &smc91x_device,
  3036. /*ZTE_TSSC_WLY_001, @2010-04-13,BEGIN*/
  3037. #if defined( CONFIG_TOUCHSCREEN_MSM_LEGACY) || defined( CONFIG_TOUCHSCREEN_MSM)
  3038.     &msm_device_tssc,
  3039. #endif
  3040. /*ZTE_TSSC_WLY_001, @2010-04-13,BEGIN*/
  3041.     &android_pmem_kernel_ebi1_device,
  3042.     &android_pmem_device,
  3043.     &android_pmem_adsp_device,
  3044.     &android_pmem_audio_device,
  3045.     &msm_fb_device,
  3046. #ifdef CONFIG_ZTE_PLATFORM
  3047.     &lcdc_qvga_panel_device,
  3048. #else
  3049.     &lcdc_gordon_panel_device,
  3050. #endif
  3051.     &msm_device_uart_dm1,
  3052. #ifdef CONFIG_BT
  3053.     &msm_bt_power_device,
  3054.     &msm_bcm_power_device,  
  3055. #endif
  3056.     &msm_device_pmic_leds,
  3057.     &android_leds, //button-backlight
  3058.     &msm_device_snd,
  3059.     &msm_device_adspdec,
  3060. #ifdef CONFIG_MT9T013
  3061.     &msm_camera_sensor_mt9t013,
  3062. #endif
  3063. #ifdef CONFIG_MT9D112
  3064.     &msm_camera_sensor_mt9d112,
  3065. #endif
  3066. #ifdef CONFIG_S5K3E2FX
  3067.     &msm_camera_sensor_s5k3e2fx,
  3068. #endif
  3069. #ifdef CONFIG_MT9P012
  3070.     &msm_camera_sensor_mt9p012,
  3071. #endif
  3072. #ifdef CONFIG_MT9P012_KM
  3073.     &msm_camera_sensor_mt9p012_km,
  3074. #endif
  3075. #ifdef CONFIG_VB6801
  3076.     &msm_camera_sensor_vb6801,
  3077. #endif
  3078.     &msm_bluesleep_device,
  3079.     &msm_bcmsleep_device,    
  3080. #ifdef CONFIG_ARCH_MSM7X27
  3081.     &msm_device_kgsl,  
  3082. #endif
  3083. #ifdef CONFIG_MT9P111
  3084.     /*
  3085.      * Commented by zh.shj
  3086.      *
  3087.      * Refer to drivers/media/video/msm/mt9p111.c
  3088.      * For MT9P111: 5.0Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  3089.      */
  3090.     &msm_camera_sensor_mt9p111,
  3091. #endif
  3092.  
  3093. #ifdef CONFIG_MT9T11X
  3094.     /*
  3095.      * Commented by zh.shj, ZTE_MSM_CAMERA_ZHSHJ_001
  3096.      *
  3097.      * Refer to drivers/media/video/msm/mt9t11x.c
  3098.      * For MT9T111: 3.1Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  3099.      * For MT9T112: 3.1Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  3100.      */
  3101.     &msm_camera_sensor_mt9t11x,
  3102. #endif
  3103.  
  3104. #ifdef CONFIG_MT9D115
  3105.     /*
  3106.      * add by ZTE_CAMERA_LIJING_20100629 for MT9D115-2.0Mp-FF-Socket
  3107.      */
  3108.     &msm_camera_sensor_mt9d115,
  3109. #endif
  3110.  
  3111. #ifdef CONFIG_MT9V113
  3112.     /*
  3113.      * Commented by zh.shj
  3114.      *
  3115.      * Refer to drivers/media/video/msm/mt9v113.c
  3116.      * For MT9V113: 0.3Mp, 1/11-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  3117.      */
  3118.     &msm_camera_sensor_mt9v113,
  3119. #endif
  3120.  
  3121. #ifdef CONFIG_OV5642
  3122.     /*
  3123.      * Commented by zh.shj
  3124.      *
  3125.      * Refer to drivers/media/video/msm/ov5642.c
  3126.      * For OV5642: 5.0Mp, 1/4-Inch System-On-A-Chip (SOC) CMOS Digital Image Sensor
  3127.      */
  3128.     &msm_camera_sensor_ov5642,
  3129. #endif
  3130.  
  3131. #ifdef CONFIG_OV5640
  3132.  
  3133.     &msm_camera_sensor_ov5640,
  3134. #endif
  3135.  
  3136.     &hs_device,
  3137.     &msm_batt_device,
  3138. #ifdef CONFIG_ANDROID_RAM_CONSOLE
  3139.     &ram_console_device,
  3140. #endif
  3141. };
  3142.  
  3143. static struct msm_panel_common_pdata mdp_pdata = {
  3144.     .gpio = 97,
  3145. };
  3146.  
  3147. static void __init msm_fb_add_devices(void)
  3148. {
  3149.     msm_fb_register_device("mdp", &mdp_pdata);
  3150.     msm_fb_register_device("pmdh", 0);
  3151.     msm_fb_register_device("lcdc", &lcdc_pdata);
  3152. }
  3153.  
  3154. /*ZTE_AUX_FYA_001,@2010-02-06,BEGIN*/
  3155. static struct i2c_board_info aux_i2c_devices[] = {
  3156. #if 0
  3157.     {
  3158.         .type         = "avago_ofn",
  3159.         /*.flags        = ,*/
  3160.         .addr         = 0x33,
  3161.         .platform_data = &avago_ofn,
  3162.         .irq          = MSM_GPIO_TO_INT(35),
  3163.     },
  3164. #endif
  3165.     {
  3166.         I2C_BOARD_INFO("si4708", 0x10),
  3167.     },
  3168.     //ZTE_ALSPRX_001 start
  3169.     {
  3170.         .type         = "taos",
  3171.         .addr         = 0x39,
  3172.     },
  3173.     //ZTE_ALSPRX_001 end
  3174. };
  3175. /*ZTE_AUX_FYA_001,@2010-02-06,END*/
  3176.  
  3177. /*ZTE_AUX2_FYA_001,@2010-02-06,BEGIN+++++++++++*/
  3178.  
  3179.  
  3180. static struct i2c_board_info aux2_i2c_devices[] = {
  3181. #if 0
  3182.     {
  3183.         I2C_BOARD_INFO("akm8973", 0x1c),
  3184.     },
  3185.     {
  3186.         .type = "accelerator", //ZTE_FYA_20101122
  3187.         .addr = 0x1d,
  3188.     },
  3189. #endif
  3190. };
  3191. /*ZTE_AUX_FYA_001,@2010-02-06,END---------------*/
  3192. extern struct sys_timer msm_timer;
  3193.  
  3194. static void __init msm7x2x_init_irq(void)
  3195. {
  3196.     msm_init_irq();
  3197. }
  3198.  
  3199. static struct msm_acpu_clock_platform_data msm7x2x_clock_data = {
  3200.     .acpu_switch_time_us = 50,
  3201.     .max_speed_delta_khz = 400000,
  3202.     .vdd_switch_time_us = 62,
  3203.     .max_axi_khz = 160000,
  3204. };
  3205.  
  3206. void msm_serial_debug_init(unsigned int base, int irq,
  3207.                struct device *clk_device, int signal_irq);
  3208.  
  3209. #ifdef CONFIG_USB_EHCI_MSM
  3210. static void msm_hsusb_vbus_power(unsigned phy_info, int on)
  3211. {
  3212.     if (on)
  3213.         msm_hsusb_vbus_powerup();
  3214.     else
  3215.         msm_hsusb_vbus_shutdown();
  3216. }
  3217.  
  3218. static struct msm_usb_host_platform_data msm_usb_host_pdata = {
  3219.     .phy_info       = (USB_PHY_INTEGRATED | USB_PHY_MODEL_65NM),
  3220.     .vbus_power = msm_hsusb_vbus_power,
  3221. };
  3222. static void __init msm7x2x_init_host(void)
  3223. {
  3224.     if (machine_is_msm7x25_ffa() || machine_is_msm7x27_ffa())
  3225.         return;
  3226.  
  3227.     msm_add_host(0, &msm_usb_host_pdata);
  3228. }
  3229. #endif
  3230.  
  3231.  
  3232. #if (defined(CONFIG_MMC_MSM_SDC1_SUPPORT)\
  3233.     || defined(CONFIG_MMC_MSM_SDC2_SUPPORT)\
  3234.     || defined(CONFIG_MMC_MSM_SDC3_SUPPORT)\
  3235.     || defined(CONFIG_MMC_MSM_SDC4_SUPPORT))
  3236.  
  3237. static unsigned long vreg_sts, gpio_sts;
  3238. static struct vreg *vreg_mmc;
  3239. static unsigned mpp_mmc = 2;
  3240.  
  3241. struct sdcc_gpio {
  3242.     struct msm_gpio *cfg_data;
  3243.     uint32_t size;
  3244.     struct msm_gpio *sleep_cfg_data;
  3245. };
  3246.  
  3247. static struct msm_gpio sdc1_cfg_data[] = {
  3248.     {GPIO_CFG(51, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc1_dat_3"},
  3249.     {GPIO_CFG(52, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc1_dat_2"},
  3250.     {GPIO_CFG(53, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc1_dat_1"},
  3251.     {GPIO_CFG(54, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc1_dat_0"},
  3252.     {GPIO_CFG(55, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc1_cmd"},
  3253.     {GPIO_CFG(56, 1, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_8MA), "sdc1_clk"},
  3254. };
  3255.  
  3256. static struct msm_gpio sdc2_cfg_data[] = {
  3257.     {GPIO_CFG(62, 2, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_8MA), "sdc2_clk"},
  3258.     {GPIO_CFG(63, 2, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc2_cmd"},
  3259.     {GPIO_CFG(64, 2, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc2_dat_3"},
  3260.     {GPIO_CFG(65, 2, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc2_dat_2"},
  3261.     {GPIO_CFG(66, 2, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc2_dat_1"},
  3262.     {GPIO_CFG(67, 2, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc2_dat_0"},
  3263. };
  3264.  
  3265. static struct msm_gpio sdc2_sleep_cfg_data[] = {
  3266.     {GPIO_CFG(62, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), "sdc2_clk"},
  3267.     {GPIO_CFG(63, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), "sdc2_cmd"},
  3268.     {GPIO_CFG(64, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), "sdc2_dat_3"},
  3269.     {GPIO_CFG(65, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), "sdc2_dat_2"},
  3270.     {GPIO_CFG(66, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), "sdc2_dat_1"},
  3271.     {GPIO_CFG(67, 0, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA), "sdc2_dat_0"},
  3272. };
  3273. static struct msm_gpio sdc3_cfg_data[] = {
  3274.     {GPIO_CFG(88, 1, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_8MA), "sdc3_clk"},
  3275.     {GPIO_CFG(89, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc3_cmd"},
  3276.     {GPIO_CFG(90, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc3_dat_3"},
  3277.     {GPIO_CFG(91, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc3_dat_2"},
  3278.     {GPIO_CFG(92, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc3_dat_1"},
  3279.     {GPIO_CFG(93, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc3_dat_0"},
  3280. };
  3281.  
  3282. static struct msm_gpio sdc4_cfg_data[] = {
  3283.     {GPIO_CFG(19, 3, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc4_dat_3"},
  3284.     {GPIO_CFG(20, 3, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc4_dat_2"},
  3285.     {GPIO_CFG(21, 4, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc4_dat_1"},
  3286.     {GPIO_CFG(107, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc4_cmd"},
  3287.     {GPIO_CFG(108, 1, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_8MA), "sdc4_dat_0"},
  3288.     {GPIO_CFG(109, 1, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_8MA), "sdc4_clk"},
  3289. };
  3290.  
  3291. static struct sdcc_gpio sdcc_cfg_data[] = {
  3292.     {
  3293.         .cfg_data = sdc1_cfg_data,
  3294.         .size = ARRAY_SIZE(sdc1_cfg_data),
  3295.         .sleep_cfg_data = NULL,
  3296.     },
  3297.     {
  3298.         .cfg_data = sdc2_cfg_data,
  3299.         .size = ARRAY_SIZE(sdc2_cfg_data),
  3300.         .sleep_cfg_data = sdc2_sleep_cfg_data,
  3301.     },
  3302.     {
  3303.         .cfg_data = sdc3_cfg_data,
  3304.         .size = ARRAY_SIZE(sdc3_cfg_data),
  3305.         .sleep_cfg_data = NULL,
  3306.     },
  3307.     {
  3308.         .cfg_data = sdc4_cfg_data,
  3309.         .size = ARRAY_SIZE(sdc4_cfg_data),
  3310.         .sleep_cfg_data = NULL,
  3311.     },
  3312. };
  3313.  
  3314. static void msm_sdcc_setup_gpio(int dev_id, unsigned int enable)
  3315. {
  3316.     int rc = 0;
  3317.     struct sdcc_gpio *curr;
  3318.  
  3319.     curr = &sdcc_cfg_data[dev_id - 1];
  3320.     if (!(test_bit(dev_id, &gpio_sts)^enable))
  3321.         return;
  3322.  
  3323.     if (enable) {
  3324.         set_bit(dev_id, &gpio_sts);
  3325.         rc = msm_gpios_request_enable(curr->cfg_data, curr->size);
  3326.         if (rc)
  3327.             printk(KERN_ERR "%s: Failed to turn on GPIOs for slot %d\n",
  3328.                 __func__,  dev_id);
  3329.     } else {
  3330.         clear_bit(dev_id, &gpio_sts);
  3331.         if (curr->sleep_cfg_data) {
  3332.             msm_gpios_enable(curr->sleep_cfg_data, curr->size);
  3333.             msm_gpios_free(curr->sleep_cfg_data, curr->size);
  3334.             return;
  3335.         }
  3336.         msm_gpios_disable_free(curr->cfg_data, curr->size);
  3337.     }
  3338. }
  3339.  
  3340. static uint32_t msm_sdcc_setup_power(struct device *dv, unsigned int vdd)
  3341. {
  3342.     int rc = 0;
  3343.     struct platform_device *pdev;
  3344.  
  3345.     pdev = container_of(dv, struct platform_device, dev);
  3346.     msm_sdcc_setup_gpio(pdev->id, !!vdd);
  3347.  
  3348.     if (vdd == 0) {
  3349.         if (!vreg_sts)
  3350.             return 0;
  3351.  
  3352.         clear_bit(pdev->id, &vreg_sts);
  3353.  
  3354.         if (!vreg_sts) {
  3355.             if (machine_is_msm7x25_ffa() ||
  3356.                     machine_is_msm7x27_ffa()) {
  3357.                 rc = mpp_config_digital_out(mpp_mmc,
  3358.                      MPP_CFG(MPP_DLOGIC_LVL_MSMP,
  3359.                      MPP_DLOGIC_OUT_CTRL_LOW));
  3360.             } else
  3361.                 rc = vreg_disable(vreg_mmc);
  3362.             if (rc)
  3363.                 printk(KERN_ERR "%s: return val: %d \n",
  3364.                     __func__, rc);
  3365.         }
  3366.         return 0;
  3367.     }
  3368.  
  3369.     if (!vreg_sts) {
  3370.         if (machine_is_msm7x25_ffa() || machine_is_msm7x27_ffa()) {
  3371.             rc = mpp_config_digital_out(mpp_mmc,
  3372.                  MPP_CFG(MPP_DLOGIC_LVL_MSMP,
  3373.                  MPP_DLOGIC_OUT_CTRL_HIGH));
  3374.         } else {
  3375.             rc = vreg_set_level(vreg_mmc, 2850);
  3376.             if (!rc)
  3377.                 rc = vreg_enable(vreg_mmc);
  3378.         }
  3379.         if (rc)
  3380.             printk(KERN_ERR "%s: return val: %d \n",
  3381.                     __func__, rc);
  3382.     }
  3383.     set_bit(pdev->id, &vreg_sts);
  3384.     return 0;
  3385. }
  3386. //ZTE_WIFI_OYHQ_20100714 wifi froyo upgrade begin
  3387. /* ATHENV+++ */
  3388. static void (*wifi_status_notify_cb)(int card_present, void *dev_id);
  3389. void *wifi_devid;
  3390. //static int msm_sdcc_register_status_notify(void (*callback)(int card_present, void *dev_id), void *dev_id)
  3391. //{
  3392. //  wifi_status_notify_cb = callback;
  3393. //  wifi_devid = dev_id;
  3394. //  printk("%s: callback %p devid %p\n", __func__, callback, dev_id);
  3395. //  return 0;
  3396. //}
  3397.  
  3398. void wifi_detect_change(int on)
  3399. {
  3400.     if (wifi_status_notify_cb) {
  3401.         printk("%s: callback %p devid %p is called!!\n", __func__, wifi_status_notify_cb, wifi_devid);
  3402.         wifi_status_notify_cb(on, wifi_devid);
  3403.     }
  3404. }
  3405. EXPORT_SYMBOL(wifi_detect_change);
  3406. /* ATHENV---*/
  3407. //ZTE_WIFI_OYHQ_20100714 wifi froyo upgrade end
  3408. #ifdef CONFIG_MMC_MSM_SDC1_SUPPORT
  3409. static struct mmc_platform_data msm7x2x_sdc1_data = {
  3410.     .ocr_mask   = MMC_VDD_28_29,
  3411.     .translate_vdd  = msm_sdcc_setup_power,
  3412.     .mmc_bus_width  = MMC_CAP_4_BIT_DATA,
  3413.     .msmsdcc_fmin   = 144000,
  3414.     .msmsdcc_fmid   = 24576000,
  3415.     .msmsdcc_fmax   = 49152000,
  3416.     .nonremovable   = 1,
  3417. };
  3418. #endif
  3419.  
  3420. #ifdef CONFIG_MMC_MSM_SDC2_SUPPORT
  3421. static struct mmc_platform_data msm7x2x_sdc2_data = {
  3422.     .ocr_mask   = MMC_VDD_28_29,
  3423.     .translate_vdd  = msm_sdcc_setup_power,
  3424.     .mmc_bus_width  = MMC_CAP_4_BIT_DATA,
  3425. #ifdef CONFIG_MMC_MSM_SDIO_SUPPORT
  3426. #if 0    //ZTE_ZBS_20110308 : disable the SDIO irq wakeup
  3427.     .sdiowakeup_irq = MSM_GPIO_TO_INT(66),
  3428. #endif
  3429. #endif
  3430.     .msmsdcc_fmin   = 144000,
  3431.     .msmsdcc_fmid   = 24576000,
  3432.     .msmsdcc_fmax   = 49152000,
  3433.     .nonremovable   = 0,
  3434.     //ZTE_WIFI_OYHQ_20100714 wifi froyo upgrade begin
  3435.     .dummy52_required = 1,
  3436.     //ZTE_WIFI_OYHQ_20100714 wifi froyo upgrade end
  3437. };
  3438. #endif
  3439.  
  3440. #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT
  3441. static struct mmc_platform_data msm7x2x_sdc3_data = {
  3442.     .ocr_mask   = MMC_VDD_28_29,
  3443.     .translate_vdd  = msm_sdcc_setup_power,
  3444.     .mmc_bus_width  = MMC_CAP_4_BIT_DATA,
  3445.     .msmsdcc_fmin   = 144000,
  3446.     .msmsdcc_fmid   = 24576000,
  3447.     .msmsdcc_fmax   = 49152000,
  3448.     .nonremovable   = 0,
  3449. };
  3450. #endif
  3451.  
  3452. #ifdef CONFIG_MMC_MSM_SDC4_SUPPORT
  3453. static struct mmc_platform_data msm7x2x_sdc4_data = {
  3454.     .ocr_mask   = MMC_VDD_28_29,
  3455.     .translate_vdd  = msm_sdcc_setup_power,
  3456.     .mmc_bus_width  = MMC_CAP_4_BIT_DATA,
  3457.     .msmsdcc_fmin   = 144000,
  3458.     .msmsdcc_fmid   = 24576000,
  3459.     .msmsdcc_fmax   = 49152000,
  3460.     .nonremovable   = 0,
  3461. };
  3462. #endif
  3463.  
  3464. static void __init msm7x2x_init_mmc(void)
  3465. {
  3466.     if (!machine_is_msm7x25_ffa() && !machine_is_msm7x27_ffa()) {
  3467.         vreg_mmc = vreg_get(NULL, "mmc");
  3468.         if (IS_ERR(vreg_mmc)) {
  3469.             printk(KERN_ERR "%s: vreg get failed (%ld)\n",
  3470.                    __func__, PTR_ERR(vreg_mmc));
  3471.             return;
  3472.         }
  3473.     }
  3474.  
  3475. #ifdef CONFIG_MMC_MSM_SDC1_SUPPORT
  3476.     if (machine_is_msm7x27_ffa())
  3477.         msm7x2x_sdc1_data.nonremovable = 0;
  3478.     msm_add_sdcc(1, &msm7x2x_sdc1_data);
  3479.  
  3480. #endif
  3481. //ZTE_WIFI_OYHQ_20100714 wifi froyo upgrade begin
  3482. //if (machine_is_msm7x25_surf() || machine_is_msm7x27_surf() ||
  3483. //machine_is_msm7x27_ffa()) {
  3484. #ifdef CONFIG_MMC_MSM_SDC2_SUPPORT
  3485.         if (machine_is_msm7x27_ffa())
  3486.             msm7x2x_sdc2_data.nonremovable = 1;
  3487.         msm_sdcc_setup_gpio(2, 1);
  3488.         msm_add_sdcc(2, &msm7x2x_sdc2_data);
  3489. #endif
  3490. //}
  3491.     if (machine_is_msm7x25_surf() || machine_is_msm7x27_surf()) {
  3492. #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT
  3493.         msm_add_sdcc(3, &msm7x2x_sdc3_data);
  3494. #endif
  3495. #ifdef CONFIG_MMC_MSM_SDC4_SUPPORT
  3496.         msm_add_sdcc(4, &msm7x2x_sdc4_data);
  3497. #endif
  3498.     }
  3499. }
  3500. #else
  3501. #define msm7x2x_init_mmc() do {} while (0)
  3502. #endif
  3503.  
  3504.  
  3505. static struct msm_pm_platform_data msm7x25_pm_data[MSM_PM_SLEEP_MODE_NR] = {
  3506.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE].latency = 16000,
  3507.  
  3508.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN].latency = 12000,
  3509.  
  3510.     [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].latency = 2000,
  3511. };
  3512.  
  3513. static struct msm_pm_platform_data msm7x27_pm_data[MSM_PM_SLEEP_MODE_NR] = {
  3514.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE].supported = 1,
  3515.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE].suspend_enabled = 1,
  3516.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE].idle_enabled = 1,
  3517.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE].latency = 16000,
  3518.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE].residency = 20000,
  3519.  
  3520.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN].supported = 1,
  3521.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN].suspend_enabled = 1,
  3522.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN].idle_enabled = 1,
  3523.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN].latency = 12000,
  3524.     [MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN].residency = 20000,
  3525.  
  3526.     [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].supported = 1,
  3527.     [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].suspend_enabled
  3528.         = 1,
  3529.     [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].idle_enabled = 1,
  3530.     [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].latency = 2000,
  3531.     [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].residency = 0,
  3532. };
  3533.  
  3534. static void
  3535. msm_i2c_gpio_config(int iface, int config_type)
  3536. {
  3537.     int gpio_scl;
  3538.     int gpio_sda;
  3539.     if (iface) {
  3540.         gpio_scl = 95;
  3541.         gpio_sda = 96;
  3542.     } else {
  3543.         gpio_scl = 60;
  3544.         gpio_sda = 61;
  3545.     }
  3546.     if (config_type) {
  3547.         gpio_tlmm_config(GPIO_CFG(gpio_scl, 1, GPIO_INPUT,
  3548.                     GPIO_NO_PULL, GPIO_16MA), GPIO_ENABLE);
  3549.         gpio_tlmm_config(GPIO_CFG(gpio_sda, 1, GPIO_INPUT,
  3550.                     GPIO_NO_PULL, GPIO_16MA), GPIO_ENABLE);
  3551.     } else {
  3552.         gpio_tlmm_config(GPIO_CFG(gpio_scl, 0, GPIO_OUTPUT,
  3553.                     GPIO_NO_PULL, GPIO_16MA), GPIO_ENABLE);
  3554.         gpio_tlmm_config(GPIO_CFG(gpio_sda, 0, GPIO_OUTPUT,
  3555.                     GPIO_NO_PULL, GPIO_16MA), GPIO_ENABLE);
  3556.     }
  3557. }
  3558.  
  3559. static struct msm_i2c_platform_data msm_i2c_pdata = {
  3560.  
  3561.     .clk_freq = 100000,
  3562.     .rmutex  = 0,
  3563.     .pri_clk = 60,
  3564.     .pri_dat = 61,
  3565.  
  3566.  
  3567. #if 0
  3568.     .aux_clk = 95,
  3569.     .aux_dat = 96,
  3570. #endif
  3571.  
  3572.     .msm_i2c_config_gpio = msm_i2c_gpio_config,
  3573. };
  3574.  
  3575. static void __init msm_device_i2c_init(void)
  3576. {
  3577.     if (gpio_request(60, "i2c_pri_clk"))
  3578.         pr_err("failed to request gpio i2c_pri_clk\n");
  3579.     if (gpio_request(61, "i2c_pri_dat"))
  3580.         pr_err("failed to request gpio i2c_pri_dat\n");
  3581.  
  3582.  
  3583. #if 0
  3584.     if (gpio_request(95, "i2c_sec_clk"))
  3585.         pr_err("failed to request gpio i2c_sec_clk\n");
  3586.     if (gpio_request(96, "i2c_sec_dat"))
  3587.         pr_err("failed to request gpio i2c_sec_dat\n");
  3588. #endif
  3589.  
  3590.     if (cpu_is_msm7x27())
  3591.         msm_i2c_pdata.pm_lat =
  3592.         msm7x27_pm_data[MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN]
  3593.         .latency;
  3594.     else
  3595.         msm_i2c_pdata.pm_lat =
  3596.         msm7x25_pm_data[MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN]
  3597.         .latency;
  3598.  
  3599.     msm_device_i2c.dev.platform_data = &msm_i2c_pdata;
  3600. }
  3601.  
  3602. #ifdef CONFIG_ZTE_PLATFORM
  3603. #define MSM_GPIO_USB3V3     21
  3604. static unsigned usb_config_power_on =   GPIO_CFG(MSM_GPIO_USB3V3, 0,
  3605.                                                                                 GPIO_OUTPUT, GPIO_PULL_UP, GPIO_2MA);
  3606. static int init_usb3v3(void)
  3607. {
  3608.     int rc;
  3609.     rc = gpio_tlmm_config(usb_config_power_on,GPIO_ENABLE);
  3610.     if (rc) {
  3611.         printk(KERN_ERR "%s: gpio_tlmm_config(%#x)=%d\n",__func__, MSM_GPIO_USB3V3, rc);
  3612.         return -EIO;
  3613.     }
  3614.     rc = gpio_request(MSM_GPIO_USB3V3, "usb");
  3615.     if(!rc)
  3616.     {
  3617.         gpio_direction_output(MSM_GPIO_USB3V3, 1);
  3618.         gpio_set_value(MSM_GPIO_USB3V3, 1);
  3619.         printk(KERN_ERR "gpio_request: %d ok!\n", MSM_GPIO_USB3V3);
  3620.     }
  3621.     else
  3622.     {
  3623.         printk(KERN_ERR "gpio_request: %d failed!\n", MSM_GPIO_USB3V3);
  3624.     }
  3625.     gpio_free(MSM_GPIO_USB3V3);
  3626.     return 0;
  3627. }  
  3628.  
  3629. #endif
  3630.  
  3631. static void usb_mpp_init(void)
  3632. {
  3633.     unsigned rc;
  3634.     unsigned mpp_usb = 7;
  3635.  
  3636.     if (machine_is_msm7x25_ffa() || machine_is_msm7x27_ffa()) {
  3637.         rc = mpp_config_digital_out(mpp_usb,
  3638.             MPP_CFG(MPP_DLOGIC_LVL_VDD,
  3639.                 MPP_DLOGIC_OUT_CTRL_HIGH));
  3640.         if (rc)
  3641.             pr_err("%s: configuring mpp pin"
  3642.                 "to enable 3.3V LDO failed\n", __func__);
  3643.     }
  3644. }
  3645.  
  3646.  extern void  __init msm_init_pmic_vibrator(void);
  3647.  
  3648. static ssize_t debug_global_read(struct file *file, char __user *buf,
  3649.                     size_t len, loff_t *offset)
  3650. {
  3651.     loff_t pos = *offset;
  3652.     ssize_t count;
  3653.     ssize_t size;
  3654.  
  3655.     size = sizeof(smem_global);
  3656.  
  3657.     if (pos >= size)
  3658.         return 0;
  3659.  
  3660.     count = min(len, (size_t)(size - pos));
  3661.     if (copy_to_user(buf, (char *)global + pos, count))
  3662.         return -EFAULT;
  3663.  
  3664.     *offset += count;
  3665.     return count;
  3666. }
  3667.  
  3668. static struct file_operations debug_global_file_ops = {
  3669.     .owner = THIS_MODULE,
  3670.     .read = debug_global_read,
  3671. };
  3672.  
  3673. static void msm7x27_wlan_init(void)
  3674. {
  3675.     int rc = 0;
  3676.     /* TBD: if (machine_is_msm7x27_ffa_with_wcn1312()) */
  3677.     if (machine_is_msm7x27_ffa()) {
  3678.         rc = mpp_config_digital_out(3, MPP_CFG(MPP_DLOGIC_LVL_MSMP,
  3679.                 MPP_DLOGIC_OUT_CTRL_LOW));
  3680.         if (rc)
  3681.             printk(KERN_ERR "%s: return val: %d \n",
  3682.                 __func__, rc);
  3683.     }
  3684. }
  3685.  
  3686. static void __init msm7x2x_init(void)
  3687. {
  3688.     struct proc_dir_entry *entry;
  3689.    
  3690. #ifdef CONFIG_ZTE_FTM_FLAG_SUPPORT
  3691.     zte_ftm_set_value(g_zte_ftm_flag_fixup);
  3692. #endif
  3693.  
  3694.     if (socinfo_init() < 0)
  3695.         BUG();
  3696. #ifdef CONFIG_ARCH_MSM7X25
  3697.     msm_clock_init(msm_clocks_7x25, msm_num_clocks_7x25);
  3698. #elif CONFIG_ARCH_MSM7X27
  3699.     msm_clock_init(msm_clocks_7x27, msm_num_clocks_7x27);
  3700. #endif
  3701.     platform_add_devices(early_devices, ARRAY_SIZE(early_devices));
  3702.  
  3703. #if defined(CONFIG_MSM_SERIAL_DEBUGGER)
  3704.     msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
  3705.             &msm_device_uart3.dev, 1);
  3706. #endif
  3707.     if (machine_is_msm7x25_ffa() || machine_is_msm7x27_ffa()) {
  3708.         smc91x_resources[0].start = 0x98000300;
  3709.         smc91x_resources[0].end = 0x980003ff;
  3710.         smc91x_resources[1].start = MSM_GPIO_TO_INT(85);
  3711.         smc91x_resources[1].end = MSM_GPIO_TO_INT(85);
  3712.         if (gpio_tlmm_config(GPIO_CFG(85, 0,
  3713.                           GPIO_INPUT,
  3714.                           GPIO_PULL_DOWN,
  3715.                           GPIO_2MA),
  3716.                      GPIO_ENABLE)) {
  3717.             printk(KERN_ERR
  3718.                    "%s: Err: Config GPIO-85 INT\n",
  3719.                 __func__);
  3720.         }
  3721.     }
  3722.  
  3723.     if (cpu_is_msm7x27())
  3724.         msm7x2x_clock_data.max_axi_khz = 200000;
  3725.  
  3726.     msm_acpu_clock_init(&msm7x2x_clock_data);
  3727. #ifdef CONFIG_ZTE_PLATFORM
  3728.     init_usb3v3();
  3729.     #endif
  3730. #ifdef CONFIG_ARCH_MSM7X27
  3731.     /* This value has been set to 160000 for power savings. */
  3732.     /* OEMs may modify the value at their discretion for performance */
  3733.     /* The appropriate maximum replacement for 160000 is: */
  3734.     /* clk_get_max_axi_khz() */
  3735.     kgsl_pdata.high_axi_3d = 160000;
  3736.  
  3737.     /* 7x27 doesn't allow graphics clocks to be run asynchronously to */
  3738.     /* the AXI bus */
  3739.     kgsl_pdata.max_grp2d_freq = 0;
  3740.     kgsl_pdata.min_grp2d_freq = 0;
  3741.     kgsl_pdata.set_grp2d_async = NULL;
  3742.     kgsl_pdata.max_grp3d_freq = 0;
  3743.     kgsl_pdata.min_grp3d_freq = 0;
  3744.     kgsl_pdata.set_grp3d_async = NULL;
  3745.     kgsl_pdata.imem_clk_name = "imem_clk";
  3746.     kgsl_pdata.grp3d_clk_name = "grp_clk";
  3747.     kgsl_pdata.grp3d_pclk_name = "grp_pclk";
  3748.     kgsl_pdata.grp2d0_clk_name = NULL;
  3749.     kgsl_pdata.idle_timeout_3d = HZ/5;
  3750.     kgsl_pdata.idle_timeout_2d = 0;
  3751. #ifdef CONFIG_KGSL_PER_PROCESS_PAGE_TABLE
  3752.     kgsl_pdata.pt_va_size = SZ_32M;
  3753. #else
  3754.     kgsl_pdata.pt_va_size = SZ_128M;
  3755. #endif
  3756. #endif
  3757.  
  3758. #if defined( CONFIG_TOUCHSCREEN_MSM_LEGACY) || defined( CONFIG_TOUCHSCREEN_MSM)
  3759.     msm_device_tssc.dev.platform_data = &msm_tssc_pdata;
  3760. #endif
  3761.  
  3762.     usb_mpp_init();
  3763.  
  3764. #ifdef CONFIG_USB_FUNCTION
  3765.     msm_hsusb_pdata.swfi_latency =
  3766.         msm7x27_pm_data
  3767.         [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].latency;
  3768.  
  3769.     msm_device_hsusb_peripheral.dev.platform_data = &msm_hsusb_pdata;
  3770. #endif
  3771.  
  3772. #ifdef CONFIG_USB_MSM_OTG_72K
  3773.     msm_device_otg.dev.platform_data = &msm_otg_pdata;
  3774.     if (machine_is_msm7x25_surf() || machine_is_msm7x25_ffa()) {
  3775.         msm_otg_pdata.pemp_level =
  3776.             PRE_EMPHASIS_WITH_20_PERCENT;
  3777.         msm_otg_pdata.drv_ampl = HS_DRV_AMPLITUDE_5_PERCENT;
  3778.         msm_otg_pdata.cdr_autoreset = CDR_AUTO_RESET_ENABLE;
  3779.         msm_otg_pdata.phy_reset_sig_inverted = 1;
  3780.     }
  3781.     if (machine_is_msm7x27_surf() || machine_is_msm7x27_ffa()) {
  3782.         msm_otg_pdata.pemp_level =
  3783.             PRE_EMPHASIS_WITH_10_PERCENT;
  3784.         msm_otg_pdata.drv_ampl = HS_DRV_AMPLITUDE_5_PERCENT;
  3785.         msm_otg_pdata.cdr_autoreset = CDR_AUTO_RESET_DISABLE;
  3786.         msm_otg_pdata.phy_reset_sig_inverted = 1;
  3787.     }
  3788.  
  3789. #ifdef CONFIG_USB_GADGET
  3790. //  msm_gadget_pdata.swfi_latency =
  3791. //      msm7x27_pm_data
  3792. //      [MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].latency;
  3793. //  msm_device_gadget_peripheral.dev.platform_data = &msm_gadget_pdata;
  3794. #endif
  3795. #endif
  3796.     msm_init_pmic_vibrator();
  3797.  
  3798.     platform_add_devices(devices, ARRAY_SIZE(devices));
  3799. #ifdef CONFIG_MSM_CAMERA
  3800. //  config_camera_off_gpios(); /* might not be necessary */
  3801. #endif
  3802.     msm_device_i2c_init();
  3803.     i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
  3804.     i2c_register_board_info(1, aux_i2c_devices, ARRAY_SIZE(aux_i2c_devices));
  3805.     i2c_register_board_info(2, aux2_i2c_devices, ARRAY_SIZE(aux2_i2c_devices));
  3806. #ifdef CONFIG_SURF_FFA_GPIO_KEYPAD
  3807.     if (machine_is_msm7x25_ffa() || machine_is_msm7x27_ffa())
  3808.         platform_device_register(&keypad_device_7k_ffa);
  3809.     else
  3810.         platform_device_register(&keypad_device_surf);
  3811. #endif
  3812. #ifdef CONFIG_ZTE_PLATFORM
  3813.     lcdc_lead_gpio_init();
  3814. #else
  3815.     lcdc_gordon_gpio_init();
  3816. #endif
  3817.     msm_fb_add_devices();
  3818. #ifdef CONFIG_USB_EHCI_MSM
  3819.     msm7x2x_init_host();
  3820. #endif
  3821.     msm7x2x_init_mmc();
  3822.     bt_power_init();
  3823.  
  3824.     if (cpu_is_msm7x27())
  3825.         msm_pm_set_platform_data(msm7x27_pm_data,
  3826.                     ARRAY_SIZE(msm7x27_pm_data));
  3827.     else
  3828.         msm_pm_set_platform_data(msm7x25_pm_data,
  3829.                     ARRAY_SIZE(msm7x25_pm_data));
  3830.                    
  3831.     msm7x27_wlan_init();               
  3832.    
  3833.     global = ioremap(SMEM_LOG_GLOBAL_BASE, sizeof(smem_global));
  3834.     if (!global) {
  3835.         printk(KERN_ERR "ioremap failed with SCL_SMEM_LOG_RAM_BASE\n");
  3836.         return;
  3837.     }
  3838.     entry = create_proc_entry("smem_global", S_IFREG | S_IRUGO, NULL);
  3839.     if (!entry) {
  3840.         printk(KERN_ERR "smem_global: failed to create proc entry\n");
  3841.         return;
  3842.     }
  3843.     entry->proc_fops = &debug_global_file_ops;
  3844.     entry->size = sizeof(smem_global);
  3845. }
  3846.  
  3847. static unsigned pmem_kernel_ebi1_size = PMEM_KERNEL_EBI1_SIZE;
  3848. static void __init pmem_kernel_ebi1_size_setup(char **p)
  3849. {
  3850.     pmem_kernel_ebi1_size = memparse(*p, p);
  3851. }
  3852. __early_param("pmem_kernel_ebi1_size=", pmem_kernel_ebi1_size_setup);
  3853.  
  3854. static unsigned pmem_mdp_size = MSM_PMEM_MDP_SIZE;
  3855. static void __init pmem_mdp_size_setup(char **p)
  3856. {
  3857.     pmem_mdp_size = memparse(*p, p);
  3858. }
  3859. __early_param("pmem_mdp_size=", pmem_mdp_size_setup);
  3860.  
  3861. static unsigned pmem_adsp_size = MSM_PMEM_ADSP_SIZE;
  3862. static void __init pmem_adsp_size_setup(char **p)
  3863. {
  3864.     pmem_adsp_size = memparse(*p, p);
  3865. }
  3866. __early_param("pmem_adsp_size=", pmem_adsp_size_setup);
  3867.  
  3868. static unsigned fb_size = MSM_FB_SIZE;
  3869. static void __init fb_size_setup(char **p)
  3870. {
  3871.     fb_size = memparse(*p, p);
  3872. }
  3873. __early_param("fb_size=", fb_size_setup);
  3874.  
  3875. static void __init msm_msm7x2x_allocate_memory_regions(void)
  3876. {
  3877.     void *addr;
  3878.     unsigned long size;
  3879.  
  3880. #if defined(CONFIG_ZTE_PLATFORM) && defined(CONFIG_F3_LOG)
  3881.     unsigned int len;
  3882.     smem_global *global_tmp = (smem_global *)(MSM_RAM_LOG_BASE + PAGE_SIZE) ;
  3883.  
  3884.     len = global_tmp->f3log;
  3885. #endif
  3886.  
  3887.     size = pmem_mdp_size;
  3888.     if (size) {
  3889.         addr = alloc_bootmem(size);
  3890.         android_pmem_pdata.start = __pa(addr);
  3891.         android_pmem_pdata.size = size;
  3892.         pr_info("allocating %lu bytes at %p (%lx physical) for mdp "
  3893.             "pmem arena\n", size, addr, __pa(addr));
  3894.     }
  3895.  
  3896.     size = pmem_adsp_size;
  3897.     if (size) {
  3898.         addr = alloc_bootmem(size);
  3899.         android_pmem_adsp_pdata.start = __pa(addr);
  3900.         android_pmem_adsp_pdata.size = size;
  3901.         pr_info("allocating %lu bytes at %p (%lx physical) for adsp "
  3902.             "pmem arena\n", size, addr, __pa(addr));
  3903.     }
  3904.  
  3905.     size = MSM_PMEM_AUDIO_SIZE ;
  3906.     android_pmem_audio_pdata.start = MSM_PMEM_AUDIO_START_ADDR ;
  3907.     android_pmem_audio_pdata.size = size;
  3908.     pr_info("allocating %lu bytes (at %lx physical) for audio "
  3909.         "pmem arena\n", size , MSM_PMEM_AUDIO_START_ADDR);
  3910.  
  3911.     size = fb_size ? : MSM_FB_SIZE;
  3912.     addr = alloc_bootmem(size);
  3913.     msm_fb_resources[0].start = __pa(addr);
  3914.     msm_fb_resources[0].end = msm_fb_resources[0].start + size - 1;
  3915.     pr_info("allocating %lu bytes at %p (%lx physical) for fb\n",
  3916.         size, addr, __pa(addr));
  3917.  
  3918.     size = pmem_kernel_ebi1_size;
  3919.     if (size) {
  3920.         addr = alloc_bootmem_aligned(size, 0x100000);
  3921.         android_pmem_kernel_ebi1_pdata.start = __pa(addr);
  3922.         android_pmem_kernel_ebi1_pdata.size = size;
  3923.         pr_info("allocating %lu bytes at %p (%lx physical) for kernel"
  3924.             " ebi1 pmem arena\n", size, addr, __pa(addr));
  3925.     }
  3926.  
  3927. #if defined(CONFIG_ZTE_PLATFORM) && defined(CONFIG_F3_LOG)
  3928.     pr_info("length = %d ++ \n", len);
  3929.  
  3930.     if (len > 12)
  3931.         len = 12;
  3932.     else
  3933.         len = len/2*2;
  3934.    
  3935.     pr_info("length = %d -- \n", len);
  3936.     size = len;
  3937.    
  3938.     if (size)
  3939.         reserve_bootmem(0x08D00000, size*0x100000, BOOTMEM_DEFAULT);
  3940.  
  3941.     addr = phys_to_virt(0x08D00000);
  3942.     pr_info("allocating %lu M at %p (%lx physical) for F3\n",size, addr, __pa(addr));
  3943. #endif
  3944.  
  3945. }
  3946.  
  3947. static void __init msm7x2x_map_io(void)
  3948. {
  3949.     msm_map_common_io();
  3950.     msm_msm7x2x_allocate_memory_regions();
  3951.  
  3952. #if 0
  3953. #ifdef CONFIG_CACHE_L2X0
  3954.     if (machine_is_msm7x27_surf() || machine_is_msm7x27_ffa() || machine_is_blade()) {
  3955.         /* 7x27 has 256KB L2 cache:
  3956.             64Kb/Way and 4-Way Associativity;
  3957.             R/W latency: 3 cycles;
  3958.             evmon/parity/share disabled. */
  3959.         l2x0_init(MSM_L2CC_BASE, 0x00068012, 0xfe000000);
  3960.     }
  3961.    
  3962. #endif
  3963. #endif
  3964. #ifdef CONFIG_CACHE_L2X0
  3965.     l2x0_init(MSM_L2CC_BASE, 0x00068012, 0xfe000000);
  3966. #endif
  3967. }
  3968.  
  3969. //ruanmeisi
  3970. #ifdef CONFIG_ZTE_PLATFORM
  3971.  
  3972. #define ATAG_ZTEFTM 0x5d53cd73
  3973. static int  parse_tag_zteftm(const struct tag *tags)
  3974. {
  3975.         int flag = 0, find = 0;
  3976.         struct tag *t = (struct tag *)tags;
  3977.  
  3978.         for (; t->hdr.size; t = tag_next(t)) {
  3979.                 if (t->hdr.tag == ATAG_ZTEFTM) {
  3980.                         printk(KERN_DEBUG "find the zte ftm tag\n");
  3981.                         find = 1;
  3982.                         break;
  3983.                 }
  3984.         }
  3985.  
  3986.         if (find)
  3987.                 flag = t->u.revision.rev;
  3988.         printk(KERN_INFO "[ZYF@FTM]parse_tag_zteftm: zte FTM %s !\n",
  3989.            flag?"enable":"disable");
  3990.         return flag;
  3991. }
  3992.  
  3993. static void __init zte_fixup(struct machine_desc *desc, struct tag *tags,
  3994.                  char **cmdline, struct meminfo *mi)
  3995. {
  3996.         g_zte_ftm_flag_fixup = parse_tag_zteftm((const struct tag *)tags);
  3997.  
  3998. }
  3999.  
  4000. int get_ftm_from_tag(void)
  4001. {
  4002.     return g_zte_ftm_flag_fixup;
  4003. }
  4004. EXPORT_SYMBOL(get_ftm_from_tag);
  4005.  
  4006. #endif
  4007. //end
  4008.  
  4009. MACHINE_START(MSM7X27_SURF, "QCT MSM7x27 SURF")
  4010. #ifdef CONFIG_MSM_DEBUG_UART
  4011.     .phys_io        = MSM_DEBUG_UART_PHYS,
  4012.     .io_pg_offst    = ((MSM_DEBUG_UART_BASE) >> 18) & 0xfffc,
  4013. #endif
  4014.     .boot_params    = PHYS_OFFSET + 0x100,
  4015.     .map_io     = msm7x2x_map_io,
  4016.     .init_irq   = msm7x2x_init_irq,
  4017.     .init_machine   = msm7x2x_init,
  4018.     .timer      = &msm_timer,
  4019. MACHINE_END
  4020.  
  4021. MACHINE_START(MSM7X27_FFA, "QCT MSM7x27 FFA")
  4022. #ifdef CONFIG_MSM_DEBUG_UART
  4023.     .phys_io        = MSM_DEBUG_UART_PHYS,
  4024.     .io_pg_offst    = ((MSM_DEBUG_UART_BASE) >> 18) & 0xfffc,
  4025. #endif
  4026.     .boot_params    = PHYS_OFFSET + 0x100,
  4027.     .map_io     = msm7x2x_map_io,
  4028.     .init_irq   = msm7x2x_init_irq,
  4029.     .init_machine   = msm7x2x_init,
  4030.     .timer      = &msm_timer,
  4031. MACHINE_END
  4032.  
  4033. MACHINE_START(MSM7X25_SURF, "QCT MSM7x25 SURF")
  4034. #ifdef CONFIG_MSM_DEBUG_UART
  4035.     .phys_io        = MSM_DEBUG_UART_PHYS,
  4036.     .io_pg_offst    = ((MSM_DEBUG_UART_BASE) >> 18) & 0xfffc,
  4037. #endif
  4038.     .boot_params    = PHYS_OFFSET + 0x100,
  4039.     .map_io     = msm7x2x_map_io,
  4040.     .init_irq   = msm7x2x_init_irq,
  4041.     .init_machine   = msm7x2x_init,
  4042.     .timer      = &msm_timer,
  4043. MACHINE_END
  4044.  
  4045. MACHINE_START(MSM7X25_FFA, "QCT MSM7x25 FFA")
  4046. #ifdef CONFIG_MSM_DEBUG_UART
  4047.     .phys_io        = MSM_DEBUG_UART_PHYS,
  4048.     .io_pg_offst    = ((MSM_DEBUG_UART_BASE) >> 18) & 0xfffc,
  4049. #endif
  4050.     .boot_params    = PHYS_OFFSET + 0x100,
  4051.     .map_io     = msm7x2x_map_io,
  4052.     .init_irq   = msm7x2x_init_irq,
  4053.     .init_machine   = msm7x2x_init,
  4054.     .timer      = &msm_timer,
  4055. MACHINE_END
  4056.  
  4057. MACHINE_START(ROAMER, "roamer")
  4058. #ifdef CONFIG_MSM_DEBUG_UART
  4059.     .phys_io        = MSM_DEBUG_UART_PHYS,
  4060.     .io_pg_offst    = ((MSM_DEBUG_UART_BASE) >> 18) & 0xfffc,
  4061. #endif
  4062.     .boot_params    = PHYS_OFFSET + 0x100,
  4063. #ifdef CONFIG_ZTE_PLATFORM
  4064.   .fixup          = zte_fixup,
  4065. #endif
  4066.     .map_io     = msm7x2x_map_io,
  4067.     .init_irq   = msm7x2x_init_irq,
  4068.     .init_machine   = msm7x2x_init,
  4069.     .timer      = &msm_timer,
  4070. MACHINE_END
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!