661 lines
16 KiB
C
661 lines
16 KiB
C
/* Copyright (c) 2012-2016, The Linux Foundation. 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 version 2 and
|
|
* only version 2 as published by the Free Software Foundation.
|
|
*
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
#include <linux/jiffies.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/kernel.h>
|
|
|
|
#include "msm_ba_debug.h"
|
|
#include "msm_ba_common.h"
|
|
|
|
struct msm_ba_input_config msm_ba_inp_cfg[] = {
|
|
/* type, index, name, adv inp, dev id, sd name, signal status */
|
|
{BA_INPUT_CVBS, 0, "CVBS-0", BA_IP_CVBS_0, 0, "adv7180", 1},
|
|
#ifdef CONFIG_MSM_S_PLATFORM
|
|
{BA_INPUT_CVBS, 1, "CVBS-1", BA_IP_CVBS_0, 0, "adv7180", 1},
|
|
#else
|
|
{BA_INPUT_CVBS, 1, "CVBS-1", BA_IP_CVBS_0, 1, "adv7180", 1},
|
|
{BA_INPUT_CVBS, 2, "CVBS-2", BA_IP_CVBS_1, 1, "adv7180", 1},
|
|
#endif
|
|
{BA_INPUT_HDMI, 1, "HDMI-1", BA_IP_HDMI_1, 2, "adv7481", 1},
|
|
};
|
|
|
|
static struct msm_ba_ctrl msm_ba_ctrls[] = {
|
|
{
|
|
.id = MSM_BA_PRIV_SD_NODE_ADDR,
|
|
.name = "Sub-device Node Address",
|
|
.type = V4L2_CTRL_TYPE_INTEGER,
|
|
.minimum = 0,
|
|
.maximum = 16,
|
|
.default_value = 0,
|
|
.step = 2,
|
|
.menu_skip_mask = 0,
|
|
.flags = V4L2_CTRL_FLAG_VOLATILE,
|
|
.qmenu = NULL,
|
|
},
|
|
{
|
|
.id = MSM_BA_PRIV_FPS,
|
|
.name = "FPS in Q16 format",
|
|
.type = V4L2_CTRL_TYPE_INTEGER,
|
|
.minimum = 0,
|
|
.maximum = 0x7fffffff,
|
|
.default_value = 60 << 16,
|
|
.step = 1,
|
|
.menu_skip_mask = 0,
|
|
.flags = V4L2_CTRL_FLAG_VOLATILE,
|
|
.qmenu = NULL,
|
|
},
|
|
};
|
|
|
|
#define BA_NUM_CTRLS ARRAY_SIZE(msm_ba_ctrls)
|
|
|
|
/* Assuming den is not zero, max 32 bits */
|
|
#define BA_FRAC_TO_Q16(q, num, den) { \
|
|
uint32_t pwr; \
|
|
pwr = ilog2(den); \
|
|
(q) = (num) << (16 - pwr); \
|
|
}
|
|
|
|
struct msm_ba_dev *get_ba_dev(void)
|
|
{
|
|
struct ba_ctxt *ba_ctxt;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
|
|
ba_ctxt = msm_ba_get_ba_context();
|
|
|
|
mutex_lock(&ba_ctxt->ba_cs);
|
|
dev_ctxt = ba_ctxt->dev_ctxt;
|
|
mutex_unlock(&ba_ctxt->ba_cs);
|
|
|
|
return dev_ctxt;
|
|
}
|
|
|
|
void msm_ba_queue_v4l2_event(struct msm_ba_inst *inst,
|
|
const struct v4l2_event *sd_event)
|
|
{
|
|
v4l2_event_queue_fh(&inst->event_handler, sd_event);
|
|
wake_up(&inst->kernel_event_queue);
|
|
}
|
|
|
|
static void msm_ba_print_event(struct v4l2_event *sd_event)
|
|
{
|
|
switch (sd_event->type) {
|
|
case V4L2_EVENT_MSM_BA_SIGNAL_IN_LOCK:
|
|
dprintk(BA_DBG, "Signal in lock for ip_idx %d",
|
|
((int *)sd_event->u.data)[0]);
|
|
break;
|
|
case V4L2_EVENT_MSM_BA_SIGNAL_LOST_LOCK:
|
|
dprintk(BA_DBG, "Signal lost lock for ip_idx %d",
|
|
((int *)sd_event->u.data)[0]);
|
|
break;
|
|
case V4L2_EVENT_MSM_BA_SOURCE_CHANGE:
|
|
dprintk(BA_DBG, "Video source change 0x%x",
|
|
((int *)sd_event->u.data)[1]);
|
|
break;
|
|
case V4L2_EVENT_MSM_BA_HDMI_HPD:
|
|
dprintk(BA_DBG, "HDMI hotplug detected!");
|
|
break;
|
|
case V4L2_EVENT_MSM_BA_HDMI_CEC_MESSAGE:
|
|
dprintk(BA_DBG, "HDMI CEC message!");
|
|
break;
|
|
case V4L2_EVENT_MSM_BA_CP:
|
|
dprintk(BA_DBG, "Content protection detected!");
|
|
break;
|
|
case V4L2_EVENT_MSM_BA_ERROR:
|
|
dprintk(BA_DBG, "Subdev error %d!",
|
|
((int *)sd_event->u.data)[1]);
|
|
break;
|
|
default:
|
|
dprintk(BA_ERR, "Unknown event: 0x%x", sd_event->type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void msm_ba_signal_sessions_event(struct v4l2_event *sd_event)
|
|
{
|
|
struct msm_ba_inst *inst = NULL;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
unsigned int *ptr;
|
|
|
|
uintptr_t arg;
|
|
|
|
const struct v4l2_event event = {
|
|
.id = 0,
|
|
.type = sd_event->type,
|
|
.u = sd_event->u};
|
|
|
|
msm_ba_print_event(sd_event);
|
|
dev_ctxt = get_ba_dev();
|
|
ptr = (unsigned int *)sd_event->u.data;
|
|
|
|
list_for_each_entry(inst, &(dev_ctxt->instances), list) {
|
|
if (inst->ext_ops && inst->ext_ops->msm_ba_cb) {
|
|
arg = ptr[1];
|
|
inst->ext_ops->msm_ba_cb(
|
|
inst, sd_event->id, (void *)arg);
|
|
} else {
|
|
msm_ba_queue_v4l2_event(inst, &event);
|
|
}
|
|
}
|
|
}
|
|
|
|
void msm_ba_subdev_event_hndlr_delayed(struct work_struct *work)
|
|
{
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
struct msm_ba_sd_event *ba_sd_event = NULL;
|
|
struct msm_ba_sd_event *ba_sd_event_tmp = NULL;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
|
|
mutex_lock(&dev_ctxt->dev_cs);
|
|
if (!list_empty(&dev_ctxt->sd_events)) {
|
|
list_for_each_entry_safe(ba_sd_event, ba_sd_event_tmp,
|
|
&(dev_ctxt->sd_events), list) {
|
|
msm_ba_signal_sessions_event(&ba_sd_event->sd_event);
|
|
list_del(&ba_sd_event->list);
|
|
kfree(ba_sd_event);
|
|
break;
|
|
}
|
|
} else {
|
|
dprintk(BA_ERR, "%s - queue empty!!!", __func__);
|
|
}
|
|
mutex_unlock(&dev_ctxt->dev_cs);
|
|
}
|
|
|
|
struct v4l2_subdev *msm_ba_sd_find(const char *name)
|
|
{
|
|
struct v4l2_subdev *sd = NULL;
|
|
struct v4l2_subdev *sd_out = NULL;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
if (!list_empty(&(dev_ctxt->v4l2_dev.subdevs))) {
|
|
list_for_each_entry(sd, &(dev_ctxt->v4l2_dev.subdevs), list)
|
|
if (!strcmp(name, sd->name)) {
|
|
sd_out = sd;
|
|
break;
|
|
}
|
|
}
|
|
return sd_out;
|
|
}
|
|
|
|
void msm_ba_add_inputs(struct v4l2_subdev *sd)
|
|
{
|
|
struct msm_ba_input *input = NULL;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
int i;
|
|
int str_length = 0;
|
|
int rc;
|
|
int start_index = 0;
|
|
int end_index = 0;
|
|
int dev_id = 0;
|
|
int status = 0;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
if (!list_empty(&dev_ctxt->inputs))
|
|
start_index = dev_ctxt->num_inputs;
|
|
|
|
dev_id = msm_ba_inp_cfg[start_index].ba_out;
|
|
end_index = sizeof(msm_ba_inp_cfg)/sizeof(msm_ba_inp_cfg[0]);
|
|
for (i = start_index; i < end_index; i++) {
|
|
str_length = strlen(msm_ba_inp_cfg[i].sd_name);
|
|
rc = memcmp(sd->name, msm_ba_inp_cfg[i].sd_name, str_length);
|
|
if (!rc && dev_id == msm_ba_inp_cfg[i].ba_out) {
|
|
input = kzalloc(sizeof(*input), GFP_KERNEL);
|
|
|
|
if (!input) {
|
|
dprintk(BA_ERR, "Failed to allocate memory");
|
|
break;
|
|
}
|
|
input->inputType = msm_ba_inp_cfg[i].inputType;
|
|
input->name_index = msm_ba_inp_cfg[i].index;
|
|
strlcpy(input->name, msm_ba_inp_cfg[i].name,
|
|
sizeof(input->name));
|
|
input->bridge_chip_ip = msm_ba_inp_cfg[i].ba_ip;
|
|
input->ba_out = msm_ba_inp_cfg[i].ba_out;
|
|
input->ba_ip_idx = i;
|
|
input->prio = V4L2_PRIORITY_DEFAULT;
|
|
input->sd = sd;
|
|
rc = v4l2_subdev_call(
|
|
sd, video, g_input_status, &status);
|
|
if (rc)
|
|
dprintk(BA_ERR,
|
|
"g_input_status failed for sd: %s",
|
|
sd->name);
|
|
else
|
|
input->signal_status = status;
|
|
list_add_tail(&input->list, &dev_ctxt->inputs);
|
|
dev_ctxt->num_inputs++;
|
|
dprintk(BA_DBG, "Add input: name %s on %d",
|
|
input->name, input->ba_out);
|
|
}
|
|
}
|
|
}
|
|
|
|
void msm_ba_del_inputs(struct v4l2_subdev *sd)
|
|
{
|
|
struct msm_ba_input *input = NULL;
|
|
struct list_head *ptr;
|
|
struct list_head *next;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
|
|
list_for_each_safe(ptr, next, &(dev_ctxt->inputs)) {
|
|
input = list_entry(ptr, struct msm_ba_input, list);
|
|
if (input->sd == sd) {
|
|
list_del(&input->list);
|
|
kfree(input);
|
|
}
|
|
}
|
|
}
|
|
|
|
void msm_ba_set_out_in_use(struct v4l2_subdev *sd, int on)
|
|
{
|
|
struct msm_ba_input *input = NULL;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
|
|
if (!list_empty(&(dev_ctxt->inputs))) {
|
|
list_for_each_entry(input, &(dev_ctxt->inputs), list)
|
|
if (input->sd == sd)
|
|
input->ba_out_in_use = on;
|
|
}
|
|
}
|
|
|
|
int msm_ba_find_ip_in_use_from_sd(struct v4l2_subdev *sd)
|
|
{
|
|
struct msm_ba_input *input = NULL;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
int ba_ip = BA_IP_MAX;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
|
|
if (!list_empty(&(dev_ctxt->inputs))) {
|
|
list_for_each_entry(input, &(dev_ctxt->inputs), list)
|
|
if (input->sd == sd &&
|
|
input->in_use) {
|
|
ba_ip = input->bridge_chip_ip;
|
|
break;
|
|
}
|
|
}
|
|
return ba_ip;
|
|
}
|
|
|
|
void msm_ba_reset_ip_in_use_from_sd(struct v4l2_subdev *sd)
|
|
{
|
|
struct msm_ba_input *input = NULL;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
|
|
if (!list_empty(&(dev_ctxt->inputs))) {
|
|
list_for_each_entry(input, &(dev_ctxt->inputs), list)
|
|
if (input->sd == sd &&
|
|
input->in_use) {
|
|
input->in_use = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct msm_ba_input *msm_ba_find_input_from_sd(struct v4l2_subdev *sd,
|
|
int bridge_chip_ip)
|
|
{
|
|
struct msm_ba_input *input = NULL;
|
|
struct msm_ba_input *input_out = NULL;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
|
|
if (!list_empty(&(dev_ctxt->inputs))) {
|
|
list_for_each_entry(input, &(dev_ctxt->inputs), list)
|
|
if (input->sd == sd &&
|
|
input->bridge_chip_ip == bridge_chip_ip) {
|
|
input_out = input;
|
|
break;
|
|
}
|
|
}
|
|
return input_out;
|
|
}
|
|
|
|
struct msm_ba_input *msm_ba_find_input(int ba_input_idx)
|
|
{
|
|
struct msm_ba_input *input = NULL;
|
|
struct msm_ba_input *input_out = NULL;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
|
|
if (!list_empty(&(dev_ctxt->inputs))) {
|
|
list_for_each_entry(input, &(dev_ctxt->inputs), list)
|
|
if (input->ba_ip_idx == ba_input_idx) {
|
|
input_out = input;
|
|
break;
|
|
}
|
|
}
|
|
return input_out;
|
|
}
|
|
|
|
struct msm_ba_input *msm_ba_find_output(int ba_output)
|
|
{
|
|
struct msm_ba_input *input = NULL;
|
|
struct msm_ba_input *input_out = NULL;
|
|
struct msm_ba_dev *dev_ctxt = NULL;
|
|
|
|
dev_ctxt = get_ba_dev();
|
|
|
|
if (!list_empty(&(dev_ctxt->inputs))) {
|
|
list_for_each_entry(input, &(dev_ctxt->inputs), list) {
|
|
if (input->ba_out == ba_output) {
|
|
input_out = input;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return input_out;
|
|
}
|
|
|
|
int msm_ba_g_fps(void *instance, int *fps_q16)
|
|
{
|
|
struct msm_ba_inst *inst = instance;
|
|
struct v4l2_subdev *sd = NULL;
|
|
struct v4l2_subdev_frame_interval sd_frame_int;
|
|
int rc = 0;
|
|
|
|
if (!inst || !fps_q16)
|
|
return -EINVAL;
|
|
|
|
sd = inst->sd;
|
|
if (!sd) {
|
|
dprintk(BA_ERR, "No sd registered");
|
|
return -EINVAL;
|
|
}
|
|
rc = v4l2_subdev_call(sd, video, g_frame_interval, &sd_frame_int);
|
|
if (rc) {
|
|
dprintk(BA_ERR, "get frame interval failed %d for sd: %s",
|
|
rc, sd->name);
|
|
} else {
|
|
/* subdevice returns frame interval not fps! */
|
|
if (sd_frame_int.interval.numerator) {
|
|
BA_FRAC_TO_Q16(*fps_q16,
|
|
sd_frame_int.interval.denominator,
|
|
sd_frame_int.interval.numerator);
|
|
} else {
|
|
*fps_q16 =
|
|
sd_frame_int.interval.denominator << 16;
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static int msm_ba_try_get_ctrl(struct msm_ba_inst *inst,
|
|
struct v4l2_ctrl *ctrl)
|
|
{
|
|
struct msm_ba_input *ba_input = NULL;
|
|
int rc = 0;
|
|
|
|
if (!inst) {
|
|
dprintk(BA_ERR, "%s invalid parameters", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
dprintk(BA_DBG, "%s ctrl->id: 0x%x", __func__, ctrl->id);
|
|
|
|
switch (ctrl->id) {
|
|
case MSM_BA_PRIV_SD_NODE_ADDR:
|
|
ba_input = msm_ba_find_input(inst->sd_input.index);
|
|
if (ba_input) {
|
|
ctrl->val = ba_input->ba_node_addr;
|
|
dprintk(BA_DBG,
|
|
"%s: SD NODE ADDR ctrl->id:0x%x ctrl->val:%d",
|
|
__func__, ctrl->id, ctrl->val);
|
|
} else {
|
|
dprintk(BA_ERR, "%s Could not find input",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
}
|
|
break;
|
|
case MSM_BA_PRIV_FPS:
|
|
rc = msm_ba_g_fps(inst, &ctrl->val);
|
|
break;
|
|
default:
|
|
dprintk(BA_ERR, "%s id: 0x%x not supported",
|
|
__func__, ctrl->id);
|
|
rc = -EINVAL;
|
|
break;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static int msm_ba_try_set_ctrl(struct msm_ba_inst *inst,
|
|
struct v4l2_ctrl *ctrl)
|
|
{
|
|
struct msm_ba_input *ba_input = NULL;
|
|
int rc = 0;
|
|
|
|
if (!inst) {
|
|
dprintk(BA_ERR, "%s invalid parameters", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
dprintk(BA_DBG, "%s ctrl->id: 0x%x", __func__, ctrl->id);
|
|
|
|
switch (ctrl->id) {
|
|
case MSM_BA_PRIV_SD_NODE_ADDR:
|
|
ba_input = msm_ba_find_input(inst->sd_input.index);
|
|
if (ba_input) {
|
|
ba_input->ba_node_addr = ctrl->val;
|
|
dprintk(BA_DBG,
|
|
"%s: SD NODE ADDR ctrl->id:0x%x node_addr:%d",
|
|
__func__, ctrl->id, ba_input->ba_node_addr);
|
|
} else {
|
|
dprintk(BA_ERR, "%s Could not find input",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
}
|
|
break;
|
|
default:
|
|
dprintk(BA_ERR, "%s id: 0x%x not supported",
|
|
__func__, ctrl->id);
|
|
rc = -EINVAL;
|
|
break;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static int msm_ba_op_s_ctrl(struct v4l2_ctrl *ctrl)
|
|
{
|
|
int rc = 0;
|
|
int c = 0;
|
|
struct msm_ba_inst *inst = container_of(ctrl->handler,
|
|
struct msm_ba_inst, ctrl_handler);
|
|
if (!inst) {
|
|
dprintk(BA_ERR, "%s invalid parameters", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
for (c = 0; c < ctrl->ncontrols; ++c) {
|
|
if (ctrl->cluster[c]->is_new) {
|
|
rc = msm_ba_try_set_ctrl(inst, ctrl->cluster[c]);
|
|
if (rc) {
|
|
dprintk(BA_ERR, "Failed setting 0x%x",
|
|
ctrl->cluster[c]->id);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static int msm_ba_op_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
|
|
{
|
|
int rc = 0;
|
|
int c = 0;
|
|
struct msm_ba_inst *inst = container_of(ctrl->handler,
|
|
struct msm_ba_inst, ctrl_handler);
|
|
struct v4l2_ctrl *master = ctrl->cluster[0];
|
|
|
|
for (c = 0; c < master->ncontrols; c++) {
|
|
if (master->cluster[c]->id == ctrl->id) {
|
|
rc = msm_ba_try_get_ctrl(inst, ctrl);
|
|
if (rc) {
|
|
dprintk(BA_ERR, "Failed getting 0x%x",
|
|
ctrl->id);
|
|
return rc;
|
|
}
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static const struct v4l2_ctrl_ops msm_ba_ctrl_ops = {
|
|
|
|
.g_volatile_ctrl = msm_ba_op_g_volatile_ctrl,
|
|
.s_ctrl = msm_ba_op_s_ctrl,
|
|
};
|
|
|
|
const struct v4l2_ctrl_ops *msm_ba_get_ctrl_ops(void)
|
|
{
|
|
return &msm_ba_ctrl_ops;
|
|
}
|
|
|
|
static struct v4l2_ctrl **msm_ba_get_super_cluster(struct msm_ba_inst *inst,
|
|
int *size)
|
|
{
|
|
int c = 0;
|
|
int sz = 0;
|
|
struct v4l2_ctrl **cluster = kmalloc(sizeof(struct v4l2_ctrl *) *
|
|
BA_NUM_CTRLS, GFP_KERNEL);
|
|
|
|
if (!size || !cluster || !inst)
|
|
return NULL;
|
|
|
|
for (c = 0; c < BA_NUM_CTRLS; c++)
|
|
cluster[sz++] = inst->ctrls[c];
|
|
|
|
*size = sz;
|
|
return cluster;
|
|
}
|
|
|
|
/*
|
|
* Controls init function.
|
|
* Caller is expected to call deinit in case of failure.
|
|
*/
|
|
int msm_ba_ctrl_init(struct msm_ba_inst *inst)
|
|
{
|
|
int idx = 0;
|
|
struct v4l2_ctrl_config ctrl_cfg = {0};
|
|
int rc = 0;
|
|
int cluster_size = 0;
|
|
|
|
if (!inst) {
|
|
dprintk(BA_ERR, "%s - invalid instance", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
inst->ctrls = kzalloc(sizeof(struct v4l2_ctrl *) * BA_NUM_CTRLS,
|
|
GFP_KERNEL);
|
|
if (!inst->ctrls) {
|
|
dprintk(BA_ERR, "%s - failed to allocate ctrl", __func__);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
rc = v4l2_ctrl_handler_init(&inst->ctrl_handler, BA_NUM_CTRLS);
|
|
|
|
if (rc) {
|
|
dprintk(BA_ERR, "CTRL ERR: Control handler init failed, %d",
|
|
inst->ctrl_handler.error);
|
|
return rc;
|
|
}
|
|
for (; idx < BA_NUM_CTRLS; idx++) {
|
|
struct v4l2_ctrl *ctrl = NULL;
|
|
|
|
if (BA_IS_PRIV_CTRL(msm_ba_ctrls[idx].id)) {
|
|
/* add private control */
|
|
ctrl_cfg.def = msm_ba_ctrls[idx].default_value;
|
|
ctrl_cfg.flags = 0;
|
|
ctrl_cfg.id = msm_ba_ctrls[idx].id;
|
|
ctrl_cfg.max = msm_ba_ctrls[idx].maximum;
|
|
ctrl_cfg.min = msm_ba_ctrls[idx].minimum;
|
|
ctrl_cfg.menu_skip_mask =
|
|
msm_ba_ctrls[idx].menu_skip_mask;
|
|
ctrl_cfg.name = msm_ba_ctrls[idx].name;
|
|
ctrl_cfg.ops = &msm_ba_ctrl_ops;
|
|
ctrl_cfg.step = msm_ba_ctrls[idx].step;
|
|
ctrl_cfg.type = msm_ba_ctrls[idx].type;
|
|
ctrl_cfg.qmenu = msm_ba_ctrls[idx].qmenu;
|
|
|
|
ctrl = v4l2_ctrl_new_custom(&inst->ctrl_handler,
|
|
&ctrl_cfg, NULL);
|
|
} else {
|
|
if (msm_ba_ctrls[idx].type == V4L2_CTRL_TYPE_MENU) {
|
|
ctrl = v4l2_ctrl_new_std_menu(
|
|
&inst->ctrl_handler,
|
|
&msm_ba_ctrl_ops,
|
|
msm_ba_ctrls[idx].id,
|
|
msm_ba_ctrls[idx].maximum,
|
|
msm_ba_ctrls[idx].menu_skip_mask,
|
|
msm_ba_ctrls[idx].default_value);
|
|
} else {
|
|
ctrl = v4l2_ctrl_new_std(&inst->ctrl_handler,
|
|
&msm_ba_ctrl_ops,
|
|
msm_ba_ctrls[idx].id,
|
|
msm_ba_ctrls[idx].minimum,
|
|
msm_ba_ctrls[idx].maximum,
|
|
msm_ba_ctrls[idx].step,
|
|
msm_ba_ctrls[idx].default_value);
|
|
}
|
|
}
|
|
|
|
switch (msm_ba_ctrls[idx].id) {
|
|
case MSM_BA_PRIV_SD_NODE_ADDR:
|
|
case MSM_BA_PRIV_FPS:
|
|
if (ctrl)
|
|
ctrl->flags |= msm_ba_ctrls[idx].flags;
|
|
break;
|
|
}
|
|
|
|
rc = inst->ctrl_handler.error;
|
|
if (rc) {
|
|
dprintk(BA_ERR,
|
|
"Error adding ctrl (%s) to ctrl handle, %d",
|
|
msm_ba_ctrls[idx].name,
|
|
inst->ctrl_handler.error);
|
|
return rc;
|
|
}
|
|
|
|
inst->ctrls[idx] = ctrl;
|
|
}
|
|
|
|
/* Construct a super cluster of all controls */
|
|
inst->cluster = msm_ba_get_super_cluster(inst, &cluster_size);
|
|
if (!inst->cluster || !cluster_size) {
|
|
dprintk(BA_WARN,
|
|
"Failed to setup super cluster");
|
|
return -EINVAL;
|
|
}
|
|
v4l2_ctrl_cluster(cluster_size, inst->cluster);
|
|
|
|
return rc;
|
|
}
|
|
|
|
void msm_ba_ctrl_deinit(struct msm_ba_inst *inst)
|
|
{
|
|
kfree(inst->ctrls);
|
|
kfree(inst->cluster);
|
|
v4l2_ctrl_handler_free(&inst->ctrl_handler);
|
|
}
|