ARM: tegra: cardhu: enable OV5650/OV5640 sensor
[linux-2.6.git] / arch / arm / mach-tegra / board-cardhu-sensors.c
index 2c4531a..af66e1f 100644 (file)
@@ -1,21 +1,34 @@
 /*
  * arch/arm/mach-tegra/board-cardhu-sensors.c
  *
- * Copyright (c) 2011, NVIDIA, All Rights Reserved.
+ * Copyright (c) 2010-2013, NVIDIA CORPORATION, All rights reserved.
  *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
  *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
  *
+ * Neither the name of NVIDIA CORPORATION nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include <linux/i2c.h>
 #include <linux/i2c/pca954x.h>
 #include <linux/i2c/pca953x.h>
 #include <linux/nct1008.h>
+#include <linux/module.h>
+
 #include <mach/fb.h>
 #include <mach/gpio.h>
 #include <media/ov5650.h>
+#include <media/ov5640.h>
+#include <media/ov14810.h>
 #include <media/ov2710.h>
+#include <media/tps61050.h>
+#include <media/soc_camera.h>
+#include <media/tegra_v4l2_camera.h>
 #include <generated/mach-types.h>
 #include "gpio-names.h"
 #include "board.h"
 #include <linux/mpu.h>
-
+#include <media/sh532u.h>
+#include <media/ad5816.h>
+#include <linux/bq27x00.h>
 #include <mach/gpio.h>
+#include <mach/edp.h>
+#include <mach/thermal.h>
+#include <linux/therm_est.h>
 
 #include "gpio-names.h"
 #include "board-cardhu.h"
+#include "cpu-tegra.h"
+
+#if defined(CONFIG_VIDEO_OV5650) || \
+       defined(CONFIG_VIDEO_OV5650_MODULE) || \
+       defined(CONFIG_SOC_CAMERA_OV5650) || \
+       defined(CONFIG_SOC_CAMERA_OV5650_MODULE)
+static struct regulator *cardhu_1v8_cam1;
+static struct regulator *cardhu_vdd_2v8_cam1;
+#endif
+static struct regulator *cardhu_1v8_cam2;
+static struct regulator *cardhu_1v8_cam3;
+static struct regulator *cardhu_vdd_2v8_cam2;
+static struct regulator *cardhu_vdd_cam3;
 
-static struct regulator *cardhu_1v8_cam1 = NULL;
-static struct regulator *cardhu_1v8_cam3 = NULL;
-static struct regulator *cardhu_avdd_dsi_csi = NULL;
-static struct regulator *cardhu_vdd_2v8_cam1 = NULL;
-static struct regulator *cardhu_vdd_cam3 = NULL;
+static struct board_info board_info;
 
-#ifdef CONFIG_I2C_MUX_PCA954x
 static struct pca954x_platform_mode cardhu_pca954x_modes[] = {
-       { .adap_id = PCA954x_I2C_BUS0, },
-       { .adap_id = PCA954x_I2C_BUS1, },
-       { .adap_id = PCA954x_I2C_BUS2, },
-       { .adap_id = PCA954x_I2C_BUS3, },
+       { .adap_id = PCA954x_I2C_BUS0, .deselect_on_exit = true, },
+       { .adap_id = PCA954x_I2C_BUS1, .deselect_on_exit = true, },
+       { .adap_id = PCA954x_I2C_BUS2, .deselect_on_exit = true, },
+       { .adap_id = PCA954x_I2C_BUS3, .deselect_on_exit = true, },
 };
 
 static struct pca954x_platform_data cardhu_pca954x_data = {
        .modes    = cardhu_pca954x_modes,
        .num_modes      = ARRAY_SIZE(cardhu_pca954x_modes),
 };
+
+#if defined(CONFIG_SOC_CAMERA_OV5640) \
+       || defined(CONFIG_SOC_CAMERA_OV5640_MODULE)
+static int cardhu_ov5640_power_on(void);
+static int cardhu_ov5640_power_off(void);
+
+static int cardhu_ov5640_power(struct device *dev, int enable)
+{
+       if (enable)
+               return cardhu_ov5640_power_on();
+       else
+               cardhu_ov5640_power_off();
+
+       return 0;
+}
+
+static struct i2c_board_info cardhu_ov5640_camera_i2c_device = {
+       I2C_BOARD_INFO("ov5640", 0x3C),
+};
+
+static struct tegra_camera_platform_data cardhu_ov5640_camera_platform_data = {
+       .flip_v                 = 0,
+       .flip_h                 = 0,
+       .port                   = TEGRA_CAMERA_PORT_CSI_B,
+       .lanes                  = 2,
+       .continuous_clk         = 0,
+};
+
+static struct soc_camera_link ov5640_iclink = {
+       .bus_id         = -1, /* This must match the .id of tegra_vi01_device */
+       .board_info     = &cardhu_ov5640_camera_i2c_device,
+       .module_name    = "ov5640",
+       .i2c_adapter_id = PCA954x_I2C_BUS2,
+       .power          = cardhu_ov5640_power,
+       .priv           = &cardhu_ov5640_camera_platform_data,
+};
+
+static struct platform_device cardhu_ov5640_soc_camera_device = {
+       .name   = "soc-camera-pdrv",
+       .id     = 1,
+       .dev    = {
+               .platform_data = &ov5640_iclink,
+       },
+};
+#endif
+
+/* OV5650 V4L2 device */
+#if defined(CONFIG_SOC_CAMERA_OV5650) \
+       || defined(CONFIG_SOC_CAMERA_OV5650_MODULE)
+static int cardhu_left_ov5650_power_on(void);
+static int cardhu_left_ov5650_power_off(void);
+
+static int cardhu_ov5650_power(struct device *dev, int enable)
+{
+       if (enable)
+               return cardhu_left_ov5650_power_on();
+       else
+               cardhu_left_ov5650_power_off();
+
+       return 0;
+}
+
+static struct i2c_board_info cardhu_ov5650_camera_i2c_device = {
+               I2C_BOARD_INFO("ov5650", 0x36),
+};
+
+static struct tegra_camera_platform_data cardhu_ov5650_camera_platform_data = {
+       .flip_v                 = 0,
+       .flip_h                 = 0,
+       .port                   = TEGRA_CAMERA_PORT_CSI_A,
+       .lanes                  = 2,
+       .continuous_clk         = 1,
+};
+
+static struct soc_camera_link ov5650_iclink = {
+       .bus_id         = -1, /* This must match the .id of tegra_vi01_device */
+       .board_info     = &cardhu_ov5650_camera_i2c_device,
+       .module_name    = "ov5650",
+       .i2c_adapter_id = PCA954x_I2C_BUS0,
+       .power          = cardhu_ov5650_power,
+       .priv           = &cardhu_ov5650_camera_platform_data,
+};
+
+static struct platform_device cardhu_ov5650_soc_camera_device = {
+       .name   = "soc-camera-pdrv",
+       .id     = 0,
+       .dev    = {
+               .platform_data = &ov5650_iclink,
+       },
+};
 #endif
 
 static int cardhu_camera_init(void)
 {
        int ret;
-       struct board_info board_info;
 
-       tegra_get_board_info(&board_info);
        /* Boards E1198 and E1291 are of Cardhu personality
         * and donot have TCA6416 exp for camera */
        if ((board_info.board_id == BOARD_E1198) ||
-               (board_info.board_id == BOARD_E1291)) {
-               tegra_gpio_enable(CAM1_POWER_DWN_GPIO);
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
                ret = gpio_request(CAM1_POWER_DWN_GPIO, "camera_power_en");
                if (ret < 0)
                        pr_err("%s: gpio_request failed for gpio %s\n",
                                __func__, "CAM1_POWER_DWN_GPIO");
-
-               tegra_gpio_enable(CAM3_POWER_DWN_GPIO);
                ret = gpio_request(CAM3_POWER_DWN_GPIO, "cam3_power_en");
                if (ret < 0)
                        pr_err("%s: gpio_request failed for gpio %s\n",
                                __func__, "CAM3_POWER_DWN_GPIO");
 
-               tegra_gpio_enable(OV5650_RESETN_GPIO);
+               ret = gpio_request(CAM2_POWER_DWN_GPIO, "camera2_power_en");
+               if (ret < 0)
+                       pr_err("%s: gpio_request failed for gpio %s\n",
+                               __func__, "CAM2_POWER_DWN_GPIO");
+
                ret = gpio_request(OV5650_RESETN_GPIO, "camera_reset");
                if (ret < 0)
                        pr_err("%s: gpio_request failed for gpio %s\n",
@@ -88,6 +211,7 @@ static int cardhu_camera_init(void)
 
                gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
                gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
                mdelay(10);
 
                gpio_direction_output(OV5650_RESETN_GPIO, 1);
@@ -96,11 +220,9 @@ static int cardhu_camera_init(void)
                mdelay(5);
                gpio_direction_output(OV5650_RESETN_GPIO, 1);
                mdelay(5);
-
        }
 
        /* To select the CSIB MUX either for cam2 or cam3 */
-       tegra_gpio_enable(CAMERA_CSI_MUX_SEL_GPIO);
        ret = gpio_request(CAMERA_CSI_MUX_SEL_GPIO, "camera_csi_sel");
        if (ret < 0)
                pr_err("%s: gpio_request failed for gpio %s\n",
@@ -111,18 +233,17 @@ static int cardhu_camera_init(void)
        return 0;
 }
 
-static int cardhu_ov5650_power_on(void)
+#if defined(CONFIG_VIDEO_OV5650) || \
+       defined(CONFIG_VIDEO_OV5650_MODULE) || \
+       defined(CONFIG_SOC_CAMERA_OV5650) || \
+       defined(CONFIG_SOC_CAMERA_OV5650_MODULE)
+static int cardhu_left_ov5650_power_on(void)
 {
-       struct board_info board_info;
-       tegra_get_board_info(&board_info);
        /* Boards E1198 and E1291 are of Cardhu personality
         * and donot have TCA6416 exp for camera */
        if ((board_info.board_id == BOARD_E1198) ||
-               (board_info.board_id == BOARD_E1291)) {
-
-               gpio_direction_output(CAM3_POWER_DWN_GPIO, 0);
-               gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
-               mdelay(10);
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
 
                if (cardhu_vdd_2v8_cam1 == NULL) {
                        cardhu_vdd_2v8_cam1 = regulator_get(NULL, "vdd_2v8_cam1");
@@ -133,28 +254,6 @@ static int cardhu_ov5650_power_on(void)
                        }
                }
                regulator_enable(cardhu_vdd_2v8_cam1);
-
-               if (cardhu_vdd_cam3 == NULL) {
-                       cardhu_vdd_cam3 = regulator_get(NULL, "vdd_cam3");
-                       if (WARN_ON(IS_ERR(cardhu_vdd_cam3))) {
-                               pr_err("%s: couldn't get regulator vdd_cam3: %ld\n",
-                                       __func__, PTR_ERR(cardhu_vdd_cam3));
-                               goto reg_alloc_fail;
-                       }
-               }
-               regulator_enable(cardhu_vdd_cam3);
-
-               /* Enable VDD_1V8_Cam3 */
-               if (cardhu_1v8_cam3 == NULL) {
-                       cardhu_1v8_cam3 = regulator_get(NULL, "vdd_1v8_cam3");
-                       if (WARN_ON(IS_ERR(cardhu_1v8_cam3))) {
-                               pr_err("%s: couldn't get regulator vdd_1v8_cam3: %ld\n",
-                                       __func__, PTR_ERR(cardhu_1v8_cam3));
-                               goto reg_alloc_fail;
-                       }
-               }
-               regulator_enable(cardhu_1v8_cam3);
-
                mdelay(5);
        }
 
@@ -169,17 +268,23 @@ static int cardhu_ov5650_power_on(void)
        }
        regulator_enable(cardhu_1v8_cam1);
 
-       /* Enable AVDD_CSI_DSI */
-       if (cardhu_avdd_dsi_csi == NULL) {
-               cardhu_avdd_dsi_csi = regulator_get(NULL, "avdd_dsi_csi");
-               if (WARN_ON(IS_ERR(cardhu_avdd_dsi_csi))) {
-                       pr_err("%s: couldn't get regulator avdd_dsi_csi: %ld\n",
-                               __func__, PTR_ERR(cardhu_avdd_dsi_csi));
-                       goto reg_alloc_fail;
-               }
-       }
-       regulator_enable(cardhu_avdd_dsi_csi);
        mdelay(5);
+       if ((board_info.board_id == BOARD_E1198) ||
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
+               mdelay(20);
+               gpio_direction_output(OV5650_RESETN_GPIO, 0);
+               mdelay(100);
+               gpio_direction_output(OV5650_RESETN_GPIO, 1);
+       }
+
+       if (board_info.board_id == BOARD_PM269) {
+               gpio_direction_output(CAM1_RST_L_GPIO, 0);
+               mdelay(100);
+               gpio_direction_output(CAM1_RST_L_GPIO, 1);
+       }
+
        return 0;
 
 reg_alloc_fail:
@@ -187,61 +292,286 @@ reg_alloc_fail:
                regulator_put(cardhu_1v8_cam1);
                cardhu_1v8_cam1 = NULL;
        }
-       if (cardhu_1v8_cam3) {
-               regulator_put(cardhu_1v8_cam3);
-               cardhu_1v8_cam3 = NULL;
-       }
-       if (cardhu_avdd_dsi_csi) {
-               regulator_put(cardhu_avdd_dsi_csi);
-               cardhu_avdd_dsi_csi = NULL;
-       }
        if (cardhu_vdd_2v8_cam1) {
                regulator_put(cardhu_vdd_2v8_cam1);
                cardhu_vdd_2v8_cam1 = NULL;
        }
-       if (cardhu_vdd_cam3) {
-               regulator_put(cardhu_vdd_cam3);
-               cardhu_vdd_cam3 = NULL;
-       }
+
        return -ENODEV;
 
 }
 
-static int cardhu_ov5650_power_off(void)
+static int cardhu_left_ov5650_power_off(void)
 {
-       struct board_info board_info;
-       tegra_get_board_info(&board_info);
        /* Boards E1198 and E1291 are of Cardhu personality
         * and donot have TCA6416 exp for camera */
        if ((board_info.board_id == BOARD_E1198) ||
-               (board_info.board_id == BOARD_E1291)) {
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
                gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
        }
        if (cardhu_1v8_cam1)
                regulator_disable(cardhu_1v8_cam1);
-       if (cardhu_avdd_dsi_csi)
-               regulator_disable(cardhu_avdd_dsi_csi);
        if (cardhu_vdd_2v8_cam1)
                regulator_disable(cardhu_vdd_2v8_cam1);
 
        return 0;
 }
+#endif
+
+#if defined(CONFIG_VIDEO_OV5650) || defined(CONFIG_VIDEO_OV5650_MODULE)
+struct ov5650_platform_data cardhu_left_ov5650_data = {
+       .power_on = cardhu_left_ov5650_power_on,
+       .power_off = cardhu_left_ov5650_power_off,
+};
+#endif
+
+#ifdef CONFIG_VIDEO_OV14810
+static int cardhu_ov14810_power_on(void)
+{
+       if (board_info.board_id == BOARD_E1198) {
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
+               mdelay(20);
+               gpio_direction_output(OV14810_RESETN_GPIO, 0);
+               mdelay(100);
+               gpio_direction_output(OV14810_RESETN_GPIO, 1);
+       }
+
+       return 0;
+}
+
+static int cardhu_ov14810_power_off(void)
+{
+       if (board_info.board_id == BOARD_E1198) {
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
+       }
+
+       return 0;
+}
+
+struct ov14810_platform_data cardhu_ov14810_data = {
+       .power_on = cardhu_ov14810_power_on,
+       .power_off = cardhu_ov14810_power_off,
+};
+
+struct ov14810_platform_data cardhu_ov14810uC_data = {
+       .power_on = NULL,
+       .power_off = NULL,
+};
+
+struct ov14810_platform_data cardhu_ov14810SlaveDev_data = {
+       .power_on = NULL,
+       .power_off = NULL,
+};
+
+static struct i2c_board_info cardhu_i2c_board_info_e1214[] = {
+       {
+               I2C_BOARD_INFO("ov14810", 0x36),
+               .platform_data = &cardhu_ov14810_data,
+       },
+       {
+               I2C_BOARD_INFO("ov14810uC", 0x67),
+               .platform_data = &cardhu_ov14810uC_data,
+       },
+       {
+               I2C_BOARD_INFO("ov14810SlaveDev", 0x69),
+               .platform_data = &cardhu_ov14810SlaveDev_data,
+       }
+};
+#endif
+
+static int cardhu_right_ov5650_power_on(void)
+{
+       /* CSI-B and front sensor are muxed on cardhu */
+       gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 0);
+
+       /* Boards E1198 and E1291 are of Cardhu personality
+        * and donot have TCA6416 exp for camera */
+       if ((board_info.board_id == BOARD_E1198) ||
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
+
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 0);
+               mdelay(10);
+
+               if (cardhu_vdd_2v8_cam2 == NULL) {
+                       cardhu_vdd_2v8_cam2 = regulator_get(NULL, "vdd_2v8_cam2");
+                       if (WARN_ON(IS_ERR(cardhu_vdd_2v8_cam2))) {
+                               pr_err("%s: couldn't get regulator vdd_2v8_cam2: %ld\n",
+                                       __func__, PTR_ERR(cardhu_vdd_2v8_cam2));
+                               goto reg_alloc_fail;
+                       }
+               }
+               regulator_enable(cardhu_vdd_2v8_cam2);
+               mdelay(5);
+       }
+
+       /* Enable VDD_1V8_Cam2 */
+       if (cardhu_1v8_cam2 == NULL) {
+               cardhu_1v8_cam2 = regulator_get(NULL, "vdd_1v8_cam2");
+               if (WARN_ON(IS_ERR(cardhu_1v8_cam2))) {
+                       pr_err("%s: couldn't get regulator vdd_1v8_cam2: %ld\n",
+                               __func__, PTR_ERR(cardhu_1v8_cam2));
+                       goto reg_alloc_fail;
+               }
+       }
+       regulator_enable(cardhu_1v8_cam2);
+
+       mdelay(5);
+
+       if (board_info.board_id == BOARD_PM269) {
+               gpio_direction_output(CAM2_RST_L_GPIO, 0);
+               mdelay(100);
+               gpio_direction_output(CAM2_RST_L_GPIO, 1);
+       }
+
+       return 0;
+
+reg_alloc_fail:
+       if (cardhu_1v8_cam2) {
+               regulator_put(cardhu_1v8_cam2);
+               cardhu_1v8_cam2 = NULL;
+       }
+       if (cardhu_vdd_2v8_cam2) {
+               regulator_put(cardhu_vdd_2v8_cam2);
+               cardhu_vdd_2v8_cam2 = NULL;
+       }
+
+       return -ENODEV;
+
+}
+
+static int cardhu_right_ov5650_power_off(void)
+{
+       /* CSI-B and front sensor are muxed on cardhu */
+       gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 0);
+
+       /* Boards E1198 and E1291 are of Cardhu personality
+        * and do not have TCA6416 for camera */
+       if ((board_info.board_id == BOARD_E1198) ||
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
+       }
+
+       if (cardhu_1v8_cam2)
+               regulator_disable(cardhu_1v8_cam2);
+       if (cardhu_vdd_2v8_cam2)
+               regulator_disable(cardhu_vdd_2v8_cam2);
+
+       return 0;
+}
 
-struct ov5650_platform_data cardhu_ov5650_data = {
-       .power_on = cardhu_ov5650_power_on,
-       .power_off = cardhu_ov5650_power_off,
+static void cardhu_ov5650_synchronize_sensors(void)
+{
+       if (board_info.board_id == BOARD_E1198) {
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
+               mdelay(50);
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
+               mdelay(50);
+       } else if ((board_info.board_id == BOARD_E1291) ||
+                       (board_info.board_id == BOARD_PM315)) {
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
+               mdelay(50);
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 0);
+               mdelay(50);
+       }
+       else
+               pr_err("%s: UnSupported BoardId\n", __func__);
+}
+
+struct ov5650_platform_data cardhu_right_ov5650_data = {
+       .power_on = cardhu_right_ov5650_power_on,
+       .power_off = cardhu_right_ov5650_power_off,
+       .synchronize_sensors = cardhu_ov5650_synchronize_sensors,
 };
 
 static int cardhu_ov2710_power_on(void)
 {
-       cardhu_ov5650_power_on();
+       /* CSI-B and front sensor are muxed on cardhu */
        gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 1);
+
+       /* Enable VDD_1V8_Cam3 */
+       if (cardhu_1v8_cam3 == NULL) {
+               cardhu_1v8_cam3 = regulator_get(NULL, "vdd_1v8_cam3");
+               if (WARN_ON(IS_ERR(cardhu_1v8_cam3))) {
+                       pr_err("%s: couldn't get regulator vdd_1v8_cam3: %ld\n",
+                               __func__, PTR_ERR(cardhu_1v8_cam3));
+                       goto reg_alloc_fail;
+               }
+       }
+       regulator_enable(cardhu_1v8_cam3);
+
+       /* Boards E1198 and E1291 are of Cardhu personality
+        * and do not have TCA6416 for camera */
+       if ((board_info.board_id == BOARD_E1198) ||
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
+               if (cardhu_vdd_cam3 == NULL) {
+                       cardhu_vdd_cam3 = regulator_get(NULL, "vdd_cam3");
+                       if (WARN_ON(IS_ERR(cardhu_vdd_cam3))) {
+                               pr_err("%s: couldn't get regulator vdd_cam3: %ld\n",
+                                       __func__, PTR_ERR(cardhu_vdd_cam3));
+                               goto reg_alloc_fail;
+                       }
+               }
+               regulator_enable(cardhu_vdd_cam3);
+
+               mdelay(5);
+
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 0);
+               gpio_direction_output(CAM3_POWER_DWN_GPIO, 0);
+               mdelay(10);
+
+       }
+
+       mdelay(20);
+
        return 0;
+
+reg_alloc_fail:
+       if (cardhu_1v8_cam3) {
+               regulator_put(cardhu_1v8_cam3);
+               cardhu_1v8_cam3 = NULL;
+       }
+       if (cardhu_vdd_cam3) {
+               regulator_put(cardhu_vdd_cam3);
+               cardhu_vdd_cam3 = NULL;
+       }
+
+       return -ENODEV;
 }
 
 static int cardhu_ov2710_power_off(void)
 {
-       cardhu_ov5650_power_off();
+       /* CSI-B and front sensor are muxed on cardhu */
+       gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 1);
+
+       /* Boards E1198 and E1291 are of Cardhu personality
+        * and donot have TCA6416 exp for camera */
+       if ((board_info.board_id == BOARD_E1198) ||
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
+               gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
+               if (cardhu_vdd_cam3)
+                       regulator_disable(cardhu_vdd_cam3);
+       }
+
+       if (cardhu_1v8_cam3)
+               regulator_disable(cardhu_1v8_cam3);
+
        return 0;
 }
 
@@ -250,21 +580,273 @@ struct ov2710_platform_data cardhu_ov2710_data = {
        .power_off = cardhu_ov2710_power_off,
 };
 
+static int cardhu_ov5640_power_on(void)
+{
+       /* CSI-B and front sensor are muxed on cardhu */
+       gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 1);
+
+       /* Boards E1198 and E1291 are of Cardhu personality
+        * and donot have TCA6416 exp for camera */
+       if ((board_info.board_id == BOARD_E1198) ||
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
+
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 0);
+               gpio_direction_output(CAM3_POWER_DWN_GPIO, 0);
+               mdelay(10);
+
+               if (cardhu_vdd_cam3 == NULL) {
+                       cardhu_vdd_cam3 = regulator_get(NULL, "vdd_cam3");
+                       if (WARN_ON(IS_ERR(cardhu_vdd_cam3))) {
+                               pr_err("%s: couldn't get regulator vdd_cam3: %ld\n",
+                                       __func__, PTR_ERR(cardhu_vdd_cam3));
+                               goto reg_alloc_fail;
+                       }
+               }
+               regulator_enable(cardhu_vdd_cam3);
+       }
+
+       /* Enable VDD_1V8_Cam3 */
+       if (cardhu_1v8_cam3 == NULL) {
+               cardhu_1v8_cam3 = regulator_get(NULL, "vdd_1v8_cam3");
+               if (WARN_ON(IS_ERR(cardhu_1v8_cam3))) {
+                       pr_err("%s: couldn't get regulator vdd_1v8_cam3: %ld\n",
+                               __func__, PTR_ERR(cardhu_1v8_cam3));
+                       goto reg_alloc_fail;
+               }
+       }
+       regulator_enable(cardhu_1v8_cam3);
+       mdelay(5);
+
+       return 0;
+
+reg_alloc_fail:
+       if (cardhu_1v8_cam3) {
+               regulator_put(cardhu_1v8_cam3);
+               cardhu_1v8_cam3 = NULL;
+       }
+       if (cardhu_vdd_cam3) {
+               regulator_put(cardhu_vdd_cam3);
+               cardhu_vdd_cam3 = NULL;
+       }
+
+       return -ENODEV;
+}
+
+static int cardhu_ov5640_power_off(void)
+{
+       /* CSI-B and front sensor are muxed on cardhu */
+       gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 1);
+
+       /* Boards E1198 and E1291 are of Cardhu personality
+        * and donot have TCA6416 exp for camera */
+       if ((board_info.board_id == BOARD_E1198) ||
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315)) {
+               gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
+               gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
+       }
+
+       if (cardhu_1v8_cam3)
+               regulator_disable(cardhu_1v8_cam3);
+       if (cardhu_vdd_cam3)
+               regulator_disable(cardhu_vdd_cam3);
+
+       return 0;
+}
+
+struct ov5640_platform_data cardhu_ov5640_data = {
+       .power_on = cardhu_ov5640_power_on,
+       .power_off = cardhu_ov5640_power_off,
+};
+
 static const struct i2c_board_info cardhu_i2c3_board_info[] = {
-#ifdef CONFIG_I2C_MUX_PCA954x
        {
                I2C_BOARD_INFO("pca9546", 0x70),
                .platform_data = &cardhu_pca954x_data,
        },
-#endif
 };
+
+
+static struct nvc_gpio_pdata sh532u_gpio_pdata[] = {
+       { SH532U_GPIO_RESET, TEGRA_GPIO_PBB0, false, 0, },
+};
+
+static struct sh532u_platform_data sh532u_left_pdata = {
+       .cfg            = NVC_CFG_NODEV,
+       .num            = 1,
+       .sync           = 2,
+       .dev_name       = "focuser",
+       .gpio_count     = ARRAY_SIZE(sh532u_gpio_pdata),
+       .gpio           = sh532u_gpio_pdata,
+};
+
+static struct sh532u_platform_data sh532u_right_pdata = {
+       .cfg            = NVC_CFG_NODEV,
+       .num            = 2,
+       .sync           = 1,
+       .dev_name       = "focuser",
+       .gpio_count     = ARRAY_SIZE(sh532u_gpio_pdata),
+       .gpio           = sh532u_gpio_pdata,
+};
+
+static struct nvc_gpio_pdata pm269_sh532u_left_gpio_pdata[] = {
+       { SH532U_GPIO_RESET, CAM1_RST_L_GPIO, false, 0, },
+};
+
+static struct sh532u_platform_data pm269_sh532u_left_pdata = {
+       .cfg            = 0,
+       .num            = 1,
+       .sync           = 2,
+       .dev_name       = "focuser",
+       .gpio_count     = ARRAY_SIZE(pm269_sh532u_left_gpio_pdata),
+       .gpio           = pm269_sh532u_left_gpio_pdata,
+};
+
+static struct nvc_gpio_pdata pm269_sh532u_right_gpio_pdata[] = {
+       { SH532U_GPIO_RESET, CAM2_RST_L_GPIO, false, 0, },
+};
+
+static struct sh532u_platform_data pm269_sh532u_right_pdata = {
+       .cfg            = 0,
+       .num            = 2,
+       .sync           = 1,
+       .dev_name       = "focuser",
+       .gpio_count     = ARRAY_SIZE(pm269_sh532u_right_gpio_pdata),
+       .gpio           = pm269_sh532u_right_gpio_pdata,
+};
+
+static struct nvc_gpio_pdata ad5816_gpio_pdata[] = {
+       { AD5816_GPIO_RESET, TEGRA_GPIO_PBB0, false, 0, },
+};
+
+static struct ad5816_platform_data ad5816_left_pdata = {
+       .cfg            = 0,
+       .num            = 1,
+       .sync           = 2,
+       .dev_name       = "focuser",
+       .gpio_count     = ARRAY_SIZE(ad5816_gpio_pdata),
+       .gpio           = ad5816_gpio_pdata,
+};
+
+static struct ad5816_platform_data ad5816_right_pdata = {
+       .cfg            = 0,
+       .num            = 2,
+       .sync           = 1,
+       .dev_name       = "focuser",
+       .gpio_count     = ARRAY_SIZE(ad5816_gpio_pdata),
+       .gpio           = ad5816_gpio_pdata,
+};
+
+static struct nvc_gpio_pdata pm269_ad5816_left_gpio_pdata[] = {
+       { AD5816_GPIO_RESET, CAM1_RST_L_GPIO, false, 0, },
+};
+
+static struct ad5816_platform_data pm269_ad5816_left_pdata = {
+       .cfg            = NVC_CFG_NODEV,
+       .num            = 1,
+       .sync           = 2,
+       .dev_name       = "focuser",
+       .gpio_count     = ARRAY_SIZE(pm269_ad5816_left_gpio_pdata),
+       .gpio           = pm269_ad5816_left_gpio_pdata,
+};
+
+static struct nvc_gpio_pdata pm269_ad5816_right_gpio_pdata[] = {
+       { AD5816_GPIO_RESET, CAM2_RST_L_GPIO, false, 0, },
+};
+
+static struct ad5816_platform_data pm269_ad5816_right_pdata = {
+       .cfg            = NVC_CFG_NODEV,
+       .num            = 2,
+       .sync           = 1,
+       .dev_name       = "focuser",
+       .gpio_count     = ARRAY_SIZE(pm269_ad5816_right_gpio_pdata),
+       .gpio           = pm269_ad5816_right_gpio_pdata,
+};
+
+
+static struct nvc_torch_pin_state cardhu_tps61050_pinstate = {
+       .mask           = 0x0008, /*VGP3*/
+       .values         = 0x0008,
+};
+
+static struct tps61050_platform_data cardhu_tps61050_pdata = {
+       .dev_name       = "torch",
+       .pinstate       = &cardhu_tps61050_pinstate,
+};
+
+static const struct i2c_board_info cardhu_i2c_board_info_tps61050[] = {
+       {
+               I2C_BOARD_INFO("tps61050", 0x33),
+               .platform_data = &cardhu_tps61050_pdata,
+       },
+};
+
 static struct i2c_board_info cardhu_i2c6_board_info[] = {
+#if defined(CONFIG_VIDEO_OV5650) || defined(CONFIG_VIDEO_OV5650_MODULE)
        {
-               I2C_BOARD_INFO("ov5650", 0x36),
-               .platform_data = &cardhu_ov5650_data,
+               I2C_BOARD_INFO("ov5650L", 0x36),
+               .platform_data = &cardhu_left_ov5650_data,
+       },
+#endif
+       {
+               I2C_BOARD_INFO("sh532u", 0x72),
+               .platform_data = &sh532u_left_pdata,
+       },
+       {
+               I2C_BOARD_INFO("ad5816", 0x0E),
+               .platform_data = &ad5816_left_pdata,
+       },
+};
+
+static struct i2c_board_info cardhu_i2c7_board_info[] = {
+#if defined(CONFIG_VIDEO_OV5650) || defined(CONFIG_VIDEO_OV5650_MODULE)
+       {
+               I2C_BOARD_INFO("ov5650R", 0x36),
+               .platform_data = &cardhu_right_ov5650_data,
+       },
+#endif
+       {
+               I2C_BOARD_INFO("sh532u", 0x72),
+               .platform_data = &sh532u_right_pdata,
        },
        {
+               I2C_BOARD_INFO("ad5816", 0x0E),
+               .platform_data = &ad5816_right_pdata,
+       },
+};
+
+static struct i2c_board_info pm269_i2c6_board_info[] = {
+#if defined(CONFIG_VIDEO_OV5650) || defined(CONFIG_VIDEO_OV5650_MODULE)
+       {
+               I2C_BOARD_INFO("ov5650L", 0x36),
+               .platform_data = &cardhu_left_ov5650_data,
+       },
+#endif
+       {
+               I2C_BOARD_INFO("sh532u", 0x72),
+               .platform_data = &pm269_sh532u_left_pdata,
+       },
+       {
+               I2C_BOARD_INFO("ad5816", 0x0E),
+               .platform_data = &pm269_ad5816_left_pdata,
+       },
+};
+
+static struct i2c_board_info pm269_i2c7_board_info[] = {
+#if defined(CONFIG_VIDEO_OV5650) || defined(CONFIG_VIDEO_OV5650_MODULE)
+       {
+               I2C_BOARD_INFO("ov5650R", 0x36),
+               .platform_data = &cardhu_right_ov5650_data,
+       },
+#endif
+       {
                I2C_BOARD_INFO("sh532u", 0x72),
+               .platform_data = &pm269_sh532u_right_pdata,
+       },
+       {
+               I2C_BOARD_INFO("ad5816", 0x0E),
+               .platform_data = &pm269_ad5816_right_pdata,
        },
 };
 
@@ -273,24 +855,117 @@ static struct i2c_board_info cardhu_i2c8_board_info[] = {
                I2C_BOARD_INFO("ov2710", 0x36),
                .platform_data = &cardhu_ov2710_data,
        },
+#if defined(CONFIG_VIDEO_OV5640) || defined(CONFIG_VIDEO_OV5640_MODULE)
+       {
+               I2C_BOARD_INFO("ov5640", 0x3C),
+               .platform_data = &cardhu_ov5640_data,
+       },
+#endif
 };
 
+static int nct_get_temp(void *_data, long *temp)
+{
+       struct nct1008_data *data = _data;
+       return nct1008_thermal_get_temp(data, temp);
+}
+
+static int nct_get_temp_low(void *_data, long *temp)
+{
+       struct nct1008_data *data = _data;
+       return nct1008_thermal_get_temp_low(data, temp);
+}
+
+static int nct_set_limits(void *_data,
+                       long lo_limit_milli,
+                       long hi_limit_milli)
+{
+       struct nct1008_data *data = _data;
+       return nct1008_thermal_set_limits(data,
+                                       lo_limit_milli,
+                                       hi_limit_milli);
+}
+
+static int nct_set_alert(void *_data,
+                               void (*alert_func)(void *),
+                               void *alert_data)
+{
+       struct nct1008_data *data = _data;
+       return nct1008_thermal_set_alert(data, alert_func, alert_data);
+}
+
+static int nct_set_shutdown_temp(void *_data, long shutdown_temp)
+{
+       struct nct1008_data *data = _data;
+       return nct1008_thermal_set_shutdown_temp(data, shutdown_temp);
+}
+
+#ifdef CONFIG_TEGRA_SKIN_THROTTLE
+static int nct_get_itemp(void *dev_data, long *temp)
+{
+       struct nct1008_data *data = dev_data;
+       return nct1008_thermal_get_temps(data, NULL, temp);
+}
+#endif
+
+static void nct1008_probe_callback(struct nct1008_data *data)
+{
+       struct tegra_thermal_device *ext_nct;
+
+       ext_nct = kzalloc(sizeof(struct tegra_thermal_device),
+                                       GFP_KERNEL);
+       if (!ext_nct) {
+               pr_err("unable to allocate thermal device\n");
+               return;
+       }
+
+       ext_nct->name = "nct_ext";
+       ext_nct->id = THERMAL_DEVICE_ID_NCT_EXT;
+       ext_nct->data = data;
+       ext_nct->offset = TDIODE_OFFSET;
+       ext_nct->get_temp = nct_get_temp;
+       ext_nct->get_temp_low = nct_get_temp_low;
+       ext_nct->set_limits = nct_set_limits;
+       ext_nct->set_alert = nct_set_alert;
+       ext_nct->set_shutdown_temp = nct_set_shutdown_temp;
+
+       tegra_thermal_device_register(ext_nct);
+
+#ifdef CONFIG_TEGRA_SKIN_THROTTLE
+       {
+               struct tegra_thermal_device *int_nct;
+               int_nct = kzalloc(sizeof(struct tegra_thermal_device),
+                                               GFP_KERNEL);
+               if (!int_nct) {
+                       kfree(int_nct);
+                       pr_err("unable to allocate thermal device\n");
+                       return;
+               }
+
+               int_nct->name = "nct_int";
+               int_nct->id = THERMAL_DEVICE_ID_NCT_INT;
+               int_nct->data = data;
+               int_nct->get_temp = nct_get_itemp;
+
+               tegra_thermal_device_register(int_nct);
+       }
+#endif
+}
+
 static struct nct1008_platform_data cardhu_nct1008_pdata = {
        .supported_hwrev = true,
-       .ext_range = false,
+       .ext_range = true,
        .conv_rate = 0x08,
-       .offset = 0,
-       .hysteresis = 5,
-       .shutdown_ext_limit = 75,
-       .shutdown_local_limit = 75,
-       .throttling_ext_limit = 60,
-       .alarm_fn = NULL,
+       .offset = 8, /* 4 * 2C. Bug 844025 - 1C for device accuracies */
+       .probe_callback = nct1008_probe_callback,
 };
 
-static struct i2c_board_info cardhu_i2c4_board_info[] = {
+static struct i2c_board_info cardhu_i2c4_bq27510_board_info[] = {
        {
                I2C_BOARD_INFO("bq27510", 0x55),
        },
+};
+
+static struct i2c_board_info cardhu_i2c4_nct1008_board_info[] = {
        {
                I2C_BOARD_INFO("nct1008", 0x4C),
                .platform_data = &cardhu_nct1008_pdata,
@@ -301,23 +976,26 @@ static struct i2c_board_info cardhu_i2c4_board_info[] = {
 static int cardhu_nct1008_init(void)
 {
        int nct1008_port = -1;
-       struct board_info BoardInfo;
-       int ret;
+       int ret = 0;
 
-       tegra_get_board_info(&BoardInfo);
-       if ((BoardInfo.board_id == BOARD_E1198) ||
-               (BoardInfo.board_id == BOARD_E1291)) {
+       if ((board_info.board_id == BOARD_E1198) ||
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_E1257) ||
+               (board_info.board_id == BOARD_PM269) ||
+               (board_info.board_id == BOARD_PM305) ||
+               (board_info.board_id == BOARD_PM311) ||
+               (board_info.board_id == BOARD_PM315)) {
                nct1008_port = TEGRA_GPIO_PCC2;
-       } else if ((BoardInfo.board_id == BOARD_E1186) ||
-               (BoardInfo.board_id == BOARD_E1187)) {
+       } else if ((board_info.board_id == BOARD_E1186) ||
+               (board_info.board_id == BOARD_E1187) ||
+               (board_info.board_id == BOARD_E1256)) {
                /* FIXME: seems to be conflicting with usb3 vbus on E1186 */
                /* nct1008_port = TEGRA_GPIO_PH7; */
        }
 
        if (nct1008_port >= 0) {
                /* FIXME: enable irq when throttling is supported */
-               /* cardhu_i2c4_board_info[0].irq = */
-               /* TEGRA_GPIO_TO_IRQ(nct1008_port); */
+               cardhu_i2c4_nct1008_board_info[0].irq = TEGRA_GPIO_TO_IRQ(nct1008_port);
 
                ret = gpio_request(nct1008_port, "temp_alert");
                if (ret < 0)
@@ -326,10 +1004,8 @@ static int cardhu_nct1008_init(void)
                ret = gpio_direction_input(nct1008_port);
                if (ret < 0)
                        gpio_free(nct1008_port);
-               else
-                       tegra_gpio_enable(nct1008_port);
-
        }
+
        return ret;
 }
 
@@ -358,11 +1034,10 @@ static const struct i2c_board_info cardhu_i2c2_board_info_tca6416[] = {
 
 static int __init pmu_tca6416_init(void)
 {
-       struct board_info board_info;
-       tegra_get_board_info(&board_info);
        if ((board_info.board_id == BOARD_E1198) ||
-                       (board_info.board_id == BOARD_E1291))
-               return 0;
+               (board_info.board_id == BOARD_E1291) ||
+                       (board_info.board_id == BOARD_PM315))
+                       return 0;
 
        pr_info("Registering pmu pca6416\n");
        i2c_register_board_info(4, cardhu_i2c4_board_info_tca6416,
@@ -372,12 +1047,11 @@ static int __init pmu_tca6416_init(void)
 
 static int __init cam_tca6416_init(void)
 {
-       struct board_info board_info;
-       tegra_get_board_info(&board_info);
        /* Boards E1198 and E1291 are of Cardhu personality
         * and donot have TCA6416 exp for camera */
        if ((board_info.board_id == BOARD_E1198) ||
-               (board_info.board_id == BOARD_E1291))
+                       (board_info.board_id == BOARD_E1291) ||
+                       (board_info.board_id == BOARD_PM315))
                return 0;
 
        pr_info("Registering cam pca6416\n");
@@ -397,48 +1071,103 @@ static int __init cam_tca6416_init(void)
 }
 #endif
 
-#ifdef CONFIG_SENSORS_MPU3050
-#define SENSOR_MPU_NAME "mpu3050"
-static struct mpu3050_platform_data mpu3050_data = {
-       .int_config  = 0x10,
-       .orientation = { 0, -1, 0, -1, 0, 0, 0, 0, -1 },  /* Orientation matrix for MPU on cardhu */
-       .level_shifter = 0,
-
-       .accel = {
-       .get_slave_descr = get_accel_slave_descr,
-       .adapt_num   = 2,
-       .bus         = EXT_SLAVE_BUS_SECONDARY,
-       .address     = 0x0F,
-       .orientation = { 0, -1, 0, -1, 0, 0, 0, 0, -1 },  /* Orientation matrix for Kionix on cardhu */
-       },
+/* MPU board file definition   */
+#if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
+#define MPU_GYRO_NAME          "mpu3050"
+#endif
+#if (MPU_GYRO_TYPE == MPU_TYPE_MPU6050)
+#define MPU_GYRO_NAME          "mpu6050"
+#endif
+static struct mpu_platform_data mpu_gyro_data = {
+       .int_config     = 0x10,
+       .level_shifter  = 0,
+       .orientation    = MPU_GYRO_ORIENTATION, /* Located in board_[platformname].h    */
+};
 
-       .compass = {
-       .get_slave_descr = get_compass_slave_descr,
-       .adapt_num   = 2,
-       .bus         = EXT_SLAVE_BUS_PRIMARY,
-       .address     = 0x0C,
-       .orientation = { 1, 0, 0, 0, -1, 0, 0, 0, -1 },  /* Orientation matrix for AKM on cardhu */
-       },
+#if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
+static struct ext_slave_platform_data mpu_accel_data = {
+       .address        = MPU_ACCEL_ADDR,
+       .irq            = 0,
+       .adapt_num      = MPU_ACCEL_BUS_NUM,
+       .bus            = EXT_SLAVE_BUS_SECONDARY,
+       .orientation    = MPU_ACCEL_ORIENTATION,        /* Located in board_[platformname].h    */
+};
+#endif
+
+static struct ext_slave_platform_data mpu_compass_data = {
+       .address        = MPU_COMPASS_ADDR,
+       .irq            = 0,
+       .adapt_num      = MPU_COMPASS_BUS_NUM,
+       .bus            = EXT_SLAVE_BUS_PRIMARY,
+       .orientation    = MPU_COMPASS_ORIENTATION,      /* Located in board_[platformname].h    */
 };
 
-static struct i2c_board_info __initdata mpu3050_i2c0_boardinfo[] = {
+static struct i2c_board_info __initdata inv_mpu_i2c2_board_info[] = {
+       {
+               I2C_BOARD_INFO(MPU_GYRO_NAME, MPU_GYRO_ADDR),
+               .irq = TEGRA_GPIO_TO_IRQ(MPU_GYRO_IRQ_GPIO),
+               .platform_data = &mpu_gyro_data,
+       },
+#if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
+       {
+               I2C_BOARD_INFO(MPU_ACCEL_NAME, MPU_ACCEL_ADDR),
+#if    MPU_ACCEL_IRQ_GPIO
+               .irq = TEGRA_GPIO_TO_IRQ(MPU_ACCEL_IRQ_GPIO),
+#endif
+               .platform_data = &mpu_accel_data,
+       },
+#endif
        {
-               I2C_BOARD_INFO(SENSOR_MPU_NAME, 0x68),
-               .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_PX1),
-               .platform_data = &mpu3050_data,
+               I2C_BOARD_INFO(MPU_COMPASS_NAME, MPU_COMPASS_ADDR),
+#if    MPU_COMPASS_IRQ_GPIO
+               .irq = TEGRA_GPIO_TO_IRQ(MPU_COMPASS_IRQ_GPIO),
+#endif
+               .platform_data = &mpu_compass_data,
        },
 };
 
-static void cardhu_mpuirq_init(void)
+static void mpuirq_init(void)
 {
-       pr_info("*** MPU START *** cardhu_mpuirq_init...\n");
-       tegra_gpio_enable(TEGRA_GPIO_PX1);
-       gpio_request(TEGRA_GPIO_PX1, SENSOR_MPU_NAME);
-       gpio_direction_input(TEGRA_GPIO_PX1);
-       pr_info("*** MPU END *** cardhu_mpuirq_init...\n");
-}
+       int ret = 0;
+
+       pr_info("*** MPU START *** mpuirq_init...\n");
+
+#if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
+#if    MPU_ACCEL_IRQ_GPIO
+       /* ACCEL-IRQ assignment */
+       ret = gpio_request(MPU_ACCEL_IRQ_GPIO, MPU_ACCEL_NAME);
+       if (ret < 0) {
+               pr_err("%s: gpio_request failed %d\n", __func__, ret);
+               return;
+       }
+
+       ret = gpio_direction_input(MPU_ACCEL_IRQ_GPIO);
+       if (ret < 0) {
+               pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
+               gpio_free(MPU_ACCEL_IRQ_GPIO);
+               return;
+       }
+#endif
 #endif
 
+       /* MPU-IRQ assignment */
+       ret = gpio_request(MPU_GYRO_IRQ_GPIO, MPU_GYRO_NAME);
+       if (ret < 0) {
+               pr_err("%s: gpio_request failed %d\n", __func__, ret);
+               return;
+       }
+
+       ret = gpio_direction_input(MPU_GYRO_IRQ_GPIO);
+       if (ret < 0) {
+               pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
+               gpio_free(MPU_GYRO_IRQ_GPIO);
+               return;
+       }
+       pr_info("*** MPU END *** mpuirq_init...\n");
+
+       i2c_register_board_info(MPU_GYRO_BUS_NUM, inv_mpu_i2c2_board_info,
+               ARRAY_SIZE(inv_mpu_i2c2_board_info));
+}
 
 static struct i2c_board_info cardhu_i2c2_isl_board_info[] = {
        {
@@ -446,53 +1175,98 @@ static struct i2c_board_info cardhu_i2c2_isl_board_info[] = {
        }
 };
 
+static struct i2c_board_info cardhu_i2c2_ltr_board_info[] = {
+       {
+               I2C_BOARD_INFO("LTR_558ALS", 0x23),
+       }
+};
+
 int __init cardhu_sensors_init(void)
 {
        int err;
 
+       tegra_get_board_info(&board_info);
+
        cardhu_camera_init();
        cam_tca6416_init();
 
-       i2c_register_board_info(2, cardhu_i2c3_board_info,
-               ARRAY_SIZE(cardhu_i2c3_board_info));
+       if (board_info.board_id != BOARD_PM315) {
+               i2c_register_board_info(2, cardhu_i2c3_board_info,
+                       ARRAY_SIZE(cardhu_i2c3_board_info));
 
-       /* CAM-A is on BUS0 to set CAM-B need to change
-        * PCA954x_I2C_BUS0 to PCA954x_I2C_BUS1 */
-       i2c_register_board_info(PCA954x_I2C_BUS0, cardhu_i2c6_board_info,
-               ARRAY_SIZE(cardhu_i2c6_board_info));
+               i2c_register_board_info(2, cardhu_i2c_board_info_tps61050,
+                       ARRAY_SIZE(cardhu_i2c_board_info_tps61050));
+       }
 
+#ifdef CONFIG_VIDEO_OV14810
+       /* This is disabled by default; To enable this change Kconfig;
+        * there should be some way to detect dynamically which board
+        * is connected (E1211/E1214), till that time sensor selection
+        * logic is static;
+        * e1214 corresponds to ov14810 sensor */
+       i2c_register_board_info(2, cardhu_i2c_board_info_e1214,
+               ARRAY_SIZE(cardhu_i2c_board_info_e1214));
+#else
+       /* Left  camera is on PCA954x's I2C BUS0, Right camera is on BUS1 &
+        * Front camera is on BUS2 */
+       if (board_info.board_id != BOARD_PM269) {
+               i2c_register_board_info(PCA954x_I2C_BUS0,
+                                       cardhu_i2c6_board_info,
+                                       ARRAY_SIZE(cardhu_i2c6_board_info));
+
+               i2c_register_board_info(PCA954x_I2C_BUS1,
+                                       cardhu_i2c7_board_info,
+                                       ARRAY_SIZE(cardhu_i2c7_board_info));
+       } else {
+               i2c_register_board_info(PCA954x_I2C_BUS0,
+                                       pm269_i2c6_board_info,
+                                       ARRAY_SIZE(pm269_i2c6_board_info));
+
+               i2c_register_board_info(PCA954x_I2C_BUS1,
+                                       pm269_i2c7_board_info,
+                                       ARRAY_SIZE(pm269_i2c7_board_info));
+       }
        i2c_register_board_info(PCA954x_I2C_BUS2, cardhu_i2c8_board_info,
                ARRAY_SIZE(cardhu_i2c8_board_info));
 
+#endif
        pmu_tca6416_init();
 
-       i2c_register_board_info(4, cardhu_i2c4_board_info,
-               ARRAY_SIZE(cardhu_i2c4_board_info));
+       if (board_info.board_id == BOARD_E1291)
+               i2c_register_board_info(4, cardhu_i2c4_bq27510_board_info,
+                       ARRAY_SIZE(cardhu_i2c4_bq27510_board_info));
 
-       i2c_register_board_info(2, cardhu_i2c2_isl_board_info,
-               ARRAY_SIZE(cardhu_i2c2_isl_board_info));
+       if (board_info.sku == BOARD_SKU_B11)
+               i2c_register_board_info(2, cardhu_i2c2_ltr_board_info,
+                       ARRAY_SIZE(cardhu_i2c2_ltr_board_info));
+       else if (board_info.board_id != BOARD_PM315)
+               i2c_register_board_info(2, cardhu_i2c2_isl_board_info,
+                       ARRAY_SIZE(cardhu_i2c2_isl_board_info));
 
        err = cardhu_nct1008_init();
        if (err)
                return err;
 
-#ifdef CONFIG_SENSORS_MPU3050
-       cardhu_mpuirq_init();
-#endif
+       i2c_register_board_info(4, cardhu_i2c4_nct1008_board_info,
+               ARRAY_SIZE(cardhu_i2c4_nct1008_board_info));
 
-       if (ARRAY_SIZE(cardhu_i2c3_board_info))
-               i2c_register_board_info(3, cardhu_i2c3_board_info,
-                       ARRAY_SIZE(cardhu_i2c3_board_info));
+       if (board_info.board_id != BOARD_PM315)
+               mpuirq_init();
 
-#ifdef CONFIG_SENSORS_MPU3050
-       i2c_register_board_info(2, mpu3050_i2c0_boardinfo,
-               ARRAY_SIZE(mpu3050_i2c0_boardinfo));
+#if defined(CONFIG_SOC_CAMERA_OV5650) \
+       || defined(CONFIG_SOC_CAMERA_OV5650_MODULE)
+       platform_device_register(&cardhu_ov5650_soc_camera_device);
+#endif
+#if defined(CONFIG_SOC_CAMERA_OV5640) \
+       || defined(CONFIG_SOC_CAMERA_OV5640_MODULE)
+       platform_device_register(&cardhu_ov5640_soc_camera_device);
 #endif
 
        return 0;
 }
 
 #if defined(CONFIG_GPIO_PCA953X)
+#if defined(CONFIG_VIDEO_OV5650) || defined(CONFIG_VIDEO_OV5650_MODULE)
 struct ov5650_gpios {
        const char *name;
        int gpio;
@@ -509,15 +1283,15 @@ struct ov5650_gpios {
 static struct ov5650_gpios ov5650_gpio_keys[] = {
        [0] = OV5650_GPIO("cam1_pwdn", CAM1_PWR_DN_GPIO, 0),
        [1] = OV5650_GPIO("cam1_rst_lo", CAM1_RST_L_GPIO, 1),
-       [2] = OV5650_GPIO("cam1_af_pwdn_lo", CAM1_AF_PWR_DN_L_GPIO, 1),
+       [2] = OV5650_GPIO("cam1_af_pwdn_lo", CAM1_AF_PWR_DN_L_GPIO, 0),
        [3] = OV5650_GPIO("cam1_ldo_shdn_lo", CAM1_LDO_SHUTDN_L_GPIO, 1),
        [4] = OV5650_GPIO("cam2_pwdn", CAM2_PWR_DN_GPIO, 0),
        [5] = OV5650_GPIO("cam2_rst_lo", CAM2_RST_L_GPIO, 1),
-       [6] = OV5650_GPIO("cam2_af_pwdn_lo", CAM2_AF_PWR_DN_L_GPIO, 1),
+       [6] = OV5650_GPIO("cam2_af_pwdn_lo", CAM2_AF_PWR_DN_L_GPIO, 0),
        [7] = OV5650_GPIO("cam2_ldo_shdn_lo", CAM2_LDO_SHUTDN_L_GPIO, 1),
        [8] = OV5650_GPIO("cam3_pwdn", CAM_FRONT_PWR_DN_GPIO, 0),
        [9] = OV5650_GPIO("cam3_rst_lo", CAM_FRONT_RST_L_GPIO, 1),
-       [10] = OV5650_GPIO("cam3_af_pwdn_lo", CAM_FRONT_AF_PWR_DN_L_GPIO, 1),
+       [10] = OV5650_GPIO("cam3_af_pwdn_lo", CAM_FRONT_AF_PWR_DN_L_GPIO, 0),
        [11] = OV5650_GPIO("cam3_ldo_shdn_lo", CAM_FRONT_LDO_SHUTDN_L_GPIO, 1),
        [12] = OV5650_GPIO("cam_led_exp", CAM_FRONT_LED_EXP, 1),
        [13] = OV5650_GPIO("cam_led_rear_exp", CAM_SNN_LED_REAR_EXP, 1),
@@ -529,14 +1303,24 @@ int __init cardhu_ov5650_late_init(void)
        int ret;
        int i;
 
+       if (!machine_is_cardhu())
+               return 0;
+
+       if ((board_info.board_id == BOARD_E1198) ||
+               (board_info.board_id == BOARD_E1291) ||
+               (board_info.board_id == BOARD_PM315))
+               return 0;
+
+       printk(KERN_INFO "%s:\n", __func__);
        for (i = 0; i < ARRAY_SIZE(ov5650_gpio_keys); i++) {
                ret = gpio_request(ov5650_gpio_keys[i].gpio,
                        ov5650_gpio_keys[i].name);
                if (ret < 0) {
-                       printk("%s: gpio_request failed for gpio #%d\n",
+                       printk(KERN_INFO "%s: gpio_request failed for gpio #%d\n",
                                __func__, i);
                        goto fail;
                }
+               printk(KERN_INFO "%s: enable - %d\n", __func__, i);
                gpio_direction_output(ov5650_gpio_keys[i].gpio,
                        ov5650_gpio_keys[i].enabled);
                gpio_export(ov5650_gpio_keys[i].gpio, false);
@@ -552,3 +1336,4 @@ fail:
 
 late_initcall(cardhu_ov5650_late_init);
 #endif
+#endif