Harini Jayaraman | a9873ab | 2011-12-20 17:29:48 -0700 | [diff] [blame] | 1 | /* Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved. |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 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> |
Amir Samuelov | 5137e39 | 2011-09-21 17:31:25 +0300 | [diff] [blame] | 19 | #include <linux/i2c/isl9519.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 20 | #include <linux/gpio.h> |
| 21 | #include <linux/msm_ssbi.h> |
Steve Muckle | f132c6c | 2012-06-06 18:30:57 -0700 | [diff] [blame] | 22 | #include <linux/regulator/msm-gpio-regulator.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 23 | #include <linux/mfd/pm8xxx/pm8921.h> |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 24 | #include <linux/mfd/pm8xxx/pm8xxx-adc.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 25 | #include <linux/regulator/consumer.h> |
| 26 | #include <linux/spi/spi.h> |
| 27 | #include <linux/slimbus/slimbus.h> |
| 28 | #include <linux/bootmem.h> |
| 29 | #ifdef CONFIG_ANDROID_PMEM |
| 30 | #include <linux/android_pmem.h> |
| 31 | #endif |
Steve Muckle | f132c6c | 2012-06-06 18:30:57 -0700 | [diff] [blame] | 32 | #include <linux/cyttsp-qc.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 33 | #include <linux/dma-mapping.h> |
| 34 | #include <linux/platform_data/qcom_crypto_device.h> |
Ankur Nandwani | b0039b0 | 2011-08-09 14:00:45 -0700 | [diff] [blame] | 35 | #include <linux/platform_data/qcom_wcnss_device.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 36 | #include <linux/leds.h> |
| 37 | #include <linux/leds-pm8xxx.h> |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 38 | #include <linux/i2c/atmel_mxt_ts.h> |
Siddartha Mohanadoss | ba21fdd | 2011-08-18 10:05:27 -0700 | [diff] [blame] | 39 | #include <linux/msm_tsens.h> |
Stepan Moskovchenko | 93d79ec | 2011-09-21 16:52:16 -0700 | [diff] [blame] | 40 | #include <linux/ks8851.h> |
Mohan Pallaka | 5e49039 | 2011-09-09 15:18:41 +0530 | [diff] [blame] | 41 | #include <linux/i2c/isa1200.h> |
Jack Cheung | 0b1987e | 2011-11-18 13:36:29 -0800 | [diff] [blame] | 42 | #include <linux/memory.h> |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 43 | #include <linux/memblock.h> |
Praveen Chidambaram | 877d7a4 | 2012-06-05 14:33:20 -0600 | [diff] [blame] | 44 | #include <linux/msm_thermal.h> |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 45 | |
| 46 | #include <asm/mach-types.h> |
| 47 | #include <asm/mach/arch.h> |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 48 | #include <asm/setup.h> |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 49 | #include <asm/hardware/gic.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 50 | #include <asm/mach/mmc.h> |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 51 | |
| 52 | #include <mach/board.h> |
Joel Nider | 266a264 | 2011-10-16 10:58:05 +0200 | [diff] [blame] | 53 | #include <mach/msm_tspp.h> |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 54 | #include <mach/msm_iomap.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 55 | #include <mach/msm_spi.h> |
Mayank Rana | e009c92 | 2012-03-22 03:02:06 +0530 | [diff] [blame] | 56 | #include <mach/msm_serial_hs.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 57 | #ifdef CONFIG_USB_MSM_OTG_72K |
| 58 | #include <mach/msm_hsusb.h> |
| 59 | #else |
| 60 | #include <linux/usb/msm_hsusb.h> |
| 61 | #endif |
| 62 | #include <linux/usb/android.h> |
| 63 | #include <mach/usbdiag.h> |
| 64 | #include <mach/socinfo.h> |
| 65 | #include <mach/rpm.h> |
Rohit Vaswani | a513aa8d | 2011-07-18 15:14:28 -0700 | [diff] [blame] | 66 | #include <mach/gpiomux.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 67 | #include <mach/msm_bus_board.h> |
| 68 | #include <mach/msm_memtypes.h> |
| 69 | #include <mach/dma.h> |
| 70 | #include <mach/msm_dsps.h> |
| 71 | #include <mach/msm_xo.h> |
Abhijeet Dharmapurikar | 6d565fd | 2011-09-15 18:49:56 -0700 | [diff] [blame] | 72 | #include <mach/restart.h> |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 73 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 74 | #ifdef CONFIG_WCD9310_CODEC |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 75 | #include <linux/mfd/wcd9xxx/core.h> |
| 76 | #include <linux/mfd/wcd9xxx/pdata.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 77 | #endif |
| 78 | |
Vijayavardhan Vennapusa | afbbb8f | 2012-04-13 16:28:45 +0530 | [diff] [blame] | 79 | #include <linux/smsc3503.h> |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 80 | #include <linux/ion.h> |
| 81 | #include <mach/ion.h> |
Joel King | b8352a1 | 2011-11-15 18:46:24 -0800 | [diff] [blame] | 82 | #include <mach/mdm2.h> |
Vamsi Krishna | 6aa6b1f | 2011-12-14 22:55:20 -0800 | [diff] [blame] | 83 | #include <mach/mdm-peripheral.h> |
Laura Abbott | f8c03b9 | 2012-02-16 14:57:58 -0800 | [diff] [blame] | 84 | #include <mach/msm_rtb.h> |
Laura Abbott | 306bcc2 | 2012-03-08 11:24:53 -0800 | [diff] [blame] | 85 | #include <mach/msm_cache_dump.h> |
| 86 | #include <mach/scm.h> |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 87 | #include <mach/iommu_domains.h> |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 88 | |
Jordan Crouse | 914de9b | 2012-07-09 13:49:46 -0600 | [diff] [blame] | 89 | #include <mach/kgsl.h> |
Larry Bassel | 41a055b | 2011-12-06 16:15:14 -0800 | [diff] [blame] | 90 | #include <linux/fmem.h> |
| 91 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 92 | #include "timer.h" |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 93 | #include "devices.h" |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 94 | #include "devices-msm8x60.h" |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 95 | #include "spm.h" |
Stepan Moskovchenko | 5a83dba | 2011-12-05 17:30:17 -0800 | [diff] [blame] | 96 | #include "board-8960.h" |
Matt Wagantall | 7cca464 | 2012-02-01 16:43:24 -0800 | [diff] [blame] | 97 | #include "pm.h" |
Abhijeet Dharmapurikar | efaca4f | 2011-12-27 16:24:07 -0800 | [diff] [blame] | 98 | #include <mach/cpuidle.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 99 | #include "rpm_resources.h" |
Subhash Jadavani | 909e04f | 2012-04-12 10:52:50 +0530 | [diff] [blame] | 100 | #include <mach/mpm.h> |
Naveen Ramaraj | 76483ad | 2011-09-06 14:25:44 -0700 | [diff] [blame] | 101 | #include "smd_private.h" |
Maheshkumar Sivasubramanian | 8ccc16e | 2011-10-25 15:59:57 -0600 | [diff] [blame] | 102 | #include "pm-boot.h" |
Jeff Ohlstein | 7e66855 | 2011-10-06 16:17:25 -0700 | [diff] [blame] | 103 | #include "msm_watchdog.h" |
Stepan Moskovchenko | c6ada42 | 2011-11-28 19:31:16 -0800 | [diff] [blame] | 104 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 105 | static struct platform_device msm_fm_platform_init = { |
| 106 | .name = "iris_fm", |
| 107 | .id = -1, |
| 108 | }; |
| 109 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 110 | #define KS8851_RST_GPIO 89 |
| 111 | #define KS8851_IRQ_GPIO 90 |
Mohan Pallaka | 5e49039 | 2011-09-09 15:18:41 +0530 | [diff] [blame] | 112 | #define HAP_SHIFT_LVL_OE_GPIO 47 |
| 113 | |
Manoj Rao | 1464874 | 2012-03-30 19:42:12 -0700 | [diff] [blame] | 114 | #define MHL_GPIO_INT 4 |
| 115 | #define MHL_GPIO_RESET 15 |
| 116 | |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 117 | #if defined(CONFIG_GPIO_SX150X) || defined(CONFIG_GPIO_SX150X_MODULE) |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 118 | |
Stepan Moskovchenko | c6ada42 | 2011-11-28 19:31:16 -0800 | [diff] [blame] | 119 | struct sx150x_platform_data msm8960_sx150x_data[] = { |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 120 | [SX150X_CAM] = { |
| 121 | .gpio_base = GPIO_CAM_EXPANDER_BASE, |
| 122 | .oscio_is_gpo = false, |
| 123 | .io_pullup_ena = 0x0, |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 124 | .io_pulldn_ena = 0xc0, |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 125 | .io_open_drain_ena = 0x0, |
| 126 | .irq_summary = -1, |
| 127 | }, |
Amir Samuelov | 755616d | 2011-12-13 16:34:46 +0200 | [diff] [blame] | 128 | [SX150X_LIQUID] = { |
| 129 | .gpio_base = GPIO_LIQUID_EXPANDER_BASE, |
| 130 | .oscio_is_gpo = false, |
| 131 | .io_pullup_ena = 0x0c08, |
| 132 | .io_pulldn_ena = 0x4060, |
| 133 | .io_open_drain_ena = 0x000c, |
| 134 | .io_polarity = 0, |
| 135 | .irq_summary = -1, |
| 136 | }, |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 137 | }; |
Nishant Pandit | 474f225 | 2011-07-23 23:17:56 +0530 | [diff] [blame] | 138 | |
| 139 | #endif |
| 140 | |
Olav Haugan | a21169d | 2012-01-04 09:17:06 -0800 | [diff] [blame] | 141 | #define MSM_PMEM_ADSP_SIZE 0x7800000 |
Bharath Ramachandramurthy | 2fd017a | 2012-03-13 10:21:09 -0700 | [diff] [blame] | 142 | #define MSM_PMEM_AUDIO_SIZE 0x4CF000 |
Mathew Karimpanal | 15fa5c4 | 2011-12-14 21:28:10 -0800 | [diff] [blame] | 143 | #define MSM_PMEM_SIZE 0x2800000 /* 40 Mbytes */ |
Ravishangar Kalyanam | 671f5ce | 2011-12-06 20:25:29 -0800 | [diff] [blame] | 144 | #define MSM_LIQUID_PMEM_SIZE 0x4000000 /* 64 Mbytes */ |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 145 | #define MSM_HDMI_PRIM_PMEM_SIZE 0x4000000 /* 64 Mbytes */ |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 146 | |
| 147 | #ifdef CONFIG_MSM_MULTIMEDIA_USE_ION |
Deepak Kotur | 3582552 | 2012-06-06 15:49:14 -0700 | [diff] [blame] | 148 | #define HOLE_SIZE 0x20000 |
Bharath Ramachandramurthy | 2fd017a | 2012-03-13 10:21:09 -0700 | [diff] [blame] | 149 | #define MSM_PMEM_KERNEL_EBI1_SIZE 0x65000 |
Olav Haugan | 3259455 | 2012-03-13 11:40:05 -0700 | [diff] [blame] | 150 | #ifdef CONFIG_MSM_IOMMU |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 151 | #define MSM_ION_MM_SIZE 0x3800000 /* Need to be multiple of 64K */ |
Olav Haugan | 3259455 | 2012-03-13 11:40:05 -0700 | [diff] [blame] | 152 | #define MSM_ION_SF_SIZE 0x0 |
Olav Haugan | fbbf05b | 2012-04-05 14:33:41 -0700 | [diff] [blame] | 153 | #define MSM_ION_QSECOM_SIZE 0x780000 /* (7.5MB) */ |
Olav Haugan | 3259455 | 2012-03-13 11:40:05 -0700 | [diff] [blame] | 154 | #define MSM_ION_HEAP_NUM 7 |
| 155 | #else |
| 156 | #define MSM_ION_MM_SIZE MSM_PMEM_ADSP_SIZE |
| 157 | #define MSM_ION_SF_SIZE MSM_PMEM_SIZE |
Olav Haugan | fbbf05b | 2012-04-05 14:33:41 -0700 | [diff] [blame] | 158 | #define MSM_ION_QSECOM_SIZE 0x600000 /* (6MB) */ |
Olav Haugan | 3259455 | 2012-03-13 11:40:05 -0700 | [diff] [blame] | 159 | #define MSM_ION_HEAP_NUM 8 |
| 160 | #endif |
Deepak Kotur | 3582552 | 2012-06-06 15:49:14 -0700 | [diff] [blame] | 161 | #define MSM_ION_MM_FW_SIZE (0x200000 - HOLE_SIZE) /* 128kb */ |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 162 | #define MSM_ION_MFC_SIZE SZ_8K |
Olav Haugan | 7355db0 | 2012-01-13 16:59:13 -0800 | [diff] [blame] | 163 | #define MSM_ION_AUDIO_SIZE MSM_PMEM_AUDIO_SIZE |
Olav Haugan | 3259455 | 2012-03-13 11:40:05 -0700 | [diff] [blame] | 164 | |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 165 | #define MSM_LIQUID_ION_MM_SIZE (MSM_ION_MM_SIZE + 0x600000) |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 166 | #define MSM_LIQUID_ION_SF_SIZE MSM_LIQUID_PMEM_SIZE |
| 167 | #define MSM_HDMI_PRIM_ION_SF_SIZE MSM_HDMI_PRIM_PMEM_SIZE |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 168 | |
Deepak Kotur | 3582552 | 2012-06-06 15:49:14 -0700 | [diff] [blame] | 169 | #define MSM_MM_FW_SIZE (0x200000 - HOLE_SIZE) /* 2mb -128kb*/ |
| 170 | #define MSM8960_FIXED_AREA_START (0xa0000000 - (MSM_ION_MM_FW_SIZE + \ |
| 171 | HOLE_SIZE)) |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 172 | #define MAX_FIXED_AREA_SIZE 0x10000000 |
Deepak Kotur | 3582552 | 2012-06-06 15:49:14 -0700 | [diff] [blame] | 173 | #define MSM8960_FW_START MSM8960_FIXED_AREA_START |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 174 | |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 175 | static unsigned msm_ion_sf_size = MSM_ION_SF_SIZE; |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 176 | #else |
Laura Abbott | 6db11c9 | 2011-11-04 10:31:43 -0700 | [diff] [blame] | 177 | #define MSM_PMEM_KERNEL_EBI1_SIZE 0x110C000 |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 178 | #define MSM_ION_HEAP_NUM 1 |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 179 | #endif |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 180 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 181 | #ifdef CONFIG_KERNEL_PMEM_EBI_REGION |
| 182 | static unsigned pmem_kernel_ebi1_size = MSM_PMEM_KERNEL_EBI1_SIZE; |
| 183 | static int __init pmem_kernel_ebi1_size_setup(char *p) |
| 184 | { |
| 185 | pmem_kernel_ebi1_size = memparse(p, NULL); |
| 186 | return 0; |
| 187 | } |
| 188 | early_param("pmem_kernel_ebi1_size", pmem_kernel_ebi1_size_setup); |
| 189 | #endif |
| 190 | |
| 191 | #ifdef CONFIG_ANDROID_PMEM |
| 192 | static unsigned pmem_size = MSM_PMEM_SIZE; |
Ravishangar Kalyanam | 671f5ce | 2011-12-06 20:25:29 -0800 | [diff] [blame] | 193 | static unsigned pmem_param_set; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 194 | static int __init pmem_size_setup(char *p) |
| 195 | { |
| 196 | pmem_size = memparse(p, NULL); |
Ravishangar Kalyanam | 671f5ce | 2011-12-06 20:25:29 -0800 | [diff] [blame] | 197 | pmem_param_set = 1; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 198 | return 0; |
| 199 | } |
| 200 | early_param("pmem_size", pmem_size_setup); |
| 201 | |
| 202 | static unsigned pmem_adsp_size = MSM_PMEM_ADSP_SIZE; |
| 203 | |
| 204 | static int __init pmem_adsp_size_setup(char *p) |
| 205 | { |
| 206 | pmem_adsp_size = memparse(p, NULL); |
| 207 | return 0; |
| 208 | } |
| 209 | early_param("pmem_adsp_size", pmem_adsp_size_setup); |
| 210 | |
| 211 | static unsigned pmem_audio_size = MSM_PMEM_AUDIO_SIZE; |
| 212 | |
| 213 | static int __init pmem_audio_size_setup(char *p) |
| 214 | { |
| 215 | pmem_audio_size = memparse(p, NULL); |
| 216 | return 0; |
| 217 | } |
| 218 | early_param("pmem_audio_size", pmem_audio_size_setup); |
| 219 | #endif |
| 220 | |
| 221 | #ifdef CONFIG_ANDROID_PMEM |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 222 | #ifndef CONFIG_MSM_MULTIMEDIA_USE_ION |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 223 | static struct android_pmem_platform_data android_pmem_pdata = { |
| 224 | .name = "pmem", |
| 225 | .allocator_type = PMEM_ALLOCATORTYPE_ALLORNOTHING, |
| 226 | .cached = 1, |
| 227 | .memory_type = MEMTYPE_EBI1, |
| 228 | }; |
| 229 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 230 | static struct platform_device msm8960_android_pmem_device = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 231 | .name = "android_pmem", |
| 232 | .id = 0, |
| 233 | .dev = {.platform_data = &android_pmem_pdata}, |
| 234 | }; |
| 235 | |
| 236 | static struct android_pmem_platform_data android_pmem_adsp_pdata = { |
| 237 | .name = "pmem_adsp", |
| 238 | .allocator_type = PMEM_ALLOCATORTYPE_BITMAP, |
| 239 | .cached = 0, |
| 240 | .memory_type = MEMTYPE_EBI1, |
| 241 | }; |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 242 | static struct platform_device msm8960_android_pmem_adsp_device = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 243 | .name = "android_pmem", |
| 244 | .id = 2, |
| 245 | .dev = { .platform_data = &android_pmem_adsp_pdata }, |
| 246 | }; |
| 247 | |
| 248 | static struct android_pmem_platform_data android_pmem_audio_pdata = { |
| 249 | .name = "pmem_audio", |
| 250 | .allocator_type = PMEM_ALLOCATORTYPE_BITMAP, |
| 251 | .cached = 0, |
| 252 | .memory_type = MEMTYPE_EBI1, |
| 253 | }; |
| 254 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 255 | static struct platform_device msm8960_android_pmem_audio_device = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 256 | .name = "android_pmem", |
| 257 | .id = 4, |
| 258 | .dev = { .platform_data = &android_pmem_audio_pdata }, |
| 259 | }; |
Bharath Ramachandramurthy | 4a3fa91 | 2012-03-13 19:16:24 -0700 | [diff] [blame] | 260 | #endif /*CONFIG_MSM_MULTIMEDIA_USE_ION*/ |
| 261 | #endif /*CONFIG_ANDROID_PMEM*/ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 262 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 263 | struct fmem_platform_data msm8960_fmem_pdata = { |
Larry Bassel | 41a055b | 2011-12-06 16:15:14 -0800 | [diff] [blame] | 264 | }; |
| 265 | |
Swaminathan Sathappan | b77c65e9 | 2011-09-30 18:36:09 -0700 | [diff] [blame] | 266 | #define DSP_RAM_BASE_8960 0x8da00000 |
| 267 | #define DSP_RAM_SIZE_8960 0x1800000 |
| 268 | static int dspcrashd_pdata_8960 = 0xDEADDEAD; |
| 269 | |
| 270 | static struct resource resources_dspcrashd_8960[] = { |
| 271 | { |
| 272 | .name = "msm_dspcrashd", |
| 273 | .start = DSP_RAM_BASE_8960, |
| 274 | .end = DSP_RAM_BASE_8960 + DSP_RAM_SIZE_8960, |
| 275 | .flags = IORESOURCE_DMA, |
| 276 | }, |
| 277 | }; |
| 278 | |
Stepan Moskovchenko | fc70d90 | 2011-11-30 12:39:36 -0800 | [diff] [blame] | 279 | static struct platform_device msm_device_dspcrashd_8960 = { |
Swaminathan Sathappan | b77c65e9 | 2011-09-30 18:36:09 -0700 | [diff] [blame] | 280 | .name = "msm_dspcrashd", |
| 281 | .num_resources = ARRAY_SIZE(resources_dspcrashd_8960), |
| 282 | .resource = resources_dspcrashd_8960, |
| 283 | .dev = { .platform_data = &dspcrashd_pdata_8960 }, |
| 284 | }; |
| 285 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 286 | static struct memtype_reserve msm8960_reserve_table[] __initdata = { |
| 287 | [MEMTYPE_SMI] = { |
| 288 | }, |
| 289 | [MEMTYPE_EBI0] = { |
| 290 | .flags = MEMTYPE_FLAGS_1M_ALIGN, |
| 291 | }, |
| 292 | [MEMTYPE_EBI1] = { |
| 293 | .flags = MEMTYPE_FLAGS_1M_ALIGN, |
| 294 | }, |
| 295 | }; |
| 296 | |
Laura Abbott | f8c03b9 | 2012-02-16 14:57:58 -0800 | [diff] [blame] | 297 | static void __init reserve_rtb_memory(void) |
| 298 | { |
| 299 | #if defined(CONFIG_MSM_RTB) |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 300 | msm8960_reserve_table[MEMTYPE_EBI1].size += msm8960_rtb_pdata.size; |
Laura Abbott | f8c03b9 | 2012-02-16 14:57:58 -0800 | [diff] [blame] | 301 | #endif |
| 302 | } |
| 303 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 304 | static void __init size_pmem_devices(void) |
| 305 | { |
| 306 | #ifdef CONFIG_ANDROID_PMEM |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 307 | #ifndef CONFIG_MSM_MULTIMEDIA_USE_ION |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 308 | android_pmem_adsp_pdata.size = pmem_adsp_size; |
Ravishangar Kalyanam | 671f5ce | 2011-12-06 20:25:29 -0800 | [diff] [blame] | 309 | |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 310 | if (!pmem_param_set) { |
| 311 | if (machine_is_msm8960_liquid()) |
| 312 | pmem_size = MSM_LIQUID_PMEM_SIZE; |
Ravishangar Kalyanam | fda36c4 | 2012-03-26 16:28:19 -0700 | [diff] [blame] | 313 | if (msm8960_hdmi_as_primary_selected()) |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 314 | pmem_size = MSM_HDMI_PRIM_PMEM_SIZE; |
| 315 | } |
| 316 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 317 | android_pmem_pdata.size = pmem_size; |
| 318 | android_pmem_audio_pdata.size = MSM_PMEM_AUDIO_SIZE; |
Bharath Ramachandramurthy | 4a3fa91 | 2012-03-13 19:16:24 -0700 | [diff] [blame] | 319 | #endif /*CONFIG_MSM_MULTIMEDIA_USE_ION*/ |
| 320 | #endif /*CONFIG_ANDROID_PMEM*/ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 321 | } |
| 322 | |
Bharath Ramachandramurthy | 4a3fa91 | 2012-03-13 19:16:24 -0700 | [diff] [blame] | 323 | #ifdef CONFIG_ANDROID_PMEM |
| 324 | #ifndef CONFIG_MSM_MULTIMEDIA_USE_ION |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 325 | static void __init reserve_memory_for(struct android_pmem_platform_data *p) |
| 326 | { |
| 327 | msm8960_reserve_table[p->memory_type].size += p->size; |
| 328 | } |
Bharath Ramachandramurthy | 4a3fa91 | 2012-03-13 19:16:24 -0700 | [diff] [blame] | 329 | #endif /*CONFIG_MSM_MULTIMEDIA_USE_ION*/ |
| 330 | #endif /*CONFIG_ANDROID_PMEM*/ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 331 | |
| 332 | static void __init reserve_pmem_memory(void) |
| 333 | { |
| 334 | #ifdef CONFIG_ANDROID_PMEM |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 335 | #ifndef CONFIG_MSM_MULTIMEDIA_USE_ION |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 336 | reserve_memory_for(&android_pmem_adsp_pdata); |
| 337 | reserve_memory_for(&android_pmem_pdata); |
| 338 | reserve_memory_for(&android_pmem_audio_pdata); |
Bharath Ramachandramurthy | 4a3fa91 | 2012-03-13 19:16:24 -0700 | [diff] [blame] | 339 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 340 | msm8960_reserve_table[MEMTYPE_EBI1].size += pmem_kernel_ebi1_size; |
| 341 | #endif |
| 342 | } |
| 343 | |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 344 | static int msm8960_paddr_to_memtype(unsigned int paddr) |
| 345 | { |
| 346 | return MEMTYPE_EBI1; |
| 347 | } |
| 348 | |
Steve Muckle | f132c6c | 2012-06-06 18:30:57 -0700 | [diff] [blame] | 349 | #define FMEM_ENABLED 0 |
Olav Haugan | f6dc774 | 2012-02-15 09:11:55 -0800 | [diff] [blame] | 350 | |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 351 | #ifdef CONFIG_ION_MSM |
Olav Haugan | 0703dbf | 2011-12-19 17:53:38 -0800 | [diff] [blame] | 352 | #ifdef CONFIG_MSM_MULTIMEDIA_USE_ION |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 353 | static struct ion_cp_heap_pdata cp_mm_msm8960_ion_pdata = { |
Olav Haugan | 0703dbf | 2011-12-19 17:53:38 -0800 | [diff] [blame] | 354 | .permission_type = IPT_TYPE_MM_CARVEOUT, |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 355 | .align = SZ_64K, |
Olav Haugan | f6dc774 | 2012-02-15 09:11:55 -0800 | [diff] [blame] | 356 | .reusable = FMEM_ENABLED, |
| 357 | .mem_is_fmem = FMEM_ENABLED, |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 358 | .fixed_position = FIXED_MIDDLE, |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 359 | .iommu_map_all = 1, |
| 360 | .iommu_2x_map_domain = VIDEO_DOMAIN, |
Olav Haugan | 0703dbf | 2011-12-19 17:53:38 -0800 | [diff] [blame] | 361 | }; |
| 362 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 363 | static struct ion_cp_heap_pdata cp_mfc_msm8960_ion_pdata = { |
Olav Haugan | 0703dbf | 2011-12-19 17:53:38 -0800 | [diff] [blame] | 364 | .permission_type = IPT_TYPE_MFC_SHAREDMEM, |
Olav Haugan | 42ebe71 | 2012-01-10 16:30:58 -0800 | [diff] [blame] | 365 | .align = PAGE_SIZE, |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 366 | .reusable = 0, |
Olav Haugan | f6dc774 | 2012-02-15 09:11:55 -0800 | [diff] [blame] | 367 | .mem_is_fmem = FMEM_ENABLED, |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 368 | .fixed_position = FIXED_HIGH, |
Olav Haugan | 0703dbf | 2011-12-19 17:53:38 -0800 | [diff] [blame] | 369 | }; |
| 370 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 371 | static struct ion_co_heap_pdata co_msm8960_ion_pdata = { |
Olav Haugan | 42ebe71 | 2012-01-10 16:30:58 -0800 | [diff] [blame] | 372 | .adjacent_mem_id = INVALID_HEAP_ID, |
| 373 | .align = PAGE_SIZE, |
Olav Haugan | f6dc774 | 2012-02-15 09:11:55 -0800 | [diff] [blame] | 374 | .mem_is_fmem = 0, |
Olav Haugan | 42ebe71 | 2012-01-10 16:30:58 -0800 | [diff] [blame] | 375 | }; |
| 376 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 377 | static struct ion_co_heap_pdata fw_co_msm8960_ion_pdata = { |
Olav Haugan | 42ebe71 | 2012-01-10 16:30:58 -0800 | [diff] [blame] | 378 | .adjacent_mem_id = ION_CP_MM_HEAP_ID, |
| 379 | .align = SZ_128K, |
Olav Haugan | f6dc774 | 2012-02-15 09:11:55 -0800 | [diff] [blame] | 380 | .mem_is_fmem = FMEM_ENABLED, |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 381 | .fixed_position = FIXED_LOW, |
Olav Haugan | 0703dbf | 2011-12-19 17:53:38 -0800 | [diff] [blame] | 382 | }; |
| 383 | #endif |
Olav Haugan | 9cdfc2f | 2012-02-15 09:52:57 -0800 | [diff] [blame] | 384 | |
| 385 | /** |
| 386 | * These heaps are listed in the order they will be allocated. Due to |
| 387 | * video hardware restrictions and content protection the FW heap has to |
| 388 | * be allocated adjacent (below) the MM heap and the MFC heap has to be |
| 389 | * allocated after the MM heap to ensure MFC heap is not more than 256MB |
| 390 | * away from the base address of the FW heap. |
| 391 | * However, the order of FW heap and MM heap doesn't matter since these |
| 392 | * two heaps are taken care of by separate code to ensure they are adjacent |
| 393 | * to each other. |
| 394 | * Don't swap the order unless you know what you are doing! |
| 395 | */ |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 396 | static struct ion_platform_data msm8960_ion_pdata = { |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 397 | .nr = MSM_ION_HEAP_NUM, |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 398 | .heaps = { |
| 399 | { |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 400 | .id = ION_SYSTEM_HEAP_ID, |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 401 | .type = ION_HEAP_TYPE_SYSTEM, |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 402 | .name = ION_VMALLOC_HEAP_NAME, |
| 403 | }, |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 404 | #ifdef CONFIG_MSM_MULTIMEDIA_USE_ION |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 405 | { |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 406 | .id = ION_CP_MM_HEAP_ID, |
Olav Haugan | 0a85251 | 2012-01-09 10:20:55 -0800 | [diff] [blame] | 407 | .type = ION_HEAP_TYPE_CP, |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 408 | .name = ION_MM_HEAP_NAME, |
| 409 | .size = MSM_ION_MM_SIZE, |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 410 | .memory_type = ION_EBI_TYPE, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 411 | .extra_data = (void *) &cp_mm_msm8960_ion_pdata, |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 412 | }, |
Laura Abbott | 8c01736 | 2011-09-22 20:59:12 -0700 | [diff] [blame] | 413 | { |
Olav Haugan | 42ebe71 | 2012-01-10 16:30:58 -0800 | [diff] [blame] | 414 | .id = ION_MM_FIRMWARE_HEAP_ID, |
| 415 | .type = ION_HEAP_TYPE_CARVEOUT, |
| 416 | .name = ION_MM_FIRMWARE_HEAP_NAME, |
| 417 | .size = MSM_ION_MM_FW_SIZE, |
| 418 | .memory_type = ION_EBI_TYPE, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 419 | .extra_data = (void *) &fw_co_msm8960_ion_pdata, |
Olav Haugan | 42ebe71 | 2012-01-10 16:30:58 -0800 | [diff] [blame] | 420 | }, |
| 421 | { |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 422 | .id = ION_CP_MFC_HEAP_ID, |
Olav Haugan | 0a85251 | 2012-01-09 10:20:55 -0800 | [diff] [blame] | 423 | .type = ION_HEAP_TYPE_CP, |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 424 | .name = ION_MFC_HEAP_NAME, |
| 425 | .size = MSM_ION_MFC_SIZE, |
| 426 | .memory_type = ION_EBI_TYPE, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 427 | .extra_data = (void *) &cp_mfc_msm8960_ion_pdata, |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 428 | }, |
Olav Haugan | 3259455 | 2012-03-13 11:40:05 -0700 | [diff] [blame] | 429 | #ifndef CONFIG_MSM_IOMMU |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 430 | { |
Olav Haugan | 9cdfc2f | 2012-02-15 09:52:57 -0800 | [diff] [blame] | 431 | .id = ION_SF_HEAP_ID, |
| 432 | .type = ION_HEAP_TYPE_CARVEOUT, |
| 433 | .name = ION_SF_HEAP_NAME, |
| 434 | .size = MSM_ION_SF_SIZE, |
| 435 | .memory_type = ION_EBI_TYPE, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 436 | .extra_data = (void *) &co_msm8960_ion_pdata, |
Olav Haugan | 9cdfc2f | 2012-02-15 09:52:57 -0800 | [diff] [blame] | 437 | }, |
Olav Haugan | 3259455 | 2012-03-13 11:40:05 -0700 | [diff] [blame] | 438 | #endif |
Olav Haugan | 9cdfc2f | 2012-02-15 09:52:57 -0800 | [diff] [blame] | 439 | { |
Olav Haugan | b5be799 | 2011-11-18 14:29:02 -0800 | [diff] [blame] | 440 | .id = ION_IOMMU_HEAP_ID, |
Laura Abbott | 8c01736 | 2011-09-22 20:59:12 -0700 | [diff] [blame] | 441 | .type = ION_HEAP_TYPE_IOMMU, |
| 442 | .name = ION_IOMMU_HEAP_NAME, |
| 443 | }, |
Olav Haugan | 80854eb | 2012-01-12 12:00:23 -0800 | [diff] [blame] | 444 | { |
| 445 | .id = ION_QSECOM_HEAP_ID, |
| 446 | .type = ION_HEAP_TYPE_CARVEOUT, |
| 447 | .name = ION_QSECOM_HEAP_NAME, |
| 448 | .size = MSM_ION_QSECOM_SIZE, |
| 449 | .memory_type = ION_EBI_TYPE, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 450 | .extra_data = (void *) &co_msm8960_ion_pdata, |
Olav Haugan | 80854eb | 2012-01-12 12:00:23 -0800 | [diff] [blame] | 451 | }, |
Olav Haugan | 7355db0 | 2012-01-13 16:59:13 -0800 | [diff] [blame] | 452 | { |
| 453 | .id = ION_AUDIO_HEAP_ID, |
| 454 | .type = ION_HEAP_TYPE_CARVEOUT, |
| 455 | .name = ION_AUDIO_HEAP_NAME, |
| 456 | .size = MSM_ION_AUDIO_SIZE, |
| 457 | .memory_type = ION_EBI_TYPE, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 458 | .extra_data = (void *) &co_msm8960_ion_pdata, |
Olav Haugan | 7355db0 | 2012-01-13 16:59:13 -0800 | [diff] [blame] | 459 | }, |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 460 | #endif |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 461 | } |
| 462 | }; |
| 463 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 464 | static struct platform_device msm8960_ion_dev = { |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 465 | .name = "ion-msm", |
| 466 | .id = 1, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 467 | .dev = { .platform_data = &msm8960_ion_pdata }, |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 468 | }; |
| 469 | #endif |
| 470 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 471 | struct platform_device msm8960_fmem_device = { |
Larry Bassel | 41a055b | 2011-12-06 16:15:14 -0800 | [diff] [blame] | 472 | .name = "fmem", |
| 473 | .id = 1, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 474 | .dev = { .platform_data = &msm8960_fmem_pdata }, |
Larry Bassel | 41a055b | 2011-12-06 16:15:14 -0800 | [diff] [blame] | 475 | }; |
| 476 | |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 477 | static void __init adjust_mem_for_liquid(void) |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 478 | { |
Ravishangar Kalyanam | 671f5ce | 2011-12-06 20:25:29 -0800 | [diff] [blame] | 479 | unsigned int i; |
| 480 | |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 481 | if (!pmem_param_set) { |
| 482 | if (machine_is_msm8960_liquid()) |
| 483 | msm_ion_sf_size = MSM_LIQUID_ION_SF_SIZE; |
| 484 | |
Ravishangar Kalyanam | fda36c4 | 2012-03-26 16:28:19 -0700 | [diff] [blame] | 485 | if (msm8960_hdmi_as_primary_selected()) |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 486 | msm_ion_sf_size = MSM_HDMI_PRIM_ION_SF_SIZE; |
| 487 | |
Ravishangar Kalyanam | fda36c4 | 2012-03-26 16:28:19 -0700 | [diff] [blame] | 488 | if (machine_is_msm8960_liquid() || |
| 489 | msm8960_hdmi_as_primary_selected()) { |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 490 | for (i = 0; i < msm8960_ion_pdata.nr; i++) { |
| 491 | if (msm8960_ion_pdata.heaps[i].id == |
| 492 | ION_SF_HEAP_ID) { |
| 493 | msm8960_ion_pdata.heaps[i].size = |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 494 | msm_ion_sf_size; |
| 495 | pr_debug("msm_ion_sf_size 0x%x\n", |
| 496 | msm_ion_sf_size); |
| 497 | break; |
| 498 | } |
Ravishangar Kalyanam | 671f5ce | 2011-12-06 20:25:29 -0800 | [diff] [blame] | 499 | } |
| 500 | } |
| 501 | } |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 502 | } |
| 503 | |
| 504 | static void __init reserve_mem_for_ion(enum ion_memory_types mem_type, |
| 505 | unsigned long size) |
| 506 | { |
| 507 | msm8960_reserve_table[mem_type].size += size; |
| 508 | } |
| 509 | |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 510 | static void __init msm8960_reserve_fixed_area(unsigned long fixed_area_size) |
| 511 | { |
| 512 | #if defined(CONFIG_ION_MSM) && defined(CONFIG_MSM_MULTIMEDIA_USE_ION) |
| 513 | int ret; |
| 514 | |
| 515 | if (fixed_area_size > MAX_FIXED_AREA_SIZE) |
| 516 | panic("fixed area size is larger than %dM\n", |
| 517 | MAX_FIXED_AREA_SIZE >> 20); |
| 518 | |
| 519 | reserve_info->fixed_area_size = fixed_area_size; |
| 520 | reserve_info->fixed_area_start = MSM8960_FW_START; |
| 521 | |
| 522 | ret = memblock_remove(reserve_info->fixed_area_start, |
| 523 | reserve_info->fixed_area_size); |
| 524 | BUG_ON(ret); |
| 525 | #endif |
| 526 | } |
| 527 | |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 528 | /** |
| 529 | * Reserve memory for ION and calculate amount of reusable memory for fmem. |
| 530 | * We only reserve memory for heaps that are not reusable. However, we only |
| 531 | * support one reusable heap at the moment so we ignore the reusable flag for |
| 532 | * other than the first heap with reusable flag set. Also handle special case |
Olav Haugan | f6dc774 | 2012-02-15 09:11:55 -0800 | [diff] [blame] | 533 | * for video heaps (MM,FW, and MFC). Video requires heaps MM and MFC to be |
| 534 | * at a higher address than FW in addition to not more than 256MB away from the |
| 535 | * base address of the firmware. This means that if MM is reusable the other |
| 536 | * two heaps must be allocated in the same region as FW. This is handled by the |
| 537 | * mem_is_fmem flag in the platform data. In addition the MM heap must be |
| 538 | * adjacent to the FW heap for content protection purposes. |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 539 | */ |
| 540 | static void __init reserve_ion_memory(void) |
| 541 | { |
| 542 | #if defined(CONFIG_ION_MSM) && defined(CONFIG_MSM_MULTIMEDIA_USE_ION) |
| 543 | unsigned int i; |
| 544 | unsigned int reusable_count = 0; |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 545 | unsigned int fixed_size = 0; |
| 546 | unsigned int fixed_low_size, fixed_middle_size, fixed_high_size; |
| 547 | unsigned long fixed_low_start, fixed_middle_start, fixed_high_start; |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 548 | |
| 549 | adjust_mem_for_liquid(); |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 550 | msm8960_fmem_pdata.size = 0; |
| 551 | msm8960_fmem_pdata.reserved_size_low = 0; |
| 552 | msm8960_fmem_pdata.reserved_size_high = 0; |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 553 | msm8960_fmem_pdata.align = PAGE_SIZE; |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 554 | fixed_low_size = 0; |
| 555 | fixed_middle_size = 0; |
| 556 | fixed_high_size = 0; |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 557 | |
| 558 | /* We only support 1 reusable heap. Check if more than one heap |
| 559 | * is specified as reusable and set as non-reusable if found. |
| 560 | */ |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 561 | for (i = 0; i < msm8960_ion_pdata.nr; ++i) { |
| 562 | const struct ion_platform_heap *heap = |
| 563 | &(msm8960_ion_pdata.heaps[i]); |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 564 | |
| 565 | if (heap->type == ION_HEAP_TYPE_CP && heap->extra_data) { |
| 566 | struct ion_cp_heap_pdata *data = heap->extra_data; |
| 567 | |
| 568 | reusable_count += (data->reusable) ? 1 : 0; |
| 569 | |
| 570 | if (data->reusable && reusable_count > 1) { |
| 571 | pr_err("%s: Too many heaps specified as " |
| 572 | "reusable. Heap %s was not configured " |
| 573 | "as reusable.\n", __func__, heap->name); |
| 574 | data->reusable = 0; |
| 575 | } |
| 576 | } |
| 577 | } |
| 578 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 579 | for (i = 0; i < msm8960_ion_pdata.nr; ++i) { |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 580 | struct ion_platform_heap *heap = |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 581 | &(msm8960_ion_pdata.heaps[i]); |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 582 | int align = SZ_4K; |
| 583 | int iommu_map_all = 0; |
| 584 | int adjacent_mem_id = INVALID_HEAP_ID; |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 585 | |
| 586 | if (heap->extra_data) { |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 587 | int fixed_position = NOT_FIXED; |
| 588 | int mem_is_fmem = 0; |
| 589 | |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 590 | switch (heap->type) { |
| 591 | case ION_HEAP_TYPE_CP: |
Olav Haugan | f6dc774 | 2012-02-15 09:11:55 -0800 | [diff] [blame] | 592 | mem_is_fmem = ((struct ion_cp_heap_pdata *) |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 593 | heap->extra_data)->mem_is_fmem; |
| 594 | fixed_position = ((struct ion_cp_heap_pdata *) |
| 595 | heap->extra_data)->fixed_position; |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 596 | align = ((struct ion_cp_heap_pdata *) |
| 597 | heap->extra_data)->align; |
| 598 | iommu_map_all = |
| 599 | ((struct ion_cp_heap_pdata *) |
| 600 | heap->extra_data)->iommu_map_all; |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 601 | break; |
| 602 | case ION_HEAP_TYPE_CARVEOUT: |
Olav Haugan | f6dc774 | 2012-02-15 09:11:55 -0800 | [diff] [blame] | 603 | mem_is_fmem = ((struct ion_co_heap_pdata *) |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 604 | heap->extra_data)->mem_is_fmem; |
| 605 | fixed_position = ((struct ion_co_heap_pdata *) |
| 606 | heap->extra_data)->fixed_position; |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 607 | adjacent_mem_id = ((struct ion_co_heap_pdata *) |
| 608 | heap->extra_data)->adjacent_mem_id; |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 609 | break; |
| 610 | default: |
| 611 | break; |
| 612 | } |
| 613 | |
Olav Haugan | 8726caf | 2012-05-10 15:11:35 -0700 | [diff] [blame] | 614 | if (iommu_map_all) { |
| 615 | if (heap->size & (SZ_64K-1)) { |
| 616 | heap->size = ALIGN(heap->size, SZ_64K); |
| 617 | pr_info("Heap %s not aligned to 64K. Adjusting size to %x\n", |
| 618 | heap->name, heap->size); |
| 619 | } |
| 620 | } |
| 621 | |
| 622 | if (mem_is_fmem && adjacent_mem_id != INVALID_HEAP_ID) |
| 623 | msm8960_fmem_pdata.align = align; |
| 624 | |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 625 | if (fixed_position != NOT_FIXED) |
| 626 | fixed_size += heap->size; |
| 627 | else |
| 628 | reserve_mem_for_ion(MEMTYPE_EBI1, heap->size); |
| 629 | |
| 630 | if (fixed_position == FIXED_LOW) |
| 631 | fixed_low_size += heap->size; |
| 632 | else if (fixed_position == FIXED_MIDDLE) |
| 633 | fixed_middle_size += heap->size; |
| 634 | else if (fixed_position == FIXED_HIGH) |
| 635 | fixed_high_size += heap->size; |
| 636 | |
| 637 | if (mem_is_fmem) |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 638 | msm8960_fmem_pdata.size += heap->size; |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 639 | } |
| 640 | } |
| 641 | |
| 642 | if (!fixed_size) |
| 643 | return; |
| 644 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 645 | if (msm8960_fmem_pdata.size) { |
Deepak Kotur | 3582552 | 2012-06-06 15:49:14 -0700 | [diff] [blame] | 646 | msm8960_fmem_pdata.reserved_size_low = fixed_low_size + |
| 647 | HOLE_SIZE; |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 648 | msm8960_fmem_pdata.reserved_size_high = fixed_high_size; |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 649 | } |
| 650 | |
Larry Bassel | 4d4f448 | 2012-04-04 11:26:09 -0700 | [diff] [blame] | 651 | /* Since the fixed area may be carved out of lowmem, |
| 652 | * make sure the length is a multiple of 1M. |
| 653 | */ |
| 654 | fixed_size = (fixed_size + MSM_MM_FW_SIZE + SECTION_SIZE - 1) |
| 655 | & SECTION_MASK; |
| 656 | msm8960_reserve_fixed_area(fixed_size); |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 657 | |
| 658 | fixed_low_start = MSM8960_FIXED_AREA_START; |
Deepak Kotur | 3582552 | 2012-06-06 15:49:14 -0700 | [diff] [blame] | 659 | fixed_middle_start = fixed_low_start + fixed_low_size + HOLE_SIZE; |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 660 | fixed_high_start = fixed_middle_start + fixed_middle_size; |
| 661 | |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 662 | for (i = 0; i < msm8960_ion_pdata.nr; ++i) { |
| 663 | struct ion_platform_heap *heap = &(msm8960_ion_pdata.heaps[i]); |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 664 | |
| 665 | if (heap->extra_data) { |
| 666 | int fixed_position = NOT_FIXED; |
Steve Muckle | 75c34ca | 2012-06-12 14:27:40 -0700 | [diff] [blame] | 667 | struct ion_cp_heap_pdata *pdata = NULL; |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 668 | |
| 669 | switch (heap->type) { |
| 670 | case ION_HEAP_TYPE_CP: |
Deepak Kotur | 3582552 | 2012-06-06 15:49:14 -0700 | [diff] [blame] | 671 | pdata = |
| 672 | (struct ion_cp_heap_pdata *)heap->extra_data; |
| 673 | fixed_position = pdata->fixed_position; |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 674 | break; |
| 675 | case ION_HEAP_TYPE_CARVEOUT: |
| 676 | fixed_position = ((struct ion_co_heap_pdata *) |
| 677 | heap->extra_data)->fixed_position; |
| 678 | break; |
| 679 | default: |
| 680 | break; |
| 681 | } |
| 682 | |
| 683 | switch (fixed_position) { |
| 684 | case FIXED_LOW: |
| 685 | heap->base = fixed_low_start; |
| 686 | break; |
| 687 | case FIXED_MIDDLE: |
| 688 | heap->base = fixed_middle_start; |
Deepak Kotur | 3582552 | 2012-06-06 15:49:14 -0700 | [diff] [blame] | 689 | pdata->secure_base = fixed_middle_start |
| 690 | - HOLE_SIZE; |
| 691 | pdata->secure_size = HOLE_SIZE + heap->size; |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 692 | break; |
| 693 | case FIXED_HIGH: |
| 694 | heap->base = fixed_high_start; |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 695 | break; |
| 696 | default: |
| 697 | break; |
| 698 | } |
| 699 | } |
Olav Haugan | 65f4bd8 | 2011-12-13 11:50:08 -0800 | [diff] [blame] | 700 | } |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 701 | #endif |
| 702 | } |
Huaibin Yang | a541942 | 2011-12-08 23:52:10 -0800 | [diff] [blame] | 703 | |
| 704 | static void __init reserve_mdp_memory(void) |
| 705 | { |
| 706 | msm8960_mdp_writeback(msm8960_reserve_table); |
| 707 | } |
| 708 | |
Stephen Boyd | 668d765 | 2012-04-25 11:31:01 -0700 | [diff] [blame] | 709 | static void __init reserve_cache_dump_memory(void) |
Laura Abbott | 306bcc2 | 2012-03-08 11:24:53 -0800 | [diff] [blame] | 710 | { |
| 711 | #ifdef CONFIG_MSM_CACHE_DUMP |
Laura Abbott | 306bcc2 | 2012-03-08 11:24:53 -0800 | [diff] [blame] | 712 | unsigned int total; |
Laura Abbott | 306bcc2 | 2012-03-08 11:24:53 -0800 | [diff] [blame] | 713 | |
Laura Abbott | 155ab6f | 2012-05-25 08:52:18 -0700 | [diff] [blame] | 714 | total = msm8960_cache_dump_pdata.l1_size + |
| 715 | msm8960_cache_dump_pdata.l2_size; |
Laura Abbott | 306bcc2 | 2012-03-08 11:24:53 -0800 | [diff] [blame] | 716 | msm8960_reserve_table[MEMTYPE_EBI1].size += total; |
Laura Abbott | 306bcc2 | 2012-03-08 11:24:53 -0800 | [diff] [blame] | 717 | #endif |
| 718 | } |
| 719 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 720 | static void __init msm8960_calculate_reserve_sizes(void) |
| 721 | { |
| 722 | size_pmem_devices(); |
| 723 | reserve_pmem_memory(); |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 724 | reserve_ion_memory(); |
Huaibin Yang | a541942 | 2011-12-08 23:52:10 -0800 | [diff] [blame] | 725 | reserve_mdp_memory(); |
Laura Abbott | f8c03b9 | 2012-02-16 14:57:58 -0800 | [diff] [blame] | 726 | reserve_rtb_memory(); |
Laura Abbott | 306bcc2 | 2012-03-08 11:24:53 -0800 | [diff] [blame] | 727 | reserve_cache_dump_memory(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 728 | } |
| 729 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 730 | static struct reserve_info msm8960_reserve_info __initdata = { |
| 731 | .memtype_reserve_table = msm8960_reserve_table, |
| 732 | .calculate_reserve_sizes = msm8960_calculate_reserve_sizes, |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 733 | .reserve_fixed_area = msm8960_reserve_fixed_area, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 734 | .paddr_to_memtype = msm8960_paddr_to_memtype, |
| 735 | }; |
| 736 | |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 737 | static int msm8960_memory_bank_size(void) |
| 738 | { |
| 739 | return 1<<29; |
| 740 | } |
| 741 | |
| 742 | static void __init locate_unstable_memory(void) |
| 743 | { |
| 744 | struct membank *mb = &meminfo.bank[meminfo.nr_banks - 1]; |
| 745 | unsigned long bank_size; |
| 746 | unsigned long low, high; |
| 747 | |
| 748 | bank_size = msm8960_memory_bank_size(); |
Larry Bassel | 4d4f448 | 2012-04-04 11:26:09 -0700 | [diff] [blame] | 749 | msm8960_reserve_info.bank_size = bank_size; |
| 750 | |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 751 | low = meminfo.bank[0].start; |
| 752 | high = mb->start + mb->size; |
Olav Haugan | 62052e4 | 2011-10-28 14:28:32 -0700 | [diff] [blame] | 753 | |
| 754 | /* Check if 32 bit overflow occured */ |
| 755 | if (high < mb->start) |
| 756 | high = ~0UL; |
| 757 | |
Larry Bassel | 4d4f448 | 2012-04-04 11:26:09 -0700 | [diff] [blame] | 758 | if (high < MAX_FIXED_AREA_SIZE + MSM8960_FIXED_AREA_START) |
| 759 | panic("fixed area extends beyond end of memory\n"); |
| 760 | |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 761 | low &= ~(bank_size - 1); |
| 762 | |
| 763 | if (high - low <= bank_size) |
Larry Bassel | 4d4f448 | 2012-04-04 11:26:09 -0700 | [diff] [blame] | 764 | goto no_dmm; |
Larry Bassel | b8d6102 | 2012-02-24 10:49:45 -0800 | [diff] [blame] | 765 | |
Larry Bassel | b8d6102 | 2012-02-24 10:49:45 -0800 | [diff] [blame] | 766 | #ifdef CONFIG_ENABLE_DMM |
Jack Cheung | 60eaeab | 2012-01-09 16:40:26 -0800 | [diff] [blame] | 767 | msm8960_reserve_info.low_unstable_address = mb->start - |
| 768 | MIN_MEMORY_BLOCK_SIZE + mb->size; |
Jack Cheung | 0b1987e | 2011-11-18 13:36:29 -0800 | [diff] [blame] | 769 | msm8960_reserve_info.max_unstable_size = MIN_MEMORY_BLOCK_SIZE; |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 770 | pr_info("low unstable address %lx max size %lx bank size %lx\n", |
| 771 | msm8960_reserve_info.low_unstable_address, |
| 772 | msm8960_reserve_info.max_unstable_size, |
| 773 | msm8960_reserve_info.bank_size); |
Larry Bassel | 4d4f448 | 2012-04-04 11:26:09 -0700 | [diff] [blame] | 774 | return; |
Larry Bassel | b8d6102 | 2012-02-24 10:49:45 -0800 | [diff] [blame] | 775 | #endif |
Larry Bassel | 4d4f448 | 2012-04-04 11:26:09 -0700 | [diff] [blame] | 776 | no_dmm: |
| 777 | msm8960_reserve_info.low_unstable_address = high; |
| 778 | msm8960_reserve_info.max_unstable_size = 0; |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 779 | } |
| 780 | |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 781 | static void __init place_movable_zone(void) |
| 782 | { |
Larry Bassel | b8d6102 | 2012-02-24 10:49:45 -0800 | [diff] [blame] | 783 | #ifdef CONFIG_ENABLE_DMM |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 784 | movable_reserved_start = msm8960_reserve_info.low_unstable_address; |
| 785 | movable_reserved_size = msm8960_reserve_info.max_unstable_size; |
| 786 | pr_info("movable zone start %lx size %lx\n", |
| 787 | movable_reserved_start, movable_reserved_size); |
Larry Bassel | b8d6102 | 2012-02-24 10:49:45 -0800 | [diff] [blame] | 788 | #endif |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 789 | } |
| 790 | |
| 791 | static void __init msm8960_early_memory(void) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 792 | { |
| 793 | reserve_info = &msm8960_reserve_info; |
Larry Bassel | b4126da | 2011-07-18 14:31:33 -0700 | [diff] [blame] | 794 | locate_unstable_memory(); |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 795 | place_movable_zone(); |
| 796 | } |
| 797 | |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 798 | static char prim_panel_name[PANEL_NAME_MAX_LEN]; |
| 799 | static char ext_panel_name[PANEL_NAME_MAX_LEN]; |
| 800 | static int __init prim_display_setup(char *param) |
| 801 | { |
| 802 | if (strnlen(param, PANEL_NAME_MAX_LEN)) |
| 803 | strlcpy(prim_panel_name, param, PANEL_NAME_MAX_LEN); |
| 804 | return 0; |
| 805 | } |
| 806 | early_param("prim_display", prim_display_setup); |
| 807 | |
| 808 | static int __init ext_display_setup(char *param) |
| 809 | { |
| 810 | if (strnlen(param, PANEL_NAME_MAX_LEN)) |
| 811 | strlcpy(ext_panel_name, param, PANEL_NAME_MAX_LEN); |
| 812 | return 0; |
| 813 | } |
| 814 | early_param("ext_display", ext_display_setup); |
| 815 | |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 816 | static void __init msm8960_reserve(void) |
| 817 | { |
Ravishangar Kalyanam | 8c79ead | 2011-12-02 21:05:01 -0800 | [diff] [blame] | 818 | msm8960_set_display_params(prim_panel_name, ext_panel_name); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 819 | msm_reserve(); |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 820 | if (msm8960_fmem_pdata.size) { |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 821 | #if defined(CONFIG_ION_MSM) && defined(CONFIG_MSM_MULTIMEDIA_USE_ION) |
Larry Bassel | 861985f | 2012-05-02 15:54:52 -0700 | [diff] [blame] | 822 | if (reserve_info->fixed_area_size) { |
| 823 | msm8960_fmem_pdata.phys = |
| 824 | reserve_info->fixed_area_start + MSM_MM_FW_SIZE; |
| 825 | pr_info("mm fw at %lx (fixed) size %x\n", |
| 826 | reserve_info->fixed_area_start, MSM_MM_FW_SIZE); |
| 827 | pr_info("fmem start %lx (fixed) size %lx\n", |
| 828 | msm8960_fmem_pdata.phys, |
| 829 | msm8960_fmem_pdata.size); |
| 830 | } |
Larry Bassel | 2d8b42d | 2012-03-12 10:41:26 -0700 | [diff] [blame] | 831 | #endif |
| 832 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 833 | } |
| 834 | |
Larry Bassel | a4414b1 | 2011-08-04 11:11:02 -0700 | [diff] [blame] | 835 | static int msm8960_change_memory_power(u64 start, u64 size, |
| 836 | int change_type) |
Larry Bassel | a7eadea | 2011-07-14 10:46:00 -0700 | [diff] [blame] | 837 | { |
Naveen Ramaraj | b03bb1b | 2011-09-12 14:34:31 -0700 | [diff] [blame] | 838 | return soc_change_memory_power(start, size, change_type); |
Larry Bassel | a7eadea | 2011-07-14 10:46:00 -0700 | [diff] [blame] | 839 | } |
| 840 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 841 | static void __init msm8960_allocate_memory_regions(void) |
| 842 | { |
Stepan Moskovchenko | 24cd864 | 2011-11-29 13:07:53 -0800 | [diff] [blame] | 843 | msm8960_allocate_fb_region(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 844 | } |
Stepan Moskovchenko | 24cd864 | 2011-11-29 13:07:53 -0800 | [diff] [blame] | 845 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 846 | #ifdef CONFIG_WCD9310_CODEC |
| 847 | |
| 848 | #define TABLA_INTERRUPT_BASE (NR_MSM_IRQS + NR_GPIO_IRQS + NR_PM8921_IRQS) |
| 849 | |
Patrick Lai | 3043fba | 2011-08-01 14:15:57 -0700 | [diff] [blame] | 850 | /* Micbias setting is based on 8660 CDP/MTP/FLUID requirement |
| 851 | * 4 micbiases are used to power various analog and digital |
| 852 | * microphones operating at 1800 mV. Technically, all micbiases |
| 853 | * can source from single cfilter since all microphones operate |
| 854 | * at the same voltage level. The arrangement below is to make |
| 855 | * sure all cfilters are exercised. LDO_H regulator ouput level |
| 856 | * does not need to be as high as 2.85V. It is choosen for |
| 857 | * microphone sensitivity purpose. |
| 858 | */ |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 859 | static struct wcd9xxx_pdata tabla_platform_data = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 860 | .slimbus_slave_device = { |
| 861 | .name = "tabla-slave", |
| 862 | .e_addr = {0, 0, 0x10, 0, 0x17, 2}, |
| 863 | }, |
| 864 | .irq = MSM_GPIO_TO_INT(62), |
| 865 | .irq_base = TABLA_INTERRUPT_BASE, |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 866 | .num_irqs = NR_WCD9XXX_IRQS, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 867 | .reset_gpio = PM8921_GPIO_PM_TO_SYS(34), |
Patrick Lai | 3043fba | 2011-08-01 14:15:57 -0700 | [diff] [blame] | 868 | .micbias = { |
| 869 | .ldoh_v = TABLA_LDOH_2P85_V, |
| 870 | .cfilt1_mv = 1800, |
Joonwoo Park | cf473b4 | 2012-03-29 19:48:16 -0700 | [diff] [blame] | 871 | .cfilt2_mv = 2700, |
Patrick Lai | 3043fba | 2011-08-01 14:15:57 -0700 | [diff] [blame] | 872 | .cfilt3_mv = 1800, |
| 873 | .bias1_cfilt_sel = TABLA_CFILT1_SEL, |
| 874 | .bias2_cfilt_sel = TABLA_CFILT2_SEL, |
| 875 | .bias3_cfilt_sel = TABLA_CFILT3_SEL, |
| 876 | .bias4_cfilt_sel = TABLA_CFILT3_SEL, |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 877 | }, |
| 878 | .regulator = { |
| 879 | { |
| 880 | .name = "CDC_VDD_CP", |
| 881 | .min_uV = 1800000, |
| 882 | .max_uV = 1800000, |
| 883 | .optimum_uA = WCD9XXX_CDC_VDDA_CP_CUR_MAX, |
| 884 | }, |
| 885 | { |
| 886 | .name = "CDC_VDDA_RX", |
| 887 | .min_uV = 1800000, |
| 888 | .max_uV = 1800000, |
| 889 | .optimum_uA = WCD9XXX_CDC_VDDA_RX_CUR_MAX, |
| 890 | }, |
| 891 | { |
| 892 | .name = "CDC_VDDA_TX", |
| 893 | .min_uV = 1800000, |
| 894 | .max_uV = 1800000, |
| 895 | .optimum_uA = WCD9XXX_CDC_VDDA_TX_CUR_MAX, |
| 896 | }, |
| 897 | { |
| 898 | .name = "VDDIO_CDC", |
| 899 | .min_uV = 1800000, |
| 900 | .max_uV = 1800000, |
| 901 | .optimum_uA = WCD9XXX_VDDIO_CDC_CUR_MAX, |
| 902 | }, |
| 903 | { |
| 904 | .name = "VDDD_CDC_D", |
| 905 | .min_uV = 1225000, |
David Collins | 8f2a196 | 2012-05-18 09:47:59 -0700 | [diff] [blame] | 906 | .max_uV = 1250000, |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 907 | .optimum_uA = WCD9XXX_VDDD_CDC_D_CUR_MAX, |
| 908 | }, |
| 909 | { |
| 910 | .name = "CDC_VDDA_A_1P2V", |
| 911 | .min_uV = 1225000, |
David Collins | 8f2a196 | 2012-05-18 09:47:59 -0700 | [diff] [blame] | 912 | .max_uV = 1250000, |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 913 | .optimum_uA = WCD9XXX_VDDD_CDC_A_CUR_MAX, |
| 914 | }, |
| 915 | }, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 916 | }; |
| 917 | |
| 918 | static struct slim_device msm_slim_tabla = { |
| 919 | .name = "tabla-slim", |
| 920 | .e_addr = {0, 1, 0x10, 0, 0x17, 2}, |
| 921 | .dev = { |
| 922 | .platform_data = &tabla_platform_data, |
| 923 | }, |
| 924 | }; |
Santosh Mardi | 60e19d9 | 2011-10-28 01:15:14 +0530 | [diff] [blame] | 925 | |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 926 | static struct wcd9xxx_pdata tabla20_platform_data = { |
Santosh Mardi | 60e19d9 | 2011-10-28 01:15:14 +0530 | [diff] [blame] | 927 | .slimbus_slave_device = { |
| 928 | .name = "tabla-slave", |
| 929 | .e_addr = {0, 0, 0x60, 0, 0x17, 2}, |
| 930 | }, |
| 931 | .irq = MSM_GPIO_TO_INT(62), |
| 932 | .irq_base = TABLA_INTERRUPT_BASE, |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 933 | .num_irqs = NR_WCD9XXX_IRQS, |
Santosh Mardi | 60e19d9 | 2011-10-28 01:15:14 +0530 | [diff] [blame] | 934 | .reset_gpio = PM8921_GPIO_PM_TO_SYS(34), |
| 935 | .micbias = { |
| 936 | .ldoh_v = TABLA_LDOH_2P85_V, |
| 937 | .cfilt1_mv = 1800, |
Joonwoo Park | cf473b4 | 2012-03-29 19:48:16 -0700 | [diff] [blame] | 938 | .cfilt2_mv = 2700, |
Santosh Mardi | 60e19d9 | 2011-10-28 01:15:14 +0530 | [diff] [blame] | 939 | .cfilt3_mv = 1800, |
| 940 | .bias1_cfilt_sel = TABLA_CFILT1_SEL, |
| 941 | .bias2_cfilt_sel = TABLA_CFILT2_SEL, |
| 942 | .bias3_cfilt_sel = TABLA_CFILT3_SEL, |
| 943 | .bias4_cfilt_sel = TABLA_CFILT3_SEL, |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 944 | }, |
| 945 | .regulator = { |
| 946 | { |
| 947 | .name = "CDC_VDD_CP", |
| 948 | .min_uV = 1800000, |
| 949 | .max_uV = 1800000, |
| 950 | .optimum_uA = WCD9XXX_CDC_VDDA_CP_CUR_MAX, |
| 951 | }, |
| 952 | { |
| 953 | .name = "CDC_VDDA_RX", |
| 954 | .min_uV = 1800000, |
| 955 | .max_uV = 1800000, |
| 956 | .optimum_uA = WCD9XXX_CDC_VDDA_RX_CUR_MAX, |
| 957 | }, |
| 958 | { |
| 959 | .name = "CDC_VDDA_TX", |
| 960 | .min_uV = 1800000, |
| 961 | .max_uV = 1800000, |
| 962 | .optimum_uA = WCD9XXX_CDC_VDDA_TX_CUR_MAX, |
| 963 | }, |
| 964 | { |
| 965 | .name = "VDDIO_CDC", |
| 966 | .min_uV = 1800000, |
| 967 | .max_uV = 1800000, |
| 968 | .optimum_uA = WCD9XXX_VDDIO_CDC_CUR_MAX, |
| 969 | }, |
| 970 | { |
| 971 | .name = "VDDD_CDC_D", |
| 972 | .min_uV = 1225000, |
David Collins | 8f2a196 | 2012-05-18 09:47:59 -0700 | [diff] [blame] | 973 | .max_uV = 1250000, |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 974 | .optimum_uA = WCD9XXX_VDDD_CDC_D_CUR_MAX, |
| 975 | }, |
| 976 | { |
| 977 | .name = "CDC_VDDA_A_1P2V", |
| 978 | .min_uV = 1225000, |
David Collins | 8f2a196 | 2012-05-18 09:47:59 -0700 | [diff] [blame] | 979 | .max_uV = 1250000, |
Asish Bhattacharya | b1aeae2 | 2012-02-15 08:29:28 +0530 | [diff] [blame] | 980 | .optimum_uA = WCD9XXX_VDDD_CDC_A_CUR_MAX, |
| 981 | }, |
| 982 | }, |
Santosh Mardi | 60e19d9 | 2011-10-28 01:15:14 +0530 | [diff] [blame] | 983 | }; |
| 984 | |
| 985 | static struct slim_device msm_slim_tabla20 = { |
| 986 | .name = "tabla2x-slim", |
| 987 | .e_addr = {0, 1, 0x60, 0, 0x17, 2}, |
| 988 | .dev = { |
| 989 | .platform_data = &tabla20_platform_data, |
| 990 | }, |
| 991 | }; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 992 | #endif |
| 993 | |
| 994 | static struct slim_boardinfo msm_slim_devices[] = { |
| 995 | #ifdef CONFIG_WCD9310_CODEC |
| 996 | { |
| 997 | .bus_num = 1, |
| 998 | .slim_slave = &msm_slim_tabla, |
| 999 | }, |
Santosh Mardi | 60e19d9 | 2011-10-28 01:15:14 +0530 | [diff] [blame] | 1000 | { |
| 1001 | .bus_num = 1, |
| 1002 | .slim_slave = &msm_slim_tabla20, |
| 1003 | }, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1004 | #endif |
| 1005 | /* add more slimbus slaves as needed */ |
| 1006 | }; |
| 1007 | |
Yunsen Wang | 5c1a739 | 2011-07-09 19:10:16 -0700 | [diff] [blame] | 1008 | #define MSM_WCNSS_PHYS 0x03000000 |
| 1009 | #define MSM_WCNSS_SIZE 0x280000 |
| 1010 | |
| 1011 | static struct resource resources_wcnss_wlan[] = { |
| 1012 | { |
| 1013 | .start = RIVA_APPS_WLAN_RX_DATA_AVAIL_IRQ, |
| 1014 | .end = RIVA_APPS_WLAN_RX_DATA_AVAIL_IRQ, |
| 1015 | .name = "wcnss_wlanrx_irq", |
| 1016 | .flags = IORESOURCE_IRQ, |
| 1017 | }, |
| 1018 | { |
| 1019 | .start = RIVA_APPS_WLAN_DATA_XFER_DONE_IRQ, |
| 1020 | .end = RIVA_APPS_WLAN_DATA_XFER_DONE_IRQ, |
| 1021 | .name = "wcnss_wlantx_irq", |
| 1022 | .flags = IORESOURCE_IRQ, |
| 1023 | }, |
| 1024 | { |
| 1025 | .start = MSM_WCNSS_PHYS, |
| 1026 | .end = MSM_WCNSS_PHYS + MSM_WCNSS_SIZE - 1, |
| 1027 | .name = "wcnss_mmio", |
| 1028 | .flags = IORESOURCE_MEM, |
| 1029 | }, |
Ankur Nandwani | ad0d9ac | 2011-09-26 11:49:25 -0700 | [diff] [blame] | 1030 | { |
| 1031 | .start = 84, |
| 1032 | .end = 88, |
| 1033 | .name = "wcnss_gpios_5wire", |
| 1034 | .flags = IORESOURCE_IO, |
| 1035 | }, |
Yunsen Wang | 5c1a739 | 2011-07-09 19:10:16 -0700 | [diff] [blame] | 1036 | }; |
| 1037 | |
Ankur Nandwani | b0039b0 | 2011-08-09 14:00:45 -0700 | [diff] [blame] | 1038 | static struct qcom_wcnss_opts qcom_wcnss_pdata = { |
| 1039 | .has_48mhz_xo = 1, |
| 1040 | }; |
| 1041 | |
Yunsen Wang | 5c1a739 | 2011-07-09 19:10:16 -0700 | [diff] [blame] | 1042 | static struct platform_device msm_device_wcnss_wlan = { |
| 1043 | .name = "wcnss_wlan", |
| 1044 | .id = 0, |
| 1045 | .num_resources = ARRAY_SIZE(resources_wcnss_wlan), |
| 1046 | .resource = resources_wcnss_wlan, |
Ankur Nandwani | b0039b0 | 2011-08-09 14:00:45 -0700 | [diff] [blame] | 1047 | .dev = {.platform_data = &qcom_wcnss_pdata}, |
Yunsen Wang | 5c1a739 | 2011-07-09 19:10:16 -0700 | [diff] [blame] | 1048 | }; |
| 1049 | |
Ramesh Masavarapu | a26cce7 | 2012-04-09 12:32:25 -0700 | [diff] [blame] | 1050 | #ifdef CONFIG_QSEECOM |
| 1051 | /* qseecom bus scaling */ |
| 1052 | static struct msm_bus_vectors qseecom_clks_init_vectors[] = { |
| 1053 | { |
| 1054 | .src = MSM_BUS_MASTER_SPS, |
| 1055 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1056 | .ib = 0, |
| 1057 | .ab = 0, |
| 1058 | }, |
| 1059 | { |
| 1060 | .src = MSM_BUS_MASTER_SPDM, |
| 1061 | .dst = MSM_BUS_SLAVE_SPDM, |
| 1062 | .ib = 0, |
| 1063 | .ab = 0, |
| 1064 | }, |
| 1065 | }; |
| 1066 | |
| 1067 | static struct msm_bus_vectors qseecom_enable_dfab_vectors[] = { |
| 1068 | { |
| 1069 | .src = MSM_BUS_MASTER_SPS, |
| 1070 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1071 | .ib = (492 * 8) * 1000000UL, |
| 1072 | .ab = (492 * 8) * 100000UL, |
| 1073 | }, |
| 1074 | { |
| 1075 | .src = MSM_BUS_MASTER_SPDM, |
| 1076 | .dst = MSM_BUS_SLAVE_SPDM, |
| 1077 | .ib = 0, |
| 1078 | .ab = 0, |
| 1079 | }, |
| 1080 | }; |
| 1081 | |
| 1082 | static struct msm_bus_vectors qseecom_enable_sfpb_vectors[] = { |
| 1083 | { |
| 1084 | .src = MSM_BUS_MASTER_SPS, |
| 1085 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1086 | .ib = 0, |
| 1087 | .ab = 0, |
| 1088 | }, |
| 1089 | { |
| 1090 | .src = MSM_BUS_MASTER_SPDM, |
| 1091 | .dst = MSM_BUS_SLAVE_SPDM, |
| 1092 | .ib = (64 * 8) * 1000000UL, |
| 1093 | .ab = (64 * 8) * 100000UL, |
| 1094 | }, |
| 1095 | }; |
| 1096 | |
| 1097 | static struct msm_bus_paths qseecom_hw_bus_scale_usecases[] = { |
| 1098 | { |
| 1099 | ARRAY_SIZE(qseecom_clks_init_vectors), |
| 1100 | qseecom_clks_init_vectors, |
| 1101 | }, |
| 1102 | { |
| 1103 | ARRAY_SIZE(qseecom_enable_dfab_vectors), |
| 1104 | qseecom_enable_sfpb_vectors, |
| 1105 | }, |
| 1106 | { |
| 1107 | ARRAY_SIZE(qseecom_enable_sfpb_vectors), |
| 1108 | qseecom_enable_sfpb_vectors, |
| 1109 | }, |
| 1110 | }; |
| 1111 | |
| 1112 | static struct msm_bus_scale_pdata qseecom_bus_pdata = { |
| 1113 | qseecom_hw_bus_scale_usecases, |
| 1114 | ARRAY_SIZE(qseecom_hw_bus_scale_usecases), |
| 1115 | .name = "qsee", |
| 1116 | }; |
| 1117 | |
| 1118 | static struct platform_device qseecom_device = { |
| 1119 | .name = "qseecom", |
| 1120 | .id = 0, |
| 1121 | .dev = { |
| 1122 | .platform_data = &qseecom_bus_pdata, |
| 1123 | }, |
| 1124 | }; |
| 1125 | #endif |
| 1126 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1127 | #if defined(CONFIG_CRYPTO_DEV_QCRYPTO) || \ |
| 1128 | defined(CONFIG_CRYPTO_DEV_QCRYPTO_MODULE) || \ |
| 1129 | defined(CONFIG_CRYPTO_DEV_QCEDEV) || \ |
| 1130 | defined(CONFIG_CRYPTO_DEV_QCEDEV_MODULE) |
| 1131 | |
| 1132 | #define QCE_SIZE 0x10000 |
| 1133 | #define QCE_0_BASE 0x18500000 |
| 1134 | |
| 1135 | #define QCE_HW_KEY_SUPPORT 0 |
| 1136 | #define QCE_SHA_HMAC_SUPPORT 1 |
| 1137 | #define QCE_SHARE_CE_RESOURCE 1 |
| 1138 | #define QCE_CE_SHARED 0 |
| 1139 | |
Ramesh Masavarapu | 4925968 | 2011-12-02 14:00:18 -0800 | [diff] [blame] | 1140 | /* Begin Bus scaling definitions */ |
| 1141 | static struct msm_bus_vectors crypto_hw_init_vectors[] = { |
| 1142 | { |
| 1143 | .src = MSM_BUS_MASTER_ADM_PORT0, |
| 1144 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1145 | .ab = 0, |
| 1146 | .ib = 0, |
| 1147 | }, |
| 1148 | { |
| 1149 | .src = MSM_BUS_MASTER_ADM_PORT1, |
| 1150 | .dst = MSM_BUS_SLAVE_GSBI1_UART, |
| 1151 | .ab = 0, |
| 1152 | .ib = 0, |
| 1153 | }, |
| 1154 | }; |
| 1155 | |
| 1156 | static struct msm_bus_vectors crypto_hw_active_vectors[] = { |
| 1157 | { |
| 1158 | .src = MSM_BUS_MASTER_ADM_PORT0, |
| 1159 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1160 | .ab = 70000000UL, |
| 1161 | .ib = 70000000UL, |
| 1162 | }, |
| 1163 | { |
| 1164 | .src = MSM_BUS_MASTER_ADM_PORT1, |
| 1165 | .dst = MSM_BUS_SLAVE_GSBI1_UART, |
| 1166 | .ab = 2480000000UL, |
| 1167 | .ib = 2480000000UL, |
| 1168 | }, |
| 1169 | }; |
| 1170 | |
| 1171 | static struct msm_bus_paths crypto_hw_bus_scale_usecases[] = { |
| 1172 | { |
| 1173 | ARRAY_SIZE(crypto_hw_init_vectors), |
| 1174 | crypto_hw_init_vectors, |
| 1175 | }, |
| 1176 | { |
| 1177 | ARRAY_SIZE(crypto_hw_active_vectors), |
| 1178 | crypto_hw_active_vectors, |
| 1179 | }, |
| 1180 | }; |
| 1181 | |
| 1182 | static struct msm_bus_scale_pdata crypto_hw_bus_scale_pdata = { |
| 1183 | crypto_hw_bus_scale_usecases, |
| 1184 | ARRAY_SIZE(crypto_hw_bus_scale_usecases), |
| 1185 | .name = "cryptohw", |
| 1186 | }; |
| 1187 | /* End Bus Scaling Definitions*/ |
| 1188 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1189 | static struct resource qcrypto_resources[] = { |
| 1190 | [0] = { |
| 1191 | .start = QCE_0_BASE, |
| 1192 | .end = QCE_0_BASE + QCE_SIZE - 1, |
| 1193 | .flags = IORESOURCE_MEM, |
| 1194 | }, |
| 1195 | [1] = { |
| 1196 | .name = "crypto_channels", |
| 1197 | .start = DMOV_CE_IN_CHAN, |
| 1198 | .end = DMOV_CE_OUT_CHAN, |
| 1199 | .flags = IORESOURCE_DMA, |
| 1200 | }, |
| 1201 | [2] = { |
| 1202 | .name = "crypto_crci_in", |
| 1203 | .start = DMOV_CE_IN_CRCI, |
| 1204 | .end = DMOV_CE_IN_CRCI, |
| 1205 | .flags = IORESOURCE_DMA, |
| 1206 | }, |
| 1207 | [3] = { |
| 1208 | .name = "crypto_crci_out", |
| 1209 | .start = DMOV_CE_OUT_CRCI, |
| 1210 | .end = DMOV_CE_OUT_CRCI, |
| 1211 | .flags = IORESOURCE_DMA, |
| 1212 | }, |
| 1213 | }; |
| 1214 | |
| 1215 | static struct resource qcedev_resources[] = { |
| 1216 | [0] = { |
| 1217 | .start = QCE_0_BASE, |
| 1218 | .end = QCE_0_BASE + QCE_SIZE - 1, |
| 1219 | .flags = IORESOURCE_MEM, |
| 1220 | }, |
| 1221 | [1] = { |
| 1222 | .name = "crypto_channels", |
| 1223 | .start = DMOV_CE_IN_CHAN, |
| 1224 | .end = DMOV_CE_OUT_CHAN, |
| 1225 | .flags = IORESOURCE_DMA, |
| 1226 | }, |
| 1227 | [2] = { |
| 1228 | .name = "crypto_crci_in", |
| 1229 | .start = DMOV_CE_IN_CRCI, |
| 1230 | .end = DMOV_CE_IN_CRCI, |
| 1231 | .flags = IORESOURCE_DMA, |
| 1232 | }, |
| 1233 | [3] = { |
| 1234 | .name = "crypto_crci_out", |
| 1235 | .start = DMOV_CE_OUT_CRCI, |
| 1236 | .end = DMOV_CE_OUT_CRCI, |
| 1237 | .flags = IORESOURCE_DMA, |
| 1238 | }, |
| 1239 | }; |
| 1240 | |
| 1241 | #endif |
| 1242 | |
| 1243 | #if defined(CONFIG_CRYPTO_DEV_QCRYPTO) || \ |
| 1244 | defined(CONFIG_CRYPTO_DEV_QCRYPTO_MODULE) |
| 1245 | |
| 1246 | static struct msm_ce_hw_support qcrypto_ce_hw_suppport = { |
| 1247 | .ce_shared = QCE_CE_SHARED, |
| 1248 | .shared_ce_resource = QCE_SHARE_CE_RESOURCE, |
| 1249 | .hw_key_support = QCE_HW_KEY_SUPPORT, |
| 1250 | .sha_hmac = QCE_SHA_HMAC_SUPPORT, |
Ramesh Masavarapu | 4925968 | 2011-12-02 14:00:18 -0800 | [diff] [blame] | 1251 | .bus_scale_table = &crypto_hw_bus_scale_pdata, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1252 | }; |
| 1253 | |
| 1254 | static struct platform_device qcrypto_device = { |
| 1255 | .name = "qcrypto", |
| 1256 | .id = 0, |
| 1257 | .num_resources = ARRAY_SIZE(qcrypto_resources), |
| 1258 | .resource = qcrypto_resources, |
| 1259 | .dev = { |
| 1260 | .coherent_dma_mask = DMA_BIT_MASK(32), |
| 1261 | .platform_data = &qcrypto_ce_hw_suppport, |
| 1262 | }, |
| 1263 | }; |
| 1264 | #endif |
| 1265 | |
| 1266 | #if defined(CONFIG_CRYPTO_DEV_QCEDEV) || \ |
| 1267 | defined(CONFIG_CRYPTO_DEV_QCEDEV_MODULE) |
| 1268 | |
| 1269 | static struct msm_ce_hw_support qcedev_ce_hw_suppport = { |
| 1270 | .ce_shared = QCE_CE_SHARED, |
| 1271 | .shared_ce_resource = QCE_SHARE_CE_RESOURCE, |
| 1272 | .hw_key_support = QCE_HW_KEY_SUPPORT, |
| 1273 | .sha_hmac = QCE_SHA_HMAC_SUPPORT, |
Ramesh Masavarapu | 4925968 | 2011-12-02 14:00:18 -0800 | [diff] [blame] | 1274 | .bus_scale_table = &crypto_hw_bus_scale_pdata, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1275 | }; |
| 1276 | |
| 1277 | static struct platform_device qcedev_device = { |
| 1278 | .name = "qce", |
| 1279 | .id = 0, |
| 1280 | .num_resources = ARRAY_SIZE(qcedev_resources), |
| 1281 | .resource = qcedev_resources, |
| 1282 | .dev = { |
| 1283 | .coherent_dma_mask = DMA_BIT_MASK(32), |
| 1284 | .platform_data = &qcedev_ce_hw_suppport, |
| 1285 | }, |
| 1286 | }; |
| 1287 | #endif |
| 1288 | |
Joel King | 0cbf5d8 | 2012-05-24 15:21:38 -0700 | [diff] [blame] | 1289 | static struct mdm_platform_data sglte_platform_data = { |
| 1290 | .mdm_version = "4.0", |
| 1291 | .ramdump_delay_ms = 1000, |
Joel King | 63ce833 | 2012-06-01 09:59:26 -0700 | [diff] [blame] | 1292 | .soft_reset_inverted = 1, |
Joel King | 0cbf5d8 | 2012-05-24 15:21:38 -0700 | [diff] [blame] | 1293 | .peripheral_platform_device = NULL, |
Ameya Thakur | c9a7a84 | 2012-06-24 22:47:52 -0700 | [diff] [blame] | 1294 | .ramdump_timeout_ms = 600000, |
Ameya Thakur | a98bde5 | 2012-06-28 18:55:19 -0700 | [diff] [blame] | 1295 | .no_powerdown_after_ramdumps = 1, |
Ameya Thakur | 43248fd | 2012-07-10 18:50:52 -0700 | [diff] [blame] | 1296 | .image_upgrade_supported = 1, |
Joel King | b8352a1 | 2011-11-15 18:46:24 -0800 | [diff] [blame] | 1297 | }; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1298 | |
Joel Nider | 266a264 | 2011-10-16 10:58:05 +0200 | [diff] [blame] | 1299 | #define MSM_TSIF0_PHYS (0x18200000) |
| 1300 | #define MSM_TSIF1_PHYS (0x18201000) |
| 1301 | #define MSM_TSIF_SIZE (0x200) |
| 1302 | #define MSM_TSPP_PHYS (0x18202000) |
| 1303 | #define MSM_TSPP_SIZE (0x1000) |
| 1304 | #define MSM_TSPP_BAM_PHYS (0x18204000) |
| 1305 | #define MSM_TSPP_BAM_SIZE (0x2000) |
| 1306 | |
| 1307 | #define TSIF_0_CLK GPIO_CFG(75, 1, GPIO_CFG_INPUT, \ |
| 1308 | GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA) |
| 1309 | #define TSIF_0_EN GPIO_CFG(76, 1, GPIO_CFG_INPUT, \ |
| 1310 | GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA) |
| 1311 | #define TSIF_0_DATA GPIO_CFG(77, 1, GPIO_CFG_INPUT, \ |
| 1312 | GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA) |
| 1313 | #define TSIF_0_SYNC GPIO_CFG(82, 1, GPIO_CFG_INPUT, \ |
| 1314 | GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA) |
| 1315 | #define TSIF_1_CLK GPIO_CFG(79, 1, GPIO_CFG_INPUT, \ |
| 1316 | GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA) |
| 1317 | #define TSIF_1_EN GPIO_CFG(80, 1, GPIO_CFG_INPUT, \ |
| 1318 | GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA) |
| 1319 | #define TSIF_1_DATA GPIO_CFG(81, 1, GPIO_CFG_INPUT, \ |
| 1320 | GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA) |
| 1321 | #define TSIF_1_SYNC GPIO_CFG(78, 1, GPIO_CFG_INPUT, \ |
| 1322 | GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA) |
| 1323 | |
| 1324 | static const struct msm_gpio tsif_gpios[] = { |
| 1325 | { .gpio_cfg = TSIF_0_CLK, .label = "tsif0_clk", }, |
| 1326 | { .gpio_cfg = TSIF_0_EN, .label = "tsif0_en", }, |
| 1327 | { .gpio_cfg = TSIF_0_DATA, .label = "tsif0_data", }, |
| 1328 | { .gpio_cfg = TSIF_0_SYNC, .label = "tsif0_sync", }, |
| 1329 | { .gpio_cfg = TSIF_1_CLK, .label = "tsif1_clk", }, |
| 1330 | { .gpio_cfg = TSIF_1_EN, .label = "tsif1_en", }, |
| 1331 | { .gpio_cfg = TSIF_1_DATA, .label = "tsif1_data", }, |
| 1332 | { .gpio_cfg = TSIF_1_SYNC, .label = "tsif1_sync", }, |
| 1333 | }; |
| 1334 | |
| 1335 | static struct resource tspp_resources[] = { |
| 1336 | [0] = { |
| 1337 | .flags = IORESOURCE_IRQ, |
| 1338 | .start = TSIF_TSPP_IRQ, |
| 1339 | .end = TSIF1_IRQ, |
| 1340 | }, |
| 1341 | [1] = { |
| 1342 | .flags = IORESOURCE_MEM, |
| 1343 | .start = MSM_TSIF0_PHYS, |
| 1344 | .end = MSM_TSIF0_PHYS + MSM_TSIF_SIZE - 1, |
| 1345 | }, |
| 1346 | [2] = { |
| 1347 | .flags = IORESOURCE_MEM, |
| 1348 | .start = MSM_TSIF1_PHYS, |
| 1349 | .end = MSM_TSIF1_PHYS + MSM_TSIF_SIZE - 1, |
| 1350 | }, |
| 1351 | [3] = { |
| 1352 | .flags = IORESOURCE_MEM, |
| 1353 | .start = MSM_TSPP_PHYS, |
| 1354 | .end = MSM_TSPP_PHYS + MSM_TSPP_SIZE - 1, |
| 1355 | }, |
| 1356 | [4] = { |
| 1357 | .flags = IORESOURCE_MEM, |
| 1358 | .start = MSM_TSPP_BAM_PHYS, |
| 1359 | .end = MSM_TSPP_BAM_PHYS + MSM_TSPP_BAM_SIZE - 1, |
| 1360 | }, |
| 1361 | }; |
| 1362 | |
| 1363 | static struct msm_tspp_platform_data tspp_platform_data = { |
| 1364 | .num_gpios = ARRAY_SIZE(tsif_gpios), |
| 1365 | .gpios = tsif_gpios, |
| 1366 | .tsif_pclk = "tsif_pclk", |
| 1367 | .tsif_ref_clk = "tsif_ref_clk", |
| 1368 | }; |
| 1369 | |
| 1370 | static struct platform_device msm_device_tspp = { |
| 1371 | .name = "msm_tspp", |
| 1372 | .id = 0, |
| 1373 | .num_resources = ARRAY_SIZE(tspp_resources), |
| 1374 | .resource = tspp_resources, |
| 1375 | .dev = { |
| 1376 | .platform_data = &tspp_platform_data |
| 1377 | }, |
| 1378 | }; |
| 1379 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1380 | #define MSM_SHARED_RAM_PHYS 0x80000000 |
| 1381 | |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 1382 | static void __init msm8960_map_io(void) |
| 1383 | { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1384 | msm_shared_ram_phys = MSM_SHARED_RAM_PHYS; |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 1385 | msm_map_msm8960_io(); |
Jeff Ohlstein | 3a77f9f | 2011-09-06 14:50:20 -0700 | [diff] [blame] | 1386 | |
| 1387 | if (socinfo_init() < 0) |
| 1388 | pr_err("socinfo_init() failed!\n"); |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 1389 | } |
| 1390 | |
| 1391 | static void __init msm8960_init_irq(void) |
| 1392 | { |
Praveen Chidambaram | 7849901 | 2011-11-01 17:15:17 -0600 | [diff] [blame] | 1393 | struct msm_mpm_device_data *data = NULL; |
| 1394 | |
| 1395 | #ifdef CONFIG_MSM_MPM |
| 1396 | data = &msm8960_mpm_dev_data; |
| 1397 | #endif |
| 1398 | |
| 1399 | msm_mpm_irq_extn_init(data); |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 1400 | gic_init(0, GIC_PPI_START, MSM_QGIC_DIST_BASE, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1401 | (void *)MSM_QGIC_CPU_BASE); |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 1402 | } |
| 1403 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1404 | static void __init msm8960_init_buses(void) |
| 1405 | { |
| 1406 | #ifdef CONFIG_MSM_BUS_SCALING |
Gagan Mac | dc1dc14 | 2011-09-16 15:13:35 -0600 | [diff] [blame] | 1407 | msm_bus_rpm_set_mt_mask(); |
Gagan Mac | ae154c4b | 2011-10-05 19:24:43 -0600 | [diff] [blame] | 1408 | msm_bus_8960_apps_fabric_pdata.rpm_enabled = 1; |
| 1409 | msm_bus_8960_sys_fabric_pdata.rpm_enabled = 1; |
| 1410 | msm_bus_8960_mm_fabric_pdata.rpm_enabled = 1; |
| 1411 | msm_bus_apps_fabric.dev.platform_data = |
| 1412 | &msm_bus_8960_apps_fabric_pdata; |
| 1413 | msm_bus_sys_fabric.dev.platform_data = &msm_bus_8960_sys_fabric_pdata; |
| 1414 | msm_bus_mm_fabric.dev.platform_data = &msm_bus_8960_mm_fabric_pdata; |
| 1415 | msm_bus_sys_fpb.dev.platform_data = &msm_bus_8960_sys_fpb_pdata; |
| 1416 | msm_bus_cpss_fpb.dev.platform_data = &msm_bus_8960_cpss_fpb_pdata; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1417 | #endif |
| 1418 | } |
| 1419 | |
| 1420 | static struct msm_spi_platform_data msm8960_qup_spi_gsbi1_pdata = { |
| 1421 | .max_clock_speed = 15060000, |
Kiran Gunda | e8f1674 | 2012-06-27 10:06:32 +0530 | [diff] [blame] | 1422 | .infinite_mode = 1 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1423 | }; |
| 1424 | |
| 1425 | #ifdef CONFIG_USB_MSM_OTG_72K |
| 1426 | static struct msm_otg_platform_data msm_otg_pdata; |
| 1427 | #else |
Anji jonnala | a8b8d73 | 2011-12-06 10:03:24 +0530 | [diff] [blame] | 1428 | static int wr_phy_init_seq[] = { |
| 1429 | 0x44, 0x80, /* set VBUS valid threshold |
| 1430 | and disconnect valid threshold */ |
| 1431 | 0x38, 0x81, /* update DC voltage level */ |
| 1432 | 0x14, 0x82, /* set preemphasis and rise/fall time */ |
| 1433 | 0x13, 0x83, /* set source impedance adjusment */ |
| 1434 | -1}; |
| 1435 | |
| 1436 | static int liquid_v1_phy_init_seq[] = { |
| 1437 | 0x44, 0x80,/* set VBUS valid threshold |
| 1438 | and disconnect valid threshold */ |
| 1439 | 0x3C, 0x81,/* update DC voltage level */ |
| 1440 | 0x18, 0x82,/* set preemphasis and rise/fall time */ |
| 1441 | 0x23, 0x83,/* set source impedance sdjusment */ |
| 1442 | -1}; |
| 1443 | |
Manu Gautam | cd82e9d | 2011-12-20 14:17:28 +0530 | [diff] [blame] | 1444 | #ifdef CONFIG_MSM_BUS_SCALING |
| 1445 | /* Bandwidth requests (zero) if no vote placed */ |
| 1446 | static struct msm_bus_vectors usb_init_vectors[] = { |
| 1447 | { |
| 1448 | .src = MSM_BUS_MASTER_SPS, |
| 1449 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1450 | .ab = 0, |
| 1451 | .ib = 0, |
| 1452 | }, |
| 1453 | }; |
| 1454 | |
| 1455 | /* Bus bandwidth requests in Bytes/sec */ |
| 1456 | static struct msm_bus_vectors usb_max_vectors[] = { |
| 1457 | { |
| 1458 | .src = MSM_BUS_MASTER_SPS, |
| 1459 | .dst = MSM_BUS_SLAVE_EBI_CH0, |
| 1460 | .ab = 60000000, /* At least 480Mbps on bus. */ |
| 1461 | .ib = 960000000, /* MAX bursts rate */ |
| 1462 | }, |
| 1463 | }; |
| 1464 | |
| 1465 | static struct msm_bus_paths usb_bus_scale_usecases[] = { |
| 1466 | { |
| 1467 | ARRAY_SIZE(usb_init_vectors), |
| 1468 | usb_init_vectors, |
| 1469 | }, |
| 1470 | { |
| 1471 | ARRAY_SIZE(usb_max_vectors), |
| 1472 | usb_max_vectors, |
| 1473 | }, |
| 1474 | }; |
| 1475 | |
| 1476 | static struct msm_bus_scale_pdata usb_bus_scale_pdata = { |
| 1477 | usb_bus_scale_usecases, |
| 1478 | ARRAY_SIZE(usb_bus_scale_usecases), |
| 1479 | .name = "usb", |
| 1480 | }; |
| 1481 | #endif |
| 1482 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1483 | static struct msm_otg_platform_data msm_otg_pdata = { |
| 1484 | .mode = USB_OTG, |
| 1485 | .otg_control = OTG_PMIC_CONTROL, |
| 1486 | .phy_type = SNPS_28NM_INTEGRATED_PHY, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1487 | .pmic_id_irq = PM8921_USB_ID_IN_IRQ(PM8921_IRQ_BASE), |
Anji jonnala | 4e3e677 | 2011-09-15 18:53:42 +0530 | [diff] [blame] | 1488 | .power_budget = 750, |
Manu Gautam | cd82e9d | 2011-12-20 14:17:28 +0530 | [diff] [blame] | 1489 | #ifdef CONFIG_MSM_BUS_SCALING |
| 1490 | .bus_scale_table = &usb_bus_scale_pdata, |
| 1491 | #endif |
Pavankumar Kondeti | 2aec9f3 | 2012-06-13 09:06:03 +0530 | [diff] [blame] | 1492 | #ifdef CONFIG_FB_MSM_HDMI_MHL_8334 |
| 1493 | .mhl_dev_name = "sii8334", |
| 1494 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1495 | }; |
| 1496 | #endif |
| 1497 | |
Vijayavardhan Vennapusa | e3316a1 | 2011-10-15 06:05:17 +0530 | [diff] [blame] | 1498 | #ifdef CONFIG_USB_EHCI_MSM_HSIC |
Vijayavardhan Vennapusa | 2b592824f | 2011-11-02 19:51:32 +0530 | [diff] [blame] | 1499 | #define HSIC_HUB_RESET_GPIO 91 |
Vijayavardhan Vennapusa | e3316a1 | 2011-10-15 06:05:17 +0530 | [diff] [blame] | 1500 | static struct msm_hsic_host_platform_data msm_hsic_pdata = { |
| 1501 | .strobe = 150, |
| 1502 | .data = 151, |
| 1503 | }; |
Vijayavardhan Vennapusa | afbbb8f | 2012-04-13 16:28:45 +0530 | [diff] [blame] | 1504 | |
| 1505 | static struct smsc_hub_platform_data hsic_hub_pdata = { |
| 1506 | .hub_reset = HSIC_HUB_RESET_GPIO, |
| 1507 | }; |
Vijayavardhan Vennapusa | e3316a1 | 2011-10-15 06:05:17 +0530 | [diff] [blame] | 1508 | #else |
| 1509 | static struct msm_hsic_host_platform_data msm_hsic_pdata; |
Vijayavardhan Vennapusa | afbbb8f | 2012-04-13 16:28:45 +0530 | [diff] [blame] | 1510 | static struct smsc_hub_platform_data hsic_hub_pdata; |
Vijayavardhan Vennapusa | e3316a1 | 2011-10-15 06:05:17 +0530 | [diff] [blame] | 1511 | #endif |
| 1512 | |
Vijayavardhan Vennapusa | afbbb8f | 2012-04-13 16:28:45 +0530 | [diff] [blame] | 1513 | static struct platform_device smsc_hub_device = { |
| 1514 | .name = "msm_smsc_hub", |
| 1515 | .id = -1, |
| 1516 | .dev = { |
| 1517 | .platform_data = &hsic_hub_pdata, |
| 1518 | }, |
| 1519 | }; |
| 1520 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1521 | #define PID_MAGIC_ID 0x71432909 |
| 1522 | #define SERIAL_NUM_MAGIC_ID 0x61945374 |
| 1523 | #define SERIAL_NUMBER_LENGTH 127 |
| 1524 | #define DLOAD_USB_BASE_ADD 0x2A03F0C8 |
| 1525 | |
| 1526 | struct magic_num_struct { |
| 1527 | uint32_t pid; |
| 1528 | uint32_t serial_num; |
| 1529 | }; |
| 1530 | |
| 1531 | struct dload_struct { |
| 1532 | uint32_t reserved1; |
| 1533 | uint32_t reserved2; |
| 1534 | uint32_t reserved3; |
| 1535 | uint16_t reserved4; |
| 1536 | uint16_t pid; |
| 1537 | char serial_number[SERIAL_NUMBER_LENGTH]; |
| 1538 | uint16_t reserved5; |
| 1539 | struct magic_num_struct magic_struct; |
| 1540 | }; |
| 1541 | |
| 1542 | static int usb_diag_update_pid_and_serial_num(uint32_t pid, const char *snum) |
| 1543 | { |
| 1544 | struct dload_struct __iomem *dload = 0; |
| 1545 | |
| 1546 | dload = ioremap(DLOAD_USB_BASE_ADD, sizeof(*dload)); |
| 1547 | if (!dload) { |
| 1548 | pr_err("%s: cannot remap I/O memory region: %08x\n", |
| 1549 | __func__, DLOAD_USB_BASE_ADD); |
| 1550 | return -ENXIO; |
| 1551 | } |
| 1552 | |
| 1553 | pr_debug("%s: dload:%p pid:%x serial_num:%s\n", |
| 1554 | __func__, dload, pid, snum); |
| 1555 | /* update pid */ |
| 1556 | dload->magic_struct.pid = PID_MAGIC_ID; |
| 1557 | dload->pid = pid; |
| 1558 | |
| 1559 | /* update serial number */ |
| 1560 | dload->magic_struct.serial_num = 0; |
| 1561 | if (!snum) { |
| 1562 | memset(dload->serial_number, 0, SERIAL_NUMBER_LENGTH); |
| 1563 | goto out; |
| 1564 | } |
| 1565 | |
| 1566 | dload->magic_struct.serial_num = SERIAL_NUM_MAGIC_ID; |
Jin Hong | e49b148 | 2011-10-03 11:15:50 -0700 | [diff] [blame] | 1567 | strlcpy(dload->serial_number, snum, SERIAL_NUMBER_LENGTH); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1568 | out: |
| 1569 | iounmap(dload); |
| 1570 | return 0; |
| 1571 | } |
| 1572 | |
| 1573 | static struct android_usb_platform_data android_usb_pdata = { |
| 1574 | .update_pid_and_serial_num = usb_diag_update_pid_and_serial_num, |
| 1575 | }; |
| 1576 | |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 1577 | static struct platform_device android_usb_device = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1578 | .name = "android_usb", |
| 1579 | .id = -1, |
| 1580 | .dev = { |
| 1581 | .platform_data = &android_usb_pdata, |
| 1582 | }, |
| 1583 | }; |
| 1584 | |
| 1585 | static uint8_t spm_wfi_cmd_sequence[] __initdata = { |
| 1586 | 0x03, 0x0f, |
| 1587 | }; |
| 1588 | |
| 1589 | static uint8_t spm_power_collapse_without_rpm[] __initdata = { |
| 1590 | 0x00, 0x24, 0x54, 0x10, |
| 1591 | 0x09, 0x03, 0x01, |
| 1592 | 0x10, 0x54, 0x30, 0x0C, |
| 1593 | 0x24, 0x30, 0x0f, |
| 1594 | }; |
| 1595 | |
| 1596 | static uint8_t spm_power_collapse_with_rpm[] __initdata = { |
| 1597 | 0x00, 0x24, 0x54, 0x10, |
| 1598 | 0x09, 0x07, 0x01, 0x0B, |
| 1599 | 0x10, 0x54, 0x30, 0x0C, |
| 1600 | 0x24, 0x30, 0x0f, |
| 1601 | }; |
| 1602 | |
| 1603 | static struct msm_spm_seq_entry msm_spm_seq_list[] __initdata = { |
| 1604 | [0] = { |
| 1605 | .mode = MSM_SPM_MODE_CLOCK_GATING, |
| 1606 | .notify_rpm = false, |
| 1607 | .cmd = spm_wfi_cmd_sequence, |
| 1608 | }, |
| 1609 | [1] = { |
| 1610 | .mode = MSM_SPM_MODE_POWER_COLLAPSE, |
| 1611 | .notify_rpm = false, |
| 1612 | .cmd = spm_power_collapse_without_rpm, |
| 1613 | }, |
| 1614 | [2] = { |
| 1615 | .mode = MSM_SPM_MODE_POWER_COLLAPSE, |
| 1616 | .notify_rpm = true, |
| 1617 | .cmd = spm_power_collapse_with_rpm, |
| 1618 | }, |
| 1619 | }; |
| 1620 | |
| 1621 | static struct msm_spm_platform_data msm_spm_data[] __initdata = { |
| 1622 | [0] = { |
| 1623 | .reg_base_addr = MSM_SAW0_BASE, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1624 | .reg_init_values[MSM_SPM_REG_SAW2_CFG] = 0x1F, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1625 | #if defined(CONFIG_MSM_AVS_HW) |
| 1626 | .reg_init_values[MSM_SPM_REG_SAW2_AVS_CTL] = 0x00, |
| 1627 | .reg_init_values[MSM_SPM_REG_SAW2_AVS_HYSTERESIS] = 0x00, |
| 1628 | #endif |
| 1629 | .reg_init_values[MSM_SPM_REG_SAW2_SPM_CTL] = 0x01, |
Praveen Chidambaram | e4b9eb1 | 2012-02-28 19:39:58 -0700 | [diff] [blame] | 1630 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DLY] = 0x02020204, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1631 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_0] = 0x0060009C, |
| 1632 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_1] = 0x0000001C, |
| 1633 | .vctl_timeout_us = 50, |
| 1634 | .num_modes = ARRAY_SIZE(msm_spm_seq_list), |
| 1635 | .modes = msm_spm_seq_list, |
| 1636 | }, |
| 1637 | [1] = { |
| 1638 | .reg_base_addr = MSM_SAW1_BASE, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1639 | .reg_init_values[MSM_SPM_REG_SAW2_CFG] = 0x1F, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1640 | #if defined(CONFIG_MSM_AVS_HW) |
| 1641 | .reg_init_values[MSM_SPM_REG_SAW2_AVS_CTL] = 0x00, |
| 1642 | .reg_init_values[MSM_SPM_REG_SAW2_AVS_HYSTERESIS] = 0x00, |
| 1643 | #endif |
| 1644 | .reg_init_values[MSM_SPM_REG_SAW2_SPM_CTL] = 0x01, |
Praveen Chidambaram | e4b9eb1 | 2012-02-28 19:39:58 -0700 | [diff] [blame] | 1645 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DLY] = 0x02020204, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1646 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_0] = 0x0060009C, |
| 1647 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_1] = 0x0000001C, |
| 1648 | .vctl_timeout_us = 50, |
| 1649 | .num_modes = ARRAY_SIZE(msm_spm_seq_list), |
| 1650 | .modes = msm_spm_seq_list, |
| 1651 | }, |
| 1652 | }; |
| 1653 | |
| 1654 | static uint8_t l2_spm_wfi_cmd_sequence[] __initdata = { |
| 1655 | 0x00, 0x20, 0x03, 0x20, |
| 1656 | 0x00, 0x0f, |
| 1657 | }; |
| 1658 | |
| 1659 | static uint8_t l2_spm_gdhs_cmd_sequence[] __initdata = { |
| 1660 | 0x00, 0x20, 0x34, 0x64, |
| 1661 | 0x48, 0x07, 0x48, 0x20, |
| 1662 | 0x50, 0x64, 0x04, 0x34, |
| 1663 | 0x50, 0x0f, |
| 1664 | }; |
| 1665 | static uint8_t l2_spm_power_off_cmd_sequence[] __initdata = { |
| 1666 | 0x00, 0x10, 0x34, 0x64, |
| 1667 | 0x48, 0x07, 0x48, 0x10, |
| 1668 | 0x50, 0x64, 0x04, 0x34, |
| 1669 | 0x50, 0x0F, |
| 1670 | }; |
| 1671 | |
| 1672 | static struct msm_spm_seq_entry msm_spm_l2_seq_list[] __initdata = { |
| 1673 | [0] = { |
| 1674 | .mode = MSM_SPM_L2_MODE_RETENTION, |
| 1675 | .notify_rpm = false, |
| 1676 | .cmd = l2_spm_wfi_cmd_sequence, |
| 1677 | }, |
| 1678 | [1] = { |
| 1679 | .mode = MSM_SPM_L2_MODE_GDHS, |
| 1680 | .notify_rpm = true, |
| 1681 | .cmd = l2_spm_gdhs_cmd_sequence, |
| 1682 | }, |
| 1683 | [2] = { |
| 1684 | .mode = MSM_SPM_L2_MODE_POWER_COLLAPSE, |
| 1685 | .notify_rpm = true, |
| 1686 | .cmd = l2_spm_power_off_cmd_sequence, |
| 1687 | }, |
| 1688 | }; |
| 1689 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1690 | static struct msm_spm_platform_data msm_spm_l2_data[] __initdata = { |
| 1691 | [0] = { |
| 1692 | .reg_base_addr = MSM_SAW_L2_BASE, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1693 | .reg_init_values[MSM_SPM_REG_SAW2_SPM_CTL] = 0x00, |
Praveen Chidambaram | e4b9eb1 | 2012-02-28 19:39:58 -0700 | [diff] [blame] | 1694 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DLY] = 0x02020204, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1695 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_0] = 0x00A000AE, |
| 1696 | .reg_init_values[MSM_SPM_REG_SAW2_PMIC_DATA_1] = 0x00A00020, |
| 1697 | .modes = msm_spm_l2_seq_list, |
| 1698 | .num_modes = ARRAY_SIZE(msm_spm_l2_seq_list), |
| 1699 | }, |
| 1700 | }; |
| 1701 | |
Mohan Pallaka | 5e49039 | 2011-09-09 15:18:41 +0530 | [diff] [blame] | 1702 | #define PM_HAP_EN_GPIO PM8921_GPIO_PM_TO_SYS(33) |
| 1703 | #define PM_HAP_LEN_GPIO PM8921_GPIO_PM_TO_SYS(20) |
| 1704 | |
| 1705 | static struct msm_xo_voter *xo_handle_d1; |
| 1706 | |
| 1707 | static int isa1200_power(int on) |
| 1708 | { |
| 1709 | int rc = 0; |
| 1710 | |
| 1711 | gpio_set_value(HAP_SHIFT_LVL_OE_GPIO, !!on); |
| 1712 | |
| 1713 | rc = on ? msm_xo_mode_vote(xo_handle_d1, MSM_XO_MODE_ON) : |
| 1714 | msm_xo_mode_vote(xo_handle_d1, MSM_XO_MODE_OFF); |
| 1715 | if (rc < 0) { |
| 1716 | pr_err("%s: failed to %svote for TCXO D1 buffer%d\n", |
| 1717 | __func__, on ? "" : "de-", rc); |
| 1718 | goto err_xo_vote; |
| 1719 | } |
| 1720 | |
| 1721 | return 0; |
| 1722 | |
| 1723 | err_xo_vote: |
| 1724 | gpio_set_value(HAP_SHIFT_LVL_OE_GPIO, !on); |
| 1725 | return rc; |
| 1726 | } |
| 1727 | |
| 1728 | static int isa1200_dev_setup(bool enable) |
| 1729 | { |
| 1730 | int rc = 0; |
| 1731 | |
| 1732 | struct pm_gpio hap_gpio_config = { |
| 1733 | .direction = PM_GPIO_DIR_OUT, |
| 1734 | .pull = PM_GPIO_PULL_NO, |
| 1735 | .out_strength = PM_GPIO_STRENGTH_HIGH, |
| 1736 | .function = PM_GPIO_FUNC_NORMAL, |
| 1737 | .inv_int_pol = 0, |
| 1738 | .vin_sel = 2, |
| 1739 | .output_buffer = PM_GPIO_OUT_BUF_CMOS, |
| 1740 | .output_value = 0, |
| 1741 | }; |
| 1742 | |
| 1743 | if (enable == true) { |
| 1744 | rc = pm8xxx_gpio_config(PM_HAP_EN_GPIO, &hap_gpio_config); |
| 1745 | if (rc) { |
| 1746 | pr_err("%s: pm8921 gpio %d config failed(%d)\n", |
| 1747 | __func__, PM_HAP_EN_GPIO, rc); |
| 1748 | return rc; |
| 1749 | } |
| 1750 | |
| 1751 | rc = pm8xxx_gpio_config(PM_HAP_LEN_GPIO, &hap_gpio_config); |
| 1752 | if (rc) { |
| 1753 | pr_err("%s: pm8921 gpio %d config failed(%d)\n", |
| 1754 | __func__, PM_HAP_LEN_GPIO, rc); |
| 1755 | return rc; |
| 1756 | } |
| 1757 | |
| 1758 | rc = gpio_request(HAP_SHIFT_LVL_OE_GPIO, "hap_shft_lvl_oe"); |
| 1759 | if (rc) { |
| 1760 | pr_err("%s: unable to request gpio %d (%d)\n", |
| 1761 | __func__, HAP_SHIFT_LVL_OE_GPIO, rc); |
| 1762 | return rc; |
| 1763 | } |
| 1764 | |
| 1765 | rc = gpio_direction_output(HAP_SHIFT_LVL_OE_GPIO, 0); |
| 1766 | if (rc) { |
| 1767 | pr_err("%s: Unable to set direction\n", __func__); |
| 1768 | goto free_gpio; |
| 1769 | } |
| 1770 | |
| 1771 | xo_handle_d1 = msm_xo_get(MSM_XO_TCXO_D1, "isa1200"); |
| 1772 | if (IS_ERR(xo_handle_d1)) { |
| 1773 | rc = PTR_ERR(xo_handle_d1); |
| 1774 | pr_err("%s: failed to get the handle for D1(%d)\n", |
| 1775 | __func__, rc); |
| 1776 | goto gpio_set_dir; |
| 1777 | } |
| 1778 | } else { |
| 1779 | gpio_free(HAP_SHIFT_LVL_OE_GPIO); |
| 1780 | |
| 1781 | msm_xo_put(xo_handle_d1); |
| 1782 | } |
| 1783 | |
| 1784 | return 0; |
| 1785 | |
| 1786 | gpio_set_dir: |
| 1787 | gpio_set_value(HAP_SHIFT_LVL_OE_GPIO, 0); |
| 1788 | free_gpio: |
| 1789 | gpio_free(HAP_SHIFT_LVL_OE_GPIO); |
| 1790 | return rc; |
| 1791 | } |
| 1792 | |
| 1793 | static struct isa1200_regulator isa1200_reg_data[] = { |
| 1794 | { |
| 1795 | .name = "vcc_i2c", |
| 1796 | .min_uV = ISA_I2C_VTG_MIN_UV, |
| 1797 | .max_uV = ISA_I2C_VTG_MAX_UV, |
| 1798 | .load_uA = ISA_I2C_CURR_UA, |
| 1799 | }, |
| 1800 | }; |
| 1801 | |
| 1802 | static struct isa1200_platform_data isa1200_1_pdata = { |
| 1803 | .name = "vibrator", |
| 1804 | .dev_setup = isa1200_dev_setup, |
| 1805 | .power_on = isa1200_power, |
| 1806 | .hap_en_gpio = PM_HAP_EN_GPIO, |
| 1807 | .hap_len_gpio = PM_HAP_LEN_GPIO, |
| 1808 | .max_timeout = 15000, |
| 1809 | .mode_ctrl = PWM_GEN_MODE, |
| 1810 | .pwm_fd = { |
| 1811 | .pwm_div = 256, |
| 1812 | }, |
| 1813 | .is_erm = false, |
| 1814 | .smart_en = true, |
| 1815 | .ext_clk_en = true, |
| 1816 | .chip_en = 1, |
| 1817 | .regulator_info = isa1200_reg_data, |
| 1818 | .num_regulators = ARRAY_SIZE(isa1200_reg_data), |
| 1819 | }; |
| 1820 | |
| 1821 | static struct i2c_board_info msm_isa1200_board_info[] __initdata = { |
| 1822 | { |
| 1823 | I2C_BOARD_INFO("isa1200_1", 0x90>>1), |
Mohan Pallaka | 5e49039 | 2011-09-09 15:18:41 +0530 | [diff] [blame] | 1824 | }, |
| 1825 | }; |
| 1826 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1827 | #define CYTTSP_TS_GPIO_IRQ 11 |
| 1828 | #define CYTTSP_TS_SLEEP_GPIO 50 |
| 1829 | #define CYTTSP_TS_RESOUT_N_GPIO 52 |
| 1830 | |
| 1831 | /*virtual key support */ |
| 1832 | static ssize_t tma340_vkeys_show(struct kobject *kobj, |
| 1833 | struct kobj_attribute *attr, char *buf) |
| 1834 | { |
| 1835 | return snprintf(buf, 200, |
| 1836 | __stringify(EV_KEY) ":" __stringify(KEY_BACK) ":73:1120:97:97" |
| 1837 | ":" __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":230:1120:97:97" |
| 1838 | ":" __stringify(EV_KEY) ":" __stringify(KEY_HOME) ":389:1120:97:97" |
| 1839 | ":" __stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":544:1120:97:97" |
| 1840 | "\n"); |
| 1841 | } |
| 1842 | |
| 1843 | static struct kobj_attribute tma340_vkeys_attr = { |
| 1844 | .attr = { |
| 1845 | .mode = S_IRUGO, |
| 1846 | }, |
| 1847 | .show = &tma340_vkeys_show, |
| 1848 | }; |
| 1849 | |
| 1850 | static struct attribute *tma340_properties_attrs[] = { |
| 1851 | &tma340_vkeys_attr.attr, |
| 1852 | NULL |
| 1853 | }; |
| 1854 | |
| 1855 | static struct attribute_group tma340_properties_attr_group = { |
| 1856 | .attrs = tma340_properties_attrs, |
| 1857 | }; |
| 1858 | |
| 1859 | |
| 1860 | static int cyttsp_platform_init(struct i2c_client *client) |
| 1861 | { |
| 1862 | int rc = 0; |
| 1863 | static struct kobject *tma340_properties_kobj; |
| 1864 | |
| 1865 | tma340_vkeys_attr.attr.name = "virtualkeys.cyttsp-i2c"; |
| 1866 | tma340_properties_kobj = kobject_create_and_add("board_properties", |
| 1867 | NULL); |
| 1868 | if (tma340_properties_kobj) |
| 1869 | rc = sysfs_create_group(tma340_properties_kobj, |
| 1870 | &tma340_properties_attr_group); |
| 1871 | if (!tma340_properties_kobj || rc) |
| 1872 | pr_err("%s: failed to create board_properties\n", |
| 1873 | __func__); |
| 1874 | |
| 1875 | return 0; |
| 1876 | } |
| 1877 | |
| 1878 | static struct cyttsp_regulator regulator_data[] = { |
| 1879 | { |
| 1880 | .name = "vdd", |
| 1881 | .min_uV = CY_TMA300_VTG_MIN_UV, |
| 1882 | .max_uV = CY_TMA300_VTG_MAX_UV, |
Anirudh Ghayal | f9929b1 | 2011-09-07 15:57:36 +0530 | [diff] [blame] | 1883 | .hpm_load_uA = CY_TMA300_CURR_24HZ_UA, |
| 1884 | .lpm_load_uA = CY_TMA300_SLEEP_CURR_UA, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1885 | }, |
| 1886 | /* TODO: Remove after runtime PM is enabled in I2C driver */ |
| 1887 | { |
| 1888 | .name = "vcc_i2c", |
| 1889 | .min_uV = CY_I2C_VTG_MIN_UV, |
| 1890 | .max_uV = CY_I2C_VTG_MAX_UV, |
Anirudh Ghayal | f9929b1 | 2011-09-07 15:57:36 +0530 | [diff] [blame] | 1891 | .hpm_load_uA = CY_I2C_CURR_UA, |
| 1892 | .lpm_load_uA = CY_I2C_SLEEP_CURR_UA, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1893 | }, |
| 1894 | }; |
| 1895 | |
| 1896 | static struct cyttsp_platform_data cyttsp_pdata = { |
| 1897 | .panel_maxx = 634, |
| 1898 | .panel_maxy = 1166, |
| 1899 | .disp_maxx = 616, |
| 1900 | .disp_maxy = 1023, |
| 1901 | .disp_minx = 0, |
| 1902 | .disp_miny = 16, |
| 1903 | .flags = 0x01, |
| 1904 | .gen = CY_GEN3, /* or */ |
| 1905 | .use_st = CY_USE_ST, |
| 1906 | .use_mt = CY_USE_MT, |
| 1907 | .use_hndshk = CY_SEND_HNDSHK, |
| 1908 | .use_trk_id = CY_USE_TRACKING_ID, |
Anirudh Ghayal | e96f66d | 2011-08-11 14:06:38 +0530 | [diff] [blame] | 1909 | .use_sleep = CY_USE_DEEP_SLEEP_SEL | CY_USE_LOW_POWER_SEL, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1910 | .use_gestures = CY_USE_GESTURES, |
| 1911 | .fw_fname = "cyttsp_8960_cdp.hex", |
| 1912 | /* activate up to 4 groups |
| 1913 | * and set active distance |
| 1914 | */ |
| 1915 | .gest_set = CY_GEST_GRP1 | CY_GEST_GRP2 | |
| 1916 | CY_GEST_GRP3 | CY_GEST_GRP4 | |
| 1917 | CY_ACT_DIST, |
Amy Maloche | 7b741b2 | 2012-06-14 14:37:22 -0700 | [diff] [blame] | 1918 | .act_intrvl = 10, |
| 1919 | .tch_tmout = 200, |
| 1920 | .lp_intrvl = 30, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1921 | .sleep_gpio = CYTTSP_TS_SLEEP_GPIO, |
| 1922 | .resout_gpio = CYTTSP_TS_RESOUT_N_GPIO, |
| 1923 | .irq_gpio = CYTTSP_TS_GPIO_IRQ, |
| 1924 | .regulator_info = regulator_data, |
| 1925 | .num_regulators = ARRAY_SIZE(regulator_data), |
| 1926 | .init = cyttsp_platform_init, |
Mohan Pallaka | 49c37d6 | 2011-08-01 11:52:00 +0530 | [diff] [blame] | 1927 | .correct_fw_ver = 9, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1928 | }; |
| 1929 | |
| 1930 | static struct i2c_board_info cyttsp_info[] __initdata = { |
| 1931 | { |
| 1932 | I2C_BOARD_INFO(CY_I2C_NAME, 0x24), |
| 1933 | .platform_data = &cyttsp_pdata, |
| 1934 | #ifndef CY_USE_TIMER |
| 1935 | .irq = MSM_GPIO_TO_INT(CYTTSP_TS_GPIO_IRQ), |
| 1936 | #endif /* CY_USE_TIMER */ |
| 1937 | }, |
| 1938 | }; |
| 1939 | |
Jing Lin | dc4413c | 2012-01-16 15:22:52 -0800 | [diff] [blame] | 1940 | /* configuration data for mxt1386 */ |
| 1941 | static const u8 mxt1386_config_data[] = { |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1942 | /* T6 Object */ |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1943 | 0, 0, 0, 0, 0, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1944 | /* T38 Object */ |
Jing Lin | 93f0708 | 2011-11-11 15:53:54 -0800 | [diff] [blame] | 1945 | 11, 2, 0, 11, 11, 11, 0, 0, 0, 0, |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1946 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1947 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1948 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1949 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1950 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1951 | 0, 0, 0, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1952 | /* T7 Object */ |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1953 | 100, 16, 50, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1954 | /* T8 Object */ |
Jing Lin | 93f0708 | 2011-11-11 15:53:54 -0800 | [diff] [blame] | 1955 | 8, 0, 0, 0, 0, 0, 8, 14, 50, 215, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1956 | /* T9 Object */ |
Jing Lin | 93f0708 | 2011-11-11 15:53:54 -0800 | [diff] [blame] | 1957 | 131, 0, 0, 26, 42, 0, 32, 63, 3, 5, |
| 1958 | 0, 2, 1, 113, 10, 10, 8, 10, 255, 2, |
| 1959 | 85, 5, 0, 0, 20, 20, 75, 25, 202, 29, |
| 1960 | 10, 10, 45, 46, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1961 | /* T15 Object */ |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1962 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1963 | 0, |
Anirudh Ghayal | dab4e0d | 2012-01-09 14:59:27 +0530 | [diff] [blame] | 1964 | /* T18 Object */ |
| 1965 | 0, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1966 | /* T22 Object */ |
Jing Lin | 93f0708 | 2011-11-11 15:53:54 -0800 | [diff] [blame] | 1967 | 5, 0, 0, 0, 0, 0, 0, 0, 30, 0, |
| 1968 | 0, 0, 5, 8, 10, 13, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1969 | /* T24 Object */ |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1970 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1971 | 0, 0, 0, 0, 0, 0, 0, 0, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1972 | /* T25 Object */ |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1973 | 3, 0, 188, 52, 52, 33, 0, 0, 0, 0, |
| 1974 | 0, 0, 0, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1975 | /* T27 Object */ |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1976 | 0, 0, 0, 0, 0, 0, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1977 | /* T28 Object */ |
Jing Lin | 93f0708 | 2011-11-11 15:53:54 -0800 | [diff] [blame] | 1978 | 0, 0, 0, 8, 12, 60, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1979 | /* T40 Object */ |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1980 | 0, 0, 0, 0, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1981 | /* T41 Object */ |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1982 | 0, 0, 0, 0, 0, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1983 | /* T43 Object */ |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 1984 | 0, 0, 0, 0, 0, 0, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 1985 | }; |
| 1986 | |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 1987 | /* configuration data for mxt1386e using V1.0 firmware */ |
| 1988 | static const u8 mxt1386e_config_data_v1_0[] = { |
| 1989 | /* T6 Object */ |
| 1990 | 0, 0, 0, 0, 0, 0, |
| 1991 | /* T38 Object */ |
| 1992 | 12, 1, 0, 17, 1, 12, 0, 0, 0, 0, |
| 1993 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1994 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1995 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1996 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1997 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 1998 | 0, 0, 0, 0, |
| 1999 | /* T7 Object */ |
| 2000 | 100, 16, 50, |
| 2001 | /* T8 Object */ |
| 2002 | 25, 0, 20, 20, 0, 0, 20, 50, 0, 0, |
| 2003 | /* T9 Object */ |
| 2004 | 131, 0, 0, 26, 42, 0, 32, 80, 2, 5, |
| 2005 | 0, 5, 5, 0, 10, 30, 10, 10, 255, 2, |
| 2006 | 85, 5, 10, 10, 10, 10, 135, 55, 70, 40, |
| 2007 | 10, 5, 0, 0, 0, |
| 2008 | /* T18 Object */ |
| 2009 | 0, 0, |
| 2010 | /* T24 Object */ |
| 2011 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2012 | 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2013 | /* T25 Object */ |
| 2014 | 3, 0, 60, 115, 156, 99, |
| 2015 | /* T27 Object */ |
| 2016 | 0, 0, 0, 0, 0, 0, 0, |
| 2017 | /* T40 Object */ |
| 2018 | 0, 0, 0, 0, 0, |
| 2019 | /* T42 Object */ |
| 2020 | 2, 0, 255, 0, 255, 0, 0, 0, 0, 0, |
| 2021 | /* T43 Object */ |
| 2022 | 0, 0, 0, 0, 0, 0, 0, |
| 2023 | /* T46 Object */ |
| 2024 | 64, 0, 20, 20, 0, 0, 0, 0, 0, |
| 2025 | /* T47 Object */ |
| 2026 | 0, 0, 0, 0, 0, 0, 3, 64, 66, 0, |
| 2027 | /* T48 Object */ |
| 2028 | 31, 64, 64, 0, 0, 0, 0, 0, 0, 0, |
| 2029 | 48, 40, 0, 10, 10, 0, 0, 100, 10, 80, |
| 2030 | 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, |
| 2031 | 52, 0, 12, 0, 17, 0, 1, 0, 0, 0, |
| 2032 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2033 | 0, 0, 0, 0, |
| 2034 | /* T56 Object */ |
| 2035 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2036 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2037 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2038 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2039 | 2, 99, 33, |
| 2040 | }; |
| 2041 | |
| 2042 | /* configuration data for mxt1386e using V2.1 firmware */ |
| 2043 | static const u8 mxt1386e_config_data_v2_1[] = { |
| 2044 | /* T6 Object */ |
| 2045 | 0, 0, 0, 0, 0, 0, |
| 2046 | /* T38 Object */ |
Jing Lin | a0bc410 | 2012-07-06 17:03:45 -0700 | [diff] [blame] | 2047 | 12, 4, 0, 5, 7, 12, 0, 0, 0, 0, |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 2048 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2049 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2050 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2051 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2052 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2053 | 0, 0, 0, 0, |
| 2054 | /* T7 Object */ |
| 2055 | 100, 16, 50, |
| 2056 | /* T8 Object */ |
| 2057 | 25, 0, 20, 20, 0, 0, 20, 50, 0, 0, |
| 2058 | /* T9 Object */ |
Jing Lin | 763f477 | 2012-05-25 13:39:40 -0700 | [diff] [blame] | 2059 | 139, 0, 0, 26, 42, 0, 32, 80, 2, 5, |
Jing Lin | a0bc410 | 2012-07-06 17:03:45 -0700 | [diff] [blame] | 2060 | 0, 5, 5, 79, 10, 30, 10, 10, 255, 2, |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 2061 | 85, 5, 10, 10, 10, 10, 135, 55, 70, 40, |
| 2062 | 10, 5, 0, 0, 0, |
| 2063 | /* T18 Object */ |
| 2064 | 0, 0, |
| 2065 | /* T24 Object */ |
| 2066 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2067 | 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2068 | /* T25 Object */ |
Jing Lin | 763f477 | 2012-05-25 13:39:40 -0700 | [diff] [blame] | 2069 | 1, 0, 60, 115, 156, 99, |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 2070 | /* T27 Object */ |
| 2071 | 0, 0, 0, 0, 0, 0, 0, |
| 2072 | /* T40 Object */ |
| 2073 | 0, 0, 0, 0, 0, |
| 2074 | /* T42 Object */ |
Jing Lin | 763f477 | 2012-05-25 13:39:40 -0700 | [diff] [blame] | 2075 | 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 2076 | /* T43 Object */ |
| 2077 | 0, 0, 0, 0, 0, 0, 0, 64, 0, 8, |
| 2078 | 16, |
| 2079 | /* T46 Object */ |
Jing Lin | a0bc410 | 2012-07-06 17:03:45 -0700 | [diff] [blame] | 2080 | 64, 0, 16, 16, 0, 0, 0, 0, 0, |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 2081 | /* T47 Object */ |
| 2082 | 0, 0, 0, 0, 0, 0, 3, 64, 66, 0, |
| 2083 | /* T48 Object */ |
Jing Lin | 763f477 | 2012-05-25 13:39:40 -0700 | [diff] [blame] | 2084 | 1, 64, 64, 0, 0, 0, 0, 0, 0, 0, |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 2085 | 48, 40, 0, 10, 10, 0, 0, 100, 10, 80, |
| 2086 | 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, |
| 2087 | 52, 0, 12, 0, 17, 0, 1, 0, 0, 0, |
| 2088 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2089 | 0, 0, 0, 0, |
| 2090 | /* T56 Object */ |
| 2091 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2092 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2093 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2094 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2095 | 2, 99, 33, 0, 149, 24, 193, 255, 255, 255, |
| 2096 | 255, |
| 2097 | }; |
| 2098 | |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2099 | /* configuration data for mxt1386e on 3D SKU using V2.1 firmware */ |
| 2100 | static const u8 mxt1386e_config_data_3d[] = { |
| 2101 | /* T6 Object */ |
| 2102 | 0, 0, 0, 0, 0, 0, |
| 2103 | /* T38 Object */ |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2104 | 13, 1, 0, 23, 2, 12, 0, 0, 0, 0, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2105 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2106 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2107 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2108 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2109 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2110 | 0, 0, 0, 0, |
| 2111 | /* T7 Object */ |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2112 | 100, 10, 50, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2113 | /* T8 Object */ |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2114 | 25, 0, 20, 20, 0, 0, 0, 0, 0, 0, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2115 | /* T9 Object */ |
| 2116 | 131, 0, 0, 26, 42, 0, 32, 80, 2, 5, |
| 2117 | 0, 5, 5, 0, 10, 30, 10, 10, 175, 4, |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2118 | 127, 7, 26, 21, 17, 19, 143, 35, 207, 40, |
| 2119 | 20, 5, 54, 49, 0, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2120 | /* T18 Object */ |
| 2121 | 0, 0, |
| 2122 | /* T24 Object */ |
| 2123 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2124 | 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2125 | /* T25 Object */ |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2126 | 0, 0, 72, 113, 168, 97, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2127 | /* T27 Object */ |
| 2128 | 0, 0, 0, 0, 0, 0, 0, |
| 2129 | /* T40 Object */ |
| 2130 | 0, 0, 0, 0, 0, |
| 2131 | /* T42 Object */ |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2132 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2133 | /* T43 Object */ |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2134 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2135 | 0, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2136 | /* T46 Object */ |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2137 | 68, 0, 16, 16, 0, 0, 0, 0, 0, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2138 | /* T47 Object */ |
| 2139 | 0, 0, 0, 0, 0, 0, 3, 64, 66, 0, |
| 2140 | /* T48 Object */ |
| 2141 | 31, 64, 64, 0, 0, 0, 0, 0, 0, 0, |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2142 | 32, 50, 0, 10, 10, 0, 0, 100, 10, 90, |
| 2143 | 0, 0, 0, 0, 0, 0, 0, 10, 1, 30, |
| 2144 | 52, 10, 5, 0, 33, 0, 1, 0, 0, 0, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2145 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2146 | 0, 0, 0, 0, |
| 2147 | /* T56 Object */ |
| 2148 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2149 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2150 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2151 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
Jing Lin | 66ba78b | 2012-02-24 21:25:12 -0800 | [diff] [blame] | 2152 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 2153 | 0, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2154 | }; |
| 2155 | |
Amy Maloche | 08266db | 2011-11-04 11:07:16 -0700 | [diff] [blame] | 2156 | #define MXT_TS_GPIO_IRQ 11 |
| 2157 | #define MXT_TS_LDO_EN_GPIO 50 |
| 2158 | #define MXT_TS_RESET_GPIO 52 |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2159 | |
| 2160 | static void mxt_init_hw_liquid(void) |
| 2161 | { |
| 2162 | int rc; |
| 2163 | |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2164 | rc = gpio_request(MXT_TS_LDO_EN_GPIO, "mxt_ldo_en_gpio"); |
| 2165 | if (rc) { |
Amy Maloche | 08266db | 2011-11-04 11:07:16 -0700 | [diff] [blame] | 2166 | pr_err("%s: unable to request mxt_ldo_en_gpio [%d]\n", |
| 2167 | __func__, MXT_TS_LDO_EN_GPIO); |
| 2168 | return; |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2169 | } |
| 2170 | |
| 2171 | rc = gpio_direction_output(MXT_TS_LDO_EN_GPIO, 1); |
| 2172 | if (rc) { |
Amy Maloche | 08266db | 2011-11-04 11:07:16 -0700 | [diff] [blame] | 2173 | pr_err("%s: unable to set_direction for mxt_ldo_en_gpio [%d]\n", |
| 2174 | __func__, MXT_TS_LDO_EN_GPIO); |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2175 | goto err_ldo_gpio_req; |
| 2176 | } |
| 2177 | |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2178 | return; |
| 2179 | |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2180 | err_ldo_gpio_req: |
| 2181 | gpio_free(MXT_TS_LDO_EN_GPIO); |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2182 | } |
| 2183 | |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2184 | static struct mxt_config_info mxt_config_array_2d[] = { |
Jing Lin | dc4413c | 2012-01-16 15:22:52 -0800 | [diff] [blame] | 2185 | { |
| 2186 | .config = mxt1386_config_data, |
| 2187 | .config_length = ARRAY_SIZE(mxt1386_config_data), |
| 2188 | .family_id = 0xA0, |
| 2189 | .variant_id = 0x0, |
| 2190 | .version = 0x10, |
| 2191 | .build = 0xAA, |
Anirudh Ghayal | a77941e | 2012-02-23 19:12:26 -0800 | [diff] [blame] | 2192 | .bootldr_id = MXT_BOOTLOADER_ID_1386, |
Jing Lin | dc4413c | 2012-01-16 15:22:52 -0800 | [diff] [blame] | 2193 | }, |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 2194 | { |
| 2195 | .config = mxt1386e_config_data_v1_0, |
| 2196 | .config_length = ARRAY_SIZE(mxt1386e_config_data_v1_0), |
| 2197 | .family_id = 0xA0, |
| 2198 | .variant_id = 0x2, |
| 2199 | .version = 0x10, |
| 2200 | .build = 0xAA, |
Anirudh Ghayal | a77941e | 2012-02-23 19:12:26 -0800 | [diff] [blame] | 2201 | .bootldr_id = MXT_BOOTLOADER_ID_1386E, |
Jing Lin | aeaeed5 | 2012-03-26 14:57:15 -0700 | [diff] [blame] | 2202 | .fw_name = "atmel_8960_liquid_v2_2_AA.hex", |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 2203 | }, |
| 2204 | { |
| 2205 | .config = mxt1386e_config_data_v2_1, |
| 2206 | .config_length = ARRAY_SIZE(mxt1386e_config_data_v2_1), |
| 2207 | .family_id = 0xA0, |
| 2208 | .variant_id = 0x7, |
| 2209 | .version = 0x21, |
| 2210 | .build = 0xAA, |
Anirudh Ghayal | a77941e | 2012-02-23 19:12:26 -0800 | [diff] [blame] | 2211 | .bootldr_id = MXT_BOOTLOADER_ID_1386E, |
Jing Lin | aeaeed5 | 2012-03-26 14:57:15 -0700 | [diff] [blame] | 2212 | .fw_name = "atmel_8960_liquid_v2_2_AA.hex", |
| 2213 | }, |
| 2214 | { |
| 2215 | /* The config data for V2.2.AA is the same as for V2.1.AA */ |
| 2216 | .config = mxt1386e_config_data_v2_1, |
| 2217 | .config_length = ARRAY_SIZE(mxt1386e_config_data_v2_1), |
| 2218 | .family_id = 0xA0, |
| 2219 | .variant_id = 0x7, |
| 2220 | .version = 0x22, |
| 2221 | .build = 0xAA, |
| 2222 | .bootldr_id = MXT_BOOTLOADER_ID_1386E, |
Jing Lin | 33b007d | 2011-12-21 17:40:23 -0800 | [diff] [blame] | 2223 | }, |
Jing Lin | dc4413c | 2012-01-16 15:22:52 -0800 | [diff] [blame] | 2224 | }; |
| 2225 | |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2226 | static struct mxt_platform_data mxt_platform_data_2d = { |
| 2227 | .config_array = mxt_config_array_2d, |
| 2228 | .config_array_size = ARRAY_SIZE(mxt_config_array_2d), |
Mohan Pallaka | 56a1a5d | 2012-02-23 12:05:13 -0800 | [diff] [blame] | 2229 | .panel_minx = 0, |
| 2230 | .panel_maxx = 1365, |
| 2231 | .panel_miny = 0, |
| 2232 | .panel_maxy = 767, |
| 2233 | .disp_minx = 0, |
| 2234 | .disp_maxx = 1365, |
| 2235 | .disp_miny = 0, |
| 2236 | .disp_maxy = 767, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2237 | .irqflags = IRQF_TRIGGER_FALLING, |
Jing Lin | 2f86317 | 2011-10-17 10:56:58 -0700 | [diff] [blame] | 2238 | .i2c_pull_up = true, |
Amy Maloche | 08266db | 2011-11-04 11:07:16 -0700 | [diff] [blame] | 2239 | .reset_gpio = MXT_TS_RESET_GPIO, |
| 2240 | .irq_gpio = MXT_TS_GPIO_IRQ, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2241 | }; |
| 2242 | |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2243 | static struct mxt_config_info mxt_config_array_3d[] = { |
| 2244 | { |
| 2245 | .config = mxt1386e_config_data_3d, |
| 2246 | .config_length = ARRAY_SIZE(mxt1386e_config_data_3d), |
| 2247 | .family_id = 0xA0, |
| 2248 | .variant_id = 0x7, |
| 2249 | .version = 0x21, |
| 2250 | .build = 0xAA, |
| 2251 | }, |
| 2252 | }; |
| 2253 | |
| 2254 | static struct mxt_platform_data mxt_platform_data_3d = { |
| 2255 | .config_array = mxt_config_array_3d, |
| 2256 | .config_array_size = ARRAY_SIZE(mxt_config_array_3d), |
Mohan Pallaka | 56a1a5d | 2012-02-23 12:05:13 -0800 | [diff] [blame] | 2257 | .panel_minx = 0, |
| 2258 | .panel_maxx = 1919, |
| 2259 | .panel_miny = 0, |
| 2260 | .panel_maxy = 1199, |
| 2261 | .disp_minx = 0, |
| 2262 | .disp_maxx = 1919, |
| 2263 | .disp_miny = 0, |
| 2264 | .disp_maxy = 1199, |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 2265 | .irqflags = IRQF_TRIGGER_FALLING, |
| 2266 | .i2c_pull_up = true, |
| 2267 | .reset_gpio = MXT_TS_RESET_GPIO, |
| 2268 | .irq_gpio = MXT_TS_GPIO_IRQ, |
| 2269 | }; |
| 2270 | |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2271 | static struct i2c_board_info mxt_device_info[] __initdata = { |
| 2272 | { |
| 2273 | I2C_BOARD_INFO("atmel_mxt_ts", 0x5b), |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2274 | .irq = MSM_GPIO_TO_INT(MXT_TS_GPIO_IRQ), |
| 2275 | }, |
| 2276 | }; |
| 2277 | |
Manoj Rao | 1464874 | 2012-03-30 19:42:12 -0700 | [diff] [blame] | 2278 | static struct msm_mhl_platform_data mhl_platform_data = { |
| 2279 | .irq = MSM_GPIO_TO_INT(4), |
Manoj Rao | c6d904c | 2012-06-22 00:32:14 -0700 | [diff] [blame] | 2280 | .gpio_mhl_int = MHL_GPIO_INT, |
| 2281 | .gpio_mhl_reset = MHL_GPIO_RESET, |
| 2282 | .gpio_mhl_power = 0, |
| 2283 | .gpio_hdmi_mhl_mux = 0, |
Manoj Rao | 1464874 | 2012-03-30 19:42:12 -0700 | [diff] [blame] | 2284 | }; |
Manoj Rao | 1464874 | 2012-03-30 19:42:12 -0700 | [diff] [blame] | 2285 | |
Eugene Yasman | d2316b8 | 2011-12-07 18:23:48 +0200 | [diff] [blame] | 2286 | static struct i2c_board_info sii_device_info[] __initdata = { |
| 2287 | { |
Manoj Rao | 1464874 | 2012-03-30 19:42:12 -0700 | [diff] [blame] | 2288 | #ifdef CONFIG_FB_MSM_HDMI_MHL_8334 |
| 2289 | /* |
| 2290 | * keeps SI 8334 as the default |
| 2291 | * MHL TX |
| 2292 | */ |
| 2293 | I2C_BOARD_INFO("sii8334", 0x39), |
| 2294 | .platform_data = &mhl_platform_data, |
| 2295 | #endif |
| 2296 | #ifdef CONFIG_FB_MSM_HDMI_MHL_9244 |
Eugene Yasman | d2316b8 | 2011-12-07 18:23:48 +0200 | [diff] [blame] | 2297 | I2C_BOARD_INFO("Sil-9244", 0x39), |
Eugene Yasman | d2316b8 | 2011-12-07 18:23:48 +0200 | [diff] [blame] | 2298 | .irq = MSM_GPIO_TO_INT(15), |
Manoj Rao | 1464874 | 2012-03-30 19:42:12 -0700 | [diff] [blame] | 2299 | #endif /* CONFIG_MSM_HDMI_MHL */ |
| 2300 | .flags = I2C_CLIENT_WAKE, |
Eugene Yasman | d2316b8 | 2011-12-07 18:23:48 +0200 | [diff] [blame] | 2301 | }, |
| 2302 | }; |
| 2303 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2304 | static struct msm_i2c_platform_data msm8960_i2c_qup_gsbi4_pdata = { |
| 2305 | .clk_freq = 100000, |
| 2306 | .src_clk_rate = 24000000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2307 | }; |
| 2308 | |
| 2309 | static struct msm_i2c_platform_data msm8960_i2c_qup_gsbi3_pdata = { |
| 2310 | .clk_freq = 100000, |
| 2311 | .src_clk_rate = 24000000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2312 | }; |
| 2313 | |
| 2314 | static struct msm_i2c_platform_data msm8960_i2c_qup_gsbi10_pdata = { |
| 2315 | .clk_freq = 100000, |
| 2316 | .src_clk_rate = 24000000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2317 | }; |
| 2318 | |
| 2319 | static struct msm_i2c_platform_data msm8960_i2c_qup_gsbi12_pdata = { |
| 2320 | .clk_freq = 100000, |
| 2321 | .src_clk_rate = 24000000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2322 | }; |
| 2323 | |
Stepan Moskovchenko | 93d79ec | 2011-09-21 16:52:16 -0700 | [diff] [blame] | 2324 | static struct ks8851_pdata spi_eth_pdata = { |
| 2325 | .irq_gpio = KS8851_IRQ_GPIO, |
| 2326 | .rst_gpio = KS8851_RST_GPIO, |
| 2327 | }; |
Praveen Chidambaram | 043f4ce | 2011-08-02 09:37:59 -0600 | [diff] [blame] | 2328 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2329 | static struct spi_board_info spi_board_info[] __initdata = { |
| 2330 | { |
| 2331 | .modalias = "ks8851", |
| 2332 | .irq = MSM_GPIO_TO_INT(KS8851_IRQ_GPIO), |
| 2333 | .max_speed_hz = 19200000, |
| 2334 | .bus_num = 0, |
| 2335 | .chip_select = 0, |
| 2336 | .mode = SPI_MODE_0, |
Stepan Moskovchenko | 93d79ec | 2011-09-21 16:52:16 -0700 | [diff] [blame] | 2337 | .platform_data = &spi_eth_pdata |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2338 | }, |
Chandan Uddaraju | 15e54b9 | 2011-09-12 10:52:36 -0700 | [diff] [blame] | 2339 | { |
| 2340 | .modalias = "dsi_novatek_3d_panel_spi", |
| 2341 | .max_speed_hz = 10800000, |
| 2342 | .bus_num = 0, |
| 2343 | .chip_select = 1, |
| 2344 | .mode = SPI_MODE_0, |
| 2345 | }, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2346 | }; |
| 2347 | |
| 2348 | static struct platform_device msm_device_saw_core0 = { |
| 2349 | .name = "saw-regulator", |
| 2350 | .id = 0, |
| 2351 | .dev = { |
| 2352 | .platform_data = &msm_saw_regulator_pdata_s5, |
| 2353 | }, |
| 2354 | }; |
| 2355 | |
| 2356 | static struct platform_device msm_device_saw_core1 = { |
| 2357 | .name = "saw-regulator", |
| 2358 | .id = 1, |
| 2359 | .dev = { |
| 2360 | .platform_data = &msm_saw_regulator_pdata_s6, |
| 2361 | }, |
| 2362 | }; |
| 2363 | |
Siddartha Mohanadoss | ba21fdd | 2011-08-18 10:05:27 -0700 | [diff] [blame] | 2364 | static struct tsens_platform_data msm_tsens_pdata = { |
Siddartha Mohanadoss | caeaa92 | 2012-02-07 16:41:38 -0800 | [diff] [blame] | 2365 | .slope = {910, 910, 910, 910, 910}, |
Siddartha Mohanadoss | ba21fdd | 2011-08-18 10:05:27 -0700 | [diff] [blame] | 2366 | .tsens_factor = 1000, |
| 2367 | .hw_type = MSM_8960, |
| 2368 | .tsens_num_sensor = 5, |
| 2369 | }; |
| 2370 | |
Siddartha Mohanadoss | 48cad91 | 2012-04-05 21:29:54 -0700 | [diff] [blame] | 2371 | static struct platform_device msm_tsens_device = { |
| 2372 | .name = "tsens8960-tm", |
| 2373 | .id = -1, |
| 2374 | }; |
| 2375 | |
Praveen Chidambaram | 877d7a4 | 2012-06-05 14:33:20 -0600 | [diff] [blame] | 2376 | static struct msm_thermal_data msm_thermal_pdata = { |
| 2377 | .sensor_id = 0, |
| 2378 | .poll_ms = 1000, |
| 2379 | .limit_temp = 60, |
| 2380 | .temp_hysteresis = 10, |
| 2381 | .limit_freq = 918000, |
| 2382 | }; |
| 2383 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2384 | #ifdef CONFIG_MSM_FAKE_BATTERY |
| 2385 | static struct platform_device fish_battery_device = { |
| 2386 | .name = "fish_battery", |
| 2387 | }; |
| 2388 | #endif |
| 2389 | |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 2390 | static struct platform_device msm8960_device_ext_5v_vreg __devinitdata = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2391 | .name = GPIO_REGULATOR_DEV_NAME, |
| 2392 | .id = PM8921_MPP_PM_TO_SYS(7), |
| 2393 | .dev = { |
| 2394 | .platform_data = &msm_gpio_regulator_pdata[GPIO_VREG_ID_EXT_5V], |
| 2395 | }, |
| 2396 | }; |
| 2397 | |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 2398 | static struct platform_device msm8960_device_ext_l2_vreg __devinitdata = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2399 | .name = GPIO_REGULATOR_DEV_NAME, |
| 2400 | .id = 91, |
| 2401 | .dev = { |
| 2402 | .platform_data = &msm_gpio_regulator_pdata[GPIO_VREG_ID_EXT_L2], |
| 2403 | }, |
| 2404 | }; |
| 2405 | |
David Collins | b10be1d | 2011-09-02 10:29:31 -0700 | [diff] [blame] | 2406 | static struct platform_device msm8960_device_ext_3p3v_vreg __devinitdata = { |
| 2407 | .name = GPIO_REGULATOR_DEV_NAME, |
| 2408 | .id = PM8921_GPIO_PM_TO_SYS(17), |
| 2409 | .dev = { |
| 2410 | .platform_data = |
| 2411 | &msm_gpio_regulator_pdata[GPIO_VREG_ID_EXT_3P3V], |
| 2412 | }, |
| 2413 | }; |
| 2414 | |
David Collins | 35a78f5 | 2011-12-14 15:54:25 -0800 | [diff] [blame] | 2415 | static struct platform_device msm8960_device_ext_otg_sw_vreg __devinitdata = { |
| 2416 | .name = GPIO_REGULATOR_DEV_NAME, |
| 2417 | .id = PM8921_GPIO_PM_TO_SYS(42), |
| 2418 | .dev = { |
| 2419 | .platform_data = |
| 2420 | &msm_gpio_regulator_pdata[GPIO_VREG_ID_EXT_OTG_SW], |
| 2421 | }, |
| 2422 | }; |
| 2423 | |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 2424 | static struct platform_device msm8960_device_rpm_regulator __devinitdata = { |
| 2425 | .name = "rpm-regulator", |
| 2426 | .id = -1, |
| 2427 | .dev = { |
| 2428 | .platform_data = &msm_rpm_regulator_pdata, |
| 2429 | }, |
| 2430 | }; |
Mayank Rana | e009c92 | 2012-03-22 03:02:06 +0530 | [diff] [blame] | 2431 | #ifdef CONFIG_SERIAL_MSM_HS |
| 2432 | static int configure_uart_gpios(int on) |
| 2433 | { |
| 2434 | int ret = 0, i; |
| 2435 | int uart_gpios[] = {93, 94, 95, 96}; |
| 2436 | |
| 2437 | for (i = 0; i < ARRAY_SIZE(uart_gpios); i++) { |
| 2438 | if (on) { |
| 2439 | ret = gpio_request(uart_gpios[i], NULL); |
| 2440 | if (ret) { |
| 2441 | pr_err("%s: unable to request uart gpio[%d]\n", |
| 2442 | __func__, uart_gpios[i]); |
| 2443 | break; |
| 2444 | } |
| 2445 | } else { |
| 2446 | gpio_free(uart_gpios[i]); |
| 2447 | } |
| 2448 | } |
| 2449 | |
| 2450 | if (ret && on && i) |
| 2451 | for (; i >= 0; i--) |
| 2452 | gpio_free(uart_gpios[i]); |
| 2453 | return ret; |
| 2454 | } |
| 2455 | |
| 2456 | static struct msm_serial_hs_platform_data msm_uart_dm9_pdata = { |
Mayank Rana | d85a508 | 2012-04-29 17:24:13 -0700 | [diff] [blame] | 2457 | .gpio_config = configure_uart_gpios, |
Mayank Rana | e009c92 | 2012-03-22 03:02:06 +0530 | [diff] [blame] | 2458 | }; |
Mayank Rana | 1f02d95 | 2012-07-04 19:11:20 +0530 | [diff] [blame] | 2459 | |
| 2460 | static int configure_gsbi8_uart_gpios(int on) |
| 2461 | { |
| 2462 | int ret = 0, i; |
| 2463 | int uart_gpios[] = {34, 35, 36, 37}; |
| 2464 | |
| 2465 | for (i = 0; i < ARRAY_SIZE(uart_gpios); i++) { |
| 2466 | if (on) { |
| 2467 | ret = gpio_request(uart_gpios[i], NULL); |
| 2468 | if (ret) { |
| 2469 | pr_err("%s: unable to request uart gpio[%d]\n", |
| 2470 | __func__, uart_gpios[i]); |
| 2471 | break; |
| 2472 | } |
| 2473 | } else { |
| 2474 | gpio_free(uart_gpios[i]); |
| 2475 | } |
| 2476 | } |
| 2477 | |
| 2478 | if (ret && on && i) |
| 2479 | for (; i >= 0; i--) |
| 2480 | gpio_free(uart_gpios[i]); |
| 2481 | return ret; |
| 2482 | } |
| 2483 | |
| 2484 | static struct msm_serial_hs_platform_data msm_uart_dm8_pdata = { |
| 2485 | .gpio_config = configure_gsbi8_uart_gpios, |
| 2486 | }; |
Mayank Rana | e009c92 | 2012-03-22 03:02:06 +0530 | [diff] [blame] | 2487 | #else |
Mayank Rana | 1f02d95 | 2012-07-04 19:11:20 +0530 | [diff] [blame] | 2488 | static struct msm_serial_hs_platform_data msm_uart_dm8_pdata; |
Mayank Rana | e009c92 | 2012-03-22 03:02:06 +0530 | [diff] [blame] | 2489 | static struct msm_serial_hs_platform_data msm_uart_dm9_pdata; |
| 2490 | #endif |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 2491 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2492 | static struct platform_device *common_devices[] __initdata = { |
Matt Wagantall | bf430eb | 2012-03-22 11:45:49 -0700 | [diff] [blame] | 2493 | &msm8960_device_acpuclk, |
Stepan Moskovchenko | df13d34 | 2011-08-03 19:01:25 -0700 | [diff] [blame] | 2494 | &msm8960_device_dmov, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2495 | &msm_device_smd, |
Mayank Rana | 9f51f58 | 2011-08-04 18:35:59 +0530 | [diff] [blame] | 2496 | &msm_device_uart_dm6, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2497 | &msm_device_saw_core0, |
| 2498 | &msm_device_saw_core1, |
| 2499 | &msm8960_device_ext_5v_vreg, |
David Collins | 8757961 | 2012-01-30 16:00:15 -0800 | [diff] [blame] | 2500 | &msm8960_device_ssbi_pmic, |
David Collins | 96aa3e1 | 2012-02-29 10:31:34 -0800 | [diff] [blame] | 2501 | &msm8960_device_ext_otg_sw_vreg, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2502 | &msm8960_device_qup_spi_gsbi1, |
| 2503 | &msm8960_device_qup_i2c_gsbi3, |
| 2504 | &msm8960_device_qup_i2c_gsbi4, |
| 2505 | &msm8960_device_qup_i2c_gsbi10, |
| 2506 | #ifndef CONFIG_MSM_DSPS |
| 2507 | &msm8960_device_qup_i2c_gsbi12, |
| 2508 | #endif |
| 2509 | &msm_slim_ctrl, |
| 2510 | &msm_device_wcnss_wlan, |
Ramesh Masavarapu | a26cce7 | 2012-04-09 12:32:25 -0700 | [diff] [blame] | 2511 | #if defined(CONFIG_QSEECOM) |
| 2512 | &qseecom_device, |
| 2513 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2514 | #if defined(CONFIG_CRYPTO_DEV_QCRYPTO) || \ |
| 2515 | defined(CONFIG_CRYPTO_DEV_QCRYPTO_MODULE) |
| 2516 | &qcrypto_device, |
| 2517 | #endif |
| 2518 | |
| 2519 | #if defined(CONFIG_CRYPTO_DEV_QCEDEV) || \ |
| 2520 | defined(CONFIG_CRYPTO_DEV_QCEDEV_MODULE) |
| 2521 | &qcedev_device, |
| 2522 | #endif |
| 2523 | #ifdef CONFIG_MSM_ROTATOR |
| 2524 | &msm_rotator_device, |
| 2525 | #endif |
| 2526 | &msm_device_sps, |
| 2527 | #ifdef CONFIG_MSM_FAKE_BATTERY |
| 2528 | &fish_battery_device, |
| 2529 | #endif |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 2530 | &msm8960_fmem_device, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2531 | #ifdef CONFIG_ANDROID_PMEM |
Laura Abbott | 2d1760b | 2011-09-29 21:31:24 -0700 | [diff] [blame] | 2532 | #ifndef CONFIG_MSM_MULTIMEDIA_USE_ION |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 2533 | &msm8960_android_pmem_device, |
| 2534 | &msm8960_android_pmem_adsp_device, |
| 2535 | &msm8960_android_pmem_audio_device, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2536 | #endif |
Bharath Ramachandramurthy | 4a3fa91 | 2012-03-13 19:16:24 -0700 | [diff] [blame] | 2537 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2538 | &msm_device_vidc, |
| 2539 | &msm_device_bam_dmux, |
| 2540 | &msm_fm_platform_init, |
Joel Nider | a126194 | 2011-09-12 16:30:09 +0300 | [diff] [blame] | 2541 | #if defined(CONFIG_TSIF) || defined(CONFIG_TSIF_MODULE) |
| 2542 | #ifdef CONFIG_MSM_USE_TSIF1 |
| 2543 | &msm_device_tsif[1], |
| 2544 | #else |
| 2545 | &msm_device_tsif[0], |
| 2546 | #endif |
| 2547 | #endif |
Joel Nider | 266a264 | 2011-10-16 10:58:05 +0200 | [diff] [blame] | 2548 | &msm_device_tspp, |
Mona Hossain | 9c430e3 | 2011-07-27 11:04:47 -0700 | [diff] [blame] | 2549 | #ifdef CONFIG_HW_RANDOM_MSM |
| 2550 | &msm_device_rng, |
| 2551 | #endif |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 2552 | #ifdef CONFIG_ION_MSM |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 2553 | &msm8960_ion_dev, |
Laura Abbott | d618379 | 2011-08-19 13:42:24 -0700 | [diff] [blame] | 2554 | #endif |
Praveen Chidambaram | 7849901 | 2011-11-01 17:15:17 -0600 | [diff] [blame] | 2555 | &msm8960_rpm_device, |
| 2556 | &msm8960_rpm_log_device, |
| 2557 | &msm8960_rpm_stat_device, |
Mona Hossain | 11c03ac | 2011-10-26 12:42:10 -0700 | [diff] [blame] | 2558 | &msm_device_tz_log, |
Pratik Patel | 7831c08 | 2011-06-08 21:44:37 -0700 | [diff] [blame] | 2559 | #ifdef CONFIG_MSM_QDSS |
Pratik Patel | 1403f2a | 2012-03-21 10:10:00 -0700 | [diff] [blame] | 2560 | &msm_qdss_device, |
Pratik Patel | 7831c08 | 2011-06-08 21:44:37 -0700 | [diff] [blame] | 2561 | &msm_etb_device, |
| 2562 | &msm_tpiu_device, |
| 2563 | &msm_funnel_device, |
Pratik Patel | 492b301 | 2012-03-06 14:22:30 -0800 | [diff] [blame] | 2564 | &msm_etm_device, |
Pratik Patel | 7831c08 | 2011-06-08 21:44:37 -0700 | [diff] [blame] | 2565 | #endif |
Swaminathan Sathappan | b77c65e9 | 2011-09-30 18:36:09 -0700 | [diff] [blame] | 2566 | &msm_device_dspcrashd_8960, |
Jeff Ohlstein | 7e66855 | 2011-10-06 16:17:25 -0700 | [diff] [blame] | 2567 | &msm8960_device_watchdog, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 2568 | &msm8960_rtb_device, |
Praveen Chidambaram | 8ea3dcd | 2011-12-07 14:46:31 -0700 | [diff] [blame] | 2569 | &msm8960_cpu_idle_device, |
Praveen Chidambaram | 5c8adf2 | 2012-02-23 18:44:37 -0700 | [diff] [blame] | 2570 | &msm8960_msm_gov_device, |
Stepan Moskovchenko | 28662c5 | 2012-03-01 12:48:45 -0800 | [diff] [blame] | 2571 | &msm8960_device_cache_erp, |
Stepan Moskovchenko | c055725 | 2012-06-07 17:39:14 -0700 | [diff] [blame] | 2572 | &msm8960_device_ebi1_ch0_erp, |
| 2573 | &msm8960_device_ebi1_ch1_erp, |
Laura Abbott | b93525f | 2012-04-12 09:57:19 -0700 | [diff] [blame] | 2574 | &msm8960_cache_dump_device, |
Laura Abbott | 0577d7b | 2012-04-17 11:14:30 -0700 | [diff] [blame] | 2575 | &msm8960_iommu_domain_device, |
Siddartha Mohanadoss | 48cad91 | 2012-04-05 21:29:54 -0700 | [diff] [blame] | 2576 | &msm_tsens_device, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2577 | }; |
| 2578 | |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 2579 | static struct platform_device *sim_devices[] __initdata = { |
Stepan Moskovchenko | 2b4b1cd | 2012-03-29 18:21:04 -0700 | [diff] [blame] | 2580 | &msm8960_device_uart_gsbi5, |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 2581 | &msm8960_device_otg, |
| 2582 | &msm8960_device_gadget_peripheral, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2583 | &msm_device_hsusb_host, |
Vijayavardhan Vennapusa | eb56648 | 2011-09-18 07:48:37 +0530 | [diff] [blame] | 2584 | &msm_device_hsic_host, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2585 | &android_usb_device, |
| 2586 | &msm_device_vidc, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2587 | &msm_bus_apps_fabric, |
| 2588 | &msm_bus_sys_fabric, |
| 2589 | &msm_bus_mm_fabric, |
| 2590 | &msm_bus_sys_fpb, |
| 2591 | &msm_bus_cpss_fpb, |
| 2592 | &msm_pcm, |
Kiran Kandi | 5e809b0 | 2012-01-31 00:24:33 -0800 | [diff] [blame] | 2593 | &msm_multi_ch_pcm, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2594 | &msm_pcm_routing, |
| 2595 | &msm_cpudai0, |
| 2596 | &msm_cpudai1, |
Kiran Kandi | 97fe19d | 2012-05-20 22:34:04 -0700 | [diff] [blame] | 2597 | &msm8960_cpudai_slimbus_2_rx, |
Kiran Kandi | 1e6371d | 2012-03-29 11:48:57 -0700 | [diff] [blame] | 2598 | &msm8960_cpudai_slimbus_2_tx, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2599 | &msm_cpudai_hdmi_rx, |
| 2600 | &msm_cpudai_bt_rx, |
| 2601 | &msm_cpudai_bt_tx, |
| 2602 | &msm_cpudai_fm_rx, |
| 2603 | &msm_cpudai_fm_tx, |
Bhalchandra Gajare | 0e795c4 | 2011-08-15 18:10:30 -0700 | [diff] [blame] | 2604 | &msm_cpudai_auxpcm_rx, |
| 2605 | &msm_cpudai_auxpcm_tx, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2606 | &msm_cpu_fe, |
| 2607 | &msm_stub_codec, |
| 2608 | &msm_voice, |
| 2609 | &msm_voip, |
| 2610 | &msm_lpa_pcm, |
Asish Bhattacharya | 96bb6f4 | 2011-11-01 20:36:09 +0530 | [diff] [blame] | 2611 | &msm_compr_dsp, |
Helen Zeng | 0705a5f | 2011-10-14 15:29:52 -0700 | [diff] [blame] | 2612 | &msm_cpudai_incall_music_rx, |
Helen Zeng | e3d716a | 2011-10-14 16:32:16 -0700 | [diff] [blame] | 2613 | &msm_cpudai_incall_record_rx, |
| 2614 | &msm_cpudai_incall_record_tx, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2615 | |
| 2616 | #if defined(CONFIG_CRYPTO_DEV_QCRYPTO) || \ |
| 2617 | defined(CONFIG_CRYPTO_DEV_QCRYPTO_MODULE) |
| 2618 | &qcrypto_device, |
| 2619 | #endif |
| 2620 | |
| 2621 | #if defined(CONFIG_CRYPTO_DEV_QCEDEV) || \ |
| 2622 | defined(CONFIG_CRYPTO_DEV_QCEDEV_MODULE) |
| 2623 | &qcedev_device, |
| 2624 | #endif |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 2625 | }; |
| 2626 | |
| 2627 | static struct platform_device *rumi3_devices[] __initdata = { |
Stepan Moskovchenko | 2b4b1cd | 2012-03-29 18:21:04 -0700 | [diff] [blame] | 2628 | &msm8960_device_uart_gsbi5, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2629 | &msm_kgsl_3d0, |
| 2630 | &msm_kgsl_2d0, |
| 2631 | &msm_kgsl_2d1, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2632 | #ifdef CONFIG_MSM_GEMINI |
| 2633 | &msm8960_gemini_device, |
| 2634 | #endif |
Kalyani Oruganti | 465d1e1 | 2012-05-15 10:23:05 -0700 | [diff] [blame] | 2635 | #ifdef CONFIG_MSM_MERCURY |
| 2636 | &msm8960_mercury_device, |
| 2637 | #endif |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 2638 | }; |
| 2639 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2640 | static struct platform_device *cdp_devices[] __initdata = { |
Stephen Boyd | eb81988 | 2011-08-29 14:46:30 -0700 | [diff] [blame] | 2641 | &msm_8960_q6_lpass, |
| 2642 | &msm_8960_q6_mss_fw, |
| 2643 | &msm_8960_q6_mss_sw, |
Stephen Boyd | 322a992 | 2011-09-20 01:05:54 -0700 | [diff] [blame] | 2644 | &msm_8960_riva, |
Stephen Boyd | d89eebe | 2011-09-28 23:28:11 -0700 | [diff] [blame] | 2645 | &msm_pil_tzapps, |
Stephen Boyd | 25c4a0b | 2011-09-20 00:12:36 -0700 | [diff] [blame] | 2646 | &msm_pil_dsps, |
Stephen Boyd | 7b973de | 2012-03-09 12:26:16 -0800 | [diff] [blame] | 2647 | &msm_pil_vidc, |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 2648 | &msm8960_device_otg, |
| 2649 | &msm8960_device_gadget_peripheral, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2650 | &msm_device_hsusb_host, |
| 2651 | &android_usb_device, |
| 2652 | &msm_pcm, |
Kiran Kandi | 5e809b0 | 2012-01-31 00:24:33 -0800 | [diff] [blame] | 2653 | &msm_multi_ch_pcm, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2654 | &msm_pcm_routing, |
| 2655 | &msm_cpudai0, |
| 2656 | &msm_cpudai1, |
Kiran Kandi | 97fe19d | 2012-05-20 22:34:04 -0700 | [diff] [blame] | 2657 | &msm8960_cpudai_slimbus_2_rx, |
Kiran Kandi | 1e6371d | 2012-03-29 11:48:57 -0700 | [diff] [blame] | 2658 | &msm8960_cpudai_slimbus_2_tx, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2659 | &msm_cpudai_hdmi_rx, |
| 2660 | &msm_cpudai_bt_rx, |
| 2661 | &msm_cpudai_bt_tx, |
| 2662 | &msm_cpudai_fm_rx, |
| 2663 | &msm_cpudai_fm_tx, |
Bhalchandra Gajare | 0e795c4 | 2011-08-15 18:10:30 -0700 | [diff] [blame] | 2664 | &msm_cpudai_auxpcm_rx, |
| 2665 | &msm_cpudai_auxpcm_tx, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2666 | &msm_cpu_fe, |
| 2667 | &msm_stub_codec, |
| 2668 | &msm_kgsl_3d0, |
| 2669 | #ifdef CONFIG_MSM_KGSL_2D |
| 2670 | &msm_kgsl_2d0, |
| 2671 | &msm_kgsl_2d1, |
| 2672 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2673 | #ifdef CONFIG_MSM_GEMINI |
| 2674 | &msm8960_gemini_device, |
| 2675 | #endif |
Kalyani Oruganti | 465d1e1 | 2012-05-15 10:23:05 -0700 | [diff] [blame] | 2676 | #ifdef CONFIG_MSM_MERCURY |
| 2677 | &msm8960_mercury_device, |
| 2678 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2679 | &msm_voice, |
| 2680 | &msm_voip, |
| 2681 | &msm_lpa_pcm, |
Laxminath Kasam | cee1d60 | 2011-08-01 19:26:57 +0530 | [diff] [blame] | 2682 | &msm_cpudai_afe_01_rx, |
| 2683 | &msm_cpudai_afe_01_tx, |
| 2684 | &msm_cpudai_afe_02_rx, |
| 2685 | &msm_cpudai_afe_02_tx, |
| 2686 | &msm_pcm_afe, |
Asish Bhattacharya | 96bb6f4 | 2011-11-01 20:36:09 +0530 | [diff] [blame] | 2687 | &msm_compr_dsp, |
Helen Zeng | 0705a5f | 2011-10-14 15:29:52 -0700 | [diff] [blame] | 2688 | &msm_cpudai_incall_music_rx, |
Helen Zeng | e3d716a | 2011-10-14 16:32:16 -0700 | [diff] [blame] | 2689 | &msm_cpudai_incall_record_rx, |
| 2690 | &msm_cpudai_incall_record_tx, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2691 | &msm_pcm_hostless, |
| 2692 | &msm_bus_apps_fabric, |
| 2693 | &msm_bus_sys_fabric, |
| 2694 | &msm_bus_mm_fabric, |
| 2695 | &msm_bus_sys_fpb, |
| 2696 | &msm_bus_cpss_fpb, |
| 2697 | }; |
| 2698 | |
| 2699 | static void __init msm8960_i2c_init(void) |
| 2700 | { |
| 2701 | msm8960_device_qup_i2c_gsbi4.dev.platform_data = |
| 2702 | &msm8960_i2c_qup_gsbi4_pdata; |
| 2703 | |
| 2704 | msm8960_device_qup_i2c_gsbi3.dev.platform_data = |
| 2705 | &msm8960_i2c_qup_gsbi3_pdata; |
| 2706 | |
| 2707 | msm8960_device_qup_i2c_gsbi10.dev.platform_data = |
| 2708 | &msm8960_i2c_qup_gsbi10_pdata; |
| 2709 | |
| 2710 | msm8960_device_qup_i2c_gsbi12.dev.platform_data = |
| 2711 | &msm8960_i2c_qup_gsbi12_pdata; |
| 2712 | } |
| 2713 | |
Lucille Sylvester | 34ec369 | 2011-08-16 16:28:04 -0600 | [diff] [blame] | 2714 | static void __init msm8960_gfx_init(void) |
| 2715 | { |
Jordan Crouse | 4815e9f | 2012-07-09 15:36:37 -0600 | [diff] [blame] | 2716 | struct kgsl_device_platform_data *kgsl_3d0_pdata = |
| 2717 | msm_kgsl_3d0.dev.platform_data; |
Jeremy Gebben | 58b2dce | 2011-10-13 11:14:19 -0600 | [diff] [blame] | 2718 | uint32_t soc_platform_version = socinfo_get_version(); |
Jordan Crouse | 4815e9f | 2012-07-09 15:36:37 -0600 | [diff] [blame] | 2719 | |
Lucille Sylvester | 34ec369 | 2011-08-16 16:28:04 -0600 | [diff] [blame] | 2720 | if (SOCINFO_VERSION_MAJOR(soc_platform_version) == 1) { |
Lucille Sylvester | dce84cd | 2011-10-12 14:15:37 -0600 | [diff] [blame] | 2721 | kgsl_3d0_pdata->pwrlevel[0].gpu_freq = 320000000; |
| 2722 | kgsl_3d0_pdata->pwrlevel[1].gpu_freq = 266667000; |
Lucille Sylvester | 34ec369 | 2011-08-16 16:28:04 -0600 | [diff] [blame] | 2723 | } |
Jordan Crouse | 4815e9f | 2012-07-09 15:36:37 -0600 | [diff] [blame] | 2724 | if (cpu_is_msm8960ab()) { |
| 2725 | kgsl_3d0_pdata->chipid = ADRENO_CHIPID(3, 2, 1, 0); |
| 2726 | } else { |
| 2727 | |
| 2728 | /* 8960v3 GPU registers returns 5 for patch release |
| 2729 | * but it should be 6, so dummy up the chipid here |
| 2730 | * based the platform type |
| 2731 | */ |
| 2732 | |
| 2733 | if (SOCINFO_VERSION_MAJOR(soc_platform_version) >= 3) |
| 2734 | kgsl_3d0_pdata->chipid = ADRENO_CHIPID(2, 2, 0, 6); |
| 2735 | } |
Lucille Sylvester | 34ec369 | 2011-08-16 16:28:04 -0600 | [diff] [blame] | 2736 | } |
| 2737 | |
Subhash Jadavani | 933e6a6 | 2011-12-26 18:05:04 +0530 | [diff] [blame] | 2738 | static struct msm_rpmrs_level msm_rpmrs_levels[] = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2739 | { |
| 2740 | MSM_PM_SLEEP_MODE_WAIT_FOR_INTERRUPT, |
| 2741 | MSM_RPMRS_LIMITS(ON, ACTIVE, MAX, ACTIVE), |
| 2742 | true, |
Girish Mahadevan | 9bf7156 | 2012-04-13 14:41:44 -0600 | [diff] [blame] | 2743 | 1, 784, 180000, 100, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2744 | }, |
| 2745 | |
| 2746 | { |
| 2747 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE_STANDALONE, |
| 2748 | MSM_RPMRS_LIMITS(ON, ACTIVE, MAX, ACTIVE), |
| 2749 | true, |
Girish Mahadevan | 9bf7156 | 2012-04-13 14:41:44 -0600 | [diff] [blame] | 2750 | 1300, 228, 1200000, 2000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2751 | }, |
| 2752 | |
| 2753 | { |
| 2754 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 2755 | MSM_RPMRS_LIMITS(ON, GDHS, MAX, ACTIVE), |
| 2756 | false, |
Girish Mahadevan | 9bf7156 | 2012-04-13 14:41:44 -0600 | [diff] [blame] | 2757 | 2000, 138, 1208400, 3200, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2758 | }, |
| 2759 | |
| 2760 | { |
| 2761 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
Maheshkumar Sivasubramanian | 7df1236 | 2011-11-02 08:25:49 -0600 | [diff] [blame] | 2762 | MSM_RPMRS_LIMITS(ON, HSFS_OPEN, ACTIVE, RET_HIGH), |
| 2763 | false, |
Girish Mahadevan | 9bf7156 | 2012-04-13 14:41:44 -0600 | [diff] [blame] | 2764 | 6000, 119, 1850300, 9000, |
Maheshkumar Sivasubramanian | 7df1236 | 2011-11-02 08:25:49 -0600 | [diff] [blame] | 2765 | }, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2766 | |
| 2767 | { |
| 2768 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 2769 | MSM_RPMRS_LIMITS(OFF, GDHS, MAX, ACTIVE), |
| 2770 | false, |
Girish Mahadevan | 9bf7156 | 2012-04-13 14:41:44 -0600 | [diff] [blame] | 2771 | 9200, 68, 2839200, 16400, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2772 | }, |
| 2773 | |
| 2774 | { |
| 2775 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 2776 | MSM_RPMRS_LIMITS(OFF, HSFS_OPEN, MAX, ACTIVE), |
| 2777 | false, |
Girish Mahadevan | 9bf7156 | 2012-04-13 14:41:44 -0600 | [diff] [blame] | 2778 | 10300, 63, 3128000, 18200, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2779 | }, |
| 2780 | |
| 2781 | { |
| 2782 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 2783 | MSM_RPMRS_LIMITS(OFF, HSFS_OPEN, ACTIVE, RET_HIGH), |
| 2784 | false, |
Girish Mahadevan | 9bf7156 | 2012-04-13 14:41:44 -0600 | [diff] [blame] | 2785 | 18000, 10, 4602600, 27000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2786 | }, |
| 2787 | |
| 2788 | { |
| 2789 | MSM_PM_SLEEP_MODE_POWER_COLLAPSE, |
| 2790 | MSM_RPMRS_LIMITS(OFF, HSFS_OPEN, RET_HIGH, RET_LOW), |
| 2791 | false, |
Girish Mahadevan | 9bf7156 | 2012-04-13 14:41:44 -0600 | [diff] [blame] | 2792 | 20000, 2, 5752000, 32000, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2793 | }, |
| 2794 | }; |
| 2795 | |
Praveen Chidambaram | 7849901 | 2011-11-01 17:15:17 -0600 | [diff] [blame] | 2796 | static struct msm_rpmrs_platform_data msm_rpmrs_data __initdata = { |
| 2797 | .levels = &msm_rpmrs_levels[0], |
| 2798 | .num_levels = ARRAY_SIZE(msm_rpmrs_levels), |
| 2799 | .vdd_mem_levels = { |
| 2800 | [MSM_RPMRS_VDD_MEM_RET_LOW] = 750000, |
| 2801 | [MSM_RPMRS_VDD_MEM_RET_HIGH] = 750000, |
| 2802 | [MSM_RPMRS_VDD_MEM_ACTIVE] = 1050000, |
| 2803 | [MSM_RPMRS_VDD_MEM_MAX] = 1150000, |
| 2804 | }, |
| 2805 | .vdd_dig_levels = { |
| 2806 | [MSM_RPMRS_VDD_DIG_RET_LOW] = 500000, |
| 2807 | [MSM_RPMRS_VDD_DIG_RET_HIGH] = 750000, |
| 2808 | [MSM_RPMRS_VDD_DIG_ACTIVE] = 950000, |
| 2809 | [MSM_RPMRS_VDD_DIG_MAX] = 1150000, |
| 2810 | }, |
| 2811 | .vdd_mask = 0x7FFFFF, |
| 2812 | .rpmrs_target_id = { |
| 2813 | [MSM_RPMRS_ID_PXO_CLK] = MSM_RPM_ID_PXO_CLK, |
| 2814 | [MSM_RPMRS_ID_L2_CACHE_CTL] = MSM_RPM_ID_LAST, |
| 2815 | [MSM_RPMRS_ID_VDD_DIG_0] = MSM_RPM_ID_PM8921_S3_0, |
| 2816 | [MSM_RPMRS_ID_VDD_DIG_1] = MSM_RPM_ID_PM8921_S3_1, |
| 2817 | [MSM_RPMRS_ID_VDD_MEM_0] = MSM_RPM_ID_PM8921_L24_0, |
| 2818 | [MSM_RPMRS_ID_VDD_MEM_1] = MSM_RPM_ID_PM8921_L24_1, |
| 2819 | [MSM_RPMRS_ID_RPM_CTL] = MSM_RPM_ID_RPM_CTL, |
| 2820 | }, |
| 2821 | }; |
| 2822 | |
Maheshkumar Sivasubramanian | c6c5503 | 2011-10-25 16:01:32 -0600 | [diff] [blame] | 2823 | static struct msm_pm_boot_platform_data msm_pm_boot_pdata __initdata = { |
| 2824 | .mode = MSM_PM_BOOT_CONFIG_TZ, |
| 2825 | }; |
| 2826 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2827 | #ifdef CONFIG_I2C |
| 2828 | #define I2C_SURF 1 |
| 2829 | #define I2C_FFA (1 << 1) |
| 2830 | #define I2C_RUMI (1 << 2) |
| 2831 | #define I2C_SIM (1 << 3) |
| 2832 | #define I2C_FLUID (1 << 4) |
Amir Samuelov | 05f8780 | 2011-08-27 18:30:12 +0300 | [diff] [blame] | 2833 | #define I2C_LIQUID (1 << 5) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2834 | |
| 2835 | struct i2c_registry { |
| 2836 | u8 machs; |
| 2837 | int bus; |
| 2838 | struct i2c_board_info *info; |
| 2839 | int len; |
| 2840 | }; |
| 2841 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2842 | /* Sensors DSPS platform data */ |
| 2843 | #ifdef CONFIG_MSM_DSPS |
| 2844 | #define DSPS_PIL_GENERIC_NAME "dsps" |
| 2845 | #endif /* CONFIG_MSM_DSPS */ |
| 2846 | |
| 2847 | static void __init msm8960_init_dsps(void) |
| 2848 | { |
| 2849 | #ifdef CONFIG_MSM_DSPS |
| 2850 | struct msm_dsps_platform_data *pdata = |
| 2851 | msm_dsps_device.dev.platform_data; |
| 2852 | pdata->pil_name = DSPS_PIL_GENERIC_NAME; |
| 2853 | pdata->gpios = NULL; |
| 2854 | pdata->gpios_num = 0; |
| 2855 | |
| 2856 | platform_device_register(&msm_dsps_device); |
| 2857 | #endif /* CONFIG_MSM_DSPS */ |
| 2858 | } |
| 2859 | |
Vamsi Krishna | 6aa6b1f | 2011-12-14 22:55:20 -0800 | [diff] [blame] | 2860 | static int hsic_peripheral_status = 1; |
| 2861 | static DEFINE_MUTEX(hsic_status_lock); |
| 2862 | |
| 2863 | void peripheral_connect() |
| 2864 | { |
| 2865 | mutex_lock(&hsic_status_lock); |
| 2866 | if (hsic_peripheral_status) |
| 2867 | goto out; |
| 2868 | platform_device_add(&msm_device_hsic_host); |
| 2869 | hsic_peripheral_status = 1; |
| 2870 | out: |
| 2871 | mutex_unlock(&hsic_status_lock); |
| 2872 | } |
| 2873 | EXPORT_SYMBOL(peripheral_connect); |
| 2874 | |
| 2875 | void peripheral_disconnect() |
| 2876 | { |
| 2877 | mutex_lock(&hsic_status_lock); |
| 2878 | if (!hsic_peripheral_status) |
| 2879 | goto out; |
| 2880 | platform_device_del(&msm_device_hsic_host); |
| 2881 | hsic_peripheral_status = 0; |
| 2882 | out: |
| 2883 | mutex_unlock(&hsic_status_lock); |
| 2884 | } |
| 2885 | EXPORT_SYMBOL(peripheral_disconnect); |
| 2886 | |
Vijayavardhan Vennapusa | afbbb8f | 2012-04-13 16:28:45 +0530 | [diff] [blame] | 2887 | static void __init msm8960_init_smsc_hub(void) |
| 2888 | { |
| 2889 | uint32_t version = socinfo_get_version(); |
| 2890 | |
| 2891 | if (SOCINFO_VERSION_MAJOR(version) == 1) |
| 2892 | return; |
| 2893 | |
| 2894 | if (machine_is_msm8960_liquid()) |
| 2895 | platform_device_register(&smsc_hub_device); |
| 2896 | } |
| 2897 | |
Vamsi Krishna | 98f54fb | 2011-11-02 14:55:41 -0700 | [diff] [blame] | 2898 | static void __init msm8960_init_hsic(void) |
| 2899 | { |
| 2900 | #ifdef CONFIG_USB_EHCI_MSM_HSIC |
| 2901 | uint32_t version = socinfo_get_version(); |
| 2902 | |
Vamsi Krishna | f74d2edb | 2011-12-02 10:41:11 -0800 | [diff] [blame] | 2903 | if (SOCINFO_VERSION_MAJOR(version) == 1) |
Vamsi Krishna | 98f54fb | 2011-11-02 14:55:41 -0700 | [diff] [blame] | 2904 | return; |
| 2905 | |
Joel King | 0cbf5d8 | 2012-05-24 15:21:38 -0700 | [diff] [blame] | 2906 | if (machine_is_msm8960_liquid()) |
Vamsi Krishna | f74d2edb | 2011-12-02 10:41:11 -0800 | [diff] [blame] | 2907 | platform_device_register(&msm_device_hsic_host); |
Vamsi Krishna | 98f54fb | 2011-11-02 14:55:41 -0700 | [diff] [blame] | 2908 | #endif |
| 2909 | } |
| 2910 | |
Amir Samuelov | 5137e39 | 2011-09-21 17:31:25 +0300 | [diff] [blame] | 2911 | #ifdef CONFIG_ISL9519_CHARGER |
| 2912 | static struct isl_platform_data isl_data __initdata = { |
| 2913 | .valid_n_gpio = 0, /* Not required when notify-by-pmic */ |
| 2914 | .chg_detection_config = NULL, /* Not required when notify-by-pmic */ |
| 2915 | .max_system_voltage = 4200, |
| 2916 | .min_system_voltage = 3200, |
Amir Samuelov | 95f49ff | 2012-01-29 09:14:08 +0200 | [diff] [blame] | 2917 | .chgcurrent = 1900, |
| 2918 | .term_current = 0, |
Amir Samuelov | 5137e39 | 2011-09-21 17:31:25 +0300 | [diff] [blame] | 2919 | .input_current = 2048, |
| 2920 | }; |
| 2921 | |
| 2922 | static struct i2c_board_info isl_charger_i2c_info[] __initdata = { |
| 2923 | { |
| 2924 | I2C_BOARD_INFO("isl9519q", 0x9), |
| 2925 | .irq = 0, /* Not required when notify-by-pmic */ |
| 2926 | .platform_data = &isl_data, |
| 2927 | }, |
| 2928 | }; |
| 2929 | #endif /* CONFIG_ISL9519_CHARGER */ |
| 2930 | |
Amir Samuelov | 755616d | 2011-12-13 16:34:46 +0200 | [diff] [blame] | 2931 | static struct i2c_board_info liquid_io_expander_i2c_info[] __initdata = { |
| 2932 | { |
| 2933 | I2C_BOARD_INFO("sx1508q", 0x20), |
| 2934 | .platform_data = &msm8960_sx150x_data[SX150X_LIQUID] |
| 2935 | }, |
| 2936 | }; |
| 2937 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2938 | static struct i2c_registry msm8960_i2c_devices[] __initdata = { |
Amir Samuelov | 5137e39 | 2011-09-21 17:31:25 +0300 | [diff] [blame] | 2939 | #ifdef CONFIG_ISL9519_CHARGER |
| 2940 | { |
| 2941 | I2C_LIQUID, |
| 2942 | MSM_8960_GSBI10_QUP_I2C_BUS_ID, |
| 2943 | isl_charger_i2c_info, |
| 2944 | ARRAY_SIZE(isl_charger_i2c_info), |
| 2945 | }, |
| 2946 | #endif /* CONFIG_ISL9519_CHARGER */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2947 | { |
| 2948 | I2C_SURF | I2C_FFA | I2C_FLUID, |
| 2949 | MSM_8960_GSBI3_QUP_I2C_BUS_ID, |
| 2950 | cyttsp_info, |
| 2951 | ARRAY_SIZE(cyttsp_info), |
Rohit Vaswani | cd2a59b | 2011-07-19 12:00:48 -0700 | [diff] [blame] | 2952 | }, |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 2953 | { |
| 2954 | I2C_LIQUID, |
| 2955 | MSM_8960_GSBI3_QUP_I2C_BUS_ID, |
| 2956 | mxt_device_info, |
| 2957 | ARRAY_SIZE(mxt_device_info), |
| 2958 | }, |
Mohan Pallaka | 5e49039 | 2011-09-09 15:18:41 +0530 | [diff] [blame] | 2959 | { |
Manoj Rao | 1464874 | 2012-03-30 19:42:12 -0700 | [diff] [blame] | 2960 | I2C_SURF | I2C_FFA | I2C_LIQUID, |
Mohan Pallaka | 5e49039 | 2011-09-09 15:18:41 +0530 | [diff] [blame] | 2961 | MSM_8960_GSBI10_QUP_I2C_BUS_ID, |
Eugene Yasman | d2316b8 | 2011-12-07 18:23:48 +0200 | [diff] [blame] | 2962 | sii_device_info, |
| 2963 | ARRAY_SIZE(sii_device_info), |
| 2964 | }, |
| 2965 | { |
| 2966 | I2C_LIQUID, |
| 2967 | MSM_8960_GSBI10_QUP_I2C_BUS_ID, |
Mohan Pallaka | 5e49039 | 2011-09-09 15:18:41 +0530 | [diff] [blame] | 2968 | msm_isa1200_board_info, |
| 2969 | ARRAY_SIZE(msm_isa1200_board_info), |
| 2970 | }, |
Amir Samuelov | 755616d | 2011-12-13 16:34:46 +0200 | [diff] [blame] | 2971 | { |
| 2972 | I2C_LIQUID, |
| 2973 | MSM_8960_GSBI10_QUP_I2C_BUS_ID, |
| 2974 | liquid_io_expander_i2c_info, |
| 2975 | ARRAY_SIZE(liquid_io_expander_i2c_info), |
| 2976 | }, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2977 | }; |
| 2978 | #endif /* CONFIG_I2C */ |
| 2979 | |
| 2980 | static void __init register_i2c_devices(void) |
| 2981 | { |
| 2982 | #ifdef CONFIG_I2C |
| 2983 | u8 mach_mask = 0; |
| 2984 | int i; |
Kevin Chan | 09f4e66 | 2011-12-16 08:17:02 -0800 | [diff] [blame] | 2985 | #ifdef CONFIG_MSM_CAMERA |
| 2986 | struct i2c_registry msm8960_camera_i2c_devices = { |
| 2987 | I2C_SURF | I2C_FFA | I2C_FLUID | I2C_LIQUID | I2C_RUMI, |
| 2988 | MSM_8960_GSBI4_QUP_I2C_BUS_ID, |
| 2989 | msm8960_camera_board_info.board_info, |
| 2990 | msm8960_camera_board_info.num_i2c_board_info, |
| 2991 | }; |
| 2992 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2993 | |
| 2994 | /* Build the matching 'supported_machs' bitmask */ |
| 2995 | if (machine_is_msm8960_cdp()) |
| 2996 | mach_mask = I2C_SURF; |
| 2997 | else if (machine_is_msm8960_rumi3()) |
| 2998 | mach_mask = I2C_RUMI; |
| 2999 | else if (machine_is_msm8960_sim()) |
| 3000 | mach_mask = I2C_SIM; |
Amy Maloche | 2d02803 | 2011-07-20 14:08:06 -0700 | [diff] [blame] | 3001 | else if (machine_is_msm8960_fluid()) |
| 3002 | mach_mask = I2C_FLUID; |
Amir Samuelov | 05f8780 | 2011-08-27 18:30:12 +0300 | [diff] [blame] | 3003 | else if (machine_is_msm8960_liquid()) |
| 3004 | mach_mask = I2C_LIQUID; |
Amy Maloche | 1b0663f | 2011-08-02 16:46:22 -0700 | [diff] [blame] | 3005 | else if (machine_is_msm8960_mtp()) |
| 3006 | mach_mask = I2C_FFA; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3007 | else |
| 3008 | pr_err("unmatched machine ID in register_i2c_devices\n"); |
| 3009 | |
Jing Lin | eec88ca | 2012-02-08 11:18:30 -0800 | [diff] [blame] | 3010 | if (machine_is_msm8960_liquid()) { |
| 3011 | if (SOCINFO_VERSION_MAJOR(socinfo_get_platform_version()) == 3) |
| 3012 | mxt_device_info[0].platform_data = |
| 3013 | &mxt_platform_data_3d; |
| 3014 | else |
| 3015 | mxt_device_info[0].platform_data = |
| 3016 | &mxt_platform_data_2d; |
| 3017 | } |
| 3018 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3019 | /* Run the array and install devices as appropriate */ |
| 3020 | for (i = 0; i < ARRAY_SIZE(msm8960_i2c_devices); ++i) { |
| 3021 | if (msm8960_i2c_devices[i].machs & mach_mask) |
| 3022 | i2c_register_board_info(msm8960_i2c_devices[i].bus, |
| 3023 | msm8960_i2c_devices[i].info, |
| 3024 | msm8960_i2c_devices[i].len); |
| 3025 | } |
Manoj Rao | c6d904c | 2012-06-22 00:32:14 -0700 | [diff] [blame] | 3026 | |
| 3027 | if (!mhl_platform_data.gpio_mhl_power) |
| 3028 | pr_debug("mhl device configured for ext debug board\n"); |
| 3029 | |
Kevin Chan | 09f4e66 | 2011-12-16 08:17:02 -0800 | [diff] [blame] | 3030 | #ifdef CONFIG_MSM_CAMERA |
| 3031 | if (msm8960_camera_i2c_devices.machs & mach_mask) |
| 3032 | i2c_register_board_info(msm8960_camera_i2c_devices.bus, |
| 3033 | msm8960_camera_i2c_devices.info, |
| 3034 | msm8960_camera_i2c_devices.len); |
| 3035 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3036 | #endif |
| 3037 | } |
| 3038 | |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3039 | static void __init msm8960_sim_init(void) |
| 3040 | { |
Jeff Ohlstein | 7e66855 | 2011-10-06 16:17:25 -0700 | [diff] [blame] | 3041 | struct msm_watchdog_pdata *wdog_pdata = (struct msm_watchdog_pdata *) |
| 3042 | &msm8960_device_watchdog.dev.platform_data; |
| 3043 | |
| 3044 | wdog_pdata->bark_time = 15000; |
Siddartha Mohanadoss | fad0af1 | 2012-01-20 15:08:38 -0800 | [diff] [blame] | 3045 | msm_tsens_early_init(&msm_tsens_pdata); |
Praveen Chidambaram | 877d7a4 | 2012-06-05 14:33:20 -0600 | [diff] [blame] | 3046 | msm_thermal_init(&msm_thermal_pdata); |
Praveen Chidambaram | 7849901 | 2011-11-01 17:15:17 -0600 | [diff] [blame] | 3047 | BUG_ON(msm_rpm_init(&msm8960_rpm_data)); |
| 3048 | BUG_ON(msm_rpmrs_levels_init(&msm_rpmrs_data)); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3049 | regulator_suppress_info_printing(); |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 3050 | platform_device_register(&msm8960_device_rpm_regulator); |
Stephen Boyd | bb600ae | 2011-08-02 20:11:40 -0700 | [diff] [blame] | 3051 | msm_clock_init(&msm8960_clock_init_data); |
Stepan Moskovchenko | ef1e0b6 | 2011-12-01 12:10:16 -0800 | [diff] [blame] | 3052 | msm8960_init_pmic(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3053 | |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 3054 | msm8960_device_otg.dev.platform_data = &msm_otg_pdata; |
Stepan Moskovchenko | 3b09bf5 | 2011-12-06 20:40:53 -0800 | [diff] [blame] | 3055 | msm8960_init_gpiomux(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3056 | msm8960_i2c_init(); |
| 3057 | msm_spm_init(msm_spm_data, ARRAY_SIZE(msm_spm_data)); |
| 3058 | msm_spm_l2_init(msm_spm_l2_data); |
| 3059 | msm8960_init_buses(); |
| 3060 | platform_add_devices(common_devices, ARRAY_SIZE(common_devices)); |
Stepan Moskovchenko | ef1e0b6 | 2011-12-01 12:10:16 -0800 | [diff] [blame] | 3061 | msm8960_pm8921_gpio_mpp_init(); |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3062 | platform_add_devices(sim_devices, ARRAY_SIZE(sim_devices)); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3063 | |
| 3064 | msm8960_device_qup_spi_gsbi1.dev.platform_data = |
| 3065 | &msm8960_qup_spi_gsbi1_pdata; |
| 3066 | spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info)); |
| 3067 | |
| 3068 | msm8960_init_mmc(); |
Stepan Moskovchenko | 24cd864 | 2011-11-29 13:07:53 -0800 | [diff] [blame] | 3069 | msm8960_init_fb(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3070 | slim_register_board_info(msm_slim_devices, |
| 3071 | ARRAY_SIZE(msm_slim_devices)); |
Maheshkumar Sivasubramanian | c6c5503 | 2011-10-25 16:01:32 -0600 | [diff] [blame] | 3072 | BUG_ON(msm_pm_boot_init(&msm_pm_boot_pdata)); |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3073 | } |
| 3074 | |
| 3075 | static void __init msm8960_rumi3_init(void) |
| 3076 | { |
Siddartha Mohanadoss | fad0af1 | 2012-01-20 15:08:38 -0800 | [diff] [blame] | 3077 | msm_tsens_early_init(&msm_tsens_pdata); |
Praveen Chidambaram | 877d7a4 | 2012-06-05 14:33:20 -0600 | [diff] [blame] | 3078 | msm_thermal_init(&msm_thermal_pdata); |
Praveen Chidambaram | 7849901 | 2011-11-01 17:15:17 -0600 | [diff] [blame] | 3079 | BUG_ON(msm_rpm_init(&msm8960_rpm_data)); |
| 3080 | BUG_ON(msm_rpmrs_levels_init(&msm_rpmrs_data)); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3081 | regulator_suppress_info_printing(); |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 3082 | platform_device_register(&msm8960_device_rpm_regulator); |
Stepan Moskovchenko | 3b09bf5 | 2011-12-06 20:40:53 -0800 | [diff] [blame] | 3083 | msm8960_init_gpiomux(); |
Stepan Moskovchenko | ef1e0b6 | 2011-12-01 12:10:16 -0800 | [diff] [blame] | 3084 | msm8960_init_pmic(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3085 | msm8960_device_qup_spi_gsbi1.dev.platform_data = |
| 3086 | &msm8960_qup_spi_gsbi1_pdata; |
| 3087 | spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info)); |
| 3088 | msm8960_i2c_init(); |
| 3089 | msm_spm_init(msm_spm_data, ARRAY_SIZE(msm_spm_data)); |
| 3090 | msm_spm_l2_init(msm_spm_l2_data); |
| 3091 | platform_add_devices(common_devices, ARRAY_SIZE(common_devices)); |
Stepan Moskovchenko | ef1e0b6 | 2011-12-01 12:10:16 -0800 | [diff] [blame] | 3092 | msm8960_pm8921_gpio_mpp_init(); |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3093 | platform_add_devices(rumi3_devices, ARRAY_SIZE(rumi3_devices)); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3094 | msm8960_init_mmc(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3095 | register_i2c_devices(); |
Mayank Rana | e009c92 | 2012-03-22 03:02:06 +0530 | [diff] [blame] | 3096 | |
Mayank Rana | e009c92 | 2012-03-22 03:02:06 +0530 | [diff] [blame] | 3097 | |
Stepan Moskovchenko | 24cd864 | 2011-11-29 13:07:53 -0800 | [diff] [blame] | 3098 | msm8960_init_fb(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3099 | slim_register_board_info(msm_slim_devices, |
| 3100 | ARRAY_SIZE(msm_slim_devices)); |
Maheshkumar Sivasubramanian | c6c5503 | 2011-10-25 16:01:32 -0600 | [diff] [blame] | 3101 | BUG_ON(msm_pm_boot_init(&msm_pm_boot_pdata)); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3102 | } |
| 3103 | |
| 3104 | static void __init msm8960_cdp_init(void) |
| 3105 | { |
Naveen Ramaraj | 76483ad | 2011-09-06 14:25:44 -0700 | [diff] [blame] | 3106 | if (meminfo_init(SYS_MEMORY, SZ_256M) < 0) |
| 3107 | pr_err("meminfo_init() failed!\n"); |
| 3108 | |
Siddartha Mohanadoss | fad0af1 | 2012-01-20 15:08:38 -0800 | [diff] [blame] | 3109 | msm_tsens_early_init(&msm_tsens_pdata); |
Praveen Chidambaram | 877d7a4 | 2012-06-05 14:33:20 -0600 | [diff] [blame] | 3110 | msm_thermal_init(&msm_thermal_pdata); |
Praveen Chidambaram | 7849901 | 2011-11-01 17:15:17 -0600 | [diff] [blame] | 3111 | BUG_ON(msm_rpm_init(&msm8960_rpm_data)); |
| 3112 | BUG_ON(msm_rpmrs_levels_init(&msm_rpmrs_data)); |
Abhijeet Dharmapurikar | 6d565fd | 2011-09-15 18:49:56 -0700 | [diff] [blame] | 3113 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3114 | regulator_suppress_info_printing(); |
| 3115 | if (msm_xo_init()) |
| 3116 | pr_err("Failed to initialize XO votes\n"); |
David Collins | 26f0556 | 2011-06-20 09:56:28 -0700 | [diff] [blame] | 3117 | platform_device_register(&msm8960_device_rpm_regulator); |
Stephen Boyd | bb600ae | 2011-08-02 20:11:40 -0700 | [diff] [blame] | 3118 | msm_clock_init(&msm8960_clock_init_data); |
Vijayavardhan Vennapusa | fc464f0 | 2011-11-04 21:54:00 +0530 | [diff] [blame] | 3119 | if (machine_is_msm8960_liquid()) |
| 3120 | msm_otg_pdata.mhl_enable = true; |
Stepan Moskovchenko | 14aa649 | 2011-08-08 15:15:01 -0700 | [diff] [blame] | 3121 | msm8960_device_otg.dev.platform_data = &msm_otg_pdata; |
Anji jonnala | a8b8d73 | 2011-12-06 10:03:24 +0530 | [diff] [blame] | 3122 | if (machine_is_msm8960_mtp() || machine_is_msm8960_fluid() || |
| 3123 | machine_is_msm8960_cdp()) { |
| 3124 | msm_otg_pdata.phy_init_seq = wr_phy_init_seq; |
| 3125 | } else if (machine_is_msm8960_liquid()) { |
| 3126 | msm_otg_pdata.phy_init_seq = |
| 3127 | liquid_v1_phy_init_seq; |
| 3128 | } |
Ofir Cohen | 94213a7 | 2012-05-03 14:26:32 +0300 | [diff] [blame] | 3129 | android_usb_pdata.swfi_latency = |
Anji jonnala | a7c1c5c | 2011-12-12 12:20:36 +0530 | [diff] [blame] | 3130 | msm_rpmrs_levels[0].latency_us; |
Vijayavardhan Vennapusa | e3316a1 | 2011-10-15 06:05:17 +0530 | [diff] [blame] | 3131 | msm_device_hsic_host.dev.platform_data = &msm_hsic_pdata; |
Vijayavardhan Vennapusa | afbbb8f | 2012-04-13 16:28:45 +0530 | [diff] [blame] | 3132 | if (SOCINFO_VERSION_MAJOR(socinfo_get_version()) >= 2 && |
| 3133 | machine_is_msm8960_liquid()) |
| 3134 | msm_device_hsic_host.dev.parent = &smsc_hub_device.dev; |
Stepan Moskovchenko | 3b09bf5 | 2011-12-06 20:40:53 -0800 | [diff] [blame] | 3135 | msm8960_init_gpiomux(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3136 | msm8960_device_qup_spi_gsbi1.dev.platform_data = |
| 3137 | &msm8960_qup_spi_gsbi1_pdata; |
| 3138 | spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info)); |
Stepan Moskovchenko | ef1e0b6 | 2011-12-01 12:10:16 -0800 | [diff] [blame] | 3139 | |
| 3140 | msm8960_init_pmic(); |
Mohan Pallaka | f69f049 | 2011-11-21 13:08:33 +0530 | [diff] [blame] | 3141 | if ((SOCINFO_VERSION_MAJOR(socinfo_get_version()) >= 2 && |
| 3142 | (machine_is_msm8960_mtp())) || machine_is_msm8960_liquid()) |
| 3143 | msm_isa1200_board_info[0].platform_data = &isa1200_1_pdata; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3144 | msm8960_i2c_init(); |
Lucille Sylvester | 34ec369 | 2011-08-16 16:28:04 -0600 | [diff] [blame] | 3145 | msm8960_gfx_init(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3146 | msm_spm_init(msm_spm_data, ARRAY_SIZE(msm_spm_data)); |
| 3147 | msm_spm_l2_init(msm_spm_l2_data); |
| 3148 | msm8960_init_buses(); |
Matt Wagantall | 1f65d9d | 2012-04-25 14:24:20 -0700 | [diff] [blame] | 3149 | platform_add_devices(msm8960_footswitch, msm8960_num_footswitch); |
David Collins | b10be1d | 2011-09-02 10:29:31 -0700 | [diff] [blame] | 3150 | if (machine_is_msm8960_liquid()) |
| 3151 | platform_device_register(&msm8960_device_ext_3p3v_vreg); |
David Collins | d5a4073 | 2011-11-29 15:53:56 -0800 | [diff] [blame] | 3152 | if (machine_is_msm8960_cdp()) |
| 3153 | platform_device_register(&msm8960_device_ext_l2_vreg); |
Stepan Moskovchenko | 2b4b1cd | 2012-03-29 18:21:04 -0700 | [diff] [blame] | 3154 | |
| 3155 | if (socinfo_get_platform_subtype() == PLATFORM_SUBTYPE_SGLTE) |
| 3156 | platform_device_register(&msm8960_device_uart_gsbi8); |
| 3157 | else |
| 3158 | platform_device_register(&msm8960_device_uart_gsbi5); |
| 3159 | |
Mayank Rana | a7f75a6 | 2012-04-21 10:09:42 -0700 | [diff] [blame] | 3160 | /* For 8960 Fusion 2.2 Primary IPC */ |
Mayank Rana | d85a508 | 2012-04-29 17:24:13 -0700 | [diff] [blame] | 3161 | if (socinfo_get_platform_subtype() == PLATFORM_SUBTYPE_SGLTE) { |
| 3162 | msm_uart_dm9_pdata.wakeup_irq = gpio_to_irq(94); /* GSBI9(2) */ |
Mayank Rana | a7f75a6 | 2012-04-21 10:09:42 -0700 | [diff] [blame] | 3163 | msm_device_uart_dm9.dev.platform_data = &msm_uart_dm9_pdata; |
Mayank Rana | 77f83c2 | 2012-07-10 09:31:02 +0530 | [diff] [blame] | 3164 | platform_device_register(&msm_device_uart_dm9); |
Mayank Rana | d85a508 | 2012-04-29 17:24:13 -0700 | [diff] [blame] | 3165 | } |
Mayank Rana | a7f75a6 | 2012-04-21 10:09:42 -0700 | [diff] [blame] | 3166 | |
Mayank Rana | 1f02d95 | 2012-07-04 19:11:20 +0530 | [diff] [blame] | 3167 | /* For 8960 Standalone External Bluetooth Interface */ |
| 3168 | if (socinfo_get_platform_subtype() != PLATFORM_SUBTYPE_SGLTE) { |
| 3169 | msm_device_uart_dm8.dev.platform_data = &msm_uart_dm8_pdata; |
| 3170 | platform_device_register(&msm_device_uart_dm8); |
| 3171 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3172 | platform_add_devices(common_devices, ARRAY_SIZE(common_devices)); |
Stepan Moskovchenko | ef1e0b6 | 2011-12-01 12:10:16 -0800 | [diff] [blame] | 3173 | msm8960_pm8921_gpio_mpp_init(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3174 | platform_add_devices(cdp_devices, ARRAY_SIZE(cdp_devices)); |
Vijayavardhan Vennapusa | afbbb8f | 2012-04-13 16:28:45 +0530 | [diff] [blame] | 3175 | msm8960_init_smsc_hub(); |
Vamsi Krishna | 98f54fb | 2011-11-02 14:55:41 -0700 | [diff] [blame] | 3176 | msm8960_init_hsic(); |
Steve Muckle | f132c6c | 2012-06-06 18:30:57 -0700 | [diff] [blame] | 3177 | #ifdef CONFIG_MSM_CAMERA |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3178 | msm8960_init_cam(); |
Steve Muckle | f132c6c | 2012-06-06 18:30:57 -0700 | [diff] [blame] | 3179 | #endif |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3180 | msm8960_init_mmc(); |
Mohan Pallaka | 5083738 | 2011-09-07 11:00:57 +0530 | [diff] [blame] | 3181 | if (machine_is_msm8960_liquid()) |
| 3182 | mxt_init_hw_liquid(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3183 | register_i2c_devices(); |
Stepan Moskovchenko | 24cd864 | 2011-11-29 13:07:53 -0800 | [diff] [blame] | 3184 | msm8960_init_fb(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3185 | slim_register_board_info(msm_slim_devices, |
| 3186 | ARRAY_SIZE(msm_slim_devices)); |
| 3187 | msm8960_init_dsps(); |
Larry Bassel | a7eadea | 2011-07-14 10:46:00 -0700 | [diff] [blame] | 3188 | change_memory_power = &msm8960_change_memory_power; |
Maheshkumar Sivasubramanian | c6c5503 | 2011-10-25 16:01:32 -0600 | [diff] [blame] | 3189 | BUG_ON(msm_pm_boot_init(&msm_pm_boot_pdata)); |
Joel King | 0cbf5d8 | 2012-05-24 15:21:38 -0700 | [diff] [blame] | 3190 | if (socinfo_get_platform_subtype() == PLATFORM_SUBTYPE_SGLTE) { |
| 3191 | mdm_sglte_device.dev.platform_data = &sglte_platform_data; |
| 3192 | platform_device_register(&mdm_sglte_device); |
| 3193 | } |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3194 | } |
| 3195 | |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 3196 | MACHINE_START(MSM8960_SIM, "QCT MSM8960 SIMULATOR") |
| 3197 | .map_io = msm8960_map_io, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3198 | .reserve = msm8960_reserve, |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 3199 | .init_irq = msm8960_init_irq, |
Marc Zyngier | 89bdafd1 | 2011-12-22 11:39:20 +0530 | [diff] [blame] | 3200 | .handle_irq = gic_handle_irq, |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 3201 | .timer = &msm_timer, |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3202 | .init_machine = msm8960_sim_init, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3203 | .init_early = msm8960_allocate_memory_regions, |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 3204 | .init_very_early = msm8960_early_memory, |
Jeff Ohlstein | dd0dd9b | 2012-05-29 17:47:21 -0700 | [diff] [blame] | 3205 | .restart = msm_restart, |
Stepan Moskovchenko | f441ca2 | 2010-12-01 19:31:16 -0800 | [diff] [blame] | 3206 | MACHINE_END |
Stepan Moskovchenko | 50ede4e | 2010-12-13 18:12:19 -0800 | [diff] [blame] | 3207 | |
| 3208 | MACHINE_START(MSM8960_RUMI3, "QCT MSM8960 RUMI3") |
| 3209 | .map_io = msm8960_map_io, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3210 | .reserve = msm8960_reserve, |
Stepan Moskovchenko | 50ede4e | 2010-12-13 18:12:19 -0800 | [diff] [blame] | 3211 | .init_irq = msm8960_init_irq, |
Marc Zyngier | 89bdafd1 | 2011-12-22 11:39:20 +0530 | [diff] [blame] | 3212 | .handle_irq = gic_handle_irq, |
Stepan Moskovchenko | 50ede4e | 2010-12-13 18:12:19 -0800 | [diff] [blame] | 3213 | .timer = &msm_timer, |
Stepan Moskovchenko | d056fca | 2011-01-27 12:12:07 -0800 | [diff] [blame] | 3214 | .init_machine = msm8960_rumi3_init, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3215 | .init_early = msm8960_allocate_memory_regions, |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 3216 | .init_very_early = msm8960_early_memory, |
Jeff Ohlstein | dd0dd9b | 2012-05-29 17:47:21 -0700 | [diff] [blame] | 3217 | .restart = msm_restart, |
Stepan Moskovchenko | 50ede4e | 2010-12-13 18:12:19 -0800 | [diff] [blame] | 3218 | MACHINE_END |
| 3219 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3220 | MACHINE_START(MSM8960_CDP, "QCT MSM8960 CDP") |
| 3221 | .map_io = msm8960_map_io, |
| 3222 | .reserve = msm8960_reserve, |
| 3223 | .init_irq = msm8960_init_irq, |
Marc Zyngier | 89bdafd1 | 2011-12-22 11:39:20 +0530 | [diff] [blame] | 3224 | .handle_irq = gic_handle_irq, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3225 | .timer = &msm_timer, |
| 3226 | .init_machine = msm8960_cdp_init, |
| 3227 | .init_early = msm8960_allocate_memory_regions, |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 3228 | .init_very_early = msm8960_early_memory, |
Jeff Ohlstein | dd0dd9b | 2012-05-29 17:47:21 -0700 | [diff] [blame] | 3229 | .restart = msm_restart, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3230 | MACHINE_END |
| 3231 | |
| 3232 | MACHINE_START(MSM8960_MTP, "QCT MSM8960 MTP") |
| 3233 | .map_io = msm8960_map_io, |
| 3234 | .reserve = msm8960_reserve, |
| 3235 | .init_irq = msm8960_init_irq, |
Marc Zyngier | 89bdafd1 | 2011-12-22 11:39:20 +0530 | [diff] [blame] | 3236 | .handle_irq = gic_handle_irq, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3237 | .timer = &msm_timer, |
| 3238 | .init_machine = msm8960_cdp_init, |
| 3239 | .init_early = msm8960_allocate_memory_regions, |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 3240 | .init_very_early = msm8960_early_memory, |
Jeff Ohlstein | dd0dd9b | 2012-05-29 17:47:21 -0700 | [diff] [blame] | 3241 | .restart = msm_restart, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3242 | MACHINE_END |
| 3243 | |
| 3244 | MACHINE_START(MSM8960_FLUID, "QCT MSM8960 FLUID") |
| 3245 | .map_io = msm8960_map_io, |
| 3246 | .reserve = msm8960_reserve, |
| 3247 | .init_irq = msm8960_init_irq, |
Marc Zyngier | 89bdafd1 | 2011-12-22 11:39:20 +0530 | [diff] [blame] | 3248 | .handle_irq = gic_handle_irq, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3249 | .timer = &msm_timer, |
| 3250 | .init_machine = msm8960_cdp_init, |
| 3251 | .init_early = msm8960_allocate_memory_regions, |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 3252 | .init_very_early = msm8960_early_memory, |
Jeff Ohlstein | dd0dd9b | 2012-05-29 17:47:21 -0700 | [diff] [blame] | 3253 | .restart = msm_restart, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3254 | MACHINE_END |
Amir Samuelov | 0d1f8ae | 2011-07-28 11:13:58 +0300 | [diff] [blame] | 3255 | |
| 3256 | MACHINE_START(MSM8960_LIQUID, "QCT MSM8960 LIQUID") |
| 3257 | .map_io = msm8960_map_io, |
| 3258 | .reserve = msm8960_reserve, |
| 3259 | .init_irq = msm8960_init_irq, |
Marc Zyngier | 89bdafd1 | 2011-12-22 11:39:20 +0530 | [diff] [blame] | 3260 | .handle_irq = gic_handle_irq, |
Amir Samuelov | 0d1f8ae | 2011-07-28 11:13:58 +0300 | [diff] [blame] | 3261 | .timer = &msm_timer, |
| 3262 | .init_machine = msm8960_cdp_init, |
| 3263 | .init_early = msm8960_allocate_memory_regions, |
Larry Bassel | b830e18 | 2011-10-14 10:46:55 -0700 | [diff] [blame] | 3264 | .init_very_early = msm8960_early_memory, |
Jeff Ohlstein | dd0dd9b | 2012-05-29 17:47:21 -0700 | [diff] [blame] | 3265 | .restart = msm_restart, |
Amir Samuelov | 0d1f8ae | 2011-07-28 11:13:58 +0300 | [diff] [blame] | 3266 | MACHINE_END |