Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 1 | /* Copyright (c) 2011, Code Aurora Forum. All rights reserved. |
| 2 | * |
| 3 | * This program is free software; you can redistribute it and/or modify |
| 4 | * it under the terms of the GNU General Public License version 2 and |
| 5 | * only version 2 as published by the Free Software Foundation. |
| 6 | * |
| 7 | * This program is distributed in the hope that it will be useful, |
| 8 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 9 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 10 | * GNU General Public License for more details. |
| 11 | * |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 12 | */ |
| 13 | #include <linux/kernel.h> |
| 14 | #include <linux/platform_device.h> |
| 15 | #include <linux/io.h> |
| 16 | #include <linux/irq.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 17 | #include <linux/i2c.h> |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 18 | #include <linux/i2c/sx150x.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 19 | #include <linux/gpio.h> |
| 20 | #include <linux/msm_ssbi.h> |
| 21 | #include <linux/regulator/gpio-regulator.h> |
| 22 | #include <linux/mfd/pm8xxx/pm8921.h> |
| 23 | #include <linux/regulator/consumer.h> |
| 24 | #include <linux/spi/spi.h> |
| 25 | #include <linux/slimbus/slimbus.h> |
| 26 | #include <linux/bootmem.h> |
Lucille Sylvester | 34ec369 | 2011-08-16 16:28:04 -0600 | [diff] [blame] | 27 | #include <linux/msm_kgsl.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 28 | #ifdef CONFIG_ANDROID_PMEM |
| 29 | #include <linux/android_pmem.h> |
| 30 | #endif |
| 31 | #include <linux/cyttsp.h> |
| 32 | #include <linux/dma-mapping.h> |
| 33 | #include <linux/platform_data/qcom_crypto_device.h> |
Ankur Nandwani | b0039b0 | 2011-08-09 14:00:45 -0700 | [diff] [blame] | 34 | #include <linux/platform_data/qcom_wcnss_device.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 35 | #include <linux/leds.h> |
| 36 | #include <linux/leds-pm8xxx.h> |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 37 | #include <linux/i2c/atmel_mxt_ts.h> |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 38 | |
| 39 | #include <asm/mach-types.h> |
| 40 | #include <asm/mach/arch.h> |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 41 | #include <asm/setup.h> |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 42 | #include <asm/hardware/gic.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 43 | #include <asm/mach/mmc.h> |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 44 | |
| 45 | #include <mach/board.h> |
| 46 | #include <mach/msm_iomap.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 47 | #include <mach/msm_spi.h> |
| 48 | #ifdef CONFIG_USB_MSM_OTG_72K |
| 49 | #include <mach/msm_hsusb.h> |
| 50 | #else |
| 51 | #include <linux/usb/msm_hsusb.h> |
| 52 | #endif |
| 53 | #include <linux/usb/android.h> |
| 54 | #include <mach/usbdiag.h> |
| 55 | #include <mach/socinfo.h> |
| 56 | #include <mach/rpm.h> |
| 57 | #include <mach/gpio.h> |
Rohit Vaswani | a513aa8d | 2011-07-18 15:14:28 -0700 | [diff] [blame] | 58 | #include <mach/gpiomux.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 59 | #include <mach/msm_bus_board.h> |
| 60 | #include <mach/msm_memtypes.h> |
| 61 | #include <mach/dma.h> |
| 62 | #include <mach/msm_dsps.h> |
| 63 | #include <mach/msm_xo.h> |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 64 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 65 | #ifdef CONFIG_WCD9310_CODEC |
| 66 | #include <linux/slimbus/slimbus.h> |
| 67 | #include <linux/mfd/wcd9310/core.h> |
| 68 | #include <linux/mfd/wcd9310/pdata.h> |
| 69 | #endif |
| 70 | |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 71 | #include <linux/ion.h> |
| 72 | #include <mach/ion.h> |
| 73 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 74 | #include "timer.h" |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 75 | #include "devices.h" |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 76 | #include "devices-msm8x60.h" |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 77 | #include "spm.h" |
| 78 | #include "board-msm8960.h" |
| 79 | #include "pm.h" |
| 80 | #include "cpuidle.h" |
| 81 | #include "rpm_resources.h" |
| 82 | #include "mpm.h" |
Matt Wagantall | 6d9ebee | 2011-08-26 12:15:24 -0700 | [diff] [blame] | 83 | #include "acpuclock.h" |
David Collins | 4c31a87 | 2011-08-31 10:07:10 -0700 | [diff] [blame] | 84 | #include "rpm_log.h" |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 85 | |
| 86 | static struct platform_device msm_fm_platform_init = { |
| 87 | .name = "iris_fm", |
| 88 | .id = -1, |
| 89 | }; |
| 90 | |
| 91 | struct pm8xxx_gpio_init { |
| 92 | unsigned gpio; |
| 93 | struct pm_gpio config; |
| 94 | }; |
| 95 | |
| 96 | struct pm8xxx_mpp_init { |
| 97 | unsigned mpp; |
| 98 | struct pm8xxx_mpp_config_data config; |
| 99 | }; |
| 100 | |
| 101 | #define PM8XXX_GPIO_INIT(_gpio, _dir, _buf, _val, _pull, _vin, _out_strength, \ |
| 102 | _func, _inv, _disable) \ |
| 103 | { \ |
| 104 | .gpio = PM8921_GPIO_PM_TO_SYS(_gpio), \ |
| 105 | .config = { \ |
| 106 | .direction = _dir, \ |
| 107 | .output_buffer = _buf, \ |
| 108 | .output_value = _val, \ |
| 109 | .pull = _pull, \ |
| 110 | .vin_sel = _vin, \ |
| 111 | .out_strength = _out_strength, \ |
| 112 | .function = _func, \ |
| 113 | .inv_int_pol = _inv, \ |
| 114 | .disable_pin = _disable, \ |
| 115 | } \ |
| 116 | } |
| 117 | |
| 118 | #define PM8XXX_MPP_INIT(_mpp, _type, _level, _control) \ |
| 119 | { \ |
| 120 | .mpp = PM8921_MPP_PM_TO_SYS(_mpp), \ |
| 121 | .config = { \ |
| 122 | .type = PM8XXX_MPP_TYPE_##_type, \ |
| 123 | .level = _level, \ |
| 124 | .control = PM8XXX_MPP_##_control, \ |
| 125 | } \ |
| 126 | } |
| 127 | |
| 128 | #define PM8XXX_GPIO_DISABLE(_gpio) \ |
| 129 | PM8XXX_GPIO_INIT(_gpio, PM_GPIO_DIR_IN, 0, 0, 0, PM_GPIO_VIN_S4, \ |
| 130 | 0, 0, 0, 1) |
| 131 | |
| 132 | #define PM8XXX_GPIO_OUTPUT(_gpio, _val) \ |
| 133 | PM8XXX_GPIO_INIT(_gpio, PM_GPIO_DIR_OUT, PM_GPIO_OUT_BUF_CMOS, _val, \ |
| 134 | PM_GPIO_PULL_NO, PM_GPIO_VIN_S4, \ |
| 135 | PM_GPIO_STRENGTH_HIGH, \ |
| 136 | PM_GPIO_FUNC_NORMAL, 0, 0) |
| 137 | |
| 138 | #define PM8XXX_GPIO_INPUT(_gpio, _pull) \ |
| 139 | PM8XXX_GPIO_INIT(_gpio, PM_GPIO_DIR_IN, PM_GPIO_OUT_BUF_CMOS, 0, \ |
| 140 | _pull, PM_GPIO_VIN_S4, \ |
| 141 | PM_GPIO_STRENGTH_NO, \ |
| 142 | PM_GPIO_FUNC_NORMAL, 0, 0) |
| 143 | |
| 144 | #define PM8XXX_GPIO_OUTPUT_FUNC(_gpio, _val, _func) \ |
| 145 | PM8XXX_GPIO_INIT(_gpio, PM_GPIO_DIR_OUT, PM_GPIO_OUT_BUF_CMOS, _val, \ |
| 146 | PM_GPIO_PULL_NO, PM_GPIO_VIN_S4, \ |
| 147 | PM_GPIO_STRENGTH_HIGH, \ |
| 148 | _func, 0, 0) |
| 149 | |
| 150 | /* Initial PM8921 GPIO configurations */ |
| 151 | static struct pm8xxx_gpio_init pm8921_gpios[] __initdata = { |
| 152 | PM8XXX_GPIO_DISABLE(6), /* Disable unused */ |
| 153 | PM8XXX_GPIO_DISABLE(7), /* Disable NFC */ |
| 154 | PM8XXX_GPIO_INPUT(16, PM_GPIO_PULL_UP_30), /* SD_CARD_WP */ |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 155 | /* External regulator shared by display and touchscreen on LiQUID */ |
| 156 | PM8XXX_GPIO_OUTPUT(17, 0), /* DISP 3.3 V Boost */ |
| 157 | PM8XXX_GPIO_OUTPUT(21, 1), /* Backlight Enable */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 158 | PM8XXX_GPIO_DISABLE(22), /* Disable NFC */ |
Nagamalleswararao Ganji | eac5dfa | 2011-07-23 17:31:16 -0700 | [diff] [blame] | 159 | PM8XXX_GPIO_OUTPUT_FUNC(24, 0, PM_GPIO_FUNC_2), /* Bl: Off, PWM mode */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 160 | PM8XXX_GPIO_INPUT(26, PM_GPIO_PULL_UP_30), /* SD_CARD_DET_N */ |
| 161 | PM8XXX_GPIO_OUTPUT(43, 0), /* DISP_RESET_N */ |
| 162 | }; |
| 163 | |
| 164 | /* Initial PM8921 MPP configurations */ |
| 165 | static struct pm8xxx_mpp_init pm8921_mpps[] __initdata = { |
| 166 | /* External 5V regulator enable; shared by HDMI and USB_OTG switches. */ |
| 167 | PM8XXX_MPP_INIT(7, D_INPUT, PM8921_MPP_DIG_LEVEL_VPH, DIN_TO_INT), |
| 168 | PM8XXX_MPP_INIT(PM8921_AMUX_MPP_3, A_INPUT, PM8XXX_MPP_AIN_AMUX_CH6, |
| 169 | DOUT_CTRL_LOW), |
| 170 | PM8XXX_MPP_INIT(PM8921_AMUX_MPP_8, A_INPUT, PM8XXX_MPP_AIN_AMUX_CH8, |
| 171 | DOUT_CTRL_LOW), |
| 172 | }; |
| 173 | |
| 174 | static void __init pm8921_gpio_mpp_init(void) |
| 175 | { |
| 176 | int i, rc; |
| 177 | |
| 178 | for (i = 0; i < ARRAY_SIZE(pm8921_gpios); i++) { |
| 179 | rc = pm8xxx_gpio_config(pm8921_gpios[i].gpio, |
| 180 | &pm8921_gpios[i].config); |
| 181 | if (rc) { |
| 182 | pr_err("%s: pm8xxx_gpio_config: rc=%d\n", __func__, rc); |
| 183 | break; |
| 184 | } |
| 185 | } |
| 186 | |
| 187 | for (i = 0; i < ARRAY_SIZE(pm8921_mpps); i++) { |
| 188 | rc = pm8xxx_mpp_config(pm8921_mpps[i].mpp, |
| 189 | &pm8921_mpps[i].config); |
| 190 | if (rc) { |
| 191 | pr_err("%s: pm8xxx_mpp_config: rc=%d\n", __func__, rc); |
| 192 | break; |
| 193 | } |
| 194 | } |
| 195 | } |
| 196 | |
| 197 | #define FPGA_CS_GPIO 14 |
| 198 | #define KS8851_RST_GPIO 89 |
| 199 | #define KS8851_IRQ_GPIO 90 |
| 200 | |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 201 | #if defined(CONFIG_GPIO_SX150X) || defined(CONFIG_GPIO_SX150X_MODULE) |
| 202 | enum { |
Abhijeet Dharmapurikar | 0fda560 | 2011-08-17 18:00:55 -0700 | [diff] [blame] | 203 | GPIO_EXPANDER_IRQ_BASE = (PM8921_IRQ_BASE + PM8921_NR_IRQS), |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 204 | GPIO_EXPANDER_GPIO_BASE = (PM8921_MPP_BASE + PM8921_NR_MPPS), |
| 205 | /* CAM Expander */ |
| 206 | GPIO_CAM_EXPANDER_BASE = GPIO_EXPANDER_GPIO_BASE, |
| 207 | GPIO_CAM_GP_STROBE_READY = GPIO_CAM_EXPANDER_BASE, |
| 208 | GPIO_CAM_GP_AFBUSY, |
| 209 | GPIO_CAM_GP_STROBE_CE, |
| 210 | GPIO_CAM_GP_CAM1MP_XCLR, |
| 211 | GPIO_CAM_GP_CAMIF_RESET_N, |
| 212 | GPIO_CAM_GP_XMT_FLASH_INT, |
| 213 | GPIO_CAM_GP_LED_EN1, |
| 214 | GPIO_CAM_GP_LED_EN2, |
| 215 | |
| 216 | }; |
| 217 | #endif |
| 218 | |
Harini Jayaraman | 608d046 | 2011-08-09 19:10:03 -0600 | [diff] [blame] | 219 | /* The SPI configurations apply to GSBI 1*/ |
| 220 | static struct gpiomux_setting spi_active = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 221 | .func = GPIOMUX_FUNC_1, |
| 222 | .drv = GPIOMUX_DRV_8MA, |
| 223 | .pull = GPIOMUX_PULL_NONE, |
| 224 | }; |
| 225 | |
Harini Jayaraman | 608d046 | 2011-08-09 19:10:03 -0600 | [diff] [blame] | 226 | static struct gpiomux_setting spi_suspended_config = { |
| 227 | .func = GPIOMUX_FUNC_GPIO, |
| 228 | .drv = GPIOMUX_DRV_2MA, |
| 229 | .pull = GPIOMUX_PULL_DOWN, |
| 230 | }; |
| 231 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 232 | static struct gpiomux_setting gsbi3 = { |
| 233 | .func = GPIOMUX_FUNC_1, |
| 234 | .drv = GPIOMUX_DRV_8MA, |
| 235 | .pull = GPIOMUX_PULL_NONE, |
| 236 | }; |
| 237 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 238 | static struct gpiomux_setting gsbi5 = { |
| 239 | .func = GPIOMUX_FUNC_1, |
| 240 | .drv = GPIOMUX_DRV_8MA, |
| 241 | .pull = GPIOMUX_PULL_NONE, |
| 242 | }; |
| 243 | |
| 244 | static struct gpiomux_setting gsbi10 = { |
| 245 | .func = GPIOMUX_FUNC_2, |
| 246 | .drv = GPIOMUX_DRV_8MA, |
| 247 | .pull = GPIOMUX_PULL_NONE, |
| 248 | }; |
| 249 | |
| 250 | static struct gpiomux_setting gsbi12 = { |
| 251 | .func = GPIOMUX_FUNC_1, |
| 252 | .drv = GPIOMUX_DRV_8MA, |
| 253 | .pull = GPIOMUX_PULL_NONE, |
| 254 | }; |
| 255 | |
| 256 | static struct gpiomux_setting cdc_mclk = { |
| 257 | .func = GPIOMUX_FUNC_1, |
| 258 | .drv = GPIOMUX_DRV_8MA, |
| 259 | .pull = GPIOMUX_PULL_NONE, |
| 260 | }; |
| 261 | |
Stepan Moskovchenko | 41d16827 | 2011-08-09 17:09:42 -0700 | [diff] [blame] | 262 | #ifdef CONFIG_KS8851 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 263 | static struct gpiomux_setting gpio_eth_config = { |
| 264 | .pull = GPIOMUX_PULL_NONE, |
| 265 | .drv = GPIOMUX_DRV_8MA, |
| 266 | .func = GPIOMUX_FUNC_GPIO, |
| 267 | }; |
Stepan Moskovchenko | 41d16827 | 2011-08-09 17:09:42 -0700 | [diff] [blame] | 268 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 269 | |
| 270 | static struct gpiomux_setting slimbus = { |
| 271 | .func = GPIOMUX_FUNC_1, |
| 272 | .drv = GPIOMUX_DRV_8MA, |
| 273 | .pull = GPIOMUX_PULL_KEEPER, |
| 274 | }; |
| 275 | |
| 276 | struct msm_gpiomux_config msm8960_gpiomux_configs[NR_GPIO_IRQS] = { |
Stepan Moskovchenko | 41d16827 | 2011-08-09 17:09:42 -0700 | [diff] [blame] | 277 | #ifdef CONFIG_KS8851 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 278 | { |
| 279 | .gpio = KS8851_IRQ_GPIO, |
| 280 | .settings = { |
| 281 | [GPIOMUX_SUSPENDED] = &gpio_eth_config, |
| 282 | } |
| 283 | }, |
| 284 | { |
| 285 | .gpio = KS8851_RST_GPIO, |
| 286 | .settings = { |
| 287 | [GPIOMUX_SUSPENDED] = &gpio_eth_config, |
| 288 | } |
| 289 | }, |
| 290 | { |
| 291 | .gpio = FPGA_CS_GPIO, |
| 292 | .settings = { |
| 293 | [GPIOMUX_SUSPENDED] = &gpio_eth_config, |
| 294 | } |
| 295 | }, |
Stepan Moskovchenko | 41d16827 | 2011-08-09 17:09:42 -0700 | [diff] [blame] | 296 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 297 | }; |
| 298 | |
| 299 | static struct msm_gpiomux_config msm8960_gsbi_configs[] __initdata = { |
| 300 | { |
| 301 | .gpio = 6, /* GSBI1 QUP SPI_DATA_MOSI */ |
| 302 | .settings = { |
Harini Jayaraman | 608d046 | 2011-08-09 19:10:03 -0600 | [diff] [blame] | 303 | [GPIOMUX_SUSPENDED] = &spi_suspended_config, |
| 304 | [GPIOMUX_ACTIVE] = &spi_active, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 305 | }, |
| 306 | }, |
| 307 | { |
| 308 | .gpio = 7, /* GSBI1 QUP SPI_DATA_MISO */ |
| 309 | .settings = { |
Harini Jayaraman | 608d046 | 2011-08-09 19:10:03 -0600 | [diff] [blame] | 310 | [GPIOMUX_SUSPENDED] = &spi_suspended_config, |
| 311 | [GPIOMUX_ACTIVE] = &spi_active, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 312 | }, |
| 313 | }, |
| 314 | { |
| 315 | .gpio = 8, /* GSBI1 QUP SPI_CS_N */ |
| 316 | .settings = { |
Harini Jayaraman | 608d046 | 2011-08-09 19:10:03 -0600 | [diff] [blame] | 317 | [GPIOMUX_SUSPENDED] = &spi_suspended_config, |
| 318 | [GPIOMUX_ACTIVE] = &spi_active, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 319 | }, |
| 320 | }, |
| 321 | { |
| 322 | .gpio = 9, /* GSBI1 QUP SPI_CLK */ |
| 323 | .settings = { |
Harini Jayaraman | 608d046 | 2011-08-09 19:10:03 -0600 | [diff] [blame] | 324 | [GPIOMUX_SUSPENDED] = &spi_suspended_config, |
| 325 | [GPIOMUX_ACTIVE] = &spi_active, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 326 | }, |
| 327 | }, |
| 328 | { |
| 329 | .gpio = 16, /* GSBI3 I2C QUP SDA */ |
| 330 | .settings = { |
| 331 | [GPIOMUX_SUSPENDED] = &gsbi3, |
| 332 | }, |
| 333 | }, |
| 334 | { |
| 335 | .gpio = 17, /* GSBI3 I2C QUP SCL */ |
| 336 | .settings = { |
| 337 | [GPIOMUX_SUSPENDED] = &gsbi3, |
| 338 | }, |
| 339 | }, |
| 340 | { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 341 | .gpio = 22, /* GSBI5 UART2 */ |
| 342 | .settings = { |
| 343 | [GPIOMUX_SUSPENDED] = &gsbi5, |
| 344 | }, |
| 345 | }, |
| 346 | { |
| 347 | .gpio = 23, /* GSBI5 UART2 */ |
| 348 | .settings = { |
| 349 | [GPIOMUX_SUSPENDED] = &gsbi5, |
| 350 | }, |
| 351 | }, |
| 352 | { |
| 353 | .gpio = 24, /* GSBI5 UART2 */ |
| 354 | .settings = { |
| 355 | [GPIOMUX_SUSPENDED] = &gsbi5, |
| 356 | }, |
| 357 | }, |
| 358 | { |
| 359 | .gpio = 25, /* GSBI5 UART2 */ |
| 360 | .settings = { |
| 361 | [GPIOMUX_SUSPENDED] = &gsbi5, |
| 362 | }, |
| 363 | }, |
| 364 | { |
| 365 | .gpio = 44, /* GSBI12 I2C QUP SDA */ |
| 366 | .settings = { |
| 367 | [GPIOMUX_SUSPENDED] = &gsbi12, |
| 368 | }, |
| 369 | }, |
| 370 | { |
| 371 | .gpio = 45, /* GSBI12 I2C QUP SCL */ |
| 372 | .settings = { |
| 373 | [GPIOMUX_SUSPENDED] = &gsbi12, |
| 374 | }, |
| 375 | }, |
| 376 | { |
| 377 | .gpio = 73, /* GSBI10 I2C QUP SDA */ |
| 378 | .settings = { |
| 379 | [GPIOMUX_SUSPENDED] = &gsbi10, |
| 380 | }, |
| 381 | }, |
| 382 | { |
| 383 | .gpio = 74, /* GSBI10 I2C QUP SCL */ |
| 384 | .settings = { |
| 385 | [GPIOMUX_SUSPENDED] = &gsbi10, |
| 386 | }, |
| 387 | }, |
| 388 | }; |
| 389 | |
| 390 | static struct msm_gpiomux_config msm8960_slimbus_config[] __initdata = { |
| 391 | { |
| 392 | .gpio = 60, /* slimbus data */ |
| 393 | .settings = { |
| 394 | [GPIOMUX_SUSPENDED] = &slimbus, |
| 395 | }, |
| 396 | }, |
| 397 | { |
| 398 | .gpio = 61, /* slimbus clk */ |
| 399 | .settings = { |
| 400 | [GPIOMUX_SUSPENDED] = &slimbus, |
| 401 | }, |
| 402 | }, |
| 403 | }; |
| 404 | |
| 405 | static struct msm_gpiomux_config msm8960_audio_codec_configs[] __initdata = { |
| 406 | { |
| 407 | .gpio = 59, |
| 408 | .settings = { |
| 409 | [GPIOMUX_SUSPENDED] = &cdc_mclk, |
| 410 | }, |
| 411 | }, |
| 412 | }; |
| 413 | static struct gpiomux_setting wcnss_5wire_suspend_cfg = { |
| 414 | .func = GPIOMUX_FUNC_GPIO, |
| 415 | .drv = GPIOMUX_DRV_2MA, |
| 416 | .pull = GPIOMUX_PULL_NONE, |
| 417 | }; |
| 418 | |
| 419 | static struct gpiomux_setting wcnss_5wire_active_cfg = { |
| 420 | .func = GPIOMUX_FUNC_1, |
| 421 | .drv = GPIOMUX_DRV_6MA, |
| 422 | .pull = GPIOMUX_PULL_DOWN, |
| 423 | }; |
| 424 | |
| 425 | static struct msm_gpiomux_config wcnss_5wire_interface[] = { |
| 426 | { |
| 427 | .gpio = 84, |
| 428 | .settings = { |
| 429 | [GPIOMUX_ACTIVE] = &wcnss_5wire_active_cfg, |
| 430 | [GPIOMUX_SUSPENDED] = &wcnss_5wire_suspend_cfg, |
| 431 | }, |
| 432 | }, |
| 433 | { |
| 434 | .gpio = 85, |
| 435 | .settings = { |
| 436 | [GPIOMUX_ACTIVE] = &wcnss_5wire_active_cfg, |
| 437 | [GPIOMUX_SUSPENDED] = &wcnss_5wire_suspend_cfg, |
| 438 | }, |
| 439 | }, |
| 440 | { |
| 441 | .gpio = 86, |
| 442 | .settings = { |
| 443 | [GPIOMUX_ACTIVE] = &wcnss_5wire_active_cfg, |
| 444 | [GPIOMUX_SUSPENDED] = &wcnss_5wire_suspend_cfg, |
| 445 | }, |
| 446 | }, |
| 447 | { |
| 448 | .gpio = 87, |
| 449 | .settings = { |
| 450 | [GPIOMUX_ACTIVE] = &wcnss_5wire_active_cfg, |
| 451 | [GPIOMUX_SUSPENDED] = &wcnss_5wire_suspend_cfg, |
| 452 | }, |
| 453 | }, |
| 454 | { |
| 455 | .gpio = 88, |
| 456 | .settings = { |
| 457 | [GPIOMUX_ACTIVE] = &wcnss_5wire_active_cfg, |
| 458 | [GPIOMUX_SUSPENDED] = &wcnss_5wire_suspend_cfg, |
| 459 | }, |
| 460 | }, |
| 461 | }; |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 462 | static struct gpiomux_setting cam_settings[] = { |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 463 | { |
| 464 | .func = GPIOMUX_FUNC_GPIO, /*suspend*/ |
| 465 | .drv = GPIOMUX_DRV_2MA, |
| 466 | .pull = GPIOMUX_PULL_DOWN, |
| 467 | }, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 468 | |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 469 | { |
| 470 | .func = GPIOMUX_FUNC_1, /*active 1*/ |
| 471 | .drv = GPIOMUX_DRV_2MA, |
| 472 | .pull = GPIOMUX_PULL_NONE, |
| 473 | }, |
| 474 | |
| 475 | { |
| 476 | .func = GPIOMUX_FUNC_GPIO, /*active 2*/ |
| 477 | .drv = GPIOMUX_DRV_2MA, |
| 478 | .pull = GPIOMUX_PULL_NONE, |
| 479 | }, |
| 480 | |
| 481 | { |
| 482 | .func = GPIOMUX_FUNC_1, /*active 3*/ |
| 483 | .drv = GPIOMUX_DRV_8MA, |
Kevin Chan | 4c58d29 | 2011-09-13 11:03:25 -0700 | [diff] [blame^] | 484 | .pull = GPIOMUX_PULL_NONE, |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 485 | }, |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 486 | |
| 487 | { |
| 488 | .func = GPIOMUX_FUNC_5, /*active 4*/ |
| 489 | .drv = GPIOMUX_DRV_8MA, |
| 490 | .pull = GPIOMUX_PULL_UP, |
| 491 | }, |
| 492 | |
| 493 | { |
| 494 | .func = GPIOMUX_FUNC_6, /*active 5*/ |
| 495 | .drv = GPIOMUX_DRV_8MA, |
| 496 | .pull = GPIOMUX_PULL_UP, |
| 497 | }, |
| 498 | |
| 499 | { |
| 500 | .func = GPIOMUX_FUNC_2, /*active 6*/ |
| 501 | .drv = GPIOMUX_DRV_2MA, |
| 502 | .pull = GPIOMUX_PULL_UP, |
| 503 | }, |
| 504 | |
| 505 | { |
| 506 | .func = GPIOMUX_FUNC_3, /*active 7*/ |
| 507 | .drv = GPIOMUX_DRV_8MA, |
| 508 | .pull = GPIOMUX_PULL_UP, |
| 509 | }, |
| 510 | |
Kevin Chan | 4c58d29 | 2011-09-13 11:03:25 -0700 | [diff] [blame^] | 511 | { |
| 512 | .func = GPIOMUX_FUNC_GPIO, /*i2c suspend*/ |
| 513 | .drv = GPIOMUX_DRV_2MA, |
| 514 | .pull = GPIOMUX_PULL_KEEPER, |
| 515 | }, |
| 516 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 517 | }; |
| 518 | |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 519 | static struct msm_gpiomux_config msm8960_cam_common_configs[] = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 520 | { |
| 521 | .gpio = 2, |
| 522 | .settings = { |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 523 | [GPIOMUX_ACTIVE] = &cam_settings[2], |
| 524 | [GPIOMUX_SUSPENDED] = &cam_settings[0], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 525 | }, |
| 526 | }, |
| 527 | { |
| 528 | .gpio = 3, |
| 529 | .settings = { |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 530 | [GPIOMUX_ACTIVE] = &cam_settings[1], |
| 531 | [GPIOMUX_SUSPENDED] = &cam_settings[0], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 532 | }, |
| 533 | }, |
| 534 | { |
| 535 | .gpio = 4, |
| 536 | .settings = { |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 537 | [GPIOMUX_ACTIVE] = &cam_settings[1], |
| 538 | [GPIOMUX_SUSPENDED] = &cam_settings[0], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 539 | }, |
| 540 | }, |
| 541 | { |
| 542 | .gpio = 5, |
| 543 | .settings = { |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 544 | [GPIOMUX_ACTIVE] = &cam_settings[1], |
| 545 | [GPIOMUX_SUSPENDED] = &cam_settings[0], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 546 | }, |
| 547 | }, |
| 548 | { |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 549 | .gpio = 76, |
| 550 | .settings = { |
| 551 | [GPIOMUX_ACTIVE] = &cam_settings[2], |
| 552 | [GPIOMUX_SUSPENDED] = &cam_settings[0], |
| 553 | }, |
| 554 | }, |
| 555 | { |
| 556 | .gpio = 107, |
| 557 | .settings = { |
| 558 | [GPIOMUX_ACTIVE] = &cam_settings[2], |
| 559 | [GPIOMUX_SUSPENDED] = &cam_settings[0], |
| 560 | }, |
| 561 | }, |
| 562 | }; |
| 563 | |
| 564 | static struct msm_gpiomux_config msm8960_cam_2d_configs[] = { |
| 565 | { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 566 | .gpio = 18, |
| 567 | .settings = { |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 568 | [GPIOMUX_ACTIVE] = &cam_settings[3], |
Kevin Chan | 4c58d29 | 2011-09-13 11:03:25 -0700 | [diff] [blame^] | 569 | [GPIOMUX_SUSPENDED] = &cam_settings[8], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 570 | }, |
| 571 | }, |
| 572 | { |
| 573 | .gpio = 19, |
| 574 | .settings = { |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 575 | [GPIOMUX_ACTIVE] = &cam_settings[3], |
Kevin Chan | 4c58d29 | 2011-09-13 11:03:25 -0700 | [diff] [blame^] | 576 | [GPIOMUX_SUSPENDED] = &cam_settings[8], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 577 | }, |
| 578 | }, |
| 579 | { |
| 580 | .gpio = 20, |
| 581 | .settings = { |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 582 | [GPIOMUX_ACTIVE] = &cam_settings[3], |
Kevin Chan | 4c58d29 | 2011-09-13 11:03:25 -0700 | [diff] [blame^] | 583 | [GPIOMUX_SUSPENDED] = &cam_settings[8], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 584 | }, |
| 585 | }, |
| 586 | { |
| 587 | .gpio = 21, |
| 588 | .settings = { |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 589 | [GPIOMUX_ACTIVE] = &cam_settings[3], |
Kevin Chan | 4c58d29 | 2011-09-13 11:03:25 -0700 | [diff] [blame^] | 590 | [GPIOMUX_SUSPENDED] = &cam_settings[8], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 591 | }, |
| 592 | }, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 593 | }; |
| 594 | |
| 595 | static struct gpiomux_setting cyts_resout_sus_cfg = { |
| 596 | .func = GPIOMUX_FUNC_GPIO, |
| 597 | .drv = GPIOMUX_DRV_6MA, |
| 598 | .pull = GPIOMUX_PULL_UP, |
| 599 | }; |
| 600 | |
| 601 | static struct gpiomux_setting cyts_resout_act_cfg = { |
| 602 | .func = GPIOMUX_FUNC_GPIO, |
| 603 | .drv = GPIOMUX_DRV_6MA, |
| 604 | .pull = GPIOMUX_PULL_UP, |
| 605 | }; |
| 606 | |
| 607 | static struct gpiomux_setting cyts_sleep_sus_cfg = { |
| 608 | .func = GPIOMUX_FUNC_GPIO, |
| 609 | .drv = GPIOMUX_DRV_6MA, |
| 610 | .pull = GPIOMUX_PULL_DOWN, |
| 611 | }; |
| 612 | |
| 613 | static struct gpiomux_setting cyts_sleep_act_cfg = { |
| 614 | .func = GPIOMUX_FUNC_GPIO, |
| 615 | .drv = GPIOMUX_DRV_6MA, |
| 616 | .pull = GPIOMUX_PULL_DOWN, |
| 617 | }; |
| 618 | |
| 619 | static struct gpiomux_setting cyts_int_act_cfg = { |
| 620 | .func = GPIOMUX_FUNC_GPIO, |
| 621 | .drv = GPIOMUX_DRV_8MA, |
| 622 | .pull = GPIOMUX_PULL_UP, |
| 623 | }; |
| 624 | |
| 625 | static struct gpiomux_setting cyts_int_sus_cfg = { |
| 626 | .func = GPIOMUX_FUNC_GPIO, |
| 627 | .drv = GPIOMUX_DRV_2MA, |
| 628 | .pull = GPIOMUX_PULL_UP, |
| 629 | }; |
| 630 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 631 | static struct msm_gpiomux_config msm8960_cyts_configs[] __initdata = { |
| 632 | { /* TS INTERRUPT */ |
| 633 | .gpio = 11, |
| 634 | .settings = { |
| 635 | [GPIOMUX_ACTIVE] = &cyts_int_act_cfg, |
| 636 | [GPIOMUX_SUSPENDED] = &cyts_int_sus_cfg, |
| 637 | }, |
| 638 | }, |
| 639 | { /* TS SLEEP */ |
| 640 | .gpio = 50, |
| 641 | .settings = { |
| 642 | [GPIOMUX_ACTIVE] = &cyts_sleep_act_cfg, |
| 643 | [GPIOMUX_SUSPENDED] = &cyts_sleep_sus_cfg, |
| 644 | }, |
| 645 | }, |
| 646 | { /* TS RESOUT */ |
| 647 | .gpio = 52, |
| 648 | .settings = { |
| 649 | [GPIOMUX_ACTIVE] = &cyts_resout_act_cfg, |
| 650 | [GPIOMUX_SUSPENDED] = &cyts_resout_sus_cfg, |
| 651 | }, |
| 652 | }, |
| 653 | }; |
| 654 | |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 655 | #if defined(CONFIG_GPIO_SX150X) || defined(CONFIG_GPIO_SX150X_MODULE) |
| 656 | enum { |
| 657 | SX150X_CAM, |
| 658 | }; |
| 659 | |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 660 | static struct sx150x_platform_data sx150x_data[] = { |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 661 | [SX150X_CAM] = { |
| 662 | .gpio_base = GPIO_CAM_EXPANDER_BASE, |
| 663 | .oscio_is_gpo = false, |
| 664 | .io_pullup_ena = 0x0, |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 665 | .io_pulldn_ena = 0xc0, |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 666 | .io_open_drain_ena = 0x0, |
| 667 | .irq_summary = -1, |
| 668 | }, |
| 669 | }; |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 670 | |
| 671 | #endif |
| 672 | |
| 673 | #ifdef CONFIG_I2C |
| 674 | |
| 675 | #define MSM_8960_GSBI4_QUP_I2C_BUS_ID 4 |
| 676 | #define MSM_8960_GSBI3_QUP_I2C_BUS_ID 3 |
| 677 | |
| 678 | #if defined(CONFIG_GPIO_SX150X) || defined(CONFIG_GPIO_SX150X_MODULE) |
| 679 | |
| 680 | static struct i2c_board_info cam_expander_i2c_info[] = { |
| 681 | { |
| 682 | I2C_BOARD_INFO("sx1508q", 0x22), |
| 683 | .platform_data = &sx150x_data[SX150X_CAM] |
| 684 | }, |
| 685 | }; |
| 686 | |
| 687 | static struct msm_cam_expander_info cam_expander_info[] = { |
| 688 | { |
| 689 | cam_expander_i2c_info, |
| 690 | MSM_8960_GSBI4_QUP_I2C_BUS_ID, |
| 691 | }, |
| 692 | }; |
| 693 | #endif |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 694 | #endif |
| 695 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 696 | #define MSM_PMEM_KERNEL_EBI1_SIZE 0x110C000 |
| 697 | #define MSM_PMEM_ADSP_SIZE 0x3800000 |
Ben Romberger | 09e462d | 2011-08-09 15:24:37 -0700 | [diff] [blame] | 698 | #define MSM_PMEM_AUDIO_SIZE 0x28B000 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 699 | #define MSM_PMEM_SIZE 0x1800000 /* 24 Mbytes */ |
| 700 | |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 701 | #define MSM_ION_EBI_SIZE SZ_8M |
| 702 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 703 | #ifdef CONFIG_KERNEL_PMEM_EBI_REGION |
| 704 | static unsigned pmem_kernel_ebi1_size = MSM_PMEM_KERNEL_EBI1_SIZE; |
| 705 | static int __init pmem_kernel_ebi1_size_setup(char *p) |
| 706 | { |
| 707 | pmem_kernel_ebi1_size = memparse(p, NULL); |
| 708 | return 0; |
| 709 | } |
| 710 | early_param("pmem_kernel_ebi1_size", pmem_kernel_ebi1_size_setup); |
| 711 | #endif |
| 712 | |
| 713 | #ifdef CONFIG_ANDROID_PMEM |
| 714 | static unsigned pmem_size = MSM_PMEM_SIZE; |
| 715 | static int __init pmem_size_setup(char *p) |
| 716 | { |
| 717 | pmem_size = memparse(p, NULL); |
| 718 | return 0; |
| 719 | } |
| 720 | early_param("pmem_size", pmem_size_setup); |
| 721 | |
| 722 | static unsigned pmem_adsp_size = MSM_PMEM_ADSP_SIZE; |
| 723 | |
| 724 | static int __init pmem_adsp_size_setup(char *p) |
| 725 | { |
| 726 | pmem_adsp_size = memparse(p, NULL); |
| 727 | return 0; |
| 728 | } |
| 729 | early_param("pmem_adsp_size", pmem_adsp_size_setup); |
| 730 | |
| 731 | static unsigned pmem_audio_size = MSM_PMEM_AUDIO_SIZE; |
| 732 | |
| 733 | static int __init pmem_audio_size_setup(char *p) |
| 734 | { |
| 735 | pmem_audio_size = memparse(p, NULL); |
| 736 | return 0; |
| 737 | } |
| 738 | early_param("pmem_audio_size", pmem_audio_size_setup); |
| 739 | #endif |
| 740 | |
| 741 | #ifdef CONFIG_ANDROID_PMEM |
| 742 | static struct android_pmem_platform_data android_pmem_pdata = { |
| 743 | .name = "pmem", |
| 744 | .allocator_type = PMEM_ALLOCATORTYPE_ALLORNOTHING, |
| 745 | .cached = 1, |
| 746 | .memory_type = MEMTYPE_EBI1, |
| 747 | }; |
| 748 | |
| 749 | static struct platform_device android_pmem_device = { |
| 750 | .name = "android_pmem", |
| 751 | .id = 0, |
| 752 | .dev = {.platform_data = &android_pmem_pdata}, |
| 753 | }; |
| 754 | |
| 755 | static struct android_pmem_platform_data android_pmem_adsp_pdata = { |
| 756 | .name = "pmem_adsp", |
| 757 | .allocator_type = PMEM_ALLOCATORTYPE_BITMAP, |
| 758 | .cached = 0, |
| 759 | .memory_type = MEMTYPE_EBI1, |
| 760 | }; |
| 761 | static struct platform_device android_pmem_adsp_device = { |
| 762 | .name = "android_pmem", |
| 763 | .id = 2, |
| 764 | .dev = { .platform_data = &android_pmem_adsp_pdata }, |
| 765 | }; |
| 766 | |
| 767 | static struct android_pmem_platform_data android_pmem_audio_pdata = { |
| 768 | .name = "pmem_audio", |
| 769 | .allocator_type = PMEM_ALLOCATORTYPE_BITMAP, |
| 770 | .cached = 0, |
| 771 | .memory_type = MEMTYPE_EBI1, |
| 772 | }; |
| 773 | |
| 774 | static struct platform_device android_pmem_audio_device = { |
| 775 | .name = "android_pmem", |
| 776 | .id = 4, |
| 777 | .dev = { .platform_data = &android_pmem_audio_pdata }, |
| 778 | }; |
| 779 | #endif |
| 780 | |
| 781 | static struct memtype_reserve msm8960_reserve_table[] __initdata = { |
| 782 | [MEMTYPE_SMI] = { |
| 783 | }, |
| 784 | [MEMTYPE_EBI0] = { |
| 785 | .flags = MEMTYPE_FLAGS_1M_ALIGN, |
| 786 | }, |
| 787 | [MEMTYPE_EBI1] = { |
| 788 | .flags = MEMTYPE_FLAGS_1M_ALIGN, |
| 789 | }, |
| 790 | }; |
| 791 | |
| 792 | static void __init size_pmem_devices(void) |
| 793 | { |
| 794 | #ifdef CONFIG_ANDROID_PMEM |
| 795 | android_pmem_adsp_pdata.size = pmem_adsp_size; |
| 796 | android_pmem_pdata.size = pmem_size; |
| 797 | android_pmem_audio_pdata.size = MSM_PMEM_AUDIO_SIZE; |
| 798 | #endif |
| 799 | } |
| 800 | |
| 801 | static void __init reserve_memory_for(struct android_pmem_platform_data *p) |
| 802 | { |
| 803 | msm8960_reserve_table[p->memory_type].size += p->size; |
| 804 | } |
| 805 | |
| 806 | static void __init reserve_pmem_memory(void) |
| 807 | { |
| 808 | #ifdef CONFIG_ANDROID_PMEM |
| 809 | reserve_memory_for(&android_pmem_adsp_pdata); |
| 810 | reserve_memory_for(&android_pmem_pdata); |
| 811 | reserve_memory_for(&android_pmem_audio_pdata); |
| 812 | msm8960_reserve_table[MEMTYPE_EBI1].size += pmem_kernel_ebi1_size; |
| 813 | #endif |
| 814 | } |
| 815 | |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 816 | static int msm8960_paddr_to_memtype(unsigned int paddr) |
| 817 | { |
| 818 | return MEMTYPE_EBI1; |
| 819 | } |
| 820 | |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 821 | #ifdef CONFIG_ION_MSM |
| 822 | struct ion_platform_data ion_pdata = { |
| 823 | .nr = 3, |
| 824 | .heaps = { |
| 825 | { |
| 826 | .id = ION_HEAP_SYSTEM_ID, |
| 827 | .type = ION_HEAP_TYPE_SYSTEM, |
| 828 | .name = ION_KMALLOC_HEAP_NAME, |
| 829 | }, |
| 830 | { |
| 831 | .id = ION_HEAP_SYSTEM_CONTIG_ID, |
| 832 | .type = ION_HEAP_TYPE_SYSTEM_CONTIG, |
| 833 | .name = ION_VMALLOC_HEAP_NAME, |
| 834 | }, |
| 835 | { |
| 836 | .id = ION_HEAP_EBI_ID, |
| 837 | .type = ION_HEAP_TYPE_CARVEOUT, |
| 838 | .name = ION_EBI1_HEAP_NAME, |
| 839 | .size = MSM_ION_EBI_SIZE, |
| 840 | .memory_type = ION_EBI_TYPE, |
| 841 | }, |
| 842 | } |
| 843 | }; |
| 844 | |
| 845 | struct platform_device ion_dev = { |
| 846 | .name = "ion-msm", |
| 847 | .id = 1, |
| 848 | .dev = { .platform_data = &ion_pdata }, |
| 849 | }; |
| 850 | #endif |
| 851 | |
| 852 | static void reserve_ion_memory(void) |
| 853 | { |
| 854 | #ifdef CONFIG_ION_MSM |
| 855 | msm8960_reserve_table[MEMTYPE_EBI1].size += MSM_ION_EBI_SIZE; |
| 856 | #endif |
| 857 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 858 | static void __init msm8960_calculate_reserve_sizes(void) |
| 859 | { |
| 860 | size_pmem_devices(); |
| 861 | reserve_pmem_memory(); |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 862 | reserve_ion_memory(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 863 | } |
| 864 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 865 | static struct reserve_info msm8960_reserve_info __initdata = { |
| 866 | .memtype_reserve_table = msm8960_reserve_table, |
| 867 | .calculate_reserve_sizes = msm8960_calculate_reserve_sizes, |
| 868 | .paddr_to_memtype = msm8960_paddr_to_memtype, |
| 869 | }; |
| 870 | |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 871 | static int msm8960_memory_bank_size(void) |
| 872 | { |
| 873 | return 1<<29; |
| 874 | } |
| 875 | |
| 876 | static void __init locate_unstable_memory(void) |
| 877 | { |
| 878 | struct membank *mb = &meminfo.bank[meminfo.nr_banks - 1]; |
| 879 | unsigned long bank_size; |
| 880 | unsigned long low, high; |
| 881 | |
| 882 | bank_size = msm8960_memory_bank_size(); |
| 883 | low = meminfo.bank[0].start; |
| 884 | high = mb->start + mb->size; |
| 885 | low &= ~(bank_size - 1); |
| 886 | |
| 887 | if (high - low <= bank_size) |
| 888 | return; |
| 889 | msm8960_reserve_info.low_unstable_address = low + bank_size; |
| 890 | msm8960_reserve_info.max_unstable_size = high - low - bank_size; |
| 891 | msm8960_reserve_info.bank_size = bank_size; |
| 892 | pr_info("low unstable address %lx max size %lx bank size %lx\n", |
| 893 | msm8960_reserve_info.low_unstable_address, |
| 894 | msm8960_reserve_info.max_unstable_size, |
| 895 | msm8960_reserve_info.bank_size); |
| 896 | } |
| 897 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 898 | static void __init msm8960_reserve(void) |
| 899 | { |
| 900 | reserve_info = &msm8960_reserve_info; |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 901 | locate_unstable_memory(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 902 | msm_reserve(); |
| 903 | } |
| 904 | |
Larry Bassel | a4414b1 | 2011-08-04 11:11:02 -0700 | [diff] [blame] | 905 | static int msm8960_change_memory_power(u64 start, u64 size, |
| 906 | int change_type) |
Larry Bassel | a7eadea | 2011-07-14 10:46:00 -0700 | [diff] [blame] | 907 | { |
Larry Bassel | a4414b1 | 2011-08-04 11:11:02 -0700 | [diff] [blame] | 908 | return size; |
Larry Bassel | a7eadea | 2011-07-14 10:46:00 -0700 | [diff] [blame] | 909 | } |
| 910 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 911 | #ifdef CONFIG_MSM_CAMERA |
| 912 | |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 913 | static uint16_t msm_cam_gpio_2d_tbl[] = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 914 | 5, /*CAMIF_MCLK*/ |
| 915 | 20, /*CAMIF_I2C_DATA*/ |
| 916 | 21, /*CAMIF_I2C_CLK*/ |
| 917 | }; |
| 918 | |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 919 | static struct msm_camera_gpio_conf gpio_conf = { |
| 920 | .cam_gpiomux_conf_tbl = msm8960_cam_2d_configs, |
| 921 | .cam_gpiomux_conf_tbl_size = ARRAY_SIZE(msm8960_cam_2d_configs), |
| 922 | .cam_gpio_tbl = msm_cam_gpio_2d_tbl, |
| 923 | .cam_gpio_tbl_size = ARRAY_SIZE(msm_cam_gpio_2d_tbl), |
| 924 | }; |
| 925 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 926 | #define VFE_CAMIF_TIMER1_GPIO 2 |
| 927 | #define VFE_CAMIF_TIMER2_GPIO 3 |
| 928 | #define VFE_CAMIF_TIMER3_GPIO_INT 4 |
| 929 | struct msm_camera_sensor_strobe_flash_data strobe_flash_xenon = { |
| 930 | .flash_trigger = VFE_CAMIF_TIMER2_GPIO, |
| 931 | .flash_charge = VFE_CAMIF_TIMER1_GPIO, |
| 932 | .flash_charge_done = VFE_CAMIF_TIMER3_GPIO_INT, |
| 933 | .flash_recharge_duration = 50000, |
| 934 | .irq = MSM_GPIO_TO_INT(VFE_CAMIF_TIMER3_GPIO_INT), |
| 935 | }; |
| 936 | |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 937 | #ifdef CONFIG_MSM_CAMERA_FLASH |
| 938 | static struct msm_camera_sensor_flash_src msm_flash_src = { |
| 939 | .flash_sr_type = MSM_CAMERA_FLASH_SRC_EXT, |
| 940 | ._fsrc.ext_driver_src.led_en = GPIO_CAM_GP_LED_EN1, |
| 941 | ._fsrc.ext_driver_src.led_flash_en = GPIO_CAM_GP_LED_EN2, |
| 942 | #if defined(CONFIG_I2C) && (defined(CONFIG_GPIO_SX150X) || \ |
| 943 | defined(CONFIG_GPIO_SX150X_MODULE)) |
| 944 | ._fsrc.ext_driver_src.expander_info = cam_expander_info, |
| 945 | #endif |
| 946 | }; |
| 947 | #endif |
| 948 | |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 949 | struct msm_camera_device_platform_data msm_camera_csi_device_data[] = { |
| 950 | { |
| 951 | .ioclk.mclk_clk_rate = 24000000, |
| 952 | .ioclk.vfe_clk_rate = 228570000, |
| 953 | .csid_core = 0, |
| 954 | }, |
| 955 | { |
| 956 | .ioclk.mclk_clk_rate = 24000000, |
| 957 | .ioclk.vfe_clk_rate = 228570000, |
| 958 | .csid_core = 1, |
| 959 | }, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 960 | }; |
| 961 | |
| 962 | #ifdef CONFIG_IMX074 |
| 963 | static struct msm_camera_sensor_flash_data flash_imx074 = { |
| 964 | .flash_type = MSM_CAMERA_FLASH_LED, |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 965 | #ifdef CONFIG_MSM_CAMERA_FLASH |
| 966 | .flash_src = &msm_flash_src |
| 967 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 968 | }; |
| 969 | |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 970 | static struct msm_camera_sensor_platform_info sensor_board_info_imx074 = { |
| 971 | .mount_angle = 90, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 972 | .sensor_reset = 107, |
| 973 | .sensor_pwd = 85, |
| 974 | .vcm_pwd = 0, |
| 975 | .vcm_enable = 1, |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 976 | }; |
| 977 | |
| 978 | static struct msm_camera_sensor_info msm_camera_sensor_imx074_data = { |
| 979 | .sensor_name = "imx074", |
| 980 | .pdata = &msm_camera_csi_device_data[0], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 981 | .flash_data = &flash_imx074, |
| 982 | .strobe_flash_data = &strobe_flash_xenon, |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 983 | .sensor_platform_info = &sensor_board_info_imx074, |
| 984 | .gpio_conf = &gpio_conf, |
| 985 | .csi_if = 1, |
| 986 | .camera_type = BACK_CAMERA_2D, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 987 | }; |
| 988 | |
| 989 | struct platform_device msm8960_camera_sensor_imx074 = { |
| 990 | .name = "msm_camera_imx074", |
| 991 | .dev = { |
| 992 | .platform_data = &msm_camera_sensor_imx074_data, |
| 993 | }, |
| 994 | }; |
| 995 | #endif |
| 996 | #ifdef CONFIG_OV2720 |
| 997 | static struct msm_camera_sensor_flash_data flash_ov2720 = { |
Kevin Chan | 1a99033 | 2011-07-26 20:31:23 -0700 | [diff] [blame] | 998 | .flash_type = MSM_CAMERA_FLASH_NONE, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 999 | }; |
| 1000 | |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 1001 | static struct msm_camera_sensor_platform_info sensor_board_info_ov2720 = { |
| 1002 | .mount_angle = 0, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1003 | .sensor_reset = 76, |
| 1004 | .sensor_pwd = 85, |
| 1005 | .vcm_pwd = 0, |
| 1006 | .vcm_enable = 1, |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 1007 | }; |
| 1008 | |
| 1009 | static struct msm_camera_sensor_info msm_camera_sensor_ov2720_data = { |
| 1010 | .sensor_name = "ov2720", |
| 1011 | .pdata = &msm_camera_csi_device_data[1], |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1012 | .flash_data = &flash_ov2720, |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 1013 | .sensor_platform_info = &sensor_board_info_ov2720, |
| 1014 | .gpio_conf = &gpio_conf, |
| 1015 | .csi_if = 1, |
| 1016 | .camera_type = FRONT_CAMERA_2D, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1017 | }; |
| 1018 | |
| 1019 | struct platform_device msm8960_camera_sensor_ov2720 = { |
| 1020 | .name = "msm_camera_ov2720", |
| 1021 | .dev = { |
| 1022 | .platform_data = &msm_camera_sensor_ov2720_data, |
| 1023 | }, |
| 1024 | }; |
| 1025 | #endif |
Kevin Chan | dfecce2 | 2011-07-13 10:52:41 -0700 | [diff] [blame] | 1026 | |
| 1027 | static struct msm_camera_sensor_flash_data flash_qs_mt9p017 = { |
| 1028 | .flash_type = MSM_CAMERA_FLASH_LED, |
| 1029 | }; |
| 1030 | |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 1031 | static struct msm_camera_sensor_platform_info sensor_board_info_qs_mt9p017 = { |
| 1032 | .mount_angle = 270, |
Kevin Chan | dfecce2 | 2011-07-13 10:52:41 -0700 | [diff] [blame] | 1033 | .sensor_reset = 107, |
| 1034 | .sensor_pwd = 85, |
| 1035 | .vcm_pwd = 0, |
| 1036 | .vcm_enable = 1, |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 1037 | }; |
| 1038 | |
| 1039 | static struct msm_camera_sensor_info msm_camera_sensor_qs_mt9p017_data = { |
| 1040 | .sensor_name = "qs_mt9p017", |
| 1041 | .pdata = &msm_camera_csi_device_data[0], |
Kevin Chan | dfecce2 | 2011-07-13 10:52:41 -0700 | [diff] [blame] | 1042 | .flash_data = &flash_qs_mt9p017, |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 1043 | .sensor_platform_info = &sensor_board_info_qs_mt9p017, |
| 1044 | .gpio_conf = &gpio_conf, |
| 1045 | .csi_if = 1, |
| 1046 | .camera_type = BACK_CAMERA_3D, |
Kevin Chan | dfecce2 | 2011-07-13 10:52:41 -0700 | [diff] [blame] | 1047 | }; |
| 1048 | |
| 1049 | struct platform_device msm8960_camera_sensor_qs_mt9p017 = { |
| 1050 | .name = "msm_camera_qs_mt9p017", |
| 1051 | .dev = { |
| 1052 | .platform_data = &msm_camera_sensor_qs_mt9p017_data, |
| 1053 | }, |
| 1054 | }; |
| 1055 | |
Kevin Chan | 8b0d232 | 2011-09-10 21:06:31 -0700 | [diff] [blame] | 1056 | static struct msm8960_privacy_light_cfg privacy_light_info = { |
| 1057 | .mpp = PM8921_MPP_PM_TO_SYS(12), |
| 1058 | }; |
| 1059 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1060 | static void __init msm8960_init_cam(void) |
| 1061 | { |
| 1062 | int i; |
| 1063 | struct platform_device *cam_dev[] = { |
| 1064 | &msm8960_camera_sensor_imx074, |
| 1065 | &msm8960_camera_sensor_ov2720, |
Kevin Chan | dfecce2 | 2011-07-13 10:52:41 -0700 | [diff] [blame] | 1066 | &msm8960_camera_sensor_qs_mt9p017, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1067 | }; |
| 1068 | |
Kevin Chan | 8b0d232 | 2011-09-10 21:06:31 -0700 | [diff] [blame] | 1069 | if (machine_is_msm8960_liquid()) { |
| 1070 | struct msm_camera_sensor_info *s_info; |
| 1071 | s_info = msm8960_camera_sensor_imx074.dev.platform_data; |
| 1072 | s_info->sensor_platform_info->mount_angle = 180; |
| 1073 | s_info = msm8960_camera_sensor_ov2720.dev.platform_data; |
| 1074 | s_info->sensor_platform_info->privacy_light = 1; |
| 1075 | s_info->sensor_platform_info->privacy_light_info = |
| 1076 | &privacy_light_info; |
| 1077 | } |
| 1078 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1079 | for (i = 0; i < ARRAY_SIZE(cam_dev); i++) { |
| 1080 | struct msm_camera_sensor_info *s_info; |
| 1081 | s_info = cam_dev[i]->dev.platform_data; |
| 1082 | msm_get_cam_resources(s_info); |
| 1083 | platform_device_register(cam_dev[i]); |
| 1084 | } |
| 1085 | } |
| 1086 | #endif |
| 1087 | |
| 1088 | #ifdef CONFIG_FB_MSM_TRIPLE_BUFFER |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 1089 | /* prim = 1366 x 768 x 3(bpp) x 3(pages) */ |
| 1090 | #define MSM_FB_PRIM_BUF_SIZE roundup(1366 * 768 * 3 * 3, 0x10000) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1091 | #else |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 1092 | /* prim = 1366 x 768 x 3(bpp) x 2(pages) */ |
| 1093 | #define MSM_FB_PRIM_BUF_SIZE roundup(1366 * 768 * 3 * 2, 0x10000) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1094 | #endif |
| 1095 | |
| 1096 | #ifdef CONFIG_FB_MSM_MIPI_DSI |
Nagamalleswararao Ganji | 0b8dbd0 | 2011-08-18 20:46:59 -0700 | [diff] [blame] | 1097 | #define MIPI_DSI_WRITEBACK_SIZE (1024 * 600 * 3 * 2) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1098 | #else |
| 1099 | #define MIPI_DSI_WRITEBACK_SIZE 0 |
| 1100 | #endif |
| 1101 | |
| 1102 | #ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL |
| 1103 | /* hdmi = 1920 x 1088 x 2(bpp) x 1(page) */ |
| 1104 | #define MSM_FB_EXT_BUF_SIZE 0x3FC000 |
| 1105 | #elif defined(CONFIG_FB_MSM_TVOUT) |
| 1106 | /* tvout = 720 x 576 x 2(bpp) x 2(pages) */ |
| 1107 | #define MSM_FB_EXT_BUF_SIZE 0x195000 |
| 1108 | #else /* CONFIG_FB_MSM_HDMI_MSM_PANEL */ |
| 1109 | #define MSM_FB_EXT_BUF_SIZE 0 |
| 1110 | #endif /* CONFIG_FB_MSM_HDMI_MSM_PANEL */ |
| 1111 | |
| 1112 | #define MSM_FB_SIZE roundup(MSM_FB_PRIM_BUF_SIZE + MSM_FB_EXT_BUF_SIZE +\ |
| 1113 | MIPI_DSI_WRITEBACK_SIZE, 4096) |
| 1114 | |
| 1115 | #define MDP_VSYNC_GPIO 0 |
| 1116 | |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 1117 | #define TOSHIBA_PANEL_NAME "mipi_video_toshiba_wsvga" |
| 1118 | #define TOSHIBA_PANEL_NAME_LEN 24 |
| 1119 | #define CHIMEI_PANEL_NAME "mipi_chimei_wxga" |
| 1120 | #define CHIMEI_PANEL_NAME_LEN 16 |
| 1121 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1122 | static struct resource msm_fb_resources[] = { |
| 1123 | { |
| 1124 | .flags = IORESOURCE_DMA, |
| 1125 | } |
| 1126 | }; |
| 1127 | |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 1128 | #ifdef CONFIG_FB_MSM_MIPI_PANEL_DETECT |
| 1129 | static int msm_fb_detect_panel(const char *name) |
| 1130 | { |
| 1131 | if (machine_is_msm8960_liquid()) { |
| 1132 | if (!strncmp(name, CHIMEI_PANEL_NAME, CHIMEI_PANEL_NAME_LEN)) |
| 1133 | return 0; |
| 1134 | } else { |
| 1135 | if (!strncmp(name, TOSHIBA_PANEL_NAME, TOSHIBA_PANEL_NAME_LEN)) |
| 1136 | return 0; |
| 1137 | } |
| 1138 | |
| 1139 | pr_warning("%s: not supported '%s'", __func__, name); |
| 1140 | |
| 1141 | return -ENODEV; |
| 1142 | } |
| 1143 | |
| 1144 | static struct msm_fb_platform_data msm_fb_pdata = { |
| 1145 | .detect_client = msm_fb_detect_panel, |
| 1146 | }; |
| 1147 | #endif /* CONFIG_FB_MSM_MIPI_PANEL_DETECT */ |
| 1148 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1149 | static struct platform_device msm_fb_device = { |
| 1150 | .name = "msm_fb", |
| 1151 | .id = 0, |
| 1152 | .num_resources = ARRAY_SIZE(msm_fb_resources), |
| 1153 | .resource = msm_fb_resources, |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 1154 | #ifdef CONFIG_FB_MSM_MIPI_PANEL_DETECT |
| 1155 | .dev.platform_data = &msm_fb_pdata, |
| 1156 | #endif /* CONFIG_FB_MSM_MIPI_PANEL_DETECT */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1157 | }; |
| 1158 | |
| 1159 | static bool dsi_power_on; |
| 1160 | |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 1161 | /** |
| 1162 | * LiQUID panel on/off |
| 1163 | * |
| 1164 | * @param on |
| 1165 | * |
| 1166 | * @return int |
| 1167 | */ |
| 1168 | static int mipi_dsi_liquid_panel_power(int on) |
| 1169 | { |
| 1170 | static struct regulator *reg_l2, *reg_ext_3p3v; |
| 1171 | static int gpio21, gpio24, gpio43; |
| 1172 | int rc; |
| 1173 | |
| 1174 | pr_info("%s: on=%d\n", __func__, on); |
| 1175 | |
| 1176 | gpio21 = PM8921_GPIO_PM_TO_SYS(21); /* disp power enable_n */ |
| 1177 | gpio43 = PM8921_GPIO_PM_TO_SYS(43); /* Displays Enable (rst_n)*/ |
| 1178 | gpio24 = PM8921_GPIO_PM_TO_SYS(24); /* Backlight PWM */ |
| 1179 | |
| 1180 | if (!dsi_power_on) { |
| 1181 | |
| 1182 | reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, |
| 1183 | "dsi_vdda"); |
| 1184 | if (IS_ERR(reg_l2)) { |
| 1185 | pr_err("could not get 8921_l2, rc = %ld\n", |
| 1186 | PTR_ERR(reg_l2)); |
| 1187 | return -ENODEV; |
| 1188 | } |
| 1189 | |
| 1190 | rc = regulator_set_voltage(reg_l2, 1200000, 1200000); |
| 1191 | if (rc) { |
| 1192 | pr_err("set_voltage l2 failed, rc=%d\n", rc); |
| 1193 | return -EINVAL; |
| 1194 | } |
| 1195 | |
| 1196 | reg_ext_3p3v = regulator_get(&msm_mipi_dsi1_device.dev, |
| 1197 | "vdd_lvds_3p3v"); |
| 1198 | if (IS_ERR(reg_ext_3p3v)) { |
| 1199 | pr_err("could not get reg_ext_3p3v, rc = %ld\n", |
| 1200 | PTR_ERR(reg_ext_3p3v)); |
| 1201 | return -ENODEV; |
| 1202 | } |
| 1203 | |
| 1204 | rc = gpio_request(gpio21, "disp_pwr_en_n"); |
| 1205 | if (rc) { |
| 1206 | pr_err("request gpio 21 failed, rc=%d\n", rc); |
| 1207 | return -ENODEV; |
| 1208 | } |
| 1209 | |
| 1210 | rc = gpio_request(gpio43, "disp_rst_n"); |
| 1211 | if (rc) { |
| 1212 | pr_err("request gpio 43 failed, rc=%d\n", rc); |
| 1213 | return -ENODEV; |
| 1214 | } |
| 1215 | |
| 1216 | rc = gpio_request(gpio24, "disp_backlight_pwm"); |
| 1217 | if (rc) { |
| 1218 | pr_err("request gpio 24 failed, rc=%d\n", rc); |
| 1219 | return -ENODEV; |
| 1220 | } |
| 1221 | |
| 1222 | dsi_power_on = true; |
| 1223 | } |
| 1224 | |
| 1225 | if (on) { |
| 1226 | rc = regulator_set_optimum_mode(reg_l2, 100000); |
| 1227 | if (rc < 0) { |
| 1228 | pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); |
| 1229 | return -EINVAL; |
| 1230 | } |
| 1231 | rc = regulator_enable(reg_l2); |
| 1232 | if (rc) { |
| 1233 | pr_err("enable l2 failed, rc=%d\n", rc); |
| 1234 | return -ENODEV; |
| 1235 | } |
| 1236 | |
| 1237 | rc = regulator_enable(reg_ext_3p3v); |
| 1238 | if (rc) { |
| 1239 | pr_err("enable reg_ext_3p3v failed, rc=%d\n", rc); |
| 1240 | return -ENODEV; |
| 1241 | } |
| 1242 | |
| 1243 | /* set reset pin before power enable */ |
| 1244 | gpio_set_value_cansleep(gpio43, 0); /* disp disable (resx=0) */ |
| 1245 | |
| 1246 | gpio_set_value_cansleep(gpio21, 0); /* disp power enable_n */ |
| 1247 | msleep(20); |
| 1248 | gpio_set_value_cansleep(gpio43, 1); /* disp enable */ |
| 1249 | msleep(20); |
| 1250 | gpio_set_value_cansleep(gpio43, 0); /* disp enable */ |
| 1251 | msleep(20); |
| 1252 | gpio_set_value_cansleep(gpio43, 1); /* disp enable */ |
| 1253 | msleep(20); |
| 1254 | } else { |
| 1255 | gpio_set_value_cansleep(gpio43, 0); |
| 1256 | gpio_set_value_cansleep(gpio21, 1); |
| 1257 | |
| 1258 | rc = regulator_disable(reg_l2); |
| 1259 | if (rc) { |
| 1260 | pr_err("disable reg_l2 failed, rc=%d\n", rc); |
| 1261 | return -ENODEV; |
| 1262 | } |
| 1263 | rc = regulator_disable(reg_ext_3p3v); |
| 1264 | if (rc) { |
| 1265 | pr_err("disable reg_ext_3p3v failed, rc=%d\n", rc); |
| 1266 | return -ENODEV; |
| 1267 | } |
| 1268 | rc = regulator_set_optimum_mode(reg_l2, 100); |
| 1269 | if (rc < 0) { |
| 1270 | pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); |
| 1271 | return -EINVAL; |
| 1272 | } |
| 1273 | } |
| 1274 | |
| 1275 | return 0; |
| 1276 | } |
| 1277 | |
| 1278 | static int mipi_dsi_cdp_panel_power(int on) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1279 | { |
| 1280 | static struct regulator *reg_l8, *reg_l23, *reg_l2; |
Nagamalleswararao Ganji | eac5dfa | 2011-07-23 17:31:16 -0700 | [diff] [blame] | 1281 | static int gpio43; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1282 | int rc; |
| 1283 | |
| 1284 | struct pm_gpio gpio43_param = { |
| 1285 | .direction = PM_GPIO_DIR_OUT, |
| 1286 | .output_buffer = PM_GPIO_OUT_BUF_CMOS, |
| 1287 | .output_value = 0, |
| 1288 | .pull = PM_GPIO_PULL_NO, |
| 1289 | .vin_sel = 2, |
| 1290 | .out_strength = PM_GPIO_STRENGTH_HIGH, |
| 1291 | .function = PM_GPIO_FUNC_PAIRED, |
| 1292 | .inv_int_pol = 0, |
| 1293 | .disable_pin = 0, |
| 1294 | }; |
| 1295 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1296 | pr_info("%s: state : %d\n", __func__, on); |
| 1297 | |
| 1298 | if (!dsi_power_on) { |
| 1299 | |
| 1300 | reg_l8 = regulator_get(&msm_mipi_dsi1_device.dev, |
| 1301 | "dsi_vdc"); |
| 1302 | if (IS_ERR(reg_l8)) { |
| 1303 | pr_err("could not get 8921_l8, rc = %ld\n", |
| 1304 | PTR_ERR(reg_l8)); |
| 1305 | return -ENODEV; |
| 1306 | } |
| 1307 | |
| 1308 | reg_l23 = regulator_get(&msm_mipi_dsi1_device.dev, |
| 1309 | "dsi_vddio"); |
| 1310 | if (IS_ERR(reg_l23)) { |
| 1311 | pr_err("could not get 8921_l23, rc = %ld\n", |
| 1312 | PTR_ERR(reg_l23)); |
| 1313 | return -ENODEV; |
| 1314 | } |
| 1315 | |
| 1316 | reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev, |
| 1317 | "dsi_vdda"); |
| 1318 | if (IS_ERR(reg_l2)) { |
| 1319 | pr_err("could not get 8921_l2, rc = %ld\n", |
| 1320 | PTR_ERR(reg_l2)); |
| 1321 | return -ENODEV; |
| 1322 | } |
| 1323 | |
| 1324 | rc = regulator_set_voltage(reg_l8, 2800000, 3000000); |
| 1325 | if (rc) { |
| 1326 | pr_err("set_voltage l8 failed, rc=%d\n", rc); |
| 1327 | return -EINVAL; |
| 1328 | } |
| 1329 | rc = regulator_set_voltage(reg_l23, 1800000, 1800000); |
| 1330 | if (rc) { |
| 1331 | pr_err("set_voltage l23 failed, rc=%d\n", rc); |
| 1332 | return -EINVAL; |
| 1333 | } |
| 1334 | rc = regulator_set_voltage(reg_l2, 1200000, 1200000); |
| 1335 | if (rc) { |
| 1336 | pr_err("set_voltage l2 failed, rc=%d\n", rc); |
| 1337 | return -EINVAL; |
| 1338 | } |
| 1339 | |
| 1340 | gpio43 = PM8921_GPIO_PM_TO_SYS(43); |
| 1341 | rc = gpio_request(gpio43, "disp_rst_n"); |
| 1342 | if (rc) { |
| 1343 | pr_err("request gpio 43 failed, rc=%d\n", rc); |
| 1344 | return -ENODEV; |
| 1345 | } |
| 1346 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1347 | dsi_power_on = true; |
| 1348 | } |
| 1349 | |
| 1350 | if (on) { |
| 1351 | rc = regulator_set_optimum_mode(reg_l8, 100000); |
| 1352 | if (rc < 0) { |
| 1353 | pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); |
| 1354 | return -EINVAL; |
| 1355 | } |
| 1356 | rc = regulator_set_optimum_mode(reg_l23, 100000); |
| 1357 | if (rc < 0) { |
| 1358 | pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); |
| 1359 | return -EINVAL; |
| 1360 | } |
| 1361 | rc = regulator_set_optimum_mode(reg_l2, 100000); |
| 1362 | if (rc < 0) { |
| 1363 | pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); |
| 1364 | return -EINVAL; |
| 1365 | } |
| 1366 | rc = regulator_enable(reg_l8); |
| 1367 | if (rc) { |
| 1368 | pr_err("enable l8 failed, rc=%d\n", rc); |
| 1369 | return -ENODEV; |
| 1370 | } |
| 1371 | rc = regulator_enable(reg_l23); |
| 1372 | if (rc) { |
| 1373 | pr_err("enable l8 failed, rc=%d\n", rc); |
| 1374 | return -ENODEV; |
| 1375 | } |
| 1376 | rc = regulator_enable(reg_l2); |
| 1377 | if (rc) { |
| 1378 | pr_err("enable l2 failed, rc=%d\n", rc); |
| 1379 | return -ENODEV; |
| 1380 | } |
| 1381 | |
| 1382 | gpio43_param.pull = PM_GPIO_PULL_NO; |
| 1383 | rc = pm8xxx_gpio_config(gpio43, &gpio43_param); |
| 1384 | if (rc) { |
| 1385 | pr_err("gpio_config 43 failed (1), rc=%d\n", rc); |
| 1386 | return -EINVAL; |
| 1387 | } |
| 1388 | gpio43_param.pull = PM_GPIO_PULL_UP_30; |
| 1389 | rc = pm8xxx_gpio_config(gpio43, &gpio43_param); |
| 1390 | if (rc) { |
| 1391 | pr_err("gpio_config 43 failed (2), rc=%d\n", rc); |
| 1392 | return -EINVAL; |
| 1393 | } |
| 1394 | gpio43_param.pull = PM_GPIO_PULL_NO; |
| 1395 | rc = pm8xxx_gpio_config(gpio43, &gpio43_param); |
| 1396 | if (rc) { |
| 1397 | pr_err("gpio_config 43 failed (3), rc=%d\n", rc); |
| 1398 | return -EINVAL; |
| 1399 | } |
| 1400 | gpio43_param.pull = PM_GPIO_PULL_UP_30; |
| 1401 | rc = pm8xxx_gpio_config(gpio43, &gpio43_param); |
| 1402 | if (rc) { |
| 1403 | pr_err("gpio_config 43 failed (4), rc=%d\n", rc); |
| 1404 | return -EINVAL; |
| 1405 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1406 | gpio_set_value_cansleep(gpio43, 1); |
| 1407 | } else { |
| 1408 | rc = regulator_set_optimum_mode(reg_l8, 100); |
| 1409 | if (rc < 0) { |
| 1410 | pr_err("set_optimum_mode l8 failed, rc=%d\n", rc); |
| 1411 | return -EINVAL; |
| 1412 | } |
| 1413 | rc = regulator_set_optimum_mode(reg_l23, 100); |
| 1414 | if (rc < 0) { |
| 1415 | pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); |
| 1416 | return -EINVAL; |
| 1417 | } |
| 1418 | rc = regulator_set_optimum_mode(reg_l2, 100); |
| 1419 | if (rc < 0) { |
| 1420 | pr_err("set_optimum_mode l2 failed, rc=%d\n", rc); |
| 1421 | return -EINVAL; |
| 1422 | } |
| 1423 | gpio_set_value_cansleep(gpio43, 0); |
| 1424 | } |
| 1425 | return 0; |
| 1426 | } |
| 1427 | |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 1428 | static int mipi_dsi_panel_power(int on) |
| 1429 | { |
| 1430 | int ret; |
| 1431 | |
| 1432 | pr_info("%s: on=%d\n", __func__, on); |
| 1433 | |
| 1434 | if (machine_is_msm8960_liquid()) |
| 1435 | ret = mipi_dsi_liquid_panel_power(on); |
| 1436 | else |
| 1437 | ret = mipi_dsi_cdp_panel_power(on); |
| 1438 | |
| 1439 | return ret; |
| 1440 | } |
| 1441 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1442 | static struct mipi_dsi_platform_data mipi_dsi_pdata = { |
| 1443 | .vsync_gpio = MDP_VSYNC_GPIO, |
| 1444 | .dsi_power_save = mipi_dsi_panel_power, |
| 1445 | }; |
| 1446 | |
| 1447 | #ifdef CONFIG_MSM_BUS_SCALING |
| 1448 | |
| 1449 | static struct msm_bus_vectors mdp_init_vectors[] = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1450 | { |
| 1451 | .src = MSM_BUS_MASTER_MDP_PORT0, |
| 1452 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1453 | .ab = 0, |
| 1454 | .ib = 0, |
| 1455 | }, |
Ravishangar Kalyanam | 882930f | 2011-07-08 17:51:52 -0700 | [diff] [blame] | 1456 | }; |
| 1457 | |
| 1458 | static struct msm_bus_vectors mdp_ui_vectors[] = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1459 | { |
| 1460 | .src = MSM_BUS_MASTER_MDP_PORT0, |
| 1461 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
Ravishangar Kalyanam | 882930f | 2011-07-08 17:51:52 -0700 | [diff] [blame] | 1462 | .ab = 216000000 * 2, |
| 1463 | .ib = 270000000 * 2, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1464 | }, |
| 1465 | }; |
| 1466 | |
| 1467 | static struct msm_bus_vectors mdp_vga_vectors[] = { |
| 1468 | /* VGA and less video */ |
| 1469 | { |
| 1470 | .src = MSM_BUS_MASTER_MDP_PORT0, |
| 1471 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
Ravishangar Kalyanam | 882930f | 2011-07-08 17:51:52 -0700 | [diff] [blame] | 1472 | .ab = 216000000 * 2, |
| 1473 | .ib = 270000000 * 2, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1474 | }, |
| 1475 | }; |
| 1476 | |
| 1477 | static struct msm_bus_vectors mdp_720p_vectors[] = { |
| 1478 | /* 720p and less video */ |
| 1479 | { |
| 1480 | .src = MSM_BUS_MASTER_MDP_PORT0, |
| 1481 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
Ravishangar Kalyanam | 882930f | 2011-07-08 17:51:52 -0700 | [diff] [blame] | 1482 | .ab = 230400000 * 2, |
| 1483 | .ib = 288000000 * 2, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1484 | }, |
| 1485 | }; |
| 1486 | |
| 1487 | static struct msm_bus_vectors mdp_1080p_vectors[] = { |
| 1488 | /* 1080p and less video */ |
| 1489 | { |
| 1490 | .src = MSM_BUS_MASTER_MDP_PORT0, |
| 1491 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
Ravishangar Kalyanam | 882930f | 2011-07-08 17:51:52 -0700 | [diff] [blame] | 1492 | .ab = 334080000 * 2, |
| 1493 | .ib = 417600000 * 2, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1494 | }, |
| 1495 | }; |
| 1496 | |
| 1497 | static struct msm_bus_paths mdp_bus_scale_usecases[] = { |
| 1498 | { |
| 1499 | ARRAY_SIZE(mdp_init_vectors), |
| 1500 | mdp_init_vectors, |
| 1501 | }, |
| 1502 | { |
Ravishangar Kalyanam | 882930f | 2011-07-08 17:51:52 -0700 | [diff] [blame] | 1503 | ARRAY_SIZE(mdp_ui_vectors), |
| 1504 | mdp_ui_vectors, |
| 1505 | }, |
| 1506 | { |
| 1507 | ARRAY_SIZE(mdp_ui_vectors), |
| 1508 | mdp_ui_vectors, |
| 1509 | }, |
| 1510 | { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1511 | ARRAY_SIZE(mdp_vga_vectors), |
| 1512 | mdp_vga_vectors, |
| 1513 | }, |
| 1514 | { |
| 1515 | ARRAY_SIZE(mdp_720p_vectors), |
| 1516 | mdp_720p_vectors, |
| 1517 | }, |
| 1518 | { |
| 1519 | ARRAY_SIZE(mdp_1080p_vectors), |
| 1520 | mdp_1080p_vectors, |
| 1521 | }, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1522 | }; |
| 1523 | |
| 1524 | static struct msm_bus_scale_pdata mdp_bus_scale_pdata = { |
| 1525 | mdp_bus_scale_usecases, |
| 1526 | ARRAY_SIZE(mdp_bus_scale_usecases), |
| 1527 | .name = "mdp", |
| 1528 | }; |
| 1529 | |
| 1530 | #endif |
| 1531 | |
| 1532 | int mdp_core_clk_rate_table[] = { |
| 1533 | 85330000, |
| 1534 | 85330000, |
Nagamalleswararao Ganji | ad31c98 | 2011-08-15 23:24:17 -0700 | [diff] [blame] | 1535 | 160000000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1536 | 200000000, |
| 1537 | }; |
| 1538 | |
| 1539 | static struct msm_panel_common_pdata mdp_pdata = { |
| 1540 | .gpio = MDP_VSYNC_GPIO, |
| 1541 | .mdp_core_clk_rate = 85330000, |
| 1542 | .mdp_core_clk_table = mdp_core_clk_rate_table, |
| 1543 | .num_mdp_clk = ARRAY_SIZE(mdp_core_clk_rate_table), |
| 1544 | #ifdef CONFIG_MSM_BUS_SCALING |
| 1545 | .mdp_bus_scale_table = &mdp_bus_scale_pdata, |
| 1546 | #endif |
| 1547 | .mdp_rev = MDP_REV_42, |
| 1548 | }; |
| 1549 | |
| 1550 | static struct platform_device mipi_dsi_renesas_panel_device = { |
| 1551 | .name = "mipi_renesas", |
| 1552 | .id = 0, |
| 1553 | }; |
| 1554 | |
| 1555 | static struct platform_device mipi_dsi_simulator_panel_device = { |
| 1556 | .name = "mipi_simulator", |
| 1557 | .id = 0, |
| 1558 | }; |
| 1559 | |
Nagamalleswararao Ganji | eac5dfa | 2011-07-23 17:31:16 -0700 | [diff] [blame] | 1560 | #define LPM_CHANNEL0 0 |
| 1561 | static int toshiba_gpio[] = {LPM_CHANNEL0}; |
| 1562 | |
| 1563 | static struct mipi_dsi_panel_platform_data toshiba_pdata = { |
| 1564 | .gpio = toshiba_gpio, |
| 1565 | }; |
| 1566 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1567 | static struct platform_device mipi_dsi_toshiba_panel_device = { |
| 1568 | .name = "mipi_toshiba", |
| 1569 | .id = 0, |
Nagamalleswararao Ganji | eac5dfa | 2011-07-23 17:31:16 -0700 | [diff] [blame] | 1570 | .dev = { |
| 1571 | .platform_data = &toshiba_pdata, |
| 1572 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1573 | }; |
| 1574 | |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 1575 | static int dsi2lvds_gpio[2] = { |
| 1576 | 0,/* Backlight PWM-ID=0 for PMIC-GPIO#24 */ |
| 1577 | 0x1F08 /* DSI2LVDS Bridge GPIO Output, mask=0x1f, out=0x08 */ |
| 1578 | }; |
| 1579 | |
| 1580 | static struct msm_panel_common_pdata mipi_dsi2lvds_pdata = { |
| 1581 | .gpio_num = dsi2lvds_gpio, |
| 1582 | }; |
| 1583 | |
| 1584 | static struct platform_device mipi_dsi2lvds_bridge_device = { |
| 1585 | .name = "mipi_tc358764", |
| 1586 | .id = 0, |
| 1587 | .dev.platform_data = &mipi_dsi2lvds_pdata, |
| 1588 | }; |
| 1589 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1590 | #ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL |
| 1591 | static struct resource hdmi_msm_resources[] = { |
| 1592 | { |
| 1593 | .name = "hdmi_msm_qfprom_addr", |
| 1594 | .start = 0x00700000, |
| 1595 | .end = 0x007060FF, |
| 1596 | .flags = IORESOURCE_MEM, |
| 1597 | }, |
| 1598 | { |
| 1599 | .name = "hdmi_msm_hdmi_addr", |
| 1600 | .start = 0x04A00000, |
| 1601 | .end = 0x04A00FFF, |
| 1602 | .flags = IORESOURCE_MEM, |
| 1603 | }, |
| 1604 | { |
| 1605 | .name = "hdmi_msm_irq", |
| 1606 | .start = HDMI_IRQ, |
| 1607 | .end = HDMI_IRQ, |
| 1608 | .flags = IORESOURCE_IRQ, |
| 1609 | }, |
| 1610 | }; |
| 1611 | |
| 1612 | static int hdmi_enable_5v(int on); |
| 1613 | static int hdmi_core_power(int on, int show); |
| 1614 | static int hdmi_cec_power(int on); |
| 1615 | |
| 1616 | static struct msm_hdmi_platform_data hdmi_msm_data = { |
| 1617 | .irq = HDMI_IRQ, |
| 1618 | .enable_5v = hdmi_enable_5v, |
| 1619 | .core_power = hdmi_core_power, |
| 1620 | .cec_power = hdmi_cec_power, |
| 1621 | }; |
| 1622 | |
| 1623 | static struct platform_device hdmi_msm_device = { |
| 1624 | .name = "hdmi_msm", |
| 1625 | .id = 0, |
| 1626 | .num_resources = ARRAY_SIZE(hdmi_msm_resources), |
| 1627 | .resource = hdmi_msm_resources, |
| 1628 | .dev.platform_data = &hdmi_msm_data, |
| 1629 | }; |
| 1630 | #endif /* CONFIG_FB_MSM_HDMI_MSM_PANEL */ |
| 1631 | |
Ravishangar Kalyanam | 882930f | 2011-07-08 17:51:52 -0700 | [diff] [blame] | 1632 | #ifdef CONFIG_MSM_BUS_SCALING |
| 1633 | static struct msm_bus_vectors dtv_bus_init_vectors[] = { |
| 1634 | { |
| 1635 | .src = MSM_BUS_MASTER_MDP_PORT0, |
| 1636 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1637 | .ab = 0, |
| 1638 | .ib = 0, |
| 1639 | }, |
| 1640 | }; |
| 1641 | static struct msm_bus_vectors dtv_bus_def_vectors[] = { |
| 1642 | { |
| 1643 | .src = MSM_BUS_MASTER_MDP_PORT0, |
| 1644 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1645 | .ab = 566092800 * 2, |
| 1646 | .ib = 707616000 * 2, |
| 1647 | }, |
| 1648 | }; |
| 1649 | static struct msm_bus_paths dtv_bus_scale_usecases[] = { |
| 1650 | { |
| 1651 | ARRAY_SIZE(dtv_bus_init_vectors), |
| 1652 | dtv_bus_init_vectors, |
| 1653 | }, |
| 1654 | { |
| 1655 | ARRAY_SIZE(dtv_bus_def_vectors), |
| 1656 | dtv_bus_def_vectors, |
| 1657 | }, |
| 1658 | }; |
| 1659 | static struct msm_bus_scale_pdata dtv_bus_scale_pdata = { |
| 1660 | dtv_bus_scale_usecases, |
| 1661 | ARRAY_SIZE(dtv_bus_scale_usecases), |
| 1662 | .name = "dtv", |
| 1663 | }; |
| 1664 | |
| 1665 | static struct lcdc_platform_data dtv_pdata = { |
| 1666 | .bus_scale_table = &dtv_bus_scale_pdata, |
| 1667 | }; |
| 1668 | #endif |
| 1669 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1670 | static void __init msm_fb_add_devices(void) |
| 1671 | { |
Amir Samuelov | 0c7270f | 2011-09-07 03:13:47 +0300 | [diff] [blame] | 1672 | struct platform_device *ptr = NULL; |
| 1673 | |
| 1674 | if (machine_is_msm8960_liquid()) |
| 1675 | ptr = &mipi_dsi2lvds_bridge_device; |
| 1676 | else |
| 1677 | ptr = &mipi_dsi_toshiba_panel_device; |
| 1678 | platform_add_devices(&ptr, 1); |
| 1679 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1680 | if (machine_is_msm8x60_rumi3()) { |
| 1681 | msm_fb_register_device("mdp", NULL); |
| 1682 | mipi_dsi_pdata.target_type = 1; |
| 1683 | } else |
| 1684 | msm_fb_register_device("mdp", &mdp_pdata); |
| 1685 | msm_fb_register_device("mipi_dsi", &mipi_dsi_pdata); |
Ravishangar Kalyanam | 882930f | 2011-07-08 17:51:52 -0700 | [diff] [blame] | 1686 | #ifdef CONFIG_MSM_BUS_SCALING |
| 1687 | msm_fb_register_device("dtv", &dtv_pdata); |
| 1688 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1689 | } |
| 1690 | |
Ravishangar Kalyanam | ba99e51 | 2011-07-20 12:57:19 -0700 | [diff] [blame] | 1691 | static struct gpiomux_setting mdp_vsync_suspend_cfg = { |
| 1692 | .func = GPIOMUX_FUNC_GPIO, |
| 1693 | .drv = GPIOMUX_DRV_2MA, |
| 1694 | .pull = GPIOMUX_PULL_DOWN, |
| 1695 | }; |
| 1696 | |
| 1697 | static struct gpiomux_setting mdp_vsync_active_cfg = { |
| 1698 | .func = GPIOMUX_FUNC_1, |
| 1699 | .drv = GPIOMUX_DRV_2MA, |
| 1700 | .pull = GPIOMUX_PULL_DOWN, |
| 1701 | }; |
| 1702 | |
| 1703 | static struct msm_gpiomux_config msm8960_mdp_vsync_configs[] __initdata = { |
| 1704 | { |
| 1705 | .gpio = MDP_VSYNC_GPIO, |
| 1706 | .settings = { |
| 1707 | [GPIOMUX_ACTIVE] = &mdp_vsync_active_cfg, |
| 1708 | [GPIOMUX_SUSPENDED] = &mdp_vsync_suspend_cfg, |
| 1709 | }, |
| 1710 | } |
| 1711 | }; |
| 1712 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1713 | #ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL |
| 1714 | static struct gpiomux_setting hdmi_suspend_cfg = { |
| 1715 | .func = GPIOMUX_FUNC_GPIO, |
| 1716 | .drv = GPIOMUX_DRV_2MA, |
| 1717 | .pull = GPIOMUX_PULL_DOWN, |
| 1718 | }; |
| 1719 | |
| 1720 | static struct gpiomux_setting hdmi_active_1_cfg = { |
| 1721 | .func = GPIOMUX_FUNC_1, |
| 1722 | .drv = GPIOMUX_DRV_2MA, |
| 1723 | .pull = GPIOMUX_PULL_UP, |
| 1724 | }; |
| 1725 | |
| 1726 | static struct gpiomux_setting hdmi_active_2_cfg = { |
| 1727 | .func = GPIOMUX_FUNC_1, |
| 1728 | .drv = GPIOMUX_DRV_2MA, |
| 1729 | .pull = GPIOMUX_PULL_DOWN, |
| 1730 | }; |
| 1731 | |
| 1732 | static struct msm_gpiomux_config msm8960_hdmi_configs[] __initdata = { |
| 1733 | { |
| 1734 | .gpio = 99, |
| 1735 | .settings = { |
| 1736 | [GPIOMUX_ACTIVE] = &hdmi_active_1_cfg, |
| 1737 | [GPIOMUX_SUSPENDED] = &hdmi_suspend_cfg, |
| 1738 | }, |
| 1739 | }, |
| 1740 | { |
| 1741 | .gpio = 100, |
| 1742 | .settings = { |
| 1743 | [GPIOMUX_ACTIVE] = &hdmi_active_1_cfg, |
| 1744 | [GPIOMUX_SUSPENDED] = &hdmi_suspend_cfg, |
| 1745 | }, |
| 1746 | }, |
| 1747 | { |
| 1748 | .gpio = 101, |
| 1749 | .settings = { |
| 1750 | [GPIOMUX_ACTIVE] = &hdmi_active_1_cfg, |
| 1751 | [GPIOMUX_SUSPENDED] = &hdmi_suspend_cfg, |
| 1752 | }, |
| 1753 | }, |
| 1754 | { |
| 1755 | .gpio = 102, |
| 1756 | .settings = { |
| 1757 | [GPIOMUX_ACTIVE] = &hdmi_active_2_cfg, |
| 1758 | [GPIOMUX_SUSPENDED] = &hdmi_suspend_cfg, |
| 1759 | }, |
| 1760 | }, |
| 1761 | }; |
| 1762 | |
| 1763 | static int hdmi_enable_5v(int on) |
| 1764 | { |
| 1765 | /* TBD: PM8921 regulator instead of 8901 */ |
| 1766 | static struct regulator *reg_8921_hdmi_mvs; /* HDMI_5V */ |
| 1767 | static int prev_on; |
| 1768 | int rc; |
| 1769 | |
| 1770 | if (on == prev_on) |
| 1771 | return 0; |
| 1772 | |
| 1773 | if (!reg_8921_hdmi_mvs) |
| 1774 | reg_8921_hdmi_mvs = regulator_get(&hdmi_msm_device.dev, |
| 1775 | "hdmi_mvs"); |
| 1776 | |
| 1777 | if (on) { |
| 1778 | rc = regulator_enable(reg_8921_hdmi_mvs); |
| 1779 | if (rc) { |
| 1780 | pr_err("'%s' regulator enable failed, rc=%d\n", |
| 1781 | "8921_hdmi_mvs", rc); |
| 1782 | return rc; |
| 1783 | } |
| 1784 | pr_debug("%s(on): success\n", __func__); |
| 1785 | } else { |
| 1786 | rc = regulator_disable(reg_8921_hdmi_mvs); |
| 1787 | if (rc) |
| 1788 | pr_warning("'%s' regulator disable failed, rc=%d\n", |
| 1789 | "8921_hdmi_mvs", rc); |
| 1790 | pr_debug("%s(off): success\n", __func__); |
| 1791 | } |
| 1792 | |
| 1793 | prev_on = on; |
| 1794 | |
| 1795 | return 0; |
| 1796 | } |
| 1797 | |
| 1798 | static int hdmi_core_power(int on, int show) |
| 1799 | { |
| 1800 | static struct regulator *reg_8921_l23, *reg_8921_s4; |
| 1801 | static int prev_on; |
| 1802 | int rc; |
| 1803 | |
| 1804 | if (on == prev_on) |
| 1805 | return 0; |
| 1806 | |
| 1807 | /* TBD: PM8921 regulator instead of 8901 */ |
| 1808 | if (!reg_8921_l23) |
| 1809 | reg_8921_l23 = regulator_get(&hdmi_msm_device.dev, "hdmi_avdd"); |
| 1810 | |
| 1811 | if (!reg_8921_s4) |
| 1812 | reg_8921_s4 = regulator_get(&hdmi_msm_device.dev, "hdmi_vcc"); |
| 1813 | |
| 1814 | if (on) { |
| 1815 | rc = regulator_set_optimum_mode(reg_8921_l23, 100000); |
| 1816 | if (rc < 0) { |
| 1817 | pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); |
| 1818 | return -EINVAL; |
| 1819 | } |
| 1820 | |
| 1821 | rc = regulator_set_voltage(reg_8921_l23, 1800000, 1800000); |
| 1822 | if (!rc) |
| 1823 | rc = regulator_enable(reg_8921_l23); |
| 1824 | if (rc) { |
| 1825 | pr_err("'%s' regulator enable failed, rc=%d\n", |
| 1826 | "hdmi_avdd", rc); |
| 1827 | return rc; |
| 1828 | } |
| 1829 | rc = regulator_set_voltage(reg_8921_s4, 1800000, 1800000); |
| 1830 | if (!rc) |
| 1831 | rc = regulator_enable(reg_8921_s4); |
| 1832 | if (rc) { |
| 1833 | pr_err("'%s' regulator enable failed, rc=%d\n", |
| 1834 | "hdmi_vcc", rc); |
| 1835 | return rc; |
| 1836 | } |
| 1837 | |
| 1838 | rc = gpio_request(100, "HDMI_DDC_CLK"); |
| 1839 | if (rc) { |
| 1840 | pr_err("'%s'(%d) gpio_request failed, rc=%d\n", |
| 1841 | "HDMI_DDC_CLK", 100, rc); |
| 1842 | goto error1; |
| 1843 | } |
| 1844 | rc = gpio_request(101, "HDMI_DDC_DATA"); |
| 1845 | if (rc) { |
| 1846 | pr_err("'%s'(%d) gpio_request failed, rc=%d\n", |
| 1847 | "HDMI_DDC_DATA", 101, rc); |
| 1848 | goto error2; |
| 1849 | } |
| 1850 | rc = gpio_request(102, "HDMI_HPD"); |
| 1851 | if (rc) { |
| 1852 | pr_err("'%s'(%d) gpio_request failed, rc=%d\n", |
| 1853 | "HDMI_HPD", 102, rc); |
| 1854 | goto error3; |
| 1855 | } |
| 1856 | pr_debug("%s(on): success\n", __func__); |
| 1857 | } else { |
| 1858 | gpio_free(100); |
| 1859 | gpio_free(101); |
| 1860 | gpio_free(102); |
| 1861 | |
| 1862 | rc = regulator_set_optimum_mode(reg_8921_l23, 100); |
| 1863 | if (rc < 0) { |
| 1864 | pr_err("set_optimum_mode l23 failed, rc=%d\n", rc); |
| 1865 | return -EINVAL; |
| 1866 | } |
| 1867 | |
| 1868 | pr_debug("%s(off): success\n", __func__); |
| 1869 | } |
| 1870 | |
| 1871 | prev_on = on; |
| 1872 | |
| 1873 | return 0; |
| 1874 | |
| 1875 | error3: |
| 1876 | gpio_free(101); |
| 1877 | error2: |
| 1878 | gpio_free(100); |
| 1879 | error1: |
| 1880 | regulator_disable(reg_8921_l23); |
| 1881 | return rc; |
| 1882 | } |
| 1883 | |
| 1884 | static int hdmi_cec_power(int on) |
| 1885 | { |
| 1886 | static int prev_on; |
| 1887 | int rc; |
| 1888 | |
| 1889 | if (on == prev_on) |
| 1890 | return 0; |
| 1891 | |
| 1892 | if (on) { |
| 1893 | rc = gpio_request(99, "HDMI_CEC_VAR"); |
| 1894 | if (rc) { |
| 1895 | pr_err("'%s'(%d) gpio_request failed, rc=%d\n", |
| 1896 | "HDMI_CEC_VAR", 99, rc); |
| 1897 | goto error; |
| 1898 | } |
| 1899 | pr_debug("%s(on): success\n", __func__); |
| 1900 | } else { |
| 1901 | gpio_free(99); |
| 1902 | pr_debug("%s(off): success\n", __func__); |
| 1903 | } |
| 1904 | |
| 1905 | prev_on = on; |
| 1906 | |
| 1907 | return 0; |
| 1908 | error: |
| 1909 | return rc; |
| 1910 | } |
| 1911 | #endif /* CONFIG_FB_MSM_HDMI_MSM_PANEL */ |
| 1912 | |
| 1913 | static void __init msm8960_allocate_memory_regions(void) |
| 1914 | { |
| 1915 | void *addr; |
| 1916 | unsigned long size; |
| 1917 | |
| 1918 | size = MSM_FB_SIZE; |
| 1919 | addr = alloc_bootmem_align(size, 0x1000); |
| 1920 | msm_fb_resources[0].start = __pa(addr); |
| 1921 | msm_fb_resources[0].end = msm_fb_resources[0].start + size - 1; |
| 1922 | pr_info("allocating %lu bytes at %p (%lx physical) for fb\n", |
| 1923 | size, addr, __pa(addr)); |
| 1924 | |
| 1925 | } |
| 1926 | #ifdef CONFIG_WCD9310_CODEC |
| 1927 | |
| 1928 | #define TABLA_INTERRUPT_BASE (NR_MSM_IRQS + NR_GPIO_IRQS + NR_PM8921_IRQS) |
| 1929 | |
Patrick Lai | 3043fba | 2011-08-01 14:15:57 -0700 | [diff] [blame] | 1930 | /* Micbias setting is based on 8660 CDP/MTP/FLUID requirement |
| 1931 | * 4 micbiases are used to power various analog and digital |
| 1932 | * microphones operating at 1800 mV. Technically, all micbiases |
| 1933 | * can source from single cfilter since all microphones operate |
| 1934 | * at the same voltage level. The arrangement below is to make |
| 1935 | * sure all cfilters are exercised. LDO_H regulator ouput level |
| 1936 | * does not need to be as high as 2.85V. It is choosen for |
| 1937 | * microphone sensitivity purpose. |
| 1938 | */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1939 | static struct tabla_pdata tabla_platform_data = { |
| 1940 | .slimbus_slave_device = { |
| 1941 | .name = "tabla-slave", |
| 1942 | .e_addr = {0, 0, 0x10, 0, 0x17, 2}, |
| 1943 | }, |
| 1944 | .irq = MSM_GPIO_TO_INT(62), |
| 1945 | .irq_base = TABLA_INTERRUPT_BASE, |
| 1946 | .num_irqs = NR_TABLA_IRQS, |
| 1947 | .reset_gpio = PM8921_GPIO_PM_TO_SYS(34), |
Patrick Lai | 3043fba | 2011-08-01 14:15:57 -0700 | [diff] [blame] | 1948 | .micbias = { |
| 1949 | .ldoh_v = TABLA_LDOH_2P85_V, |
| 1950 | .cfilt1_mv = 1800, |
| 1951 | .cfilt2_mv = 1800, |
| 1952 | .cfilt3_mv = 1800, |
| 1953 | .bias1_cfilt_sel = TABLA_CFILT1_SEL, |
| 1954 | .bias2_cfilt_sel = TABLA_CFILT2_SEL, |
| 1955 | .bias3_cfilt_sel = TABLA_CFILT3_SEL, |
| 1956 | .bias4_cfilt_sel = TABLA_CFILT3_SEL, |
| 1957 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1958 | }; |
| 1959 | |
| 1960 | static struct slim_device msm_slim_tabla = { |
| 1961 | .name = "tabla-slim", |
| 1962 | .e_addr = {0, 1, 0x10, 0, 0x17, 2}, |
| 1963 | .dev = { |
| 1964 | .platform_data = &tabla_platform_data, |
| 1965 | }, |
| 1966 | }; |
| 1967 | #endif |
| 1968 | |
| 1969 | static struct slim_boardinfo msm_slim_devices[] = { |
| 1970 | #ifdef CONFIG_WCD9310_CODEC |
| 1971 | { |
| 1972 | .bus_num = 1, |
| 1973 | .slim_slave = &msm_slim_tabla, |
| 1974 | }, |
| 1975 | #endif |
| 1976 | /* add more slimbus slaves as needed */ |
| 1977 | }; |
| 1978 | |
Yunsen Wang | 5c1a739 | 2011-07-09 19:10:16 -0700 | [diff] [blame] | 1979 | #define MSM_WCNSS_PHYS 0x03000000 |
| 1980 | #define MSM_WCNSS_SIZE 0x280000 |
| 1981 | |
| 1982 | static struct resource resources_wcnss_wlan[] = { |
| 1983 | { |
| 1984 | .start = RIVA_APPS_WLAN_RX_DATA_AVAIL_IRQ, |
| 1985 | .end = RIVA_APPS_WLAN_RX_DATA_AVAIL_IRQ, |
| 1986 | .name = "wcnss_wlanrx_irq", |
| 1987 | .flags = IORESOURCE_IRQ, |
| 1988 | }, |
| 1989 | { |
| 1990 | .start = RIVA_APPS_WLAN_DATA_XFER_DONE_IRQ, |
| 1991 | .end = RIVA_APPS_WLAN_DATA_XFER_DONE_IRQ, |
| 1992 | .name = "wcnss_wlantx_irq", |
| 1993 | .flags = IORESOURCE_IRQ, |
| 1994 | }, |
| 1995 | { |
| 1996 | .start = MSM_WCNSS_PHYS, |
| 1997 | .end = MSM_WCNSS_PHYS + MSM_WCNSS_SIZE - 1, |
| 1998 | .name = "wcnss_mmio", |
| 1999 | .flags = IORESOURCE_MEM, |
| 2000 | }, |
| 2001 | }; |
| 2002 | |
Ankur Nandwani | b0039b0 | 2011-08-09 14:00:45 -0700 | [diff] [blame] | 2003 | static struct qcom_wcnss_opts qcom_wcnss_pdata = { |
| 2004 | .has_48mhz_xo = 1, |
| 2005 | }; |
| 2006 | |
Yunsen Wang | 5c1a739 | 2011-07-09 19:10:16 -0700 | [diff] [blame] | 2007 | static struct platform_device msm_device_wcnss_wlan = { |
| 2008 | .name = "wcnss_wlan", |
| 2009 | .id = 0, |
| 2010 | .num_resources = ARRAY_SIZE(resources_wcnss_wlan), |
| 2011 | .resource = resources_wcnss_wlan, |
Ankur Nandwani | b0039b0 | 2011-08-09 14:00:45 -0700 | [diff] [blame] | 2012 | .dev = {.platform_data = &qcom_wcnss_pdata}, |
Yunsen Wang | 5c1a739 | 2011-07-09 19:10:16 -0700 | [diff] [blame] | 2013 | }; |
| 2014 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2015 | #if defined(CONFIG_CRYPTO_DEV_QCRYPTO) || \ |
| 2016 | defined(CONFIG_CRYPTO_DEV_QCRYPTO_MODULE) || \ |
| 2017 | defined(CONFIG_CRYPTO_DEV_QCEDEV) || \ |
| 2018 | defined(CONFIG_CRYPTO_DEV_QCEDEV_MODULE) |
| 2019 | |
| 2020 | #define QCE_SIZE 0x10000 |
| 2021 | #define QCE_0_BASE 0x18500000 |
| 2022 | |
| 2023 | #define QCE_HW_KEY_SUPPORT 0 |
| 2024 | #define QCE_SHA_HMAC_SUPPORT 1 |
| 2025 | #define QCE_SHARE_CE_RESOURCE 1 |
| 2026 | #define QCE_CE_SHARED 0 |
| 2027 | |
| 2028 | static struct resource qcrypto_resources[] = { |
| 2029 | [0] = { |
| 2030 | .start = QCE_0_BASE, |
| 2031 | .end = QCE_0_BASE + QCE_SIZE - 1, |
| 2032 | .flags = IORESOURCE_MEM, |
| 2033 | }, |
| 2034 | [1] = { |
| 2035 | .name = "crypto_channels", |
| 2036 | .start = DMOV_CE_IN_CHAN, |
| 2037 | .end = DMOV_CE_OUT_CHAN, |
| 2038 | .flags = IORESOURCE_DMA, |
| 2039 | }, |
| 2040 | [2] = { |
| 2041 | .name = "crypto_crci_in", |
| 2042 | .start = DMOV_CE_IN_CRCI, |
| 2043 | .end = DMOV_CE_IN_CRCI, |
| 2044 | .flags = IORESOURCE_DMA, |
| 2045 | }, |
| 2046 | [3] = { |
| 2047 | .name = "crypto_crci_out", |
| 2048 | .start = DMOV_CE_OUT_CRCI, |
| 2049 | .end = DMOV_CE_OUT_CRCI, |
| 2050 | .flags = IORESOURCE_DMA, |
| 2051 | }, |
| 2052 | }; |
| 2053 | |
| 2054 | static struct resource qcedev_resources[] = { |
| 2055 | [0] = { |
| 2056 | .start = QCE_0_BASE, |
| 2057 | .end = QCE_0_BASE + QCE_SIZE - 1, |
| 2058 | .flags = IORESOURCE_MEM, |
| 2059 | }, |
| 2060 | [1] = { |
| 2061 | .name = "crypto_channels", |
| 2062 | .start = DMOV_CE_IN_CHAN, |
| 2063 | .end = DMOV_CE_OUT_CHAN, |
| 2064 | .flags = IORESOURCE_DMA, |
| 2065 | }, |
| 2066 | [2] = { |
| 2067 | .name = "crypto_crci_in", |
| 2068 | .start = DMOV_CE_IN_CRCI, |
| 2069 | .end = DMOV_CE_IN_CRCI, |
| 2070 | .flags = IORESOURCE_DMA, |
| 2071 | }, |
| 2072 | [3] = { |
| 2073 | .name = "crypto_crci_out", |
| 2074 | .start = DMOV_CE_OUT_CRCI, |
| 2075 | .end = DMOV_CE_OUT_CRCI, |
| 2076 | .flags = IORESOURCE_DMA, |
| 2077 | }, |
| 2078 | }; |
| 2079 | |
| 2080 | #endif |
| 2081 | |
| 2082 | #if defined(CONFIG_CRYPTO_DEV_QCRYPTO) || \ |
| 2083 | defined(CONFIG_CRYPTO_DEV_QCRYPTO_MODULE) |
| 2084 | |
| 2085 | static struct msm_ce_hw_support qcrypto_ce_hw_suppport = { |
| 2086 | .ce_shared = QCE_CE_SHARED, |
| 2087 | .shared_ce_resource = QCE_SHARE_CE_RESOURCE, |
| 2088 | .hw_key_support = QCE_HW_KEY_SUPPORT, |
| 2089 | .sha_hmac = QCE_SHA_HMAC_SUPPORT, |
| 2090 | }; |
| 2091 | |
| 2092 | static struct platform_device qcrypto_device = { |
| 2093 | .name = "qcrypto", |
| 2094 | .id = 0, |
| 2095 | .num_resources = ARRAY_SIZE(qcrypto_resources), |
| 2096 | .resource = qcrypto_resources, |
| 2097 | .dev = { |
| 2098 | .coherent_dma_mask = DMA_BIT_MASK(32), |
| 2099 | .platform_data = &qcrypto_ce_hw_suppport, |
| 2100 | }, |
| 2101 | }; |
| 2102 | #endif |
| 2103 | |
| 2104 | #if defined(CONFIG_CRYPTO_DEV_QCEDEV) || \ |
| 2105 | defined(CONFIG_CRYPTO_DEV_QCEDEV_MODULE) |
| 2106 | |
| 2107 | static struct msm_ce_hw_support qcedev_ce_hw_suppport = { |
| 2108 | .ce_shared = QCE_CE_SHARED, |
| 2109 | .shared_ce_resource = QCE_SHARE_CE_RESOURCE, |
| 2110 | .hw_key_support = QCE_HW_KEY_SUPPORT, |
| 2111 | .sha_hmac = QCE_SHA_HMAC_SUPPORT, |
| 2112 | }; |
| 2113 | |
| 2114 | static struct platform_device qcedev_device = { |
| 2115 | .name = "qce", |
| 2116 | .id = 0, |
| 2117 | .num_resources = ARRAY_SIZE(qcedev_resources), |
| 2118 | .resource = qcedev_resources, |
| 2119 | .dev = { |
| 2120 | .coherent_dma_mask = DMA_BIT_MASK(32), |
| 2121 | .platform_data = &qcedev_ce_hw_suppport, |
| 2122 | }, |
| 2123 | }; |
| 2124 | #endif |
| 2125 | |
| 2126 | |
| 2127 | static int __init gpiomux_init(void) |
| 2128 | { |
| 2129 | int rc; |
| 2130 | |
| 2131 | rc = msm_gpiomux_init(NR_GPIO_IRQS); |
| 2132 | if (rc) { |
| 2133 | pr_err(KERN_ERR "msm_gpiomux_init failed %d\n", rc); |
| 2134 | return rc; |
| 2135 | } |
| 2136 | |
Nishant Pandit | 24153d8 | 2011-08-27 16:05:13 +0530 | [diff] [blame] | 2137 | msm_gpiomux_install(msm8960_cam_common_configs, |
| 2138 | ARRAY_SIZE(msm8960_cam_common_configs)); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2139 | |
| 2140 | msm_gpiomux_install(msm8960_gpiomux_configs, |
Stepan Moskovchenko | d2a45a8 | 2011-08-09 17:02:57 -0700 | [diff] [blame] | 2141 | ARRAY_SIZE(msm8960_gpiomux_configs)); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2142 | |
| 2143 | msm_gpiomux_install(msm8960_gsbi_configs, |
| 2144 | ARRAY_SIZE(msm8960_gsbi_configs)); |
| 2145 | |
| 2146 | msm_gpiomux_install(msm8960_cyts_configs, |
| 2147 | ARRAY_SIZE(msm8960_cyts_configs)); |
| 2148 | |
| 2149 | msm_gpiomux_install(msm8960_slimbus_config, |
| 2150 | ARRAY_SIZE(msm8960_slimbus_config)); |
| 2151 | |
| 2152 | msm_gpiomux_install(msm8960_audio_codec_configs, |
| 2153 | ARRAY_SIZE(msm8960_audio_codec_configs)); |
| 2154 | |
| 2155 | #ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL |
| 2156 | msm_gpiomux_install(msm8960_hdmi_configs, |
| 2157 | ARRAY_SIZE(msm8960_hdmi_configs)); |
| 2158 | #endif |
| 2159 | |
Ravishangar Kalyanam | ba99e51 | 2011-07-20 12:57:19 -0700 | [diff] [blame] | 2160 | msm_gpiomux_install(msm8960_mdp_vsync_configs, |
| 2161 | ARRAY_SIZE(msm8960_mdp_vsync_configs)); |
| 2162 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2163 | msm_gpiomux_install(wcnss_5wire_interface, |
| 2164 | ARRAY_SIZE(wcnss_5wire_interface)); |
| 2165 | |
| 2166 | return 0; |
| 2167 | } |
| 2168 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2169 | #define MSM_SHARED_RAM_PHYS 0x80000000 |
| 2170 | |
| 2171 | static struct pm8921_adc_amux pm8921_adc_channels_data[] = { |
| 2172 | {"vcoin", CHANNEL_VCOIN, CHAN_PATH_SCALING2, AMUX_RSV1, |
| 2173 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2174 | {"vbat", CHANNEL_VBAT, CHAN_PATH_SCALING2, AMUX_RSV1, |
| 2175 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2176 | {"dcin", CHANNEL_DCIN, CHAN_PATH_SCALING4, AMUX_RSV1, |
| 2177 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2178 | {"ichg", CHANNEL_ICHG, CHAN_PATH_SCALING1, AMUX_RSV1, |
| 2179 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2180 | {"vph_pwr", CHANNEL_VPH_PWR, CHAN_PATH_SCALING2, AMUX_RSV1, |
| 2181 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2182 | {"ibat", CHANNEL_IBAT, CHAN_PATH_SCALING1, AMUX_RSV1, |
| 2183 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2184 | {"m4", CHANNEL_MPP_1, CHAN_PATH_SCALING1, AMUX_RSV1, |
| 2185 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2186 | {"m5", CHANNEL_MPP_2, CHAN_PATH_SCALING2, AMUX_RSV1, |
| 2187 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2188 | {"batt_therm", CHANNEL_BATT_THERM, CHAN_PATH_SCALING1, AMUX_RSV2, |
| 2189 | ADC_DECIMATION_TYPE2, ADC_SCALE_BATT_THERM}, |
| 2190 | {"batt_id", CHANNEL_BATT_ID, CHAN_PATH_SCALING1, AMUX_RSV1, |
| 2191 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2192 | {"usbin", CHANNEL_USBIN, CHAN_PATH_SCALING3, AMUX_RSV1, |
| 2193 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2194 | {"pmic_therm", CHANNEL_DIE_TEMP, CHAN_PATH_SCALING1, AMUX_RSV1, |
| 2195 | ADC_DECIMATION_TYPE2, ADC_SCALE_PMIC_THERM}, |
| 2196 | {"625mv", CHANNEL_625MV, CHAN_PATH_SCALING1, AMUX_RSV1, |
| 2197 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2198 | {"125v", CHANNEL_125V, CHAN_PATH_SCALING1, AMUX_RSV1, |
| 2199 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2200 | {"chg_temp", CHANNEL_CHG_TEMP, CHAN_PATH_SCALING1, AMUX_RSV1, |
| 2201 | ADC_DECIMATION_TYPE2, ADC_SCALE_DEFAULT}, |
| 2202 | }; |
| 2203 | |
| 2204 | static struct pm8921_adc_properties pm8921_adc_data = { |
| 2205 | .adc_vdd_reference = 1800, /* milli-voltage for this adc */ |
| 2206 | .bitresolution = 15, |
| 2207 | .bipolar = 0, |
| 2208 | }; |
| 2209 | |
| 2210 | static struct pm8921_adc_platform_data pm8921_adc_pdata = { |
| 2211 | .adc_channel = pm8921_adc_channels_data, |
| 2212 | .adc_num_channel = ARRAY_SIZE(pm8921_adc_channels_data), |
| 2213 | .adc_prop = &pm8921_adc_data, |
| 2214 | }; |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 2215 | |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 2216 | static void __init msm8960_map_io(void) |
| 2217 | { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2218 | msm_shared_ram_phys = MSM_SHARED_RAM_PHYS; |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 2219 | msm_map_msm8960_io(); |
| 2220 | } |
| 2221 | |
| 2222 | static void __init msm8960_init_irq(void) |
| 2223 | { |
| 2224 | unsigned int i; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2225 | |
| 2226 | msm_mpm_irq_extn_init(); |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 2227 | gic_init(0, GIC_PPI_START, MSM_QGIC_DIST_BASE, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2228 | (void *)MSM_QGIC_CPU_BASE); |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 2229 | |
| 2230 | /* Edge trigger PPIs except AVS_SVICINT and AVS_SVICINTSWDONE */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2231 | writel_relaxed(0xFFFFD7FF, MSM_QGIC_DIST_BASE + GIC_DIST_CONFIG + 4); |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 2232 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2233 | writel_relaxed(0x0000FFFF, MSM_QGIC_DIST_BASE + GIC_DIST_ENABLE_SET); |
| 2234 | mb(); |
Stepan Moskovchenko | 50ede4e | 2010-12-13 18:12:19 -0800 | [diff] [blame] | 2235 | |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 2236 | /* FIXME: Not installing AVS_SVICINT and AVS_SVICINTSWDONE yet |
| 2237 | * as they are configured as level, which does not play nice with |
| 2238 | * handle_percpu_irq. |
| 2239 | */ |
| 2240 | for (i = GIC_PPI_START; i < GIC_SPI_START; i++) { |
| 2241 | if (i != AVS_SVICINT && i != AVS_SVICINTSWDONE) |
Thomas Gleixner | 6845664a | 2011-03-24 13:25:22 +0100 | [diff] [blame] | 2242 | irq_set_handler(i, handle_percpu_irq); |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 2243 | } |
| 2244 | } |
| 2245 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2246 | /* MSM8960 have 5 SDCC controllers */ |
| 2247 | enum sdcc_controllers { |
| 2248 | SDCC1, |
| 2249 | SDCC2, |
| 2250 | SDCC3, |
| 2251 | SDCC4, |
| 2252 | SDCC5, |
| 2253 | MAX_SDCC_CONTROLLER |
| 2254 | }; |
| 2255 | |
| 2256 | /* All SDCC controllers requires VDD/VCC voltage */ |
| 2257 | static struct msm_mmc_reg_data mmc_vdd_reg_data[MAX_SDCC_CONTROLLER] = { |
| 2258 | /* SDCC1 : eMMC card connected */ |
| 2259 | [SDCC1] = { |
| 2260 | .name = "sdc_vdd", |
| 2261 | .set_voltage_sup = 1, |
Subhash Jadavani | 99ba53a | 2011-08-01 16:04:18 +0530 | [diff] [blame] | 2262 | .high_vol_level = 2950000, |
| 2263 | .low_vol_level = 2950000, |
Subhash Jadavani | dd7ef89 | 2011-08-18 16:49:57 +0530 | [diff] [blame] | 2264 | .always_on = 1, |
| 2265 | .lpm_sup = 1, |
| 2266 | .lpm_uA = 9000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2267 | .hpm_uA = 200000, /* 200mA */ |
| 2268 | }, |
| 2269 | /* SDCC3 : External card slot connected */ |
| 2270 | [SDCC3] = { |
| 2271 | .name = "sdc_vdd", |
| 2272 | .set_voltage_sup = 1, |
Subhash Jadavani | 99ba53a | 2011-08-01 16:04:18 +0530 | [diff] [blame] | 2273 | .high_vol_level = 2950000, |
| 2274 | .low_vol_level = 2950000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2275 | .hpm_uA = 600000, /* 600mA */ |
| 2276 | } |
| 2277 | }; |
| 2278 | |
| 2279 | /* Only slots having eMMC card will require VCCQ voltage */ |
| 2280 | static struct msm_mmc_reg_data mmc_vccq_reg_data[1] = { |
| 2281 | /* SDCC1 : eMMC card connected */ |
| 2282 | [SDCC1] = { |
| 2283 | .name = "sdc_vccq", |
| 2284 | .set_voltage_sup = 1, |
| 2285 | .always_on = 1, |
Subhash Jadavani | 99ba53a | 2011-08-01 16:04:18 +0530 | [diff] [blame] | 2286 | .high_vol_level = 1800000, |
| 2287 | .low_vol_level = 1800000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2288 | .hpm_uA = 200000, /* 200mA */ |
| 2289 | } |
| 2290 | }; |
| 2291 | |
| 2292 | /* All SDCC controllers may require voting for VDD PAD voltage */ |
| 2293 | static struct msm_mmc_reg_data mmc_vddp_reg_data[MAX_SDCC_CONTROLLER] = { |
| 2294 | /* SDCC3 : External card slot connected */ |
| 2295 | [SDCC3] = { |
| 2296 | .name = "sdc_vddp", |
| 2297 | .set_voltage_sup = 1, |
Subhash Jadavani | 99ba53a | 2011-08-01 16:04:18 +0530 | [diff] [blame] | 2298 | .high_vol_level = 2950000, |
| 2299 | .low_vol_level = 1850000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2300 | .always_on = 1, |
| 2301 | .lpm_sup = 1, |
| 2302 | /* Max. Active current required is 16 mA */ |
| 2303 | .hpm_uA = 16000, |
| 2304 | /* |
| 2305 | * Sleep current required is ~300 uA. But min. vote can be |
| 2306 | * in terms of mA (min. 1 mA). So let's vote for 2 mA |
| 2307 | * during sleep. |
| 2308 | */ |
| 2309 | .lpm_uA = 2000, |
| 2310 | } |
| 2311 | }; |
| 2312 | |
| 2313 | static struct msm_mmc_slot_reg_data mmc_slot_vreg_data[MAX_SDCC_CONTROLLER] = { |
| 2314 | /* SDCC1 : eMMC card connected */ |
| 2315 | [SDCC1] = { |
| 2316 | .vdd_data = &mmc_vdd_reg_data[SDCC1], |
| 2317 | .vccq_data = &mmc_vccq_reg_data[SDCC1], |
| 2318 | }, |
| 2319 | /* SDCC3 : External card slot connected */ |
| 2320 | [SDCC3] = { |
| 2321 | .vdd_data = &mmc_vdd_reg_data[SDCC3], |
| 2322 | .vddp_data = &mmc_vddp_reg_data[SDCC3], |
| 2323 | } |
| 2324 | }; |
| 2325 | |
| 2326 | /* SDC1 pad data */ |
| 2327 | static struct msm_mmc_pad_drv sdc1_pad_drv_on_cfg[] = { |
| 2328 | {TLMM_HDRV_SDC1_CLK, GPIO_CFG_16MA}, |
Subhash Jadavani | 87bda5a | 2011-08-30 17:40:44 +0530 | [diff] [blame] | 2329 | {TLMM_HDRV_SDC1_CMD, GPIO_CFG_10MA}, |
| 2330 | {TLMM_HDRV_SDC1_DATA, GPIO_CFG_10MA} |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2331 | }; |
| 2332 | |
| 2333 | static struct msm_mmc_pad_drv sdc1_pad_drv_off_cfg[] = { |
| 2334 | {TLMM_HDRV_SDC1_CLK, GPIO_CFG_2MA}, |
| 2335 | {TLMM_HDRV_SDC1_CMD, GPIO_CFG_2MA}, |
| 2336 | {TLMM_HDRV_SDC1_DATA, GPIO_CFG_2MA} |
| 2337 | }; |
| 2338 | |
| 2339 | static struct msm_mmc_pad_pull sdc1_pad_pull_on_cfg[] = { |
Subhash Jadavani | b7b5b8a | 2011-09-13 13:00:40 +0530 | [diff] [blame] | 2340 | {TLMM_PULL_SDC1_CLK, GPIO_CFG_NO_PULL}, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2341 | {TLMM_PULL_SDC1_CMD, GPIO_CFG_PULL_UP}, |
| 2342 | {TLMM_PULL_SDC1_DATA, GPIO_CFG_PULL_UP} |
| 2343 | }; |
| 2344 | |
| 2345 | static struct msm_mmc_pad_pull sdc1_pad_pull_off_cfg[] = { |
Subhash Jadavani | b7b5b8a | 2011-09-13 13:00:40 +0530 | [diff] [blame] | 2346 | {TLMM_PULL_SDC1_CLK, GPIO_CFG_NO_PULL}, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2347 | {TLMM_PULL_SDC1_CMD, GPIO_CFG_PULL_DOWN}, |
| 2348 | {TLMM_PULL_SDC1_DATA, GPIO_CFG_PULL_DOWN} |
| 2349 | }; |
| 2350 | |
| 2351 | /* SDC3 pad data */ |
| 2352 | static struct msm_mmc_pad_drv sdc3_pad_drv_on_cfg[] = { |
| 2353 | {TLMM_HDRV_SDC3_CLK, GPIO_CFG_8MA}, |
| 2354 | {TLMM_HDRV_SDC3_CMD, GPIO_CFG_8MA}, |
| 2355 | {TLMM_HDRV_SDC3_DATA, GPIO_CFG_8MA} |
| 2356 | }; |
| 2357 | |
| 2358 | static struct msm_mmc_pad_drv sdc3_pad_drv_off_cfg[] = { |
| 2359 | {TLMM_HDRV_SDC3_CLK, GPIO_CFG_2MA}, |
| 2360 | {TLMM_HDRV_SDC3_CMD, GPIO_CFG_2MA}, |
| 2361 | {TLMM_HDRV_SDC3_DATA, GPIO_CFG_2MA} |
| 2362 | }; |
| 2363 | |
| 2364 | static struct msm_mmc_pad_pull sdc3_pad_pull_on_cfg[] = { |
Subhash Jadavani | b7b5b8a | 2011-09-13 13:00:40 +0530 | [diff] [blame] | 2365 | {TLMM_PULL_SDC3_CLK, GPIO_CFG_NO_PULL}, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2366 | {TLMM_PULL_SDC3_CMD, GPIO_CFG_PULL_UP}, |
| 2367 | {TLMM_PULL_SDC3_DATA, GPIO_CFG_PULL_UP} |
| 2368 | }; |
| 2369 | |
| 2370 | static struct msm_mmc_pad_pull sdc3_pad_pull_off_cfg[] = { |
Subhash Jadavani | b7b5b8a | 2011-09-13 13:00:40 +0530 | [diff] [blame] | 2371 | {TLMM_PULL_SDC3_CLK, GPIO_CFG_NO_PULL}, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2372 | {TLMM_PULL_SDC3_CMD, GPIO_CFG_PULL_DOWN}, |
| 2373 | {TLMM_PULL_SDC3_DATA, GPIO_CFG_PULL_DOWN} |
| 2374 | }; |
| 2375 | |
| 2376 | struct msm_mmc_pad_pull_data mmc_pad_pull_data[MAX_SDCC_CONTROLLER] = { |
| 2377 | [SDCC1] = { |
| 2378 | .on = sdc1_pad_pull_on_cfg, |
| 2379 | .off = sdc1_pad_pull_off_cfg, |
| 2380 | .size = ARRAY_SIZE(sdc1_pad_pull_on_cfg) |
| 2381 | }, |
| 2382 | [SDCC3] = { |
| 2383 | .on = sdc3_pad_pull_on_cfg, |
| 2384 | .off = sdc3_pad_pull_off_cfg, |
| 2385 | .size = ARRAY_SIZE(sdc3_pad_pull_on_cfg) |
| 2386 | }, |
| 2387 | }; |
| 2388 | |
| 2389 | struct msm_mmc_pad_drv_data mmc_pad_drv_data[MAX_SDCC_CONTROLLER] = { |
| 2390 | [SDCC1] = { |
| 2391 | .on = sdc1_pad_drv_on_cfg, |
| 2392 | .off = sdc1_pad_drv_off_cfg, |
| 2393 | .size = ARRAY_SIZE(sdc1_pad_drv_on_cfg) |
| 2394 | }, |
| 2395 | [SDCC3] = { |
| 2396 | .on = sdc3_pad_drv_on_cfg, |
| 2397 | .off = sdc3_pad_drv_off_cfg, |
| 2398 | .size = ARRAY_SIZE(sdc3_pad_drv_on_cfg) |
| 2399 | }, |
| 2400 | }; |
| 2401 | |
| 2402 | struct msm_mmc_pad_data mmc_pad_data[MAX_SDCC_CONTROLLER] = { |
| 2403 | [SDCC1] = { |
| 2404 | .pull = &mmc_pad_pull_data[SDCC1], |
| 2405 | .drv = &mmc_pad_drv_data[SDCC1] |
| 2406 | }, |
| 2407 | [SDCC3] = { |
| 2408 | .pull = &mmc_pad_pull_data[SDCC3], |
| 2409 | .drv = &mmc_pad_drv_data[SDCC3] |
| 2410 | }, |
| 2411 | }; |
| 2412 | |
| 2413 | struct msm_mmc_pin_data mmc_slot_pin_data[MAX_SDCC_CONTROLLER] = { |
| 2414 | [SDCC1] = { |
| 2415 | .pad_data = &mmc_pad_data[SDCC1], |
| 2416 | }, |
| 2417 | [SDCC3] = { |
| 2418 | .pad_data = &mmc_pad_data[SDCC3], |
| 2419 | }, |
| 2420 | }; |
| 2421 | |
| 2422 | static unsigned int sdc1_sup_clk_rates[] = { |
Subhash Jadavani | 0e027b7 | 2011-08-30 17:40:55 +0530 | [diff] [blame] | 2423 | 400000, 24000000, 48000000 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2424 | }; |
| 2425 | |
| 2426 | static unsigned int sdc3_sup_clk_rates[] = { |
| 2427 | 400000, 24000000, 48000000, 96000000 |
| 2428 | }; |
| 2429 | |
| 2430 | #ifdef CONFIG_MMC_MSM_SDC1_SUPPORT |
| 2431 | static struct mmc_platform_data msm8960_sdc1_data = { |
| 2432 | .ocr_mask = MMC_VDD_27_28 | MMC_VDD_28_29, |
| 2433 | #ifdef CONFIG_MMC_MSM_SDC1_8_BIT_SUPPORT |
| 2434 | .mmc_bus_width = MMC_CAP_8_BIT_DATA, |
| 2435 | #else |
| 2436 | .mmc_bus_width = MMC_CAP_4_BIT_DATA, |
| 2437 | #endif |
| 2438 | .sup_clk_table = sdc1_sup_clk_rates, |
| 2439 | .sup_clk_cnt = ARRAY_SIZE(sdc1_sup_clk_rates), |
| 2440 | .nonremovable = 1, |
| 2441 | .sdcc_v4_sup = true, |
| 2442 | .vreg_data = &mmc_slot_vreg_data[SDCC1], |
Subhash Jadavani | 0e027b7 | 2011-08-30 17:40:55 +0530 | [diff] [blame] | 2443 | .pin_data = &mmc_slot_pin_data[SDCC1] |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2444 | }; |
| 2445 | #endif |
| 2446 | |
| 2447 | #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT |
| 2448 | static struct mmc_platform_data msm8960_sdc3_data = { |
| 2449 | .ocr_mask = MMC_VDD_27_28 | MMC_VDD_28_29, |
| 2450 | .mmc_bus_width = MMC_CAP_4_BIT_DATA, |
| 2451 | .sup_clk_table = sdc3_sup_clk_rates, |
| 2452 | .sup_clk_cnt = ARRAY_SIZE(sdc3_sup_clk_rates), |
| 2453 | .wpswitch_gpio = PM8921_GPIO_PM_TO_SYS(16), |
| 2454 | .sdcc_v4_sup = true, |
| 2455 | .vreg_data = &mmc_slot_vreg_data[SDCC3], |
| 2456 | .pin_data = &mmc_slot_pin_data[SDCC3], |
| 2457 | #ifdef CONFIG_MMC_MSM_CARD_HW_DETECTION |
| 2458 | .status_gpio = PM8921_GPIO_PM_TO_SYS(26), |
| 2459 | .status_irq = PM8921_GPIO_IRQ(PM8921_IRQ_BASE, 26), |
| 2460 | .irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 2461 | #endif |
| 2462 | .xpc_cap = 1, |
| 2463 | .uhs_caps = (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | |
| 2464 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_DDR50 | |
Subhash Jadavani | 0e027b7 | 2011-08-30 17:40:55 +0530 | [diff] [blame] | 2465 | MMC_CAP_MAX_CURRENT_600) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2466 | }; |
| 2467 | #endif |
| 2468 | |
| 2469 | static void __init msm8960_init_mmc(void) |
| 2470 | { |
| 2471 | #ifdef CONFIG_MMC_MSM_SDC1_SUPPORT |
| 2472 | /* SDC1 : eMMC card connected */ |
| 2473 | msm_add_sdcc(1, &msm8960_sdc1_data); |
| 2474 | #endif |
| 2475 | #ifdef CONFIG_MMC_MSM_SDC3_SUPPORT |
| 2476 | /* SDC3: External card slot */ |
| 2477 | msm_add_sdcc(3, &msm8960_sdc3_data); |
| 2478 | #endif |
| 2479 | } |
| 2480 | |
| 2481 | static void __init msm8960_init_buses(void) |
| 2482 | { |
| 2483 | #ifdef CONFIG_MSM_BUS_SCALING |
| 2484 | msm_bus_apps_fabric_pdata.rpm_enabled = 1; |
| 2485 | msm_bus_sys_fabric_pdata.rpm_enabled = 1; |
| 2486 | msm_bus_mm_fabric_pdata.rpm_enabled = 1; |
| 2487 | msm_bus_sys_fpb_pdata.rpm_enabled = 1; |
| 2488 | msm_bus_cpss_fpb_pdata.rpm_enabled = 1; |
| 2489 | msm_bus_apps_fabric.dev.platform_data = &msm_bus_apps_fabric_pdata; |
| 2490 | msm_bus_sys_fabric.dev.platform_data = &msm_bus_sys_fabric_pdata; |
| 2491 | msm_bus_mm_fabric.dev.platform_data = &msm_bus_mm_fabric_pdata; |
| 2492 | msm_bus_sys_fpb.dev.platform_data = &msm_bus_sys_fpb_pdata; |
| 2493 | msm_bus_cpss_fpb.dev.platform_data = &msm_bus_cpss_fpb_pdata; |
| 2494 | #endif |
| 2495 | } |
| 2496 | |
| 2497 | static struct msm_spi_platform_data msm8960_qup_spi_gsbi1_pdata = { |
| 2498 | .max_clock_speed = 15060000, |
| 2499 | }; |
| 2500 | |
| 2501 | #ifdef CONFIG_USB_MSM_OTG_72K |
| 2502 | static struct msm_otg_platform_data msm_otg_pdata; |
| 2503 | #else |
| 2504 | #define USB_5V_EN 42 |
| 2505 | static void msm_hsusb_vbus_power(bool on) |
| 2506 | { |
| 2507 | int rc; |
| 2508 | static bool vbus_is_on; |
| 2509 | static struct regulator *mvs_otg_switch; |
| 2510 | struct pm_gpio param = { |
| 2511 | .direction = PM_GPIO_DIR_OUT, |
| 2512 | .output_buffer = PM_GPIO_OUT_BUF_CMOS, |
| 2513 | .output_value = 1, |
| 2514 | .pull = PM_GPIO_PULL_NO, |
| 2515 | .vin_sel = PM_GPIO_VIN_S4, |
| 2516 | .out_strength = PM_GPIO_STRENGTH_MED, |
| 2517 | .function = PM_GPIO_FUNC_NORMAL, |
| 2518 | }; |
| 2519 | |
| 2520 | if (vbus_is_on == on) |
| 2521 | return; |
| 2522 | |
| 2523 | if (on) { |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 2524 | mvs_otg_switch = regulator_get(&msm8960_device_otg.dev, |
| 2525 | "vbus_otg"); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2526 | if (IS_ERR(mvs_otg_switch)) { |
| 2527 | pr_err("Unable to get mvs_otg_switch\n"); |
| 2528 | return; |
| 2529 | } |
| 2530 | |
| 2531 | rc = gpio_request(PM8921_GPIO_PM_TO_SYS(USB_5V_EN), |
| 2532 | "usb_5v_en"); |
| 2533 | if (rc < 0) { |
| 2534 | pr_err("failed to request usb_5v_en gpio\n"); |
| 2535 | goto put_mvs_otg; |
| 2536 | } |
| 2537 | |
| 2538 | if (regulator_enable(mvs_otg_switch)) { |
| 2539 | pr_err("unable to enable mvs_otg_switch\n"); |
| 2540 | goto free_usb_5v_en; |
| 2541 | } |
| 2542 | |
| 2543 | rc = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(USB_5V_EN), |
| 2544 | ¶m); |
| 2545 | if (rc < 0) { |
| 2546 | pr_err("failed to configure usb_5v_en gpio\n"); |
| 2547 | goto disable_mvs_otg; |
| 2548 | } |
| 2549 | vbus_is_on = true; |
| 2550 | return; |
| 2551 | } |
| 2552 | disable_mvs_otg: |
| 2553 | regulator_disable(mvs_otg_switch); |
| 2554 | free_usb_5v_en: |
| 2555 | gpio_free(PM8921_GPIO_PM_TO_SYS(USB_5V_EN)); |
| 2556 | put_mvs_otg: |
| 2557 | regulator_put(mvs_otg_switch); |
| 2558 | vbus_is_on = false; |
| 2559 | } |
| 2560 | |
| 2561 | static struct msm_otg_platform_data msm_otg_pdata = { |
| 2562 | .mode = USB_OTG, |
| 2563 | .otg_control = OTG_PMIC_CONTROL, |
| 2564 | .phy_type = SNPS_28NM_INTEGRATED_PHY, |
| 2565 | .pclk_src_name = "dfab_usb_hs_clk", |
| 2566 | .pmic_id_irq = PM8921_USB_ID_IN_IRQ(PM8921_IRQ_BASE), |
| 2567 | .vbus_power = msm_hsusb_vbus_power, |
| 2568 | }; |
| 2569 | #endif |
| 2570 | |
| 2571 | #define PID_MAGIC_ID 0x71432909 |
| 2572 | #define SERIAL_NUM_MAGIC_ID 0x61945374 |
| 2573 | #define SERIAL_NUMBER_LENGTH 127 |
| 2574 | #define DLOAD_USB_BASE_ADD 0x2A03F0C8 |
| 2575 | |
| 2576 | struct magic_num_struct { |
| 2577 | uint32_t pid; |
| 2578 | uint32_t serial_num; |
| 2579 | }; |
| 2580 | |
| 2581 | struct dload_struct { |
| 2582 | uint32_t reserved1; |
| 2583 | uint32_t reserved2; |
| 2584 | uint32_t reserved3; |
| 2585 | uint16_t reserved4; |
| 2586 | uint16_t pid; |
| 2587 | char serial_number[SERIAL_NUMBER_LENGTH]; |
| 2588 | uint16_t reserved5; |
| 2589 | struct magic_num_struct magic_struct; |
| 2590 | }; |
| 2591 | |
| 2592 | static int usb_diag_update_pid_and_serial_num(uint32_t pid, const char *snum) |
| 2593 | { |
| 2594 | struct dload_struct __iomem *dload = 0; |
| 2595 | |
| 2596 | dload = ioremap(DLOAD_USB_BASE_ADD, sizeof(*dload)); |
| 2597 | if (!dload) { |
| 2598 | pr_err("%s: cannot remap I/O memory region: %08x\n", |
| 2599 | __func__, DLOAD_USB_BASE_ADD); |
| 2600 | return -ENXIO; |
| 2601 | } |
| 2602 | |
| 2603 | pr_debug("%s: dload:%p pid:%x serial_num:%s\n", |
| 2604 | __func__, dload, pid, snum); |
| 2605 | /* update pid */ |
| 2606 | dload->magic_struct.pid = PID_MAGIC_ID; |
| 2607 | dload->pid = pid; |
| 2608 | |
| 2609 | /* update serial number */ |
| 2610 | dload->magic_struct.serial_num = 0; |
| 2611 | if (!snum) { |
| 2612 | memset(dload->serial_number, 0, SERIAL_NUMBER_LENGTH); |
| 2613 | goto out; |
| 2614 | } |
| 2615 | |
| 2616 | dload->magic_struct.serial_num = SERIAL_NUM_MAGIC_ID; |
| 2617 | strncpy(dload->serial_number, snum, SERIAL_NUMBER_LENGTH); |
| 2618 | dload->serial_number[SERIAL_NUMBER_LENGTH - 1] = '\0'; |
| 2619 | out: |
| 2620 | iounmap(dload); |
| 2621 | return 0; |
| 2622 | } |
| 2623 | |
| 2624 | static struct android_usb_platform_data android_usb_pdata = { |
| 2625 | .update_pid_and_serial_num = usb_diag_update_pid_and_serial_num, |
| 2626 | }; |
| 2627 | |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 2628 | static struct platform_device android_usb_device = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2629 | .name = "android_usb", |
| 2630 | .id = -1, |
| 2631 | .dev = { |
| 2632 | .platform_data = &android_usb_pdata, |
| 2633 | }, |
| 2634 | }; |
| 2635 | |
| 2636 | static uint8_t spm_wfi_cmd_sequence[] __initdata = { |
| 2637 | 0x03, 0x0f, |
| 2638 | }; |
| 2639 | |
| 2640 | static uint8_t spm_power_collapse_without_rpm[] __initdata = { |
| 2641 | 0x00, 0x24, 0x54, 0x10, |
| 2642 | 0x09, 0x03, 0x01, |
| 2643 | 0x10, 0x54, 0x30, 0x0C, |
| 2644 | 0x24, 0x30, 0x0f, |
| 2645 | }; |
| 2646 | |
| 2647 | static uint8_t spm_power_collapse_with_rpm[] __initdata = { |
| 2648 | 0x00, 0x24, 0x54, 0x10, |
| 2649 | 0x09, 0x07, 0x01, 0x0B, |
| 2650 | 0x10, 0x54, 0x30, 0x0C, |
| 2651 | 0x24, 0x30, 0x0f, |
| 2652 | }; |
| 2653 | |
| 2654 | static struct msm_spm_seq_entry msm_spm_seq_list[] __initdata = { |
| 2655 | [0] = { |
| 2656 | .mode = MSM_SPM_MODE_CLOCK_GATING, |
| 2657 | .notify_rpm = false, |
| 2658 | .cmd = spm_wfi_cmd_sequence, |
| 2659 | }, |
| 2660 | [1] = { |
| 2661 | .mode = MSM_SPM_MODE_POWER_COLLAPSE, |
| 2662 | .notify_rpm = false, |
| 2663 | .cmd = spm_power_collapse_without_rpm, |
| 2664 | }, |
| 2665 | [2] = { |
| 2666 | .mode = MSM_SPM_MODE_POWER_COLLAPSE, |
| 2667 | .notify_rpm = true, |
| 2668 | .cmd = spm_power_collapse_with_rpm, |
| 2669 | }, |
| 2670 | }; |
| 2671 | |
| 2672 | static struct msm_spm_platform_data msm_spm_data[] __initdata = { |
| 2673 | [0] = { |
| 2674 | .reg_base_addr = MSM_SAW0_BASE, |
| 2675 | .reg_init_values[MSM_SPM_REG_SAW2_SECURE] = 0x00, |
| 2676 | .reg_init_values[MSM_SPM_REG_SAW2_CFG] = 0x1F, |
| 2677 | .reg_init_values[MSM_SPM_REG_SAW2_VCTL] = 0x9C, |
| 2678 | #if defined(CONFIG_MSM_AVS_HW) |
| 2679 | .reg_init_values[MSM_SPM_REG_SAW2_AVS_CTL] = 0x00, |
| 2680 | .reg_init_values[MSM_SPM_REG_SAW2_AVS_HYSTERESIS] = 0x00, |
| 2681 | #endif |
| 2682 | .reg_init_values[MSM_SPM_REG_SAW2_SPM_CTL] = 0x01, |
| 2683 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DLY] = 0x02020202, |
| 2684 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_0] = 0x0060009C, |
| 2685 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_1] = 0x0000001C, |
| 2686 | .vctl_timeout_us = 50, |
| 2687 | .num_modes = ARRAY_SIZE(msm_spm_seq_list), |
| 2688 | .modes = msm_spm_seq_list, |
| 2689 | }, |
| 2690 | [1] = { |
| 2691 | .reg_base_addr = MSM_SAW1_BASE, |
| 2692 | .reg_init_values[MSM_SPM_REG_SAW2_SECURE] = 0x00, |
| 2693 | .reg_init_values[MSM_SPM_REG_SAW2_CFG] = 0x1F, |
| 2694 | .reg_init_values[MSM_SPM_REG_SAW2_VCTL] = 0x9C, |
| 2695 | #if defined(CONFIG_MSM_AVS_HW) |
| 2696 | .reg_init_values[MSM_SPM_REG_SAW2_AVS_CTL] = 0x00, |
| 2697 | .reg_init_values[MSM_SPM_REG_SAW2_AVS_HYSTERESIS] = 0x00, |
| 2698 | #endif |
| 2699 | .reg_init_values[MSM_SPM_REG_SAW2_SPM_CTL] = 0x01, |
| 2700 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DLY] = 0x02020202, |
| 2701 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_0] = 0x0060009C, |
| 2702 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_1] = 0x0000001C, |
| 2703 | .vctl_timeout_us = 50, |
| 2704 | .num_modes = ARRAY_SIZE(msm_spm_seq_list), |
| 2705 | .modes = msm_spm_seq_list, |
| 2706 | }, |
| 2707 | }; |
| 2708 | |
| 2709 | static uint8_t l2_spm_wfi_cmd_sequence[] __initdata = { |
| 2710 | 0x00, 0x20, 0x03, 0x20, |
| 2711 | 0x00, 0x0f, |
| 2712 | }; |
| 2713 | |
| 2714 | static uint8_t l2_spm_gdhs_cmd_sequence[] __initdata = { |
| 2715 | 0x00, 0x20, 0x34, 0x64, |
| 2716 | 0x48, 0x07, 0x48, 0x20, |
| 2717 | 0x50, 0x64, 0x04, 0x34, |
| 2718 | 0x50, 0x0f, |
| 2719 | }; |
| 2720 | static uint8_t l2_spm_power_off_cmd_sequence[] __initdata = { |
| 2721 | 0x00, 0x10, 0x34, 0x64, |
| 2722 | 0x48, 0x07, 0x48, 0x10, |
| 2723 | 0x50, 0x64, 0x04, 0x34, |
| 2724 | 0x50, 0x0F, |
| 2725 | }; |
| 2726 | |
| 2727 | static struct msm_spm_seq_entry msm_spm_l2_seq_list[] __initdata = { |
| 2728 | [0] = { |
| 2729 | .mode = MSM_SPM_L2_MODE_RETENTION, |
| 2730 | .notify_rpm = false, |
| 2731 | .cmd = l2_spm_wfi_cmd_sequence, |
| 2732 | }, |
| 2733 | [1] = { |
| 2734 | .mode = MSM_SPM_L2_MODE_GDHS, |
| 2735 | .notify_rpm = true, |
| 2736 | .cmd = l2_spm_gdhs_cmd_sequence, |
| 2737 | }, |
| 2738 | [2] = { |
| 2739 | .mode = MSM_SPM_L2_MODE_POWER_COLLAPSE, |
| 2740 | .notify_rpm = true, |
| 2741 | .cmd = l2_spm_power_off_cmd_sequence, |
| 2742 | }, |
| 2743 | }; |
| 2744 | |
| 2745 | |
| 2746 | static struct msm_spm_platform_data msm_spm_l2_data[] __initdata = { |
| 2747 | [0] = { |
| 2748 | .reg_base_addr = MSM_SAW_L2_BASE, |
| 2749 | .reg_init_values[MSM_SPM_REG_SAW2_SECURE] = 0x00, |
| 2750 | .reg_init_values[MSM_SPM_REG_SAW2_SPM_CTL] = 0x00, |
| 2751 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DLY] = 0x02020202, |
| 2752 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_0] = 0x00A000AE, |
| 2753 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_1] = 0x00A00020, |
| 2754 | .modes = msm_spm_l2_seq_list, |
| 2755 | .num_modes = ARRAY_SIZE(msm_spm_l2_seq_list), |
| 2756 | }, |
| 2757 | }; |
| 2758 | |
| 2759 | #define CYTTSP_TS_GPIO_IRQ 11 |
| 2760 | #define CYTTSP_TS_SLEEP_GPIO 50 |
| 2761 | #define CYTTSP_TS_RESOUT_N_GPIO 52 |
| 2762 | |
| 2763 | /*virtual key support */ |
| 2764 | static ssize_t tma340_vkeys_show(struct kobject *kobj, |
| 2765 | struct kobj_attribute *attr, char *buf) |
| 2766 | { |
| 2767 | return snprintf(buf, 200, |
| 2768 | __stringify(EV_KEY) ":" __stringify(KEY_BACK) ":73:1120:97:97" |
| 2769 | ":" __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":230:1120:97:97" |
| 2770 | ":" __stringify(EV_KEY) ":" __stringify(KEY_HOME) ":389:1120:97:97" |
| 2771 | ":" __stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":544:1120:97:97" |
| 2772 | "\n"); |
| 2773 | } |
| 2774 | |
| 2775 | static struct kobj_attribute tma340_vkeys_attr = { |
| 2776 | .attr = { |
| 2777 | .mode = S_IRUGO, |
| 2778 | }, |
| 2779 | .show = &tma340_vkeys_show, |
| 2780 | }; |
| 2781 | |
| 2782 | static struct attribute *tma340_properties_attrs[] = { |
| 2783 | &tma340_vkeys_attr.attr, |
| 2784 | NULL |
| 2785 | }; |
| 2786 | |
| 2787 | static struct attribute_group tma340_properties_attr_group = { |
| 2788 | .attrs = tma340_properties_attrs, |
| 2789 | }; |
| 2790 | |
| 2791 | |
| 2792 | static int cyttsp_platform_init(struct i2c_client *client) |
| 2793 | { |
| 2794 | int rc = 0; |
| 2795 | static struct kobject *tma340_properties_kobj; |
| 2796 | |
| 2797 | tma340_vkeys_attr.attr.name = "virtualkeys.cyttsp-i2c"; |
| 2798 | tma340_properties_kobj = kobject_create_and_add("board_properties", |
| 2799 | NULL); |
| 2800 | if (tma340_properties_kobj) |
| 2801 | rc = sysfs_create_group(tma340_properties_kobj, |
| 2802 | &tma340_properties_attr_group); |
| 2803 | if (!tma340_properties_kobj || rc) |
| 2804 | pr_err("%s: failed to create board_properties\n", |
| 2805 | __func__); |
| 2806 | |
| 2807 | return 0; |
| 2808 | } |
| 2809 | |
| 2810 | static struct cyttsp_regulator regulator_data[] = { |
| 2811 | { |
| 2812 | .name = "vdd", |
| 2813 | .min_uV = CY_TMA300_VTG_MIN_UV, |
| 2814 | .max_uV = CY_TMA300_VTG_MAX_UV, |
| 2815 | .load_uA = CY_TMA300_CURR_24HZ_UA, |
| 2816 | }, |
| 2817 | /* TODO: Remove after runtime PM is enabled in I2C driver */ |
| 2818 | { |
| 2819 | .name = "vcc_i2c", |
| 2820 | .min_uV = CY_I2C_VTG_MIN_UV, |
| 2821 | .max_uV = CY_I2C_VTG_MAX_UV, |
| 2822 | .load_uA = CY_I2C_CURR_UA, |
| 2823 | }, |
| 2824 | }; |
| 2825 | |
| 2826 | static struct cyttsp_platform_data cyttsp_pdata = { |
| 2827 | .panel_maxx = 634, |
| 2828 | .panel_maxy = 1166, |
| 2829 | .disp_maxx = 616, |
| 2830 | .disp_maxy = 1023, |
| 2831 | .disp_minx = 0, |
| 2832 | .disp_miny = 16, |
| 2833 | .flags = 0x01, |
| 2834 | .gen = CY_GEN3, /* or */ |
| 2835 | .use_st = CY_USE_ST, |
| 2836 | .use_mt = CY_USE_MT, |
| 2837 | .use_hndshk = CY_SEND_HNDSHK, |
| 2838 | .use_trk_id = CY_USE_TRACKING_ID, |
Anirudh Ghayal | e96f66d | 2011-08-11 14:06:38 +0530 | [diff] [blame] | 2839 | .use_sleep = CY_USE_DEEP_SLEEP_SEL | CY_USE_LOW_POWER_SEL, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2840 | .use_gestures = CY_USE_GESTURES, |
| 2841 | .fw_fname = "cyttsp_8960_cdp.hex", |
| 2842 | /* activate up to 4 groups |
| 2843 | * and set active distance |
| 2844 | */ |
| 2845 | .gest_set = CY_GEST_GRP1 | CY_GEST_GRP2 | |
| 2846 | CY_GEST_GRP3 | CY_GEST_GRP4 | |
| 2847 | CY_ACT_DIST, |
| 2848 | /* change act_intrvl to customize the Active power state |
| 2849 | * scanning/processing refresh interval for Operating mode |
| 2850 | */ |
| 2851 | .act_intrvl = CY_ACT_INTRVL_DFLT, |
| 2852 | /* change tch_tmout to customize the touch timeout for the |
| 2853 | * Active power state for Operating mode |
| 2854 | */ |
| 2855 | .tch_tmout = CY_TCH_TMOUT_DFLT, |
| 2856 | /* change lp_intrvl to customize the Low Power power state |
| 2857 | * scanning/processing refresh interval for Operating mode |
| 2858 | */ |
| 2859 | .lp_intrvl = CY_LP_INTRVL_DFLT, |
| 2860 | .sleep_gpio = CYTTSP_TS_SLEEP_GPIO, |
| 2861 | .resout_gpio = CYTTSP_TS_RESOUT_N_GPIO, |
| 2862 | .irq_gpio = CYTTSP_TS_GPIO_IRQ, |
| 2863 | .regulator_info = regulator_data, |
| 2864 | .num_regulators = ARRAY_SIZE(regulator_data), |
| 2865 | .init = cyttsp_platform_init, |
Mohan Pallaka | 49c37d6 | 2011-08-01 11:52:00 +0530 | [diff] [blame] | 2866 | .correct_fw_ver = 9, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2867 | }; |
| 2868 | |
| 2869 | static struct i2c_board_info cyttsp_info[] __initdata = { |
| 2870 | { |
| 2871 | I2C_BOARD_INFO(CY_I2C_NAME, 0x24), |
| 2872 | .platform_data = &cyttsp_pdata, |
| 2873 | #ifndef CY_USE_TIMER |
| 2874 | .irq = MSM_GPIO_TO_INT(CYTTSP_TS_GPIO_IRQ), |
| 2875 | #endif /* CY_USE_TIMER */ |
| 2876 | }, |
| 2877 | }; |
| 2878 | |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2879 | /* configuration data */ |
| 2880 | static const u8 mxt_config_data[] = { |
| 2881 | /* T6 Object */ |
| 2882 | 0, 0, 0, 0, 0, 0, |
| 2883 | /* T38 Object */ |
| 2884 | 11, 0, 0, 6, 9, 11, 0, 0, 0, 0, |
| 2885 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2886 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2887 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2888 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2889 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2890 | 0, 0, 0, 0, |
| 2891 | /* T7 Object */ |
| 2892 | 10, 10, 50, |
| 2893 | /* T8 Object */ |
| 2894 | 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2895 | /* T9 Object */ |
| 2896 | 131, 0, 0, 26, 42, 0, 32, 60, 2, 5, |
| 2897 | 0, 5, 5, 34, 10, 10, 10, 10, 85, 5, |
| 2898 | 255, 2, 8, 9, 9, 9, 0, 0, 5, 20, |
| 2899 | 0, 5, 45, 46, |
| 2900 | /* T15 Object */ |
| 2901 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2902 | 0, |
| 2903 | /* T22 Object */ |
| 2904 | 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, |
| 2905 | 0, 0, 255, 255, 255, 255, 0, |
| 2906 | /* T24 Object */ |
| 2907 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2908 | 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2909 | /* T25 Object */ |
| 2910 | 3, 0, 188, 52, 52, 33, 0, 0, 0, 0, |
| 2911 | 0, 0, 0, 0, |
| 2912 | /* T27 Object */ |
| 2913 | 0, 0, 0, 0, 0, 0, 0, |
| 2914 | /* T28 Object */ |
| 2915 | 0, 0, 0, 8, 8, 8, |
| 2916 | /* T40 Object */ |
| 2917 | 0, 0, 0, 0, 0, |
| 2918 | /* T41 Object */ |
| 2919 | 0, 0, 0, 0, 0, 0, |
| 2920 | /* T43 Object */ |
| 2921 | 0, 0, 0, 0, 0, 0, |
| 2922 | }; |
| 2923 | |
| 2924 | #define MXT_TS_GPIO_IRQ 11 |
| 2925 | #define MXT_TS_LDO_EN_GPIO 50 |
| 2926 | #define MXT_TS_RESET_GPIO 52 |
| 2927 | |
| 2928 | static void mxt_init_hw_liquid(void) |
| 2929 | { |
| 2930 | int rc; |
| 2931 | |
| 2932 | rc = gpio_request(MXT_TS_GPIO_IRQ, "mxt_ts_irq_gpio"); |
| 2933 | if (rc) { |
| 2934 | pr_err("%s: unable to request mxt_ts_irq gpio [%d]\n", |
| 2935 | __func__, MXT_TS_GPIO_IRQ); |
| 2936 | return; |
| 2937 | } |
| 2938 | |
| 2939 | rc = gpio_direction_input(MXT_TS_GPIO_IRQ); |
| 2940 | if (rc) { |
| 2941 | pr_err("%s: unable to set_direction for mxt_ts_irq gpio [%d]\n", |
| 2942 | __func__, MXT_TS_GPIO_IRQ); |
| 2943 | goto err_irq_gpio_req; |
| 2944 | } |
| 2945 | |
| 2946 | rc = gpio_request(MXT_TS_LDO_EN_GPIO, "mxt_ldo_en_gpio"); |
| 2947 | if (rc) { |
| 2948 | pr_err("%s: unable to request mxt_ldo_en gpio [%d]\n", |
| 2949 | __func__, MXT_TS_LDO_EN_GPIO); |
| 2950 | goto err_irq_gpio_req; |
| 2951 | } |
| 2952 | |
| 2953 | rc = gpio_direction_output(MXT_TS_LDO_EN_GPIO, 1); |
| 2954 | if (rc) { |
| 2955 | pr_err("%s: unable to set_direction for mxt_ldo_en gpio [%d]\n", |
| 2956 | __func__, MXT_TS_LDO_EN_GPIO); |
| 2957 | goto err_ldo_gpio_req; |
| 2958 | } |
| 2959 | |
| 2960 | rc = gpio_request(MXT_TS_RESET_GPIO, "mxt_reset_gpio"); |
| 2961 | if (rc) { |
| 2962 | pr_err("%s: unable to request mxt_reset gpio [%d]\n", |
| 2963 | __func__, MXT_TS_RESET_GPIO); |
| 2964 | goto err_ldo_gpio_set_dir; |
| 2965 | } |
| 2966 | |
| 2967 | rc = gpio_direction_output(MXT_TS_RESET_GPIO, 1); |
| 2968 | if (rc) { |
| 2969 | pr_err("%s: unable to set_direction for mxt_reset gpio [%d]\n", |
| 2970 | __func__, MXT_TS_RESET_GPIO); |
| 2971 | goto err_reset_gpio_req; |
| 2972 | } |
| 2973 | |
| 2974 | return; |
| 2975 | |
| 2976 | err_reset_gpio_req: |
| 2977 | gpio_free(MXT_TS_RESET_GPIO); |
| 2978 | err_ldo_gpio_set_dir: |
| 2979 | gpio_set_value(MXT_TS_LDO_EN_GPIO, 0); |
| 2980 | err_ldo_gpio_req: |
| 2981 | gpio_free(MXT_TS_LDO_EN_GPIO); |
| 2982 | err_irq_gpio_req: |
| 2983 | gpio_free(MXT_TS_GPIO_IRQ); |
| 2984 | } |
| 2985 | |
| 2986 | static struct mxt_platform_data mxt_platform_data = { |
| 2987 | .config = mxt_config_data, |
| 2988 | .config_length = ARRAY_SIZE(mxt_config_data), |
| 2989 | .x_line = 26, |
| 2990 | .y_line = 42, |
| 2991 | .x_size = 767, |
| 2992 | .y_size = 1365, |
| 2993 | .blen = 32, |
| 2994 | .threshold = 40, |
| 2995 | .voltage = 3300000, /* 3.3V */ |
| 2996 | .orient = MXT_ROTATED_90, |
| 2997 | .irqflags = IRQF_TRIGGER_FALLING, |
| 2998 | }; |
| 2999 | |
| 3000 | static struct i2c_board_info mxt_device_info[] __initdata = { |
| 3001 | { |
| 3002 | I2C_BOARD_INFO("atmel_mxt_ts", 0x5b), |
| 3003 | .platform_data = &mxt_platform_data, |
| 3004 | .irq = MSM_GPIO_TO_INT(MXT_TS_GPIO_IRQ), |
| 3005 | }, |
| 3006 | }; |
| 3007 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3008 | static void gsbi_qup_i2c_gpio_config(int adap_id, int config_type) |
| 3009 | { |
| 3010 | } |
| 3011 | |
| 3012 | static struct msm_i2c_platform_data msm8960_i2c_qup_gsbi4_pdata = { |
| 3013 | .clk_freq = 100000, |
| 3014 | .src_clk_rate = 24000000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3015 | .msm_i2c_config_gpio = gsbi_qup_i2c_gpio_config, |
| 3016 | }; |
| 3017 | |
| 3018 | static struct msm_i2c_platform_data msm8960_i2c_qup_gsbi3_pdata = { |
| 3019 | .clk_freq = 100000, |
| 3020 | .src_clk_rate = 24000000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3021 | .msm_i2c_config_gpio = gsbi_qup_i2c_gpio_config, |
| 3022 | }; |
| 3023 | |
| 3024 | static struct msm_i2c_platform_data msm8960_i2c_qup_gsbi10_pdata = { |
| 3025 | .clk_freq = 100000, |
| 3026 | .src_clk_rate = 24000000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3027 | .msm_i2c_config_gpio = gsbi_qup_i2c_gpio_config, |
| 3028 | }; |
| 3029 | |
| 3030 | static struct msm_i2c_platform_data msm8960_i2c_qup_gsbi12_pdata = { |
| 3031 | .clk_freq = 100000, |
| 3032 | .src_clk_rate = 24000000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3033 | .msm_i2c_config_gpio = gsbi_qup_i2c_gpio_config, |
| 3034 | }; |
| 3035 | |
| 3036 | static struct msm_rpm_platform_data msm_rpm_data = { |
| 3037 | .reg_base_addrs = { |
| 3038 | [MSM_RPM_PAGE_STATUS] = MSM_RPM_BASE, |
| 3039 | [MSM_RPM_PAGE_CTRL] = MSM_RPM_BASE + 0x400, |
| 3040 | [MSM_RPM_PAGE_REQ] = MSM_RPM_BASE + 0x600, |
| 3041 | [MSM_RPM_PAGE_ACK] = MSM_RPM_BASE + 0xa00, |
| 3042 | }, |
| 3043 | |
| 3044 | .irq_ack = RPM_APCC_CPU0_GP_HIGH_IRQ, |
| 3045 | .irq_err = RPM_APCC_CPU0_GP_LOW_IRQ, |
| 3046 | .irq_vmpm = RPM_APCC_CPU0_GP_MEDIUM_IRQ, |
| 3047 | .msm_apps_ipc_rpm_reg = MSM_APCS_GCC_BASE + 0x008, |
| 3048 | .msm_apps_ipc_rpm_val = 4, |
| 3049 | }; |
| 3050 | |
Praveen Chidambaram | 043f4ce | 2011-08-02 09:37:59 -0600 | [diff] [blame] | 3051 | static struct platform_device msm_rpm_device = { |
| 3052 | .name = "msm_rpm", |
| 3053 | .id = -1, |
| 3054 | }; |
| 3055 | |
| 3056 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3057 | static struct spi_board_info spi_board_info[] __initdata = { |
| 3058 | { |
| 3059 | .modalias = "ks8851", |
| 3060 | .irq = MSM_GPIO_TO_INT(KS8851_IRQ_GPIO), |
| 3061 | .max_speed_hz = 19200000, |
| 3062 | .bus_num = 0, |
| 3063 | .chip_select = 0, |
| 3064 | .mode = SPI_MODE_0, |
| 3065 | }, |
| 3066 | }; |
| 3067 | |
| 3068 | static struct platform_device msm_device_saw_core0 = { |
| 3069 | .name = "saw-regulator", |
| 3070 | .id = 0, |
| 3071 | .dev = { |
| 3072 | .platform_data = &msm_saw_regulator_pdata_s5, |
| 3073 | }, |
| 3074 | }; |
| 3075 | |
| 3076 | static struct platform_device msm_device_saw_core1 = { |
| 3077 | .name = "saw-regulator", |
| 3078 | .id = 1, |
| 3079 | .dev = { |
| 3080 | .platform_data = &msm_saw_regulator_pdata_s6, |
| 3081 | }, |
| 3082 | }; |
| 3083 | |
| 3084 | #ifdef CONFIG_MSM_FAKE_BATTERY |
| 3085 | static struct platform_device fish_battery_device = { |
| 3086 | .name = "fish_battery", |
| 3087 | }; |
| 3088 | #endif |
| 3089 | |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 3090 | static struct platform_device msm8960_device_ext_5v_vreg __devinitdata = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3091 | .name = GPIO_REGULATOR_DEV_NAME, |
| 3092 | .id = PM8921_MPP_PM_TO_SYS(7), |
| 3093 | .dev = { |
| 3094 | .platform_data = &msm_gpio_regulator_pdata[GPIO_VREG_ID_EXT_5V], |
| 3095 | }, |
| 3096 | }; |
| 3097 | |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 3098 | static struct platform_device msm8960_device_ext_l2_vreg __devinitdata = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3099 | .name = GPIO_REGULATOR_DEV_NAME, |
| 3100 | .id = 91, |
| 3101 | .dev = { |
| 3102 | .platform_data = &msm_gpio_regulator_pdata[GPIO_VREG_ID_EXT_L2], |
| 3103 | }, |
| 3104 | }; |
| 3105 | |
David Collins | b10be1d | 2011-09-02 10:29:31 -0700 | [diff] [blame] | 3106 | static struct platform_device msm8960_device_ext_3p3v_vreg __devinitdata = { |
| 3107 | .name = GPIO_REGULATOR_DEV_NAME, |
| 3108 | .id = PM8921_GPIO_PM_TO_SYS(17), |
| 3109 | .dev = { |
| 3110 | .platform_data = |
| 3111 | &msm_gpio_regulator_pdata[GPIO_VREG_ID_EXT_3P3V], |
| 3112 | }, |
| 3113 | }; |
| 3114 | |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 3115 | static struct platform_device msm8960_device_rpm_regulator __devinitdata = { |
| 3116 | .name = "rpm-regulator", |
| 3117 | .id = -1, |
| 3118 | .dev = { |
| 3119 | .platform_data = &msm_rpm_regulator_pdata, |
| 3120 | }, |
| 3121 | }; |
| 3122 | |
David Collins | 4c31a87 | 2011-08-31 10:07:10 -0700 | [diff] [blame] | 3123 | static struct msm_rpm_log_platform_data msm_rpm_log_pdata = { |
| 3124 | .phys_addr_base = 0x0010C000, |
| 3125 | .reg_offsets = { |
| 3126 | [MSM_RPM_LOG_PAGE_INDICES] = 0x00000080, |
| 3127 | [MSM_RPM_LOG_PAGE_BUFFER] = 0x000000A0, |
| 3128 | }, |
| 3129 | .phys_size = SZ_8K, |
| 3130 | .log_len = 4096, /* log's buffer length in bytes */ |
| 3131 | .log_len_mask = (4096 >> 2) - 1, /* length mask in units of u32 */ |
| 3132 | }; |
| 3133 | |
| 3134 | static struct platform_device msm_rpm_log_device = { |
| 3135 | .name = "msm_rpm_log", |
| 3136 | .id = -1, |
| 3137 | .dev = { |
| 3138 | .platform_data = &msm_rpm_log_pdata, |
| 3139 | }, |
| 3140 | }; |
| 3141 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3142 | static struct platform_device *common_devices[] __initdata = { |
Stepan Moskovchenko | df13d34 | 2011-08-03 19:01:25 -0700 | [diff] [blame] | 3143 | &msm8960_device_dmov, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3144 | &msm_device_smd, |
| 3145 | &msm8960_device_uart_gsbi5, |
Mayank Rana | 9f51f58 | 2011-08-04 18:35:59 +0530 | [diff] [blame] | 3146 | &msm_device_uart_dm6, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3147 | &msm_device_saw_core0, |
| 3148 | &msm_device_saw_core1, |
| 3149 | &msm8960_device_ext_5v_vreg, |
| 3150 | &msm8960_device_ext_l2_vreg, |
| 3151 | &msm8960_device_ssbi_pm8921, |
| 3152 | &msm8960_device_qup_spi_gsbi1, |
| 3153 | &msm8960_device_qup_i2c_gsbi3, |
| 3154 | &msm8960_device_qup_i2c_gsbi4, |
| 3155 | &msm8960_device_qup_i2c_gsbi10, |
| 3156 | #ifndef CONFIG_MSM_DSPS |
| 3157 | &msm8960_device_qup_i2c_gsbi12, |
| 3158 | #endif |
| 3159 | &msm_slim_ctrl, |
| 3160 | &msm_device_wcnss_wlan, |
| 3161 | #if defined(CONFIG_CRYPTO_DEV_QCRYPTO) || \ |
| 3162 | defined(CONFIG_CRYPTO_DEV_QCRYPTO_MODULE) |
| 3163 | &qcrypto_device, |
| 3164 | #endif |
| 3165 | |
| 3166 | #if defined(CONFIG_CRYPTO_DEV_QCEDEV) || \ |
| 3167 | defined(CONFIG_CRYPTO_DEV_QCEDEV_MODULE) |
| 3168 | &qcedev_device, |
| 3169 | #endif |
| 3170 | #ifdef CONFIG_MSM_ROTATOR |
| 3171 | &msm_rotator_device, |
| 3172 | #endif |
| 3173 | &msm_device_sps, |
| 3174 | #ifdef CONFIG_MSM_FAKE_BATTERY |
| 3175 | &fish_battery_device, |
| 3176 | #endif |
| 3177 | #ifdef CONFIG_ANDROID_PMEM |
| 3178 | &android_pmem_device, |
| 3179 | &android_pmem_adsp_device, |
| 3180 | &android_pmem_audio_device, |
| 3181 | #endif |
| 3182 | &msm_fb_device, |
| 3183 | &msm_device_vidc, |
| 3184 | &msm_device_bam_dmux, |
| 3185 | &msm_fm_platform_init, |
Mona Hossain | 9c430e3 | 2011-07-27 11:04:47 -0700 | [diff] [blame] | 3186 | |
| 3187 | #ifdef CONFIG_HW_RANDOM_MSM |
| 3188 | &msm_device_rng, |
| 3189 | #endif |
Praveen Chidambaram | 043f4ce | 2011-08-02 09:37:59 -0600 | [diff] [blame] | 3190 | &msm_rpm_device, |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 3191 | #ifdef CONFIG_ION_MSM |
| 3192 | &ion_dev, |
| 3193 | #endif |
David Collins | 4c31a87 | 2011-08-31 10:07:10 -0700 | [diff] [blame] | 3194 | &msm_rpm_log_device, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3195 | }; |
| 3196 | |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3197 | static struct platform_device *sim_devices[] __initdata = { |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 3198 | &msm8960_device_otg, |
| 3199 | &msm8960_device_gadget_peripheral, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3200 | &msm_device_hsusb_host, |
| 3201 | &android_usb_device, |
| 3202 | &msm_device_vidc, |
| 3203 | &mipi_dsi_simulator_panel_device, |
| 3204 | &msm_bus_apps_fabric, |
| 3205 | &msm_bus_sys_fabric, |
| 3206 | &msm_bus_mm_fabric, |
| 3207 | &msm_bus_sys_fpb, |
| 3208 | &msm_bus_cpss_fpb, |
| 3209 | &msm_pcm, |
| 3210 | &msm_pcm_routing, |
| 3211 | &msm_cpudai0, |
| 3212 | &msm_cpudai1, |
| 3213 | &msm_cpudai_hdmi_rx, |
| 3214 | &msm_cpudai_bt_rx, |
| 3215 | &msm_cpudai_bt_tx, |
| 3216 | &msm_cpudai_fm_rx, |
| 3217 | &msm_cpudai_fm_tx, |
| 3218 | &msm_cpu_fe, |
| 3219 | &msm_stub_codec, |
| 3220 | &msm_voice, |
| 3221 | &msm_voip, |
| 3222 | &msm_lpa_pcm, |
| 3223 | |
| 3224 | #if defined(CONFIG_CRYPTO_DEV_QCRYPTO) || \ |
| 3225 | defined(CONFIG_CRYPTO_DEV_QCRYPTO_MODULE) |
| 3226 | &qcrypto_device, |
| 3227 | #endif |
| 3228 | |
| 3229 | #if defined(CONFIG_CRYPTO_DEV_QCEDEV) || \ |
| 3230 | defined(CONFIG_CRYPTO_DEV_QCEDEV_MODULE) |
| 3231 | &qcedev_device, |
| 3232 | #endif |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3233 | }; |
| 3234 | |
| 3235 | static struct platform_device *rumi3_devices[] __initdata = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3236 | &msm_kgsl_3d0, |
| 3237 | &msm_kgsl_2d0, |
| 3238 | &msm_kgsl_2d1, |
| 3239 | &mipi_dsi_renesas_panel_device, |
| 3240 | #ifdef CONFIG_MSM_GEMINI |
| 3241 | &msm8960_gemini_device, |
| 3242 | #endif |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3243 | }; |
| 3244 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3245 | static struct platform_device *cdp_devices[] __initdata = { |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 3246 | &msm8960_device_otg, |
| 3247 | &msm8960_device_gadget_peripheral, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3248 | &msm_device_hsusb_host, |
| 3249 | &android_usb_device, |
| 3250 | &msm_pcm, |
| 3251 | &msm_pcm_routing, |
| 3252 | &msm_cpudai0, |
| 3253 | &msm_cpudai1, |
| 3254 | &msm_cpudai_hdmi_rx, |
| 3255 | &msm_cpudai_bt_rx, |
| 3256 | &msm_cpudai_bt_tx, |
| 3257 | &msm_cpudai_fm_rx, |
| 3258 | &msm_cpudai_fm_tx, |
| 3259 | &msm_cpu_fe, |
| 3260 | &msm_stub_codec, |
| 3261 | &msm_kgsl_3d0, |
| 3262 | #ifdef CONFIG_MSM_KGSL_2D |
| 3263 | &msm_kgsl_2d0, |
| 3264 | &msm_kgsl_2d1, |
| 3265 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3266 | #ifdef CONFIG_MSM_GEMINI |
| 3267 | &msm8960_gemini_device, |
| 3268 | #endif |
| 3269 | &msm_voice, |
| 3270 | &msm_voip, |
| 3271 | &msm_lpa_pcm, |
Laxminath Kasam | cee1d60 | 2011-08-01 19:26:57 +0530 | [diff] [blame] | 3272 | &msm_cpudai_afe_01_rx, |
| 3273 | &msm_cpudai_afe_01_tx, |
| 3274 | &msm_cpudai_afe_02_rx, |
| 3275 | &msm_cpudai_afe_02_tx, |
| 3276 | &msm_pcm_afe, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3277 | #ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL |
| 3278 | &hdmi_msm_device, |
| 3279 | #endif |
| 3280 | &msm_pcm_hostless, |
| 3281 | &msm_bus_apps_fabric, |
| 3282 | &msm_bus_sys_fabric, |
| 3283 | &msm_bus_mm_fabric, |
| 3284 | &msm_bus_sys_fpb, |
| 3285 | &msm_bus_cpss_fpb, |
| 3286 | }; |
| 3287 | |
| 3288 | static void __init msm8960_i2c_init(void) |
| 3289 | { |
| 3290 | msm8960_device_qup_i2c_gsbi4.dev.platform_data = |
| 3291 | &msm8960_i2c_qup_gsbi4_pdata; |
| 3292 | |
| 3293 | msm8960_device_qup_i2c_gsbi3.dev.platform_data = |
| 3294 | &msm8960_i2c_qup_gsbi3_pdata; |
| 3295 | |
| 3296 | msm8960_device_qup_i2c_gsbi10.dev.platform_data = |
| 3297 | &msm8960_i2c_qup_gsbi10_pdata; |
| 3298 | |
| 3299 | msm8960_device_qup_i2c_gsbi12.dev.platform_data = |
| 3300 | &msm8960_i2c_qup_gsbi12_pdata; |
| 3301 | } |
| 3302 | |
Lucille Sylvester | 34ec369 | 2011-08-16 16:28:04 -0600 | [diff] [blame] | 3303 | static void __init msm8960_gfx_init(void) |
| 3304 | { |
| 3305 | uint32_t soc_platform_version = socinfo_get_platform_version(); |
| 3306 | if (SOCINFO_VERSION_MAJOR(soc_platform_version) == 1) { |
| 3307 | struct kgsl_device_platform_data *kgsl_3d0_pdata = |
| 3308 | msm_kgsl_3d0.dev.platform_data; |
| 3309 | kgsl_3d0_pdata->pwr_data.pwrlevel[0].gpu_freq = |
| 3310 | 320000000; |
| 3311 | kgsl_3d0_pdata->pwr_data.pwrlevel[1].gpu_freq = |
| 3312 | 266667000; |
| 3313 | } |
| 3314 | } |
| 3315 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3316 | static struct pm8xxx_irq_platform_data pm8xxx_irq_pdata __devinitdata = { |
| 3317 | .irq_base = PM8921_IRQ_BASE, |
| 3318 | .devirq = MSM_GPIO_TO_INT(104), |
| 3319 | .irq_trigger_flag = IRQF_TRIGGER_LOW, |
| 3320 | }; |
| 3321 | |
| 3322 | static struct pm8xxx_gpio_platform_data pm8xxx_gpio_pdata __devinitdata = { |
| 3323 | .gpio_base = PM8921_GPIO_PM_TO_SYS(1), |
| 3324 | }; |
| 3325 | |
| 3326 | static struct pm8xxx_mpp_platform_data pm8xxx_mpp_pdata __devinitdata = { |
| 3327 | .mpp_base = PM8921_MPP_PM_TO_SYS(1), |
| 3328 | }; |
| 3329 | |
| 3330 | static struct pm8xxx_rtc_platform_data pm8xxx_rtc_pdata __devinitdata = { |
| 3331 | .rtc_write_enable = false, |
| 3332 | }; |
| 3333 | |
| 3334 | static struct pm8xxx_pwrkey_platform_data pm8xxx_pwrkey_pdata = { |
| 3335 | .pull_up = 1, |
| 3336 | .kpd_trigger_delay_us = 970, |
| 3337 | .wakeup = 1, |
| 3338 | }; |
| 3339 | |
Mohan Pallaka | 002e9e0 | 2011-08-05 11:23:22 +0530 | [diff] [blame] | 3340 | /* Rotate lock key is not available so use F1 */ |
| 3341 | #define KEY_ROTATE_LOCK KEY_F1 |
| 3342 | |
| 3343 | static const unsigned int keymap_liquid[] = { |
| 3344 | KEY(0, 0, KEY_VOLUMEUP), |
| 3345 | KEY(0, 1, KEY_VOLUMEDOWN), |
| 3346 | KEY(1, 3, KEY_ROTATE_LOCK), |
| 3347 | KEY(1, 4, KEY_HOME), |
| 3348 | }; |
| 3349 | |
| 3350 | static struct matrix_keymap_data keymap_data_liquid = { |
| 3351 | .keymap_size = ARRAY_SIZE(keymap_liquid), |
| 3352 | .keymap = keymap_liquid, |
| 3353 | }; |
| 3354 | |
| 3355 | static struct pm8xxx_keypad_platform_data keypad_data_liquid = { |
| 3356 | .input_name = "keypad_8960_liquid", |
| 3357 | .input_phys_device = "keypad_8960/input0", |
| 3358 | .num_rows = 2, |
| 3359 | .num_cols = 5, |
| 3360 | .rows_gpio_start = PM8921_GPIO_PM_TO_SYS(9), |
| 3361 | .cols_gpio_start = PM8921_GPIO_PM_TO_SYS(1), |
| 3362 | .debounce_ms = 15, |
| 3363 | .scan_delay_ms = 32, |
| 3364 | .row_hold_ns = 91500, |
| 3365 | .wakeup = 1, |
| 3366 | .keymap_data = &keymap_data_liquid, |
| 3367 | }; |
| 3368 | |
| 3369 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3370 | static const unsigned int keymap[] = { |
| 3371 | KEY(0, 0, KEY_VOLUMEUP), |
| 3372 | KEY(0, 1, KEY_VOLUMEDOWN), |
| 3373 | KEY(0, 2, KEY_CAMERA_SNAPSHOT), |
| 3374 | KEY(0, 3, KEY_CAMERA_FOCUS), |
| 3375 | }; |
| 3376 | |
| 3377 | static struct matrix_keymap_data keymap_data = { |
| 3378 | .keymap_size = ARRAY_SIZE(keymap), |
| 3379 | .keymap = keymap, |
| 3380 | }; |
| 3381 | |
| 3382 | static struct pm8xxx_keypad_platform_data keypad_data = { |
| 3383 | .input_name = "keypad_8960", |
| 3384 | .input_phys_device = "keypad_8960/input0", |
| 3385 | .num_rows = 1, |
| 3386 | .num_cols = 5, |
| 3387 | .rows_gpio_start = PM8921_GPIO_PM_TO_SYS(9), |
| 3388 | .cols_gpio_start = PM8921_GPIO_PM_TO_SYS(1), |
| 3389 | .debounce_ms = 15, |
| 3390 | .scan_delay_ms = 32, |
| 3391 | .row_hold_ns = 91500, |
| 3392 | .wakeup = 1, |
| 3393 | .keymap_data = &keymap_data, |
| 3394 | }; |
| 3395 | |
| 3396 | static const unsigned int keymap_sim[] = { |
| 3397 | KEY(0, 0, KEY_7), |
| 3398 | KEY(0, 1, KEY_DOWN), |
| 3399 | KEY(0, 2, KEY_UP), |
| 3400 | KEY(0, 3, KEY_RIGHT), |
| 3401 | KEY(0, 4, KEY_ENTER), |
| 3402 | KEY(0, 5, KEY_L), |
| 3403 | KEY(0, 6, KEY_BACK), |
| 3404 | KEY(0, 7, KEY_M), |
| 3405 | |
| 3406 | KEY(1, 0, KEY_LEFT), |
| 3407 | KEY(1, 1, KEY_SEND), |
| 3408 | KEY(1, 2, KEY_1), |
| 3409 | KEY(1, 3, KEY_4), |
| 3410 | KEY(1, 4, KEY_CLEAR), |
| 3411 | KEY(1, 5, KEY_MSDOS), |
| 3412 | KEY(1, 6, KEY_SPACE), |
| 3413 | KEY(1, 7, KEY_COMMA), |
| 3414 | |
| 3415 | KEY(2, 0, KEY_6), |
| 3416 | KEY(2, 1, KEY_5), |
| 3417 | KEY(2, 2, KEY_8), |
| 3418 | KEY(2, 3, KEY_3), |
| 3419 | KEY(2, 4, KEY_NUMERIC_STAR), |
| 3420 | KEY(2, 5, KEY_UP), |
| 3421 | KEY(2, 6, KEY_DOWN), |
| 3422 | KEY(2, 7, KEY_LEFTSHIFT), |
| 3423 | |
| 3424 | KEY(3, 0, KEY_9), |
| 3425 | KEY(3, 1, KEY_NUMERIC_POUND), |
| 3426 | KEY(3, 2, KEY_0), |
| 3427 | KEY(3, 3, KEY_2), |
| 3428 | KEY(3, 4, KEY_SLEEP), |
| 3429 | KEY(3, 5, KEY_F1), |
| 3430 | KEY(3, 6, KEY_F2), |
| 3431 | KEY(3, 7, KEY_F3), |
| 3432 | |
| 3433 | KEY(4, 0, KEY_BACK), |
| 3434 | KEY(4, 1, KEY_HOME), |
| 3435 | KEY(4, 2, KEY_MENU), |
| 3436 | KEY(4, 3, KEY_VOLUMEUP), |
| 3437 | KEY(4, 4, KEY_VOLUMEDOWN), |
| 3438 | KEY(4, 5, KEY_F4), |
| 3439 | KEY(4, 6, KEY_F5), |
| 3440 | KEY(4, 7, KEY_F6), |
| 3441 | |
| 3442 | KEY(5, 0, KEY_R), |
| 3443 | KEY(5, 1, KEY_T), |
| 3444 | KEY(5, 2, KEY_Y), |
| 3445 | KEY(5, 3, KEY_LEFTALT), |
| 3446 | KEY(5, 4, KEY_KPENTER), |
| 3447 | KEY(5, 5, KEY_Q), |
| 3448 | KEY(5, 6, KEY_W), |
| 3449 | KEY(5, 7, KEY_E), |
| 3450 | |
| 3451 | KEY(6, 0, KEY_F), |
| 3452 | KEY(6, 1, KEY_G), |
| 3453 | KEY(6, 2, KEY_H), |
| 3454 | KEY(6, 3, KEY_CAPSLOCK), |
| 3455 | KEY(6, 4, KEY_PAGEUP), |
| 3456 | KEY(6, 5, KEY_A), |
| 3457 | KEY(6, 6, KEY_S), |
| 3458 | KEY(6, 7, KEY_D), |
| 3459 | |
| 3460 | KEY(7, 0, KEY_V), |
| 3461 | KEY(7, 1, KEY_B), |
| 3462 | KEY(7, 2, KEY_N), |
| 3463 | KEY(7, 3, KEY_MENU), |
| 3464 | KEY(7, 4, KEY_PAGEDOWN), |
| 3465 | KEY(7, 5, KEY_Z), |
| 3466 | KEY(7, 6, KEY_X), |
| 3467 | KEY(7, 7, KEY_C), |
| 3468 | |
| 3469 | KEY(8, 0, KEY_P), |
| 3470 | KEY(8, 1, KEY_J), |
| 3471 | KEY(8, 2, KEY_K), |
| 3472 | KEY(8, 3, KEY_INSERT), |
| 3473 | KEY(8, 4, KEY_LINEFEED), |
| 3474 | KEY(8, 5, KEY_U), |
| 3475 | KEY(8, 6, KEY_I), |
| 3476 | KEY(8, 7, KEY_O), |
| 3477 | |
| 3478 | KEY(9, 0, KEY_4), |
| 3479 | KEY(9, 1, KEY_5), |
| 3480 | KEY(9, 2, KEY_6), |
| 3481 | KEY(9, 3, KEY_7), |
| 3482 | KEY(9, 4, KEY_8), |
| 3483 | KEY(9, 5, KEY_1), |
| 3484 | KEY(9, 6, KEY_2), |
| 3485 | KEY(9, 7, KEY_3), |
| 3486 | |
| 3487 | KEY(10, 0, KEY_F7), |
| 3488 | KEY(10, 1, KEY_F8), |
| 3489 | KEY(10, 2, KEY_F9), |
| 3490 | KEY(10, 3, KEY_F10), |
| 3491 | KEY(10, 4, KEY_FN), |
| 3492 | KEY(10, 5, KEY_9), |
| 3493 | KEY(10, 6, KEY_0), |
| 3494 | KEY(10, 7, KEY_DOT), |
| 3495 | |
| 3496 | KEY(11, 0, KEY_LEFTCTRL), |
| 3497 | KEY(11, 1, KEY_F11), |
| 3498 | KEY(11, 2, KEY_ENTER), |
| 3499 | KEY(11, 3, KEY_SEARCH), |
| 3500 | KEY(11, 4, KEY_DELETE), |
| 3501 | KEY(11, 5, KEY_RIGHT), |
| 3502 | KEY(11, 6, KEY_LEFT), |
| 3503 | KEY(11, 7, KEY_RIGHTSHIFT), |
| 3504 | KEY(0, 0, KEY_VOLUMEUP), |
| 3505 | KEY(0, 1, KEY_VOLUMEDOWN), |
| 3506 | KEY(0, 2, KEY_CAMERA_SNAPSHOT), |
| 3507 | KEY(0, 3, KEY_CAMERA_FOCUS), |
| 3508 | }; |
| 3509 | |
| 3510 | static struct matrix_keymap_data keymap_data_sim = { |
| 3511 | .keymap_size = ARRAY_SIZE(keymap_sim), |
| 3512 | .keymap = keymap_sim, |
| 3513 | }; |
| 3514 | |
| 3515 | static struct pm8xxx_keypad_platform_data keypad_data_sim = { |
| 3516 | .input_name = "keypad_8960", |
| 3517 | .input_phys_device = "keypad_8960/input0", |
| 3518 | .num_rows = 12, |
| 3519 | .num_cols = 8, |
| 3520 | .rows_gpio_start = PM8921_GPIO_PM_TO_SYS(9), |
| 3521 | .cols_gpio_start = PM8921_GPIO_PM_TO_SYS(1), |
| 3522 | .debounce_ms = 15, |
| 3523 | .scan_delay_ms = 32, |
| 3524 | .row_hold_ns = 91500, |
| 3525 | .wakeup = 1, |
| 3526 | .keymap_data = &keymap_data_sim, |
| 3527 | }; |
| 3528 | |
Abhijeet Dharmapurikar | ad74236 | 2011-08-29 19:50:02 -0700 | [diff] [blame] | 3529 | static int pm8921_therm_mitigation[] = { |
| 3530 | 1100, |
| 3531 | 700, |
| 3532 | 600, |
| 3533 | 325, |
| 3534 | }; |
| 3535 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3536 | static struct pm8921_charger_platform_data pm8921_chg_pdata __devinitdata = { |
Abhijeet Dharmapurikar | 3405933 | 2011-08-16 19:19:39 -0700 | [diff] [blame] | 3537 | .safety_time = 180, |
| 3538 | .update_time = 1, |
| 3539 | .max_voltage = 4200, |
| 3540 | .min_voltage = 3200, |
| 3541 | .resume_voltage = 4100, |
| 3542 | .term_current = 100, |
| 3543 | .cool_temp = 10, |
| 3544 | .warm_temp = 40, |
| 3545 | .temp_check_period = 1, |
Abhijeet Dharmapurikar | ad74236 | 2011-08-29 19:50:02 -0700 | [diff] [blame] | 3546 | .max_bat_chg_current = 1100, |
Abhijeet Dharmapurikar | 3405933 | 2011-08-16 19:19:39 -0700 | [diff] [blame] | 3547 | .cool_bat_chg_current = 350, |
| 3548 | .warm_bat_chg_current = 350, |
| 3549 | .cool_bat_voltage = 4100, |
| 3550 | .warm_bat_voltage = 4100, |
Abhijeet Dharmapurikar | ad74236 | 2011-08-29 19:50:02 -0700 | [diff] [blame] | 3551 | .thermal_mitigation = pm8921_therm_mitigation, |
| 3552 | .thermal_levels = ARRAY_SIZE(pm8921_therm_mitigation), |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3553 | }; |
| 3554 | |
| 3555 | static struct pm8xxx_misc_platform_data pm8xxx_misc_pdata = { |
| 3556 | .priority = 0, |
| 3557 | }; |
| 3558 | |
| 3559 | static struct pm8921_bms_platform_data pm8921_bms_pdata __devinitdata = { |
| 3560 | .r_sense = 10, |
| 3561 | .i_test = 2500, |
| 3562 | .v_failure = 3000, |
| 3563 | .calib_delay_ms = 600000, |
| 3564 | .batt_data = &palladium_1500_data, |
| 3565 | }; |
| 3566 | |
Jay Chokshi | de4cefb | 2011-08-04 18:10:44 -0700 | [diff] [blame] | 3567 | #define PM8921_LC_LED_MAX_CURRENT 4 /* I = 4mA */ |
| 3568 | |
| 3569 | /** |
| 3570 | * 'flag' stores three values; led id, led mode, and max current of led. |
| 3571 | * The bit packing format is as follow, |
| 3572 | * reserved (1 byte) | max_current (2 bytes) | led_mode (1 nibble) | |
| 3573 | * led_id (1 nibble) |
| 3574 | */ |
| 3575 | #define PM8XXX_SET_FLAG(led_id, led_mode, led_max_current) \ |
| 3576 | (((led_id << PM8XXX_LED_ID_SHIFT) & PM8XXX_LED_ID_MASK) |\ |
| 3577 | ((led_mode << PM8XXX_LED_MODE_SHIFT) & PM8XXX_LED_MODE_MASK) |\ |
| 3578 | ((led_max_current << PM8XXX_LED_MAX_CURRENT_SHIFT) & \ |
| 3579 | PM8XXX_LED_MAX_CURRENT_MASK)) |
| 3580 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3581 | static struct led_info pm8921_led_info[] = { |
| 3582 | [0] = { |
Jay Chokshi | de4cefb | 2011-08-04 18:10:44 -0700 | [diff] [blame] | 3583 | .name = "led:usb", |
| 3584 | .default_trigger = "usb-online", |
| 3585 | .flags = PM8XXX_SET_FLAG(PM8XXX_ID_LED_0, |
| 3586 | PM8XXX_LED_MODE_MANUAL, |
| 3587 | PM8921_LC_LED_MAX_CURRENT), |
| 3588 | }, |
| 3589 | [1] = { |
| 3590 | .name = "led:ac", |
| 3591 | .default_trigger = "ac-online", |
| 3592 | .flags = PM8XXX_SET_FLAG(PM8XXX_ID_LED_1, |
| 3593 | PM8XXX_LED_MODE_MANUAL, |
| 3594 | PM8921_LC_LED_MAX_CURRENT), |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3595 | }, |
| 3596 | }; |
| 3597 | |
| 3598 | static struct led_platform_data pm8xxx_leds_pdata = { |
| 3599 | .num_leds = ARRAY_SIZE(pm8921_led_info), |
| 3600 | .leds = pm8921_led_info, |
| 3601 | }; |
| 3602 | |
| 3603 | static struct pm8921_platform_data pm8921_platform_data __devinitdata = { |
| 3604 | .irq_pdata = &pm8xxx_irq_pdata, |
| 3605 | .gpio_pdata = &pm8xxx_gpio_pdata, |
| 3606 | .mpp_pdata = &pm8xxx_mpp_pdata, |
| 3607 | .rtc_pdata = &pm8xxx_rtc_pdata, |
| 3608 | .pwrkey_pdata = &pm8xxx_pwrkey_pdata, |
| 3609 | .keypad_pdata = &keypad_data, |
| 3610 | .misc_pdata = &pm8xxx_misc_pdata, |
| 3611 | .regulator_pdatas = msm_pm8921_regulator_pdata, |
| 3612 | .charger_pdata = &pm8921_chg_pdata, |
| 3613 | .bms_pdata = &pm8921_bms_pdata, |
| 3614 | .adc_pdata = &pm8921_adc_pdata, |
| 3615 | .leds_pdata = &pm8xxx_leds_pdata, |
| 3616 | }; |
| 3617 | |
| 3618 | static struct msm_ssbi_platform_data msm8960_ssbi_pm8921_pdata __devinitdata = { |
| 3619 | .controller_type = MSM_SBI_CTRL_PMIC_ARBITER, |
| 3620 | .slave = { |
| 3621 | .name = "pm8921-core", |
| 3622 | .platform_data = &pm8921_platform_data, |
| 3623 | }, |
| 3624 | }; |
| 3625 | |
| 3626 | static void msm8960_wcnss_init(void) |
| 3627 | { |
| 3628 | int i, ret, j; |
| 3629 | |
| 3630 | for (i = 0; i < ARRAY_SIZE(wcnss_5wire_interface); i++) { |
| 3631 | ret = gpio_request(wcnss_5wire_interface[i].gpio, |
| 3632 | "wcnss_5_wire"); |
| 3633 | if (ret) { |
| 3634 | pr_err("wcnss_5_wire gpio %d failed: %d\n", |
| 3635 | wcnss_5wire_interface[i].gpio, ret); |
| 3636 | goto fail; |
| 3637 | } |
| 3638 | } |
| 3639 | |
| 3640 | pr_info("%s: Iris 5-wire gpios configured\n", __func__); |
| 3641 | |
| 3642 | return; |
| 3643 | |
| 3644 | fail: |
| 3645 | for (j = 0; j < i; j++) |
| 3646 | gpio_free(wcnss_5wire_interface[j].gpio); |
| 3647 | } |
| 3648 | |
Stepan Moskovchenko | 41d16827 | 2011-08-09 17:09:42 -0700 | [diff] [blame] | 3649 | #ifdef CONFIG_KS8851 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3650 | static int ethernet_init(void) |
| 3651 | { |
| 3652 | int ret; |
| 3653 | ret = gpio_request(KS8851_IRQ_GPIO, "ks8851_irq"); |
| 3654 | if (ret) { |
| 3655 | pr_err("ks8851 gpio_request failed: %d\n", ret); |
| 3656 | goto fail; |
| 3657 | } |
| 3658 | |
| 3659 | ret = gpio_request(KS8851_RST_GPIO, "ks8851_rst"); |
| 3660 | if (ret) { |
| 3661 | pr_err("ks8851 gpio_request failed: %d\n", ret); |
| 3662 | goto fail_rst; |
| 3663 | } |
| 3664 | |
| 3665 | ret = gpio_request(FPGA_CS_GPIO, "fpga_cs"); |
| 3666 | if (ret) { |
| 3667 | pr_err("ks8851 gpio_request failed: %d\n", ret); |
| 3668 | goto fail_cs; |
| 3669 | } |
| 3670 | |
| 3671 | gpio_direction_output(FPGA_CS_GPIO, 1); |
| 3672 | gpio_direction_output(KS8851_RST_GPIO, 1); |
| 3673 | return 0; |
| 3674 | fail_cs: |
| 3675 | gpio_free(KS8851_RST_GPIO); |
| 3676 | fail_rst: |
| 3677 | gpio_free(KS8851_IRQ_GPIO); |
| 3678 | fail: |
| 3679 | return ret; |
| 3680 | } |
Stepan Moskovchenko | 41d16827 | 2011-08-09 17:09:42 -0700 | [diff] [blame] | 3681 | #else |
| 3682 | static int ethernet_init(void) |
| 3683 | { |
| 3684 | return 0; |
| 3685 | } |
| 3686 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3687 | |
| 3688 | static struct msm_cpuidle_state msm_cstates[] __initdata = { |
| 3689 | {0, 0, "C0", "WFI", |
| 3690 | MSM_PM_SLEEP_MODE_WAIT_FOR_INTERRUPT}, |
| 3691 | |
| 3692 | {0, 1, "C1", "STANDALONE_POWER_COLLAPSE", |
| 3693 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE_STANDALONE}, |
| 3694 | |
| 3695 | {0, 2, "C2", "POWER_COLLAPSE", |
| 3696 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE}, |
| 3697 | |
| 3698 | {1, 0, "C0", "WFI", |
| 3699 | MSM_PM_SLEEP_MODE_WAIT_FOR_INTERRUPT}, |
| 3700 | |
| 3701 | {1, 1, "C1", "STANDALONE_POWER_COLLAPSE", |
| 3702 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE_STANDALONE}, |
| 3703 | }; |
| 3704 | |
| 3705 | static struct msm_pm_platform_data msm_pm_data[MSM_PM_SLEEP_MODE_NR * 2] = { |
| 3706 | [MSM_PM_MODE(0, MSM_PM_SLEEP_MODE_POWER_COLLAPSE)] = { |
| 3707 | .idle_supported = 1, |
| 3708 | .suspend_supported = 1, |
| 3709 | .idle_enabled = 0, |
| 3710 | .suspend_enabled = 0, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3711 | }, |
| 3712 | |
| 3713 | [MSM_PM_MODE(0, MSM_PM_SLEEP_MODE_POWER_COLLAPSE_STANDALONE)] = { |
| 3714 | .idle_supported = 1, |
| 3715 | .suspend_supported = 1, |
| 3716 | .idle_enabled = 0, |
| 3717 | .suspend_enabled = 0, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3718 | }, |
| 3719 | |
| 3720 | [MSM_PM_MODE(0, MSM_PM_SLEEP_MODE_WAIT_FOR_INTERRUPT)] = { |
| 3721 | .idle_supported = 1, |
| 3722 | .suspend_supported = 1, |
| 3723 | .idle_enabled = 1, |
| 3724 | .suspend_enabled = 1, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3725 | }, |
| 3726 | |
| 3727 | [MSM_PM_MODE(1, MSM_PM_SLEEP_MODE_POWER_COLLAPSE)] = { |
| 3728 | .idle_supported = 0, |
| 3729 | .suspend_supported = 1, |
| 3730 | .idle_enabled = 0, |
| 3731 | .suspend_enabled = 0, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3732 | }, |
| 3733 | |
| 3734 | [MSM_PM_MODE(1, MSM_PM_SLEEP_MODE_POWER_COLLAPSE_STANDALONE)] = { |
| 3735 | .idle_supported = 1, |
| 3736 | .suspend_supported = 1, |
| 3737 | .idle_enabled = 0, |
| 3738 | .suspend_enabled = 0, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3739 | }, |
| 3740 | |
| 3741 | [MSM_PM_MODE(1, MSM_PM_SLEEP_MODE_WAIT_FOR_INTERRUPT)] = { |
| 3742 | .idle_supported = 1, |
| 3743 | .suspend_supported = 0, |
| 3744 | .idle_enabled = 1, |
| 3745 | .suspend_enabled = 0, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3746 | }, |
| 3747 | }; |
| 3748 | |
| 3749 | static struct msm_rpmrs_level msm_rpmrs_levels[] __initdata = { |
| 3750 | { |
| 3751 | MSM_PM_SLEEP_MODE_WAIT_FOR_INTERRUPT, |
| 3752 | MSM_RPMRS_LIMITS(ON, ACTIVE, MAX, ACTIVE), |
| 3753 | true, |
| 3754 | 1, 8000, 100000, 1, |
| 3755 | }, |
| 3756 | |
| 3757 | { |
| 3758 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE_STANDALONE, |
| 3759 | MSM_RPMRS_LIMITS(ON, ACTIVE, MAX, ACTIVE), |
| 3760 | true, |
| 3761 | 1500, 5000, 60100000, 3000, |
| 3762 | }, |
| 3763 | |
| 3764 | { |
| 3765 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 3766 | MSM_RPMRS_LIMITS(ON, GDHS, MAX, ACTIVE), |
| 3767 | false, |
| 3768 | 1800, 5000, 60350000, 3500, |
| 3769 | }, |
| 3770 | |
| 3771 | { |
| 3772 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 3773 | MSM_RPMRS_LIMITS(ON, HSFS_OPEN, MAX, ACTIVE), |
| 3774 | false, |
| 3775 | 2800, 2500, 65350000, 4800, |
| 3776 | }, |
| 3777 | |
| 3778 | { |
| 3779 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 3780 | MSM_RPMRS_LIMITS(OFF, GDHS, MAX, ACTIVE), |
| 3781 | false, |
| 3782 | 3800, 4500, 67850000, 5500, |
| 3783 | }, |
| 3784 | |
| 3785 | { |
| 3786 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 3787 | MSM_RPMRS_LIMITS(OFF, HSFS_OPEN, MAX, ACTIVE), |
| 3788 | false, |
| 3789 | 4800, 2000, 71850000, 6800, |
| 3790 | }, |
| 3791 | |
| 3792 | { |
| 3793 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 3794 | MSM_RPMRS_LIMITS(OFF, HSFS_OPEN, ACTIVE, RET_HIGH), |
| 3795 | false, |
| 3796 | 6800, 500, 75850000, 8800, |
| 3797 | }, |
| 3798 | |
| 3799 | { |
| 3800 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 3801 | MSM_RPMRS_LIMITS(OFF, HSFS_OPEN, RET_HIGH, RET_LOW), |
| 3802 | false, |
| 3803 | 7800, 0, 76350000, 9800, |
| 3804 | }, |
| 3805 | }; |
| 3806 | |
| 3807 | #ifdef CONFIG_I2C |
| 3808 | #define I2C_SURF 1 |
| 3809 | #define I2C_FFA (1 << 1) |
| 3810 | #define I2C_RUMI (1 << 2) |
| 3811 | #define I2C_SIM (1 << 3) |
| 3812 | #define I2C_FLUID (1 << 4) |
Amir Samuelov | 05f8780 | 2011-08-27 18:30:12 +0300 | [diff] [blame] | 3813 | #define I2C_LIQUID (1 << 5) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3814 | |
| 3815 | struct i2c_registry { |
| 3816 | u8 machs; |
| 3817 | int bus; |
| 3818 | struct i2c_board_info *info; |
| 3819 | int len; |
| 3820 | }; |
| 3821 | |
| 3822 | #ifdef CONFIG_MSM_CAMERA |
| 3823 | static struct i2c_board_info msm_camera_boardinfo[] __initdata = { |
| 3824 | #ifdef CONFIG_IMX074 |
| 3825 | { |
| 3826 | I2C_BOARD_INFO("imx074", 0x1A), |
| 3827 | }, |
| 3828 | #endif |
| 3829 | #ifdef CONFIG_OV2720 |
| 3830 | { |
| 3831 | I2C_BOARD_INFO("ov2720", 0x6C), |
| 3832 | }, |
| 3833 | #endif |
Kevin Chan | dfecce2 | 2011-07-13 10:52:41 -0700 | [diff] [blame] | 3834 | { |
| 3835 | I2C_BOARD_INFO("qs_mt9p017", 0x6C >> 1), |
| 3836 | }, |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 3837 | #ifdef CONFIG_MSM_CAMERA_FLASH_SC628A |
| 3838 | { |
| 3839 | I2C_BOARD_INFO("sc628a", 0x6E), |
| 3840 | }, |
| 3841 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3842 | }; |
| 3843 | #endif |
| 3844 | |
| 3845 | /* Sensors DSPS platform data */ |
| 3846 | #ifdef CONFIG_MSM_DSPS |
| 3847 | #define DSPS_PIL_GENERIC_NAME "dsps" |
| 3848 | #endif /* CONFIG_MSM_DSPS */ |
| 3849 | |
| 3850 | static void __init msm8960_init_dsps(void) |
| 3851 | { |
| 3852 | #ifdef CONFIG_MSM_DSPS |
| 3853 | struct msm_dsps_platform_data *pdata = |
| 3854 | msm_dsps_device.dev.platform_data; |
| 3855 | pdata->pil_name = DSPS_PIL_GENERIC_NAME; |
| 3856 | pdata->gpios = NULL; |
| 3857 | pdata->gpios_num = 0; |
| 3858 | |
| 3859 | platform_device_register(&msm_dsps_device); |
| 3860 | #endif /* CONFIG_MSM_DSPS */ |
| 3861 | } |
| 3862 | |
| 3863 | static struct i2c_registry msm8960_i2c_devices[] __initdata = { |
| 3864 | #ifdef CONFIG_MSM_CAMERA |
| 3865 | { |
Amir Samuelov | 05f8780 | 2011-08-27 18:30:12 +0300 | [diff] [blame] | 3866 | I2C_SURF | I2C_FFA | I2C_FLUID | I2C_LIQUID | I2C_RUMI, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3867 | MSM_8960_GSBI4_QUP_I2C_BUS_ID, |
| 3868 | msm_camera_boardinfo, |
| 3869 | ARRAY_SIZE(msm_camera_boardinfo), |
| 3870 | }, |
| 3871 | #endif |
| 3872 | { |
| 3873 | I2C_SURF | I2C_FFA | I2C_FLUID, |
| 3874 | MSM_8960_GSBI3_QUP_I2C_BUS_ID, |
| 3875 | cyttsp_info, |
| 3876 | ARRAY_SIZE(cyttsp_info), |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 3877 | }, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 3878 | { |
| 3879 | I2C_LIQUID, |
| 3880 | MSM_8960_GSBI3_QUP_I2C_BUS_ID, |
| 3881 | mxt_device_info, |
| 3882 | ARRAY_SIZE(mxt_device_info), |
| 3883 | }, |
| 3884 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3885 | }; |
| 3886 | #endif /* CONFIG_I2C */ |
| 3887 | |
| 3888 | static void __init register_i2c_devices(void) |
| 3889 | { |
| 3890 | #ifdef CONFIG_I2C |
| 3891 | u8 mach_mask = 0; |
| 3892 | int i; |
| 3893 | |
| 3894 | /* Build the matching 'supported_machs' bitmask */ |
| 3895 | if (machine_is_msm8960_cdp()) |
| 3896 | mach_mask = I2C_SURF; |
| 3897 | else if (machine_is_msm8960_rumi3()) |
| 3898 | mach_mask = I2C_RUMI; |
| 3899 | else if (machine_is_msm8960_sim()) |
| 3900 | mach_mask = I2C_SIM; |
Amy Maloche | 2d02803 | 2011-07-20 14:08:06 -0700 | [diff] [blame] | 3901 | else if (machine_is_msm8960_fluid()) |
| 3902 | mach_mask = I2C_FLUID; |
Amir Samuelov | 05f8780 | 2011-08-27 18:30:12 +0300 | [diff] [blame] | 3903 | else if (machine_is_msm8960_liquid()) |
| 3904 | mach_mask = I2C_LIQUID; |
Amy Maloche | 1b0663f | 2011-08-02 16:46:22 -0700 | [diff] [blame] | 3905 | else if (machine_is_msm8960_mtp()) |
| 3906 | mach_mask = I2C_FFA; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3907 | else |
| 3908 | pr_err("unmatched machine ID in register_i2c_devices\n"); |
| 3909 | |
| 3910 | /* Run the array and install devices as appropriate */ |
| 3911 | for (i = 0; i < ARRAY_SIZE(msm8960_i2c_devices); ++i) { |
| 3912 | if (msm8960_i2c_devices[i].machs & mach_mask) |
| 3913 | i2c_register_board_info(msm8960_i2c_devices[i].bus, |
| 3914 | msm8960_i2c_devices[i].info, |
| 3915 | msm8960_i2c_devices[i].len); |
| 3916 | } |
| 3917 | #endif |
| 3918 | } |
| 3919 | |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3920 | static void __init msm8960_sim_init(void) |
| 3921 | { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3922 | if (socinfo_init() < 0) |
| 3923 | pr_err("socinfo_init() failed!\n"); |
| 3924 | |
| 3925 | BUG_ON(msm_rpm_init(&msm_rpm_data)); |
| 3926 | BUG_ON(msm_rpmrs_levels_init(msm_rpmrs_levels, |
| 3927 | ARRAY_SIZE(msm_rpmrs_levels))); |
| 3928 | regulator_suppress_info_printing(); |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 3929 | platform_device_register(&msm8960_device_rpm_regulator); |
Stephen Boyd | bb600ae | 2011-08-02 20:11:40 -0700 | [diff] [blame] | 3930 | msm_clock_init(&msm8960_clock_init_data); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3931 | msm8960_device_ssbi_pm8921.dev.platform_data = |
| 3932 | &msm8960_ssbi_pm8921_pdata; |
| 3933 | pm8921_platform_data.num_regulators = msm_pm8921_regulator_pdata_len; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3934 | |
| 3935 | /* Simulator supports a QWERTY keypad */ |
| 3936 | pm8921_platform_data.keypad_pdata = &keypad_data_sim; |
| 3937 | |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 3938 | msm8960_device_otg.dev.platform_data = &msm_otg_pdata; |
| 3939 | msm8960_device_gadget_peripheral.dev.parent = &msm8960_device_otg.dev; |
| 3940 | msm_device_hsusb_host.dev.parent = &msm8960_device_otg.dev; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3941 | gpiomux_init(); |
| 3942 | ethernet_init(); |
| 3943 | msm8960_i2c_init(); |
| 3944 | msm_spm_init(msm_spm_data, ARRAY_SIZE(msm_spm_data)); |
| 3945 | msm_spm_l2_init(msm_spm_l2_data); |
| 3946 | msm8960_init_buses(); |
| 3947 | platform_add_devices(common_devices, ARRAY_SIZE(common_devices)); |
| 3948 | pm8921_gpio_mpp_init(); |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3949 | platform_add_devices(sim_devices, ARRAY_SIZE(sim_devices)); |
Matt Wagantall | ec57f06 | 2011-08-16 23:54:46 -0700 | [diff] [blame] | 3950 | acpuclk_init(&acpuclk_8960_soc_data); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3951 | |
| 3952 | msm8960_device_qup_spi_gsbi1.dev.platform_data = |
| 3953 | &msm8960_qup_spi_gsbi1_pdata; |
| 3954 | spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info)); |
| 3955 | |
| 3956 | msm8960_init_mmc(); |
| 3957 | msm_fb_add_devices(); |
| 3958 | slim_register_board_info(msm_slim_devices, |
| 3959 | ARRAY_SIZE(msm_slim_devices)); |
| 3960 | msm_pm_set_platform_data(msm_pm_data, ARRAY_SIZE(msm_pm_data)); |
| 3961 | msm_pm_set_rpm_wakeup_irq(RPM_APCC_CPU0_WAKE_UP_IRQ); |
| 3962 | msm_cpuidle_set_states(msm_cstates, ARRAY_SIZE(msm_cstates), |
| 3963 | msm_pm_data); |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3964 | } |
| 3965 | |
| 3966 | static void __init msm8960_rumi3_init(void) |
| 3967 | { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3968 | if (socinfo_init() < 0) |
| 3969 | pr_err("socinfo_init() failed!\n"); |
| 3970 | |
| 3971 | BUG_ON(msm_rpm_init(&msm_rpm_data)); |
| 3972 | BUG_ON(msm_rpmrs_levels_init(msm_rpmrs_levels, |
| 3973 | ARRAY_SIZE(msm_rpmrs_levels))); |
| 3974 | regulator_suppress_info_printing(); |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 3975 | platform_device_register(&msm8960_device_rpm_regulator); |
Stephen Boyd | bb600ae | 2011-08-02 20:11:40 -0700 | [diff] [blame] | 3976 | msm_clock_init(&msm8960_dummy_clock_init_data); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3977 | gpiomux_init(); |
| 3978 | ethernet_init(); |
| 3979 | msm8960_device_ssbi_pm8921.dev.platform_data = |
| 3980 | &msm8960_ssbi_pm8921_pdata; |
| 3981 | pm8921_platform_data.num_regulators = msm_pm8921_regulator_pdata_len; |
| 3982 | msm8960_device_qup_spi_gsbi1.dev.platform_data = |
| 3983 | &msm8960_qup_spi_gsbi1_pdata; |
| 3984 | spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info)); |
| 3985 | msm8960_i2c_init(); |
| 3986 | msm_spm_init(msm_spm_data, ARRAY_SIZE(msm_spm_data)); |
| 3987 | msm_spm_l2_init(msm_spm_l2_data); |
| 3988 | platform_add_devices(common_devices, ARRAY_SIZE(common_devices)); |
| 3989 | pm8921_gpio_mpp_init(); |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3990 | platform_add_devices(rumi3_devices, ARRAY_SIZE(rumi3_devices)); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3991 | msm8960_init_mmc(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3992 | register_i2c_devices(); |
| 3993 | msm_fb_add_devices(); |
| 3994 | slim_register_board_info(msm_slim_devices, |
| 3995 | ARRAY_SIZE(msm_slim_devices)); |
| 3996 | msm_pm_set_platform_data(msm_pm_data, ARRAY_SIZE(msm_pm_data)); |
| 3997 | msm_pm_set_rpm_wakeup_irq(RPM_APCC_CPU0_WAKE_UP_IRQ); |
| 3998 | msm_cpuidle_set_states(msm_cstates, ARRAY_SIZE(msm_cstates), |
| 3999 | msm_pm_data); |
| 4000 | } |
| 4001 | |
| 4002 | static void __init msm8960_cdp_init(void) |
| 4003 | { |
| 4004 | if (socinfo_init() < 0) |
| 4005 | pr_err("socinfo_init() failed!\n"); |
| 4006 | |
| 4007 | BUG_ON(msm_rpm_init(&msm_rpm_data)); |
| 4008 | BUG_ON(msm_rpmrs_levels_init(msm_rpmrs_levels, |
| 4009 | ARRAY_SIZE(msm_rpmrs_levels))); |
| 4010 | regulator_suppress_info_printing(); |
| 4011 | if (msm_xo_init()) |
| 4012 | pr_err("Failed to initialize XO votes\n"); |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 4013 | platform_device_register(&msm8960_device_rpm_regulator); |
Stephen Boyd | bb600ae | 2011-08-02 20:11:40 -0700 | [diff] [blame] | 4014 | msm_clock_init(&msm8960_clock_init_data); |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 4015 | msm8960_device_otg.dev.platform_data = &msm_otg_pdata; |
| 4016 | msm8960_device_gadget_peripheral.dev.parent = &msm8960_device_otg.dev; |
| 4017 | msm_device_hsusb_host.dev.parent = &msm8960_device_otg.dev; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4018 | gpiomux_init(); |
| 4019 | ethernet_init(); |
Mohan Pallaka | 002e9e0 | 2011-08-05 11:23:22 +0530 | [diff] [blame] | 4020 | if (machine_is_msm8960_liquid()) |
| 4021 | pm8921_platform_data.keypad_pdata = &keypad_data_liquid; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4022 | msm8960_device_qup_spi_gsbi1.dev.platform_data = |
| 4023 | &msm8960_qup_spi_gsbi1_pdata; |
| 4024 | spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info)); |
| 4025 | msm8960_device_ssbi_pm8921.dev.platform_data = |
| 4026 | &msm8960_ssbi_pm8921_pdata; |
| 4027 | pm8921_platform_data.num_regulators = msm_pm8921_regulator_pdata_len; |
| 4028 | msm8960_i2c_init(); |
Lucille Sylvester | 34ec369 | 2011-08-16 16:28:04 -0600 | [diff] [blame] | 4029 | msm8960_gfx_init(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4030 | msm_spm_init(msm_spm_data, ARRAY_SIZE(msm_spm_data)); |
| 4031 | msm_spm_l2_init(msm_spm_l2_data); |
| 4032 | msm8960_init_buses(); |
| 4033 | platform_add_devices(msm_footswitch_devices, |
| 4034 | msm_num_footswitch_devices); |
David Collins | b10be1d | 2011-09-02 10:29:31 -0700 | [diff] [blame] | 4035 | if (machine_is_msm8960_liquid()) |
| 4036 | platform_device_register(&msm8960_device_ext_3p3v_vreg); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4037 | platform_add_devices(common_devices, ARRAY_SIZE(common_devices)); |
| 4038 | pm8921_gpio_mpp_init(); |
| 4039 | platform_add_devices(cdp_devices, ARRAY_SIZE(cdp_devices)); |
| 4040 | msm8960_init_cam(); |
| 4041 | msm8960_init_mmc(); |
Matt Wagantall | ec57f06 | 2011-08-16 23:54:46 -0700 | [diff] [blame] | 4042 | acpuclk_init(&acpuclk_8960_soc_data); |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 4043 | if (machine_is_msm8960_liquid()) |
| 4044 | mxt_init_hw_liquid(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4045 | register_i2c_devices(); |
| 4046 | msm8960_wcnss_init(); |
| 4047 | msm_fb_add_devices(); |
| 4048 | slim_register_board_info(msm_slim_devices, |
| 4049 | ARRAY_SIZE(msm_slim_devices)); |
| 4050 | msm8960_init_dsps(); |
| 4051 | msm_pm_set_platform_data(msm_pm_data, ARRAY_SIZE(msm_pm_data)); |
| 4052 | msm_pm_set_rpm_wakeup_irq(RPM_APCC_CPU0_WAKE_UP_IRQ); |
| 4053 | msm_cpuidle_set_states(msm_cstates, ARRAY_SIZE(msm_cstates), |
| 4054 | msm_pm_data); |
Larry Bassel | a7eadea | 2011-07-14 10:46:00 -0700 | [diff] [blame] | 4055 | change_memory_power = &msm8960_change_memory_power; |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 4056 | } |
| 4057 | |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 4058 | MACHINE_START(MSM8960_SIM, "QCT MSM8960 SIMULATOR") |
| 4059 | .map_io = msm8960_map_io, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4060 | .reserve = msm8960_reserve, |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 4061 | .init_irq = msm8960_init_irq, |
| 4062 | .timer = &msm_timer, |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 4063 | .init_machine = msm8960_sim_init, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4064 | .init_early = msm8960_allocate_memory_regions, |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 4065 | MACHINE_END |
Stepan Moskovchenko | 50ede4e | 2010-12-13 18:12:19 -0800 | [diff] [blame] | 4066 | |
| 4067 | MACHINE_START(MSM8960_RUMI3, "QCT MSM8960 RUMI3") |
| 4068 | .map_io = msm8960_map_io, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4069 | .reserve = msm8960_reserve, |
Stepan Moskovchenko | 50ede4e | 2010-12-13 18:12:19 -0800 | [diff] [blame] | 4070 | .init_irq = msm8960_init_irq, |
| 4071 | .timer = &msm_timer, |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 4072 | .init_machine = msm8960_rumi3_init, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4073 | .init_early = msm8960_allocate_memory_regions, |
Stepan Moskovchenko | 50ede4e | 2010-12-13 18:12:19 -0800 | [diff] [blame] | 4074 | MACHINE_END |
| 4075 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4076 | MACHINE_START(MSM8960_CDP, "QCT MSM8960 CDP") |
| 4077 | .map_io = msm8960_map_io, |
| 4078 | .reserve = msm8960_reserve, |
| 4079 | .init_irq = msm8960_init_irq, |
| 4080 | .timer = &msm_timer, |
| 4081 | .init_machine = msm8960_cdp_init, |
| 4082 | .init_early = msm8960_allocate_memory_regions, |
| 4083 | MACHINE_END |
| 4084 | |
| 4085 | MACHINE_START(MSM8960_MTP, "QCT MSM8960 MTP") |
| 4086 | .map_io = msm8960_map_io, |
| 4087 | .reserve = msm8960_reserve, |
| 4088 | .init_irq = msm8960_init_irq, |
| 4089 | .timer = &msm_timer, |
| 4090 | .init_machine = msm8960_cdp_init, |
| 4091 | .init_early = msm8960_allocate_memory_regions, |
| 4092 | MACHINE_END |
| 4093 | |
| 4094 | MACHINE_START(MSM8960_FLUID, "QCT MSM8960 FLUID") |
| 4095 | .map_io = msm8960_map_io, |
| 4096 | .reserve = msm8960_reserve, |
| 4097 | .init_irq = msm8960_init_irq, |
| 4098 | .timer = &msm_timer, |
| 4099 | .init_machine = msm8960_cdp_init, |
| 4100 | .init_early = msm8960_allocate_memory_regions, |
| 4101 | MACHINE_END |
Amir Samuelov | 0d1f8ae | 2011-07-28 11:13:58 +0300 | [diff] [blame] | 4102 | |
| 4103 | MACHINE_START(MSM8960_LIQUID, "QCT MSM8960 LIQUID") |
| 4104 | .map_io = msm8960_map_io, |
| 4105 | .reserve = msm8960_reserve, |
| 4106 | .init_irq = msm8960_init_irq, |
| 4107 | .timer = &msm_timer, |
| 4108 | .init_machine = msm8960_cdp_init, |
| 4109 | .init_early = msm8960_allocate_memory_regions, |
| 4110 | MACHINE_END |