drivers: media: tegra: Tegra Camera framework

Tegra camera device register - Takes care of
necessary initialization to work with common
framework for tegra

Tegra camera v4l2device register - Takes care of
v4l2 subdevice initialization and Async framework
initialization to bind with v4l2device.
In addition, tegra camera control layer is setup
for the sensor drivers to add controls selectively.
As next step all the v4l2 controls in tegra camera
drivers will be added here.

The common framework initializes the drivers based
on the device tree properties to setup for each
sensor mode.

Bug 1946718

Change-Id: I1f8dbce452248e9749c473bb83c4ea86e42ef531
Signed-off-by: Bhanu Murthy V <bmurthyv@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/1611726
Reviewed-by: Frank Chen <frankc@nvidia.com>
GVS: Gerrit_Virtual_Submit
Reviewed-by: Jihoon Bang <jbang@nvidia.com>
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>

8 files changed, 695 insertions, 4 deletions

diff --git a/drivers/media/platform/tegra/camera/Makefile b/drivers/media/platform/tegra/camera/Makefile
index cf95f283f..e89cffc4e 100644
--- a/drivers/media/platform/tegra/camera/Makefile
+++ b/drivers/media/platform/tegra/camera/Makefile
@@ -7,7 +7,8 @@ ccflags-y += -Werror
 
 obj-y += vi/
 obj-y += csi/
-obj-y += camera_common.o camera_gpio.o sensor_common.o camera_version_utils.o
+obj-y += camera_common.o camera_gpio.o sensor_common.o camera_version_utils.o \
+        tegracam_ctrls.o tegracam_core.o
 obj-$(CONFIG_TEGRA_CAMERA_RTCPU) += capture_common.o
 obj-$(CONFIG_TEGRA_CAMERA_RTCPU) += isp/isp_channel.o
 obj-$(CONFIG_TEGRA_CAMERA_RTCPU) += isp/capture_isp.o
diff --git a/drivers/media/platform/tegra/camera/camera_common.c b/drivers/media/platform/tegra/camera/camera_common.c
index 71763d124..7584f5b46 100644
--- a/drivers/media/platform/tegra/camera/camera_common.c
+++ b/drivers/media/platform/tegra/camera/camera_common.c
@@ -392,6 +392,20 @@ const struct camera_common_colorfmt *camera_common_find_datafmt(
 }
 EXPORT_SYMBOL_GPL(camera_common_find_datafmt);
 
+/* Find a data format by pixel format in an array*/
+const struct camera_common_colorfmt *camera_common_find_pixelfmt(
+                unsigned int pix_fmt)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(camera_common_color_fmts); i++)
+                if (camera_common_color_fmts[i].pix_fmt == pix_fmt)
+                        return camera_common_color_fmts + i;
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(camera_common_find_pixelfmt);
+
 /* Filters for the sensor's supported colors */
 static const struct camera_common_colorfmt *find_matching_color_fmt(
                 const struct camera_common_data *s_data,
@@ -693,7 +707,7 @@ int camera_common_enum_frameintervals(struct v4l2_subdev *sd,
 }
 EXPORT_SYMBOL_GPL(camera_common_enum_frameintervals);
 
-static void camera_common_mclk_disable(struct camera_common_data *s_data)
+void camera_common_mclk_disable(struct camera_common_data *s_data)
 {
         struct camera_common_power_rail *pw = s_data->power;
 
@@ -706,8 +720,9 @@ static void camera_common_mclk_disable(struct camera_common_data *s_data)
         dev_dbg(s_data->dev, "%s: disable MCLK\n", __func__);
         clk_disable_unprepare(pw->mclk);
 }
+EXPORT_SYMBOL_GPL(camera_common_mclk_disable);
 
-static int camera_common_mclk_enable(struct camera_common_data *s_data)
+int camera_common_mclk_enable(struct camera_common_data *s_data)
 {
         int err;
         struct camera_common_power_rail *pw = s_data->power;
@@ -728,6 +743,7 @@ static int camera_common_mclk_enable(struct camera_common_data *s_data)
 
         return err;
 }
+EXPORT_SYMBOL_GPL(camera_common_mclk_enable);
 
 void camera_common_dpd_disable(struct camera_common_data *s_data)
 {
diff --git a/drivers/media/platform/tegra/camera/sensor_common.c b/drivers/media/platform/tegra/camera/sensor_common.c
index 16ecd9976..a5482e7c0 100644
--- a/drivers/media/platform/tegra/camera/sensor_common.c
+++ b/drivers/media/platform/tegra/camera/sensor_common.c
@@ -327,6 +327,14 @@ static int sensor_common_parse_control_props(
         } else
                 control->framerate_factor = value;
 
+        err = read_property_u32(node, "exposure_factor", &value);
+        if (err) {
+                dev_err(dev, "%s:%s:property missing\n",
+                        __func__, "framerate_factor");
+                control->exposure_factor = 1;
+        } else
+                control->exposure_factor = value;
+
         /* ignore err for this prop */
         err = read_property_u32(node, "inherent_gain", &value);
         if (err)
@@ -350,6 +358,14 @@ static int sensor_common_parse_control_props(
         } else
                 control->max_gain_val = value;
 
+        err = read_property_u32(node, "step_gain_val", &value);
+        if (err) {
+                dev_err(dev, "%s:%s:property missing\n",
+                        __func__, "step_gain_val");
+                control->step_gain_val = 0;
+        } else
+                control->step_gain_val = value;
+
         /* ignore err for this prop */
         err = read_property_u32(node, "min_hdr_ratio", &value);
         if (err)
@@ -379,6 +395,14 @@ static int sensor_common_parse_control_props(
         } else
                 control->max_framerate = value;
 
+        err = read_property_u32(node, "step_framerate", &value);
+        if (err) {
+                dev_err(dev, "%s:%s:property missing\n",
+                        __func__, "step_framerate");
+                control->step_framerate = 0;
+        } else
+                control->step_framerate = value;
+
         err = read_property_u64(node, "min_exp_time", &val64);
         if (err) {
                 dev_err(dev, "%s:%s:property missing\n",
@@ -395,7 +419,15 @@ static int sensor_common_parse_control_props(
         } else
                 control->max_exp_time.val = val64;
 
-        return err;
+        err = read_property_u64(node, "step_exp_time", &val64);
+        if (err) {
+                dev_err(dev, "%s:%s:property missing\n",
+                        __func__, "step_exp_time");
+                control->step_exp_time.val = 0;
+        } else
+                control->step_exp_time.val = val64;
+
+        return 0;
 }
 
 int sensor_common_init_sensor_properties(
diff --git a/drivers/media/platform/tegra/camera/tegracam_core.c b/drivers/media/platform/tegra/camera/tegracam_core.c
new file mode 100644
index 000000000..25a1593be
--- /dev/null
+++ b/drivers/media/platform/tegra/camera/tegracam_core.c
@@ -0,0 +1,203 @@
+/*
+ * tegracam_core - tegra camera framework initialization
+ *
+ * Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <linux/types.h>
+#include <media/tegra-v4l2-camera.h>
+#include <media/tegracam_core.h>
+
+
+void tegracam_set_privdata(struct tegracam_device *tc_dev, void *priv)
+{
+        tc_dev->s_data->priv = priv;
+}
+EXPORT_SYMBOL_GPL(tegracam_set_privdata);
+
+void *tegracam_get_privdata(struct tegracam_device *tc_dev)
+{
+        return tc_dev->s_data->priv;
+}
+EXPORT_SYMBOL_GPL(tegracam_get_privdata);
+
+int tegracam_device_register(struct tegracam_device *tc_dev)
+{
+        struct device *dev = tc_dev->dev;
+        struct tegracam_ctrl_handler *ctrl_hdl = NULL;
+        struct camera_common_power_rail *pw_rail = NULL;
+        struct camera_common_data *s_data = NULL;
+        struct sensor_mode_properties *sensor_mode = NULL;
+        struct sensor_signal_properties *signal_props = NULL;
+        struct sensor_image_properties *image_props = NULL;
+        u32 mode_idx = 0;
+        int err = 0;
+
+        s_data = devm_kzalloc(dev,
+                sizeof(struct camera_common_data), GFP_KERNEL);
+        s_data->dev = dev;
+
+        ctrl_hdl = devm_kzalloc(dev,
+                sizeof(struct tegracam_ctrl_handler), GFP_KERNEL);
+        ctrl_hdl->s_data = s_data;
+        s_data->tegracam_ctrl_hdl = ctrl_hdl;
+
+        pw_rail = devm_kzalloc(dev,
+                sizeof(struct camera_common_power_rail), GFP_KERNEL);
+        s_data->power = pw_rail;
+
+        s_data->regmap = devm_regmap_init_i2c(tc_dev->client,
+                                        tc_dev->dev_regmap_config);
+        if (IS_ERR(s_data->regmap)) {
+                dev_err(dev,
+                        "regmap init failed: %ld\n", PTR_ERR(s_data->regmap));
+                return -ENODEV;
+        }
+
+        if (!tc_dev->sensor_ops) {
+                dev_err(dev, "sensor ops not initialized\n");
+                return -EINVAL;
+        }
+        s_data->ops = tc_dev->sensor_ops;
+
+        s_data->pdata = tc_dev->sensor_ops->parse_dt(dev);
+        if (!s_data->pdata) {
+                dev_err(dev, "unable to get platform data\n");
+                return -EFAULT;
+        }
+
+        err = tc_dev->sensor_ops->power_get(s_data);
+        if (err) {
+                dev_err(dev, "unable to power get\n");
+                return -EFAULT;
+        }
+
+        err = camera_common_initialize(s_data, tc_dev->name);
+        if (err) {
+                dev_err(dev, "Failed to initialize %s\n", tc_dev->name);
+                return err;
+        }
+
+        /* TODO: updated default mode from DT ?? */
+        mode_idx = s_data->mode_prop_idx = 0;
+        /* init format context */
+        /*TODO: compile frmfmt array from DT */
+        s_data->frmfmt = tc_dev->sensor_ops->frmfmt_table;
+        s_data->numfmts = tc_dev->sensor_ops->numfrmfmts;
+        sensor_mode = &s_data->sensor_props.sensor_modes[mode_idx];
+        signal_props = &sensor_mode->signal_properties;
+        image_props = &sensor_mode->image_properties;
+
+        s_data->def_mode = s_data->frmfmt[mode_idx].mode;
+        s_data->colorfmt =
+                camera_common_find_pixelfmt(image_props->pixel_format);
+        s_data->def_width = s_data->fmt_width =
+                s_data->frmfmt[mode_idx].size.width;
+        s_data->def_height = s_data->fmt_height =
+                s_data->frmfmt[mode_idx].size.height;
+        s_data->def_clk_freq = signal_props->mclk_freq * 1000;
+
+        tc_dev->s_data = s_data;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(tegracam_device_register);
+
+int tegracam_v4l2subdev_register(struct tegracam_device *tc_dev,
+                                bool is_sensor)
+{
+        struct camera_common_data *s_data = tc_dev->s_data;
+        struct tegracam_ctrl_handler *ctrl_hdl = s_data->tegracam_ctrl_hdl;
+        struct v4l2_subdev *sd = NULL;
+        struct device *dev = tc_dev->dev;
+        int err = 0;
+
+        /* init v4l2 subdevice for registration */
+        sd = &s_data->subdev;
+        if (!sd || !tc_dev->client) {
+                dev_err(dev, "Invalid subdev context\n");
+                return -ENODEV;
+        }
+
+        if (!tc_dev->v4l2sd_ops || !tc_dev->v4l2sd_internal_ops) {
+                dev_err(dev, "uninitialized v4l2 subdev ops\n");
+                return -EINVAL;
+        }
+
+        if (!tc_dev->media_ops) {
+                dev_err(dev, "uninitialized media entiry ops\n");
+                return -EINVAL;
+        }
+
+        if (!tc_dev->tcctrl_ops) {
+                dev_err(dev, "uninitialized control ops\n");
+                return -EINVAL;
+        }
+
+        v4l2_i2c_subdev_init(sd, tc_dev->client, tc_dev->v4l2sd_ops);
+
+        ctrl_hdl->ctrl_ops = tc_dev->tcctrl_ops;
+        err = tegracam_ctrl_handler_init(ctrl_hdl);
+        if (err) {
+                dev_err(dev, "Failed to init ctrls %s\n", tc_dev->name);
+                return err;
+        }
+        s_data->numctrls = tc_dev->numctrls;
+        sd->ctrl_handler = s_data->ctrl_handler = &ctrl_hdl->ctrl_handler;
+        s_data->ctrls = ctrl_hdl->ctrls;
+
+        sd->internal_ops = tc_dev->v4l2sd_internal_ops;
+        sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE |
+                        V4L2_SUBDEV_FL_HAS_EVENTS;
+
+#if defined(CONFIG_MEDIA_CONTROLLER)
+        tc_dev->pad.flags = MEDIA_PAD_FL_SOURCE;
+        sd->entity.ops = tc_dev->media_ops;
+        err = tegra_media_entity_init(&sd->entity,
+                        1, &tc_dev->pad, true, is_sensor);
+        if (err < 0) {
+                dev_err(dev, "unable to init media entity\n");
+                return err;
+        }
+#endif
+
+        err = v4l2_async_register_subdev(sd);
+        if (err)
+                return err;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(tegracam_v4l2subdev_register);
+
+void tegracam_device_unregister(struct tegracam_device *tc_dev)
+{
+        struct camera_common_data *s_data = tc_dev->s_data;
+
+        tc_dev->sensor_ops->power_put(s_data);
+        camera_common_cleanup(s_data);
+}
+EXPORT_SYMBOL_GPL(tegracam_device_unregister);
+
+void tegracam_v4l2subdev_unregister(struct tegracam_device *tc_dev)
+{
+        struct camera_common_data *s_data = tc_dev->s_data;
+        struct v4l2_subdev *sd = &s_data->subdev;
+
+        v4l2_ctrl_handler_free(s_data->ctrl_handler);
+        v4l2_async_unregister_subdev(sd);
+#if defined(CONFIG_MEDIA_CONTROLLER)
+        media_entity_cleanup(&sd->entity);
+#endif
+}
+EXPORT_SYMBOL_GPL(tegracam_v4l2subdev_unregister);
diff --git a/drivers/media/platform/tegra/camera/tegracam_ctrls.c b/drivers/media/platform/tegra/camera/tegracam_ctrls.c
new file mode 100644
index 000000000..b87570d3e
--- /dev/null
+++ b/drivers/media/platform/tegra/camera/tegracam_ctrls.c
@@ -0,0 +1,335 @@
+/*
+ * tegracam_ctrls - control framework for tegra camera drivers
+ *
+ * Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <linux/types.h>
+#include <media/tegra-v4l2-camera.h>
+#include <media/camera_common.h>
+
+#define CTRL_U32_MIN 0
+#define CTRL_U32_MAX 0x7FFFFFFF
+#define CTRL_U64_MIN 0
+#define CTRL_U64_MAX 0x7FFFFFFFFFFFFFFFLL
+#define CTRL_S32_MIN 0x80000000
+#define CTRL_S32_MAX 0x7FFFFFFF
+#define CTRL_S64_MIN 0x8000000000000000LL
+#define CTRL_S64_MAX 0x7FFFFFFFFFFFFFFFLL
+#define CTRL_MAX_STR_SIZE 4096
+
+static int tegracam_s_ctrl(struct v4l2_ctrl *ctrl);
+static const struct v4l2_ctrl_ops tegracam_ctrl_ops = {
+        .s_ctrl = tegracam_s_ctrl,
+};
+
+static struct v4l2_ctrl_config ctrl_cfg_list[] = {
+/* Do not change the name field for the controls! */
+        {
+                .ops = &tegracam_ctrl_ops,
+                .id = TEGRA_CAMERA_CID_GAIN,
+                .name = "Gain",
+                .type = V4L2_CTRL_TYPE_INTEGER64,
+                .flags = V4L2_CTRL_FLAG_SLIDER,
+                .min = CTRL_U64_MIN,
+                .max = CTRL_U64_MAX,
+                .def = CTRL_U64_MIN,
+                .step = 1,
+        },
+        {
+                .ops = &tegracam_ctrl_ops,
+                .id = TEGRA_CAMERA_CID_EXPOSURE,
+                .name = "Exposure",
+                .type = V4L2_CTRL_TYPE_INTEGER64,
+                .flags = V4L2_CTRL_FLAG_SLIDER,
+                .min = CTRL_U64_MIN,
+                .max = CTRL_U64_MAX,
+                .def = CTRL_U64_MIN,
+                .step = 1,
+        },
+        {
+                .ops = &tegracam_ctrl_ops,
+                .id = TEGRA_CAMERA_CID_FRAME_RATE,
+                .name = "Frame Rate",
+                .type = V4L2_CTRL_TYPE_INTEGER64,
+                .flags = V4L2_CTRL_FLAG_SLIDER,
+                .min = CTRL_U64_MIN,
+                .max = CTRL_U64_MAX,
+                .def = CTRL_U64_MIN,
+                .step = 1,
+        },
+        {
+                .ops = &tegracam_ctrl_ops,
+                .id = TEGRA_CAMERA_CID_GROUP_HOLD,
+                .name = "Group Hold",
+                .type = V4L2_CTRL_TYPE_BOOLEAN,
+                .min = 0,
+                .max = 1,
+                .def = 0,
+                .step = 1,
+        },
+        {
+                .ops = &tegracam_ctrl_ops,
+                .id = TEGRA_CAMERA_CID_EEPROM_DATA,
+                .name = "EEPROM Data",
+                .type = V4L2_CTRL_TYPE_STRING,
+                .flags = V4L2_CTRL_FLAG_READ_ONLY,
+                .min = 0,
+                .max = CTRL_MAX_STR_SIZE,
+                .step = 2,
+        },
+        {
+                .ops = &tegracam_ctrl_ops,
+                .id = TEGRA_CAMERA_CID_FUSE_ID,
+                .name = "Fuse ID",
+                .type = V4L2_CTRL_TYPE_STRING,
+                .flags = V4L2_CTRL_FLAG_READ_ONLY,
+                .min = 0,
+                .max = CTRL_MAX_STR_SIZE,
+                .step = 2,
+        },
+};
+
+static int tegracam_get_ctrl_index(u32 cid)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(ctrl_cfg_list); i++) {
+                if (ctrl_cfg_list[i].id == cid)
+                        return i;
+        }
+
+        return -EINVAL;
+}
+
+static int tegracam_get_string_ctrl_size(u32 cid,
+                const struct tegracam_ctrl_ops *ops)
+{
+        u32 index = 0;
+
+        switch (cid) {
+        case TEGRA_CAMERA_CID_EEPROM_DATA:
+                index = TEGRA_CAM_STRING_CTRL_EEPROM_INDEX;
+                break;
+        case TEGRA_CAMERA_CID_FUSE_ID:
+                index = TEGRA_CAM_STRING_CTRL_FUSEID_INDEX;
+                break;
+        case TEGRA_CAMERA_CID_OTP_DATA:
+                index = TEGRA_CAM_STRING_CTRL_OTP_INDEX;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return ops->string_ctrl_size[index];
+}
+
+static int tegracam_setup_string_ctrls(struct camera_common_data *s_data,
+                                struct tegracam_ctrl_handler *handler)
+{
+        const struct tegracam_ctrl_ops *ops = handler->ctrl_ops;
+        u32 numctrls = ops->numctrls;
+        int i;
+        int err = 0;
+
+        for (i = 0; i < numctrls; i++) {
+                struct v4l2_ctrl *ctrl = handler->ctrls[i];
+
+                if (ctrl->type == V4L2_CTRL_TYPE_STRING) {
+                        err = ops->fill_string_ctrl(s_data, ctrl);
+                        if (err)
+                                return err;
+                }
+        }
+
+        return 0;
+}
+
+static int tegracam_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct tegracam_ctrl_handler *handler =
+                container_of(ctrl->handler,
+                        struct tegracam_ctrl_handler, ctrl_handler);
+        const struct tegracam_ctrl_ops *ops = handler->ctrl_ops;
+        struct camera_common_data *s_data = handler->s_data;
+        int err = 0;
+        u32 status = 0;
+
+        if (v4l2_subdev_call(&s_data->subdev, video, g_input_status, &status)) {
+                dev_err(s_data->dev, "power status query unsupported\n");
+                return -ENOTTY;
+        }
+
+        /* power state is turned off, do not program sensor now */
+        if (!status)
+                return 0;
+
+        switch (ctrl->id) {
+        case TEGRA_CAMERA_CID_GAIN:
+                err = ops->set_gain(s_data, *ctrl->p_new.p_s64);
+                break;
+        case TEGRA_CAMERA_CID_FRAME_RATE:
+                err = ops->set_frame_rate(s_data, *ctrl->p_new.p_s64);
+                break;
+        case TEGRA_CAMERA_CID_EXPOSURE:
+                err = ops->set_exposure(s_data, *ctrl->p_new.p_s64);
+                break;
+        case TEGRA_CAMERA_CID_GROUP_HOLD:
+                err = ops->set_group_hold(s_data, ctrl->val);
+                break;
+        default:
+                pr_err("%s: unknown ctrl id.\n", __func__);
+                return -EINVAL;
+        }
+
+        return err;
+}
+
+int tegracam_init_ctrl_ranges_by_mode(
+                struct tegracam_ctrl_handler *handler,
+                u32 modeidx)
+{
+        struct camera_common_data *s_data = handler->s_data;
+        struct sensor_control_properties *ctrlprops = NULL;
+        int i;
+
+        if (modeidx >= s_data->sensor_props.num_modes)
+                return -EINVAL;
+
+        ctrlprops =
+                &s_data->sensor_props.sensor_modes[modeidx].control_properties;
+
+        for (i = 0; i < handler->numctrls; i++) {
+                struct v4l2_ctrl *ctrl = handler->ctrls[i];
+                int err = 0;
+
+                switch (ctrl->id) {
+                case TEGRA_CAMERA_CID_GAIN:
+                        err = v4l2_ctrl_modify_range(ctrl,
+                                ctrlprops->min_gain_val,
+                                ctrlprops->max_gain_val,
+                                ctrlprops->step_gain_val,
+                                ctrlprops->min_gain_val);
+                        break;
+                case TEGRA_CAMERA_CID_FRAME_RATE:
+                        err = v4l2_ctrl_modify_range(ctrl,
+                                ctrlprops->min_framerate,
+                                ctrlprops->max_framerate,
+                                ctrlprops->step_framerate,
+                                ctrlprops->max_framerate);
+                        break;
+                case TEGRA_CAMERA_CID_EXPOSURE:
+                        err = v4l2_ctrl_modify_range(ctrl,
+                                ctrlprops->min_exp_time.val,
+                                ctrlprops->max_exp_time.val,
+                                ctrlprops->step_exp_time.val,
+                                ctrlprops->max_exp_time.val);
+                        break;
+                default:
+                        /* Not required to modify these control ranges */
+                        break;
+                }
+
+                if (err) {
+                        dev_err(s_data->dev,
+                                "ctrl %s range update failed\n", ctrl->name);
+                        return err;
+                }
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(tegracam_init_ctrl_ranges_by_mode);
+
+int tegracam_ctrl_handler_init(struct tegracam_ctrl_handler *handler)
+{
+        struct camera_common_data *s_data = handler->s_data;
+        struct v4l2_ctrl *ctrl;
+        struct v4l2_ctrl_config *ctrl_cfg;
+        struct device *dev = s_data->dev;
+        const struct tegracam_ctrl_ops *ops = handler->ctrl_ops;
+        const u32 *cids = ops->ctrl_cid_list;
+        u32 numctrls = ops->numctrls;
+        int i;
+        int err = 0;
+
+        v4l2_ctrl_handler_init(&handler->ctrl_handler, numctrls);
+
+        for (i = 0; i < numctrls; i++) {
+                int index = tegracam_get_ctrl_index(cids[i]);
+                int size = 0;
+
+                if (index >= ARRAY_SIZE(ctrl_cfg_list)) {
+                        dev_err(dev, "unsupported control in the list\n");
+                        return -ENOTTY;
+                }
+
+                ctrl_cfg = &ctrl_cfg_list[index];
+                if (ctrl_cfg->type == V4L2_CTRL_TYPE_STRING) {
+                        size = tegracam_get_string_ctrl_size(ctrl_cfg->id, ops);
+                        if (size < 0) {
+                                dev_err(dev, "Invalid string ctrl size\n");
+                                return -EINVAL;
+                        }
+                        ctrl_cfg->max = size;
+                }
+
+                ctrl = v4l2_ctrl_new_custom(&handler->ctrl_handler,
+                        ctrl_cfg, NULL);
+                if (ctrl == NULL) {
+                        dev_err(dev, "Failed to init %s ctrl\n",
+                                ctrl_cfg->name);
+                        return -EINVAL;
+                }
+
+                if (ctrl_cfg->type == V4L2_CTRL_TYPE_STRING &&
+                        ctrl_cfg->flags & V4L2_CTRL_FLAG_READ_ONLY) {
+                        ctrl->p_new.p_char = devm_kzalloc(s_data->dev,
+                                size + 1, GFP_KERNEL);
+                }
+                handler->ctrls[i] = ctrl;
+        };
+
+        handler->numctrls = numctrls;
+        err = v4l2_ctrl_handler_setup(&handler->ctrl_handler);
+        if (err) {
+                dev_err(dev, "Error %d in control hdl setup\n", err);
+                goto error;
+        }
+
+        err = handler->ctrl_handler.error;
+        if (err) {
+                dev_err(dev, "Error %d adding controls\n", err);
+                goto error;
+        }
+
+        err = tegracam_setup_string_ctrls(s_data, handler);
+        if (err) {
+                dev_err(dev, "setup string controls failed\n");
+                goto error;
+        }
+
+        err = tegracam_init_ctrl_ranges_by_mode(handler,
+                                s_data->mode_prop_idx);
+        if (err) {
+                dev_err(dev, "Error %d updating control ranges\n", err);
+                goto error;
+        }
+
+        return 0;
+error:
+        v4l2_ctrl_handler_free(&handler->ctrl_handler);
+        return err;
+}
+EXPORT_SYMBOL_GPL(tegracam_ctrl_handler_init);
diff --git a/include/media/camera_common.h b/include/media/camera_common.h
index 674a29e6c..6c3ae9531 100644
--- a/include/media/camera_common.h
+++ b/include/media/camera_common.h
@@ -158,16 +158,42 @@ struct camera_common_framesync {
 struct camera_common_data;
 
 struct camera_common_sensor_ops {
+        u32 numfrmfmts;
+        const struct camera_common_frmfmt *frmfmt_table;
         int (*power_on)(struct camera_common_data *s_data);
         int (*power_off)(struct camera_common_data *s_data);
         int (*write_reg)(struct camera_common_data *s_data,
           u16 addr, u8 val);
         int (*read_reg)(struct camera_common_data *s_data,
           u16 addr, u8 *val);
+        struct camera_common_pdata *(*parse_dt)(struct device *dev);
+        int (*power_get)(struct camera_common_data *s_data);
+        int (*power_put)(struct camera_common_data *s_data);
         int (*get_framesync)(struct camera_common_data *s_data,
                 struct camera_common_framesync *vshs);
 };
 
+struct tegracam_ctrl_ops {
+        u32 numctrls;
+        u32 string_ctrl_size[TEGRA_CAM_MAX_STRING_CONTROLS];
+        const u32 *ctrl_cid_list;
+        int (*set_gain)(struct camera_common_data *s_data, s64 val);
+        int (*set_exposure)(struct camera_common_data *s_data, s64 val);
+        int (*set_frame_rate)(struct camera_common_data *s_data, s64 val);
+        int (*set_group_hold)(struct camera_common_data *s_data, bool val);
+        int (*fill_string_ctrl)(struct camera_common_data *s_data,
+                struct v4l2_ctrl *ctrl);
+};
+
+struct tegracam_ctrl_handler {
+        struct v4l2_ctrl_handler        ctrl_handler;
+        const struct tegracam_ctrl_ops  *ctrl_ops;
+        struct camera_common_data       *s_data;
+
+        int                             numctrls;
+        struct v4l2_ctrl                *ctrls[MAX_CID_CONTROLS];
+};
+
 struct camera_common_data {
         struct camera_common_sensor_ops         *ops;
         struct v4l2_ctrl_handler                *ctrl_handler;
@@ -181,6 +207,10 @@ struct camera_common_data {
         struct v4l2_ctrl                        **ctrls;
 
         struct sensor_properties                sensor_props;
+        /* TODO: cleanup neeeded once all the sensors adapt new framework */
+        struct tegracam_ctrl_handler            *tegracam_ctrl_hdl;
+        struct regmap                           *regmap;
+        struct camera_common_pdata              *pdata;
 
         void    *priv;
         int     numctrls;
@@ -247,6 +277,9 @@ int camera_common_parse_clocks(struct device *dev,
                         struct camera_common_pdata *pdata);
 int camera_common_parse_ports(struct device *dev,
                               struct camera_common_data *s_data);
+int camera_common_mclk_enable(struct camera_common_data *s_data);
+void camera_common_mclk_disable(struct camera_common_data *s_data);
+
 
 int camera_common_debugfs_show(struct seq_file *s, void *unused);
 ssize_t camera_common_debugfs_write(
@@ -294,6 +327,15 @@ void camera_common_cleanup(struct camera_common_data *s_data);
 int camera_common_focuser_init(struct camera_common_focuser_data *s_data);
 int camera_common_focuser_s_power(struct v4l2_subdev *sd, int on);
 
+const struct camera_common_colorfmt *camera_common_find_pixelfmt(
+        unsigned int pix_fmt);
+
+/* common control layer init */
+int tegracam_ctrl_handler_init(struct tegracam_ctrl_handler *handler);
+int tegracam_init_ctrl_ranges_by_mode(
+                struct tegracam_ctrl_handler *handler,
+                u32 modeidx);
+
 /* Regmap / RTCPU I2C driver interface */
 struct tegra_i2c_rtcpu_sensor;
 struct tegra_i2c_rtcpu_config;
diff --git a/include/media/tegra-v4l2-camera.h b/include/media/tegra-v4l2-camera.h
index 5c5e2da75..4b6b54e47 100644
--- a/include/media/tegra-v4l2-camera.h
+++ b/include/media/tegra-v4l2-camera.h
@@ -67,6 +67,11 @@
  */
 #define FIXED_POINT_SCALING_FACTOR (1ULL << 22)
 
+#define TEGRA_CAM_MAX_STRING_CONTROLS 8
+#define TEGRA_CAM_STRING_CTRL_EEPROM_INDEX 0
+#define TEGRA_CAM_STRING_CTRL_FUSEID_INDEX 1
+#define TEGRA_CAM_STRING_CTRL_OTP_INDEX 2
+
 struct unpackedU64 {
         __u32 high;
         __u32 low;
@@ -86,6 +91,7 @@ struct sensor_signal_properties {
         __u32 discontinuous_clk;
         __u32 dpcm_enable;
         __u32 tegra_sinterface;
+        __u32 reserved[7];
 };
 
 struct sensor_image_properties {
@@ -94,6 +100,7 @@ struct sensor_image_properties {
         __u32 line_length;
         __u32 pixel_format;
         __u32 embedded_metadata_height;
+        __u32 reserved[11];
 };
 
 struct sensor_dv_timings {
@@ -103,6 +110,7 @@ struct sensor_dv_timings {
         __u32 vfrontporch;
         __u32 vsync;
         __u32 vbackporch;
+        __u32 reserved[10];
 };
 
 struct sensor_control_properties {
@@ -117,6 +125,11 @@ struct sensor_control_properties {
         __u32 max_framerate;
         union __u64val min_exp_time;
         union __u64val max_exp_time;
+        __u32 step_gain_val;
+        __u32 step_framerate;
+        __u32 exposure_factor;
+        union __u64val step_exp_time;
+        __u32 reserved[14];
 };
 
 struct sensor_mode_properties {
diff --git a/include/media/tegracam_core.h b/include/media/tegracam_core.h
new file mode 100644
index 000000000..1a1e8a2f5
--- /dev/null
+++ b/include/media/tegracam_core.h
@@ -0,0 +1,49 @@
+/**
+ * tegracam_core.h - tegra camera framework core utilities
+ *
+ * Copyright (c) 2017, NVIDIA Corporation.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __TEGRACAM_CORE_H__
+#define __TEGRACAM_CORE_H__
+
+#include <media/camera_common.h>
+
+struct tegracam_device {
+        struct camera_common_data       *s_data;
+        struct media_pad                pad;
+        /* variables to be filled by the driver to register */
+        char                            name[32];
+        struct i2c_client               *client;
+        struct device                   *dev;
+        u32                             numctrls;
+        const u32                       *ctrl_cid_list;
+        const struct regmap_config      *dev_regmap_config;
+        struct camera_common_sensor_ops         *sensor_ops;
+        const struct v4l2_subdev_ops            *v4l2sd_ops;
+        const struct v4l2_subdev_internal_ops   *v4l2sd_internal_ops;
+        const struct media_entity_operations    *media_ops;
+        const struct tegracam_ctrl_ops          *tcctrl_ops;
+};
+
+void tegracam_set_privdata(struct tegracam_device *tc_dev, void *priv);
+void *tegracam_get_privdata(struct tegracam_device *tc_dev);
+
+int tegracam_v4l2subdev_register(struct tegracam_device *tc_dev,
+                                bool is_sensor);
+void tegracam_v4l2subdev_unregister(struct tegracam_device *tc_dev);
+int tegracam_device_register(struct tegracam_device *tc_dev);
+void tegracam_device_unregister(struct tegracam_device *tc_dev);
+#endif