static int nxp_video_streamon(struct file *file, void *fh,
enum v4l2_buf_type i)
{
int ret;
u32 pad;
struct nxp_video *me = file->private_data;
struct v4l2_subdev *subdev = _get_remote_subdev(me, i, &pad);
void *hostdata_back;
vmsg("%s: me %p, %s\n", __func__, me, me->name);
if (me->vbq) {
ret = vb2_streamon(me->vbq, i);
if (ret < 0) {
pr_err("%s: failed to vb2_streamon()\n", __func__);
return ret;
}
} else {
struct vb2_queue *vq = v4l2_m2m_get_vq(me->m2m_ctx, i);
ret = vb2_streamon(vq, i);
if (ret < 0) {
pr_err("%s: m2m, failed to vb2_streamon()\n", __func__);
return ret;
}
}
/* for mlc subdev */
hostdata_back = v4l2_get_subdev_hostdata(subdev);
v4l2_set_subdev_hostdata(subdev, me->name);
ret = v4l2_subdev_call(subdev, video, s_stream, 1);
v4l2_set_subdev_hostdata(subdev, hostdata_back);
return ret;
}
int msm_csi_register_subdevs(struct msm_cam_media_controller *p_mctl,
int core_index, struct msm_cam_server_dev *server_dev)
{
int rc = -ENODEV;
/* register csiphy subdev */
p_mctl->csiphy_sdev = server_dev->csiphy_device[core_index];
if (!p_mctl->csiphy_sdev)
goto out;
v4l2_set_subdev_hostdata(p_mctl->csiphy_sdev, p_mctl);
/* register csid subdev */
p_mctl->csid_sdev = server_dev->csid_device[core_index];
if (!p_mctl->csid_sdev)
goto out;
v4l2_set_subdev_hostdata(p_mctl->csid_sdev, p_mctl);
/* register ispif subdev */
p_mctl->ispif_sdev = server_dev->ispif_device[0];
if (!p_mctl->ispif_sdev)
goto out;
v4l2_set_subdev_hostdata(p_mctl->ispif_sdev, p_mctl);
rc = 0;
return rc;
out:
p_mctl->ispif_sdev = NULL;
return rc;
}
/*
* Sensor subdevice helper functions
*/
static struct v4l2_subdev *fimc_md_register_is_sensor(struct fimc_md *fmd,
struct fimc_sensor_info *s_info, int index)
{
struct v4l2_subdev *sd = NULL;
const char *sd_name;
if (fmd->fimc_is == NULL)
return NULL;
sd = &fmd->fimc_is->sensor[index].subdev;
/* Override FIMC-IS subdev name */
sd_name = fimc_is_get_sensor_name(s_info->pdata.is_sensor_info);
pr_info("fimc_md_register_is_sensor : sd_name (%s)\n", sd_name);
if (sd_name == NULL) {
v4l2_err(sd, "Null FIMC-IS sensor name\n");
return NULL;
}
strlcpy(sd->name, sd_name, sizeof(sd->name));
v4l2_set_subdev_hostdata(sd, s_info);
sd->grp_id = FIMC_IS_SENSOR_GROUP_ID;
v4l2_info(&fmd->v4l2_dev, "Registered logical sensor subdevice %s\n",
sd->name);
return sd;
}
/*
* Configure MIPI CSI physical parameters.
* @port: ATOMISP_CAMERA_PORT_PRIMARY or ATOMISP_CAMERA_PORT_SECONDARY
* @lanes: for ATOMISP_CAMERA_PORT_PRIMARY, there could be 2 or 4 lanes
* for ATOMISP_CAMERA_PORT_SECONDARY, there is only one lane.
* @format: MIPI CSI pixel format, see include/linux/atomisp_platform.h
* @bayer_order: MIPI CSI bayer order, see include/linux/atomisp_platform.h
*/
int camera_sensor_csi(struct v4l2_subdev *sd, u32 port,
u32 lanes, u32 format, u32 bayer_order, int flag)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct camera_mipi_info *csi = NULL;
if (flag) {
csi = kzalloc(sizeof(*csi), GFP_KERNEL);
if (!csi) {
dev_err(&client->dev, "out of memory\n");
return -ENOMEM;
}
csi->port = port;
csi->num_lanes = lanes;
csi->input_format = format;
csi->raw_bayer_order = bayer_order;
v4l2_set_subdev_hostdata(sd, (void *)csi);
csi->metadata_format = ATOMISP_INPUT_FORMAT_EMBEDDED;
csi->metadata_effective_width = NULL;
dev_info(&client->dev,
"camera pdata: port: %d lanes: %d order: %8.8x\n",
port, lanes, bayer_order);
} else {
csi = v4l2_get_subdev_hostdata(sd);
kfree(csi);
}
return 0;
}
static int register_fimc_entity(struct fimc_md *fmd, struct fimc_dev *fimc)
{
struct v4l2_subdev *sd;
struct exynos_media_pipeline *ep;
int ret;
if (WARN_ON(fimc->id >= FIMC_MAX_DEVS || fmd->fimc[fimc->id]))
return -EBUSY;
sd = &fimc->vid_cap.subdev;
sd->grp_id = GRP_ID_FIMC;
ep = fimc_md_pipeline_create(fmd);
if (!ep)
return -ENOMEM;
v4l2_set_subdev_hostdata(sd, ep);
ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
if (!ret) {
if (!fmd->pmf && fimc->pdev)
fmd->pmf = &fimc->pdev->dev;
fmd->fimc[fimc->id] = fimc;
fimc->vid_cap.user_subdev_api = fmd->user_subdev_api;
} else {
v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.%d (%d)\n",
fimc->id, ret);
}
return ret;
}
static int rvin_digital_notify_bound(struct v4l2_async_notifier *notifier,
struct v4l2_subdev *subdev,
struct v4l2_async_subdev *asd)
{
struct rvin_dev *vin = notifier_to_vin(notifier);
int ret;
v4l2_set_subdev_hostdata(subdev, vin);
/* Find source and sink pad of remote subdevice */
ret = rvin_find_pad(subdev, MEDIA_PAD_FL_SOURCE);
if (ret < 0)
return ret;
vin->digital.source_pad = ret;
ret = rvin_find_pad(subdev, MEDIA_PAD_FL_SINK);
vin->digital.sink_pad = ret < 0 ? 0 : ret;
vin->digital.subdev = subdev;
vin_dbg(vin, "bound subdev %s source pad: %u sink pad: %u\n",
subdev->name, vin->digital.source_pad,
vin->digital.sink_pad);
return 0;
}
/*
* Sensor subdevice helper functions
*/
static struct v4l2_subdev *fimc_md_register_sensor(struct fimc_md *fmd,
struct fimc_sensor_info *s_info)
{
struct i2c_adapter *adapter;
struct v4l2_subdev *sd = NULL;
if (!s_info || !fmd)
return NULL;
adapter = i2c_get_adapter(s_info->pdata.i2c_bus_num);
if (!adapter) {
v4l2_warn(&fmd->v4l2_dev,
"Failed to get I2C adapter %d, deferring probe\n",
s_info->pdata.i2c_bus_num);
return ERR_PTR(-EPROBE_DEFER);
}
sd = v4l2_i2c_new_subdev_board(&fmd->v4l2_dev, adapter,
s_info->pdata.board_info, NULL);
if (IS_ERR_OR_NULL(sd)) {
i2c_put_adapter(adapter);
v4l2_warn(&fmd->v4l2_dev,
"Failed to acquire subdev %s, deferring probe\n",
s_info->pdata.board_info->type);
return ERR_PTR(-EPROBE_DEFER);
}
v4l2_set_subdev_hostdata(sd, s_info);
sd->grp_id = SENSOR_GROUP_ID;
v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice %s\n",
s_info->pdata.board_info->type);
return sd;
}
/*
* MIPI-CSIS, FIMC and FIMC-LITE platform devices registration.
*/
static int register_fimc_lite_entity(struct fimc_md *fmd,
struct fimc_lite *fimc_lite)
{
struct v4l2_subdev *sd;
struct exynos_media_pipeline *ep;
int ret;
if (WARN_ON(fimc_lite->index >= FIMC_LITE_MAX_DEVS ||
fmd->fimc_lite[fimc_lite->index]))
return -EBUSY;
sd = &fimc_lite->subdev;
sd->grp_id = GRP_ID_FLITE;
ep = fimc_md_pipeline_create(fmd);
if (!ep)
return -ENOMEM;
v4l2_set_subdev_hostdata(sd, ep);
ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
if (!ret)
fmd->fimc_lite[fimc_lite->index] = fimc_lite;
else
v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.LITE%d\n",
fimc_lite->index);
return ret;
}
/*
* Configure MIPI CSI physical parameters.
* @port: ATOMISP_CAMERA_PORT_PRIMARY or ATOMISP_CAMERA_PORT_SECONDARY
* @lanes: for ATOMISP_CAMERA_PORT_PRIMARY, there could be 2 or 4 lanes
* for ATOMISP_CAMERA_PORT_SECONDARY, there is only one lane.
* @format: MIPI CSI pixel format, see include/linux/atomisp_platform.h
* @bayer_order: MIPI CSI bayer order, see include/linux/atomisp_platform.h
*/
int camera_sensor_csi(struct v4l2_subdev *sd, u32 port,
u32 lanes, u32 format, u32 bayer_order,
bool need_sof_signal, int flag)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct camera_mipi_info *csi = NULL;
if (flag) {
csi = kzalloc(sizeof(*csi), GFP_KERNEL);
if (!csi) {
dev_err(&client->dev, "out of memory\n");
return -ENOMEM;
}
csi->port = port;
csi->num_lanes = lanes;
csi->input_format = format;
csi->raw_bayer_order = bayer_order;
csi->need_sof_signal = need_sof_signal;
v4l2_set_subdev_hostdata(sd, (void *)csi);
} else {
csi = v4l2_get_subdev_hostdata(sd);
kfree(csi);
}
return 0;
}
int msm_axi_subdev_init(struct v4l2_subdev *sd,
struct msm_cam_media_controller *mctl)
{
int rc = 0;
struct axi_ctrl_t *axi_ctrl = v4l2_get_subdevdata(sd);
v4l2_set_subdev_hostdata(sd, mctl);
spin_lock_init(&axi_ctrl->tasklet_lock);
INIT_LIST_HEAD(&axi_ctrl->tasklet_q);
spin_lock_init(&axi_ctrl->share_ctrl->sd_notify_lock);
axi_ctrl->share_ctrl->vfebase = ioremap(axi_ctrl->vfemem->start,
resource_size(axi_ctrl->vfemem));
if (!axi_ctrl->share_ctrl->vfebase) {
rc = -ENOMEM;
pr_err("%s: vfe ioremap failed\n", __func__);
goto remap_failed;
}
if (axi_ctrl->fs_vfe == NULL) {
axi_ctrl->fs_vfe =
regulator_get(&axi_ctrl->pdev->dev, "vdd");
if (IS_ERR(axi_ctrl->fs_vfe)) {
pr_err("%s: Regulator FS_VFE get failed %ld\n",
__func__, PTR_ERR(axi_ctrl->fs_vfe));
axi_ctrl->fs_vfe = NULL;
goto fs_failed;
} else if (regulator_enable(axi_ctrl->fs_vfe)) {
pr_err("%s: Regulator FS_VFE enable failed\n",
__func__);
regulator_put(axi_ctrl->fs_vfe);
axi_ctrl->fs_vfe = NULL;
goto fs_failed;
}
}
rc = msm_cam_clk_enable(&axi_ctrl->pdev->dev, vfe40_clk_info,
axi_ctrl->vfe_clk, ARRAY_SIZE(vfe40_clk_info), 1);
if (rc < 0)
goto clk_enable_failed;
msm_camio_bus_scale_cfg(
mctl->sdata->pdata->cam_bus_scale_table, S_INIT);
msm_camio_bus_scale_cfg(
mctl->sdata->pdata->cam_bus_scale_table, S_PREVIEW);
axi_ctrl->share_ctrl->register_total = VFE40_REGISTER_TOTAL;
enable_irq(axi_ctrl->vfeirq->start);
return rc;
clk_enable_failed:
regulator_disable(axi_ctrl->fs_vfe);
regulator_put(axi_ctrl->fs_vfe);
axi_ctrl->fs_vfe = NULL;
fs_failed:
iounmap(axi_ctrl->share_ctrl->vfebase);
axi_ctrl->share_ctrl->vfebase = NULL;
remap_failed:
disable_irq(axi_ctrl->vfeirq->start);
return rc;
}
/*
* Sensor subdevice helper functions
*/
static struct v4l2_subdev *fimc_md_register_sensor(struct fimc_md *fmd,
struct fimc_sensor_info *s_info)
{
struct i2c_adapter *adapter;
struct v4l2_subdev *sd = NULL;
if (!s_info || !fmd)
return NULL;
adapter = i2c_get_adapter(s_info->pdata->i2c_bus_num);
if (!adapter)
return NULL;
sd = v4l2_i2c_new_subdev_board(&fmd->v4l2_dev, adapter,
s_info->pdata->board_info, NULL);
if (IS_ERR_OR_NULL(sd)) {
i2c_put_adapter(adapter);
v4l2_err(&fmd->v4l2_dev, "Failed to acquire subdev\n");
return NULL;
}
v4l2_set_subdev_hostdata(sd, s_info);
sd->grp_id = SENSOR_GROUP_ID;
v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice %s\n",
s_info->pdata->board_info->type);
return sd;
}
/* Register I2C client subdev associated with @node. */
static int fimc_md_of_add_sensor(struct fimc_md *fmd,
struct device_node *node, int index)
{
struct fimc_sensor_info *si;
struct i2c_client *client;
struct v4l2_subdev *sd;
int ret;
if (WARN_ON(index >= ARRAY_SIZE(fmd->sensor)))
return -EINVAL;
si = &fmd->sensor[index];
client = of_find_i2c_device_by_node(node);
if (!client)
return -EPROBE_DEFER;
device_lock(&client->dev);
if (!client->driver ||
!try_module_get(client->driver->driver.owner)) {
ret = -EPROBE_DEFER;
v4l2_info(&fmd->v4l2_dev, "No driver found for %s\n",
node->full_name);
goto dev_put;
}
/* Enable sensor's master clock */
ret = __fimc_md_set_camclk(fmd, &si->pdata, true);
if (ret < 0)
goto mod_put;
sd = i2c_get_clientdata(client);
ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
__fimc_md_set_camclk(fmd, &si->pdata, false);
if (ret < 0)
goto mod_put;
v4l2_set_subdev_hostdata(sd, &si->pdata);
if (si->pdata.fimc_bus_type == FIMC_BUS_TYPE_ISP_WRITEBACK)
sd->grp_id = GRP_ID_FIMC_IS_SENSOR;
else
sd->grp_id = GRP_ID_SENSOR;
si->subdev = sd;
v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice: %s (%d)\n",
sd->name, fmd->num_sensors);
fmd->num_sensors++;
mod_put:
module_put(client->driver->driver.owner);
dev_put:
device_unlock(&client->dev);
put_device(&client->dev);
return ret;
}
static int nxp_video_streamoff(struct file *file, void *fh,
enum v4l2_buf_type i)
{
int ret;
u32 pad;
struct nxp_video *me;
struct v4l2_subdev *subdev;
void *hostdata_back;
me = file->private_data;
subdev = _get_remote_subdev(me, i, &pad);
if (me->vbq) {
ret = vb2_streamoff(me->vbq, i);
if (ret < 0) {
printk(KERN_ERR "%s: failed to vb2_streamoff() %s\n", __func__, me->name);
return 0;
}
} else {
struct vb2_queue *vq = v4l2_m2m_get_vq(me->m2m_ctx, i);
ret = vb2_streamoff(vq, i);
if (ret < 0) {
pr_err(KERN_ERR "%s: m2m, failed to vb2_streamoff() %s\n", __func__, me->name);
return 0;
}
}
vmsg("%s %s\n", __func__, me->name);
hostdata_back = v4l2_get_subdev_hostdata(subdev);
v4l2_set_subdev_hostdata(subdev, me->name);
ret = v4l2_subdev_call(subdev, video, s_stream, 0);
v4l2_set_subdev_hostdata(subdev, hostdata_back);
vmsg("%s: %s exit\n", __func__, me->name);
return ret;
}
static struct v4l2_subdev *gsc_cap_register_sensor(struct gsc_dev *gsc, int i)
{
struct exynos_md *mdev = gsc->mdev[MDEV_CAPTURE];
struct v4l2_subdev *sd = NULL;
sd = mdev->sensor_sd[i];
if (!sd)
return NULL;
v4l2_set_subdev_hostdata(sd, &gsc->cap.sensor[i]);
return sd;
}
int msm_csi_register_subdevs(struct msm_cam_media_controller *p_mctl,
uint8_t csiphy_code_index, uint8_t csid_core_index,
struct msm_cam_server_dev *server_dev)
{
int rc = -ENODEV;
p_mctl->csic_sdev = server_dev->csic_device[csid_core_index];
if (!p_mctl->csic_sdev)
goto out;
v4l2_set_subdev_hostdata(p_mctl->csic_sdev, p_mctl);
rc = 0;
p_mctl->ispif_sdev = NULL;
return rc;
out:
p_mctl->ispif_sdev = NULL;
return rc;
}
int msm_vpe_subdev_init(struct v4l2_subdev *sd,
struct msm_cam_media_controller *mctl)
{
int rc = 0;
CDBG("%s:begin", __func__);
if (atomic_read(&vpe_init_done)) {
pr_err("%s: VPE has been initialized", __func__);
return -EBUSY;
}
atomic_set(&vpe_init_done, 1);
rc = msm_vpe_resource_init();
if (rc < 0) {
atomic_set(&vpe_init_done, 0);
return rc;
}
v4l2_set_subdev_hostdata(sd, mctl);
spin_lock_init(&vpe_ctrl->lock);
CDBG("%s:end", __func__);
return rc;
}
int msm_vpe_subdev_init(struct v4l2_subdev *sd, void *data,
struct platform_device *pdev)
{
int rc = 0;
CDBG("%s:begin", __func__);
if (atomic_read(&vpe_init_done)) {
pr_err("%s: VPE has been initialized", __func__);
return -EBUSY;
}
atomic_set(&vpe_init_done, 1);
rc = msm_vpe_resource_init(pdev);
if (rc < 0) {
atomic_set(&vpe_init_done, 0);
return rc;
}
v4l2_set_subdev_hostdata(sd, data);
spin_lock_init(&vpe_ctrl->lock);
CDBG("%s:end", __func__);
return rc;
}
static struct v4l2_subdev *gsc_cap_register_sensor(struct gsc_dev *gsc, int i)
{
struct exynos_md *mdev = gsc->mdev[MDEV_CAPTURE];
struct v4l2_subdev *sd = NULL;
sd = mdev->sensor_sd[i];
if (!sd)
return NULL;
if (sd->host_priv) {
pr_info("~~~ Attention please! ~~~~\n");
dev_info(&gsc->pdev->dev, "%s(): sd(0x%p)'s host_priv has already\n"
"been set to 0x%p in FIMC-LITE driver!!!\n"
"Consequently I will NOT change it to 0x%p in case "
"of FIMC-LITE driver being contaminated!!!\n",
__func__, sd, sd->host_priv, &gsc->cap.sensor[i]);
} else {
v4l2_set_subdev_hostdata(sd, &gsc->cap.sensor[i]);
}
return sd;
}
static int fimc_lite_register_callback(struct device *dev, void *p)
{
struct fimc_lite *fimc = dev_get_drvdata(dev);
struct fimc_md *fmd = p;
int ret;
if (fimc == NULL || fimc->index >= FIMC_LITE_MAX_DEVS)
return 0;
fimc->subdev.grp_id = FLITE_GROUP_ID;
v4l2_set_subdev_hostdata(&fimc->subdev, (void *)&fimc_pipeline_ops);
ret = v4l2_device_register_subdev(&fmd->v4l2_dev, &fimc->subdev);
if (ret) {
v4l2_err(&fmd->v4l2_dev,
"Failed to register FIMC-LITE.%d (%d)\n",
fimc->index, ret);
return ret;
}
fmd->fimc_lite[fimc->index] = fimc;
return 0;
}
static int register_fimc_is_entity(struct fimc_md *fmd, struct fimc_is *is)
{
struct v4l2_subdev *sd = &is->isp.subdev;
struct exynos_media_pipeline *ep;
int ret;
/* Allocate pipeline object for the ISP capture video node. */
ep = fimc_md_pipeline_create(fmd);
if (!ep)
return -ENOMEM;
v4l2_set_subdev_hostdata(sd, ep);
ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
if (ret) {
v4l2_err(&fmd->v4l2_dev,
"Failed to register FIMC-ISP (%d)\n", ret);
return ret;
}
fmd->fimc_is = is;
return 0;
}
/*
* Sensor subdevice helper functions
*/
static struct v4l2_subdev *fimc_md_register_sensor(struct fimc_md *fmd,
struct fimc_source_info *si)
{
struct i2c_adapter *adapter;
struct v4l2_subdev *sd = NULL;
if (!si || !fmd)
return NULL;
/*
* If FIMC bus type is not Writeback FIFO assume it is same
* as sensor_bus_type.
*/
si->fimc_bus_type = si->sensor_bus_type;
adapter = i2c_get_adapter(si->i2c_bus_num);
if (!adapter) {
v4l2_warn(&fmd->v4l2_dev,
"Failed to get I2C adapter %d, deferring probe\n",
si->i2c_bus_num);
return ERR_PTR(-EPROBE_DEFER);
}
sd = v4l2_i2c_new_subdev_board(&fmd->v4l2_dev, adapter,
si->board_info, NULL);
if (IS_ERR_OR_NULL(sd)) {
i2c_put_adapter(adapter);
v4l2_warn(&fmd->v4l2_dev,
"Failed to acquire subdev %s, deferring probe\n",
si->board_info->type);
return ERR_PTR(-EPROBE_DEFER);
}
v4l2_set_subdev_hostdata(sd, si);
sd->grp_id = GRP_ID_SENSOR;
v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice %s\n",
sd->name);
return sd;
}
/*
* MIPI CSIS and FIMC platform devices registration.
*/
static int fimc_register_callback(struct device *dev, void *p)
{
struct fimc_dev *fimc = dev_get_drvdata(dev);
struct v4l2_subdev *sd;
struct fimc_md *fmd = p;
int ret;
if (fimc == NULL || fimc->id >= FIMC_MAX_DEVS)
return 0;
sd = &fimc->vid_cap.subdev;
sd->grp_id = FIMC_GROUP_ID;
v4l2_set_subdev_hostdata(sd, (void *)&fimc_pipeline_ops);
ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
if (ret) {
v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.%d (%d)\n",
fimc->id, ret);
return ret;
}
fmd->fimc[fimc->id] = fimc;
return 0;
}
int sensor_2p2_probe(struct platform_device *pdev)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
struct exynos_platform_fimc_is_module *pdata;
struct device *dev;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
probe_err("core device is not yet probed");
return -EPROBE_DEFER;
}
dev = &pdev->dev;
#ifdef CONFIG_OF
fimc_is_sensor_module_parse_dt(pdev, sensor_2p2_power_setpin);
#endif
pdata = dev_get_platdata(dev);
device = &core->sensor[pdata->id];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
probe_err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
clear_bit(FIMC_IS_MODULE_GPIO_ON, &module->state);
module->pdata = pdata;
module->pdev = pdev;
module->sensor_id = SENSOR_NAME_S5K2P2;
module->subdev = subdev_module;
module->device = pdata->id;
module->client = NULL;
module->active_width = 5312;
module->active_height = 2990;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 300;
module->position = pdata->position;
module->mode = CSI_MODE_DT_ONLY;
module->lanes = CSI_DATA_LANES_4;
module->vcis = ARRAY_SIZE(vci_2p2);
module->vci = vci_2p2;
module->sensor_maker = "SLSI";
module->sensor_name = "S5K2P2";
module->setfile_name = "setfile_2p2.bin";
module->cfgs = ARRAY_SIZE(config_2p2);
module->cfg = config_2p2;
module->ops = NULL;
module->private_data = NULL;
ext = &module->ext;
ext->mipi_lane_num = module->lanes;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = SENSOR_NAME_S5K2P2;
ext->sensor_con.peri_type = SE_I2C;
ext->sensor_con.peri_setting.i2c.channel = pdata->sensor_i2c_ch;
ext->sensor_con.peri_setting.i2c.slave_address = pdata->sensor_i2c_addr;
ext->sensor_con.peri_setting.i2c.speed = 400000;
if (pdata->af_product_name != ACTUATOR_NAME_NOTHING) {
ext->actuator_con.product_name = pdata->af_product_name;
ext->actuator_con.peri_type = SE_I2C;
ext->actuator_con.peri_setting.i2c.channel = pdata->af_i2c_ch;
ext->actuator_con.peri_setting.i2c.slave_address = pdata->af_i2c_addr;
ext->actuator_con.peri_setting.i2c.speed = 400000;
}
if (pdata->flash_product_name != FLADRV_NAME_NOTHING) {
ext->flash_con.product_name = pdata->flash_product_name;
ext->flash_con.peri_type = SE_GPIO;
ext->flash_con.peri_setting.gpio.first_gpio_port_no = pdata->flash_first_gpio;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = pdata->flash_second_gpio;
}
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
if (pdata->companion_product_name != COMPANION_NAME_NOTHING) {
ext->companion_con.product_name = pdata->companion_product_name;
ext->companion_con.peri_info0.valid = true;
ext->companion_con.peri_info0.peri_type = SE_SPI;
ext->companion_con.peri_info0.peri_setting.spi.channel = pdata->companion_spi_channel;
ext->companion_con.peri_info1.valid = true;
ext->companion_con.peri_info1.peri_type = SE_I2C;
ext->companion_con.peri_info1.peri_setting.i2c.channel = pdata->companion_i2c_ch;
ext->companion_con.peri_info1.peri_setting.i2c.slave_address = pdata->companion_i2c_addr;
ext->companion_con.peri_info1.peri_setting.i2c.speed = 400000;
ext->companion_con.peri_info2.valid = true;
ext->companion_con.peri_info2.peri_type = SE_FIMC_LITE;
ext->companion_con.peri_info2.peri_setting.fimc_lite.channel = FLITE_ID_D;
} else {
ext->companion_con.product_name = pdata->companion_product_name;
}
if (pdata->ois_product_name != OIS_NAME_NOTHING) {
ext->ois_con.product_name = pdata->ois_product_name;
ext->ois_con.peri_type = SE_I2C;
ext->ois_con.peri_setting.i2c.channel = pdata->ois_i2c_ch;
ext->ois_con.peri_setting.i2c.slave_address = pdata->ois_i2c_addr;
ext->ois_con.peri_setting.i2c.speed = 400000;
} else {
ext->ois_con.product_name = pdata->ois_product_name;
ext->ois_con.peri_type = SE_NULL;
}
v4l2_subdev_init(subdev_module, &subdev_ops);
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->sensor_id);
p_err:
probe_info("%s(%d)\n", __func__, ret);
return ret;
}
int sensor_3l2_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_S5K3L2_INSTANCE];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
module->id = SENSOR_NAME_S5K3L2;
module->subdev = subdev_module;
module->device = SENSOR_S5K3L2_INSTANCE;
module->client = client;
module->active_width = 4128;
module->active_height = 3096;
module->margin_left = 8;
module->margin_right = 8;
module->margin_top = 6;
module->margin_bottom = 4;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 120;
module->position = SENSOR_POSITION_REAR;
module->mode = CSI_MODE_CH0_ONLY;
module->lanes = CSI_DATA_LANES_4;
module->sensor_maker = "SLSI";
module->sensor_name = "S5K3L2";
module->setfile_name = "setfile_3l2.bin";
module->cfgs = ARRAY_SIZE(config_3l2);
module->cfg = config_3l2;
module->ops = NULL;
module->private_data = NULL;
#ifdef CONFIG_OF
module->power_setpin = sensor_3l2_power_setpin;
#endif
ext = &module->ext;
ext->mipi_lane_num = module->lanes;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = SENSOR_NAME_S5K3L2;
ext->sensor_con.peri_type = SE_I2C;
ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0;
ext->sensor_con.peri_setting.i2c.slave_address = 0x5A;
ext->sensor_con.peri_setting.i2c.speed = 400000;
ext->actuator_con.product_name = ACTUATOR_NAME_DW9804;
ext->actuator_con.peri_type = SE_I2C;
ext->actuator_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C1;
ext->actuator_con.peri_setting.i2c.slave_address = 0x18;
ext->actuator_con.peri_setting.i2c.speed = 400000;
/* Flash is not working now, it will define agian after solving kernel panic*/
ext->flash_con.product_name = FLADRV_NAME_RT5033;
ext->flash_con.peri_type = SE_GPIO;
ext->flash_con.peri_setting.gpio.first_gpio_port_no = 1;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = 2;
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
ext->companion_con.product_name = COMPANION_NAME_NOTHING;
if (client)
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
else
v4l2_subdev_init(subdev_module, &subdev_ops);
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id);
p_err:
info("%s(%d)\n", __func__, ret);
return ret;
}
int sensor_ov5693_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_OV5693_INSTANCE];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
module->id = SENSOR_NAME_OV5693;
module->subdev = subdev_module;
module->device = SENSOR_OV5693_INSTANCE;
module->client = client;
module->active_width = 2592 -16;
module->active_height = 1944 -10;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 300;
module->position = SENSOR_POSITION_FRONT;
module->mode = CSI_MODE_CH0_ONLY;
module->lanes = CSI_DATA_LANES_2;
module->setfile_name = "setfile_ov5693.bin";
module->cfgs = ARRAY_SIZE(config_ov5693);
module->cfg = config_ov5693;
module->ops = NULL;
module->private_data = NULL;
ext = &module->ext;
ext->mipi_lane_num = module->lanes;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = SENSOR_NAME_OV5693;
ext->sensor_con.peri_type = SE_I2C;
ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C1;
ext->sensor_con.peri_setting.i2c.slave_address = 0x6c;
ext->sensor_con.peri_setting.i2c.speed = 400000;
ext->actuator_con.product_name = ACTUATOR_NAME_NOTHING;
ext->flash_con.product_name = FLADRV_NAME_NOTHING;
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
ext->companion_con.product_name = COMPANION_NAME_NOTHING;
ext->sOISCon.product_name = OIS_NAME_NOTHING;
if (client)
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
else
v4l2_subdev_init(subdev_module, &subdev_ops);
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id);
p_err:
info("%s(%d)\n", __func__, ret);
return ret;
}
int sensor_3h7_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_S5K3H7_INSTANCE];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
module->id = SENSOR_NAME_S5K3H7;
module->subdev = subdev_module;
module->device = SENSOR_S5K3H7_INSTANCE;
module->client = client;
module->active_width = 3248;
module->active_height = 2438;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 30;
module->position = SENSOR_POSITION_REAR;
module->setfile_name = "setfile_3h7.bin";
module->cfgs = ARRAY_SIZE(config_3h7);
module->cfg = config_3h7;
module->ops = NULL;
module->private_data = NULL;
ext = &module->ext;
ext->mipi_lane_num = 4;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = 0;
ext->sensor_con.peri_type = SE_I2C;
ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0;
ext->sensor_con.peri_setting.i2c.slave_address = 0x20;
ext->sensor_con.peri_setting.i2c.speed = 400000;
ext->actuator_con.product_name = ACTUATOR_NAME_AK7343;
ext->actuator_con.peri_type = SE_I2C;
ext->actuator_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0;
ext->flash_con.product_name = FLADRV_NAME_KTD267;
ext->flash_con.peri_type = SE_GPIO;
ext->flash_con.peri_setting.gpio.first_gpio_port_no = 17;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = 16;
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
ext->companion_con.product_name = COMPANION_NAME_NOTHING;
#ifdef DEFAULT_S5K3H7_DRIVING
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
#else
v4l2_subdev_init(subdev_module, &subdev_ops);
#endif
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id);
p_err:
info("%s(%d)\n", __func__, ret);
return ret;
}
int sensor_4h5_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_S5K4H5_INSTANCE];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
clear_bit(FIMC_IS_MODULE_GPIO_ON, &module->state);
module->sensor_id = SENSOR_NAME_S5K4H5;
module->subdev = subdev_module;
module->device = SENSOR_S5K4H5_INSTANCE;
module->ops = NULL;
module->client = client;
module->active_width = 3264;
module->active_height = 2448;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 120;
module->position = SENSOR_POSITION_REAR;
module->mode = CSI_MODE_CH0_ONLY;
module->lanes = CSI_DATA_LANES_4;
module->bitwidth = 10;
module->sensor_maker = "SLSI";
module->sensor_name = "S5K4H5";
module->setfile_name = "setfile_4h5.bin";
module->cfgs = ARRAY_SIZE(config_4h5);
module->cfg = config_4h5;
module->ops = NULL;
module->private_data = NULL;
ext = &module->ext;
ext->mipi_lane_num = module->lanes;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = 0;
ext->sensor_con.peri_type = SE_I2C;
ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0;
ext->sensor_con.peri_setting.i2c.slave_address = 0x6E;
ext->sensor_con.peri_setting.i2c.speed = 400000;
ext->actuator_con.product_name = ACTUATOR_NAME_DW9804;
ext->actuator_con.peri_type = SE_I2C;
ext->actuator_con.peri_setting.i2c.channel
= SENSOR_CONTROL_I2C0;
ext->flash_con.product_name = FLADRV_NAME_RT5033;
ext->flash_con.peri_type = SE_GPIO;
ext->flash_con.peri_setting.gpio.first_gpio_port_no = 8;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = 6;
/* ext->from_con.product_name = FROMDRV_NAME_W25Q80BW; */
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
ext->mclk = 0;
ext->mipi_lane_num = 0;
ext->mipi_speed = 0;
ext->fast_open_sensor = 0;
ext->self_calibration_mode = 0;
ext->I2CSclk = I2C_L0;
ext->preprocessor_con.product_name = PREPROCESSOR_NAME_NOTHING;
if (client) {
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
} else {
v4l2_subdev_init(subdev_module, &subdev_ops);
}
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id);
p_err:
probe_info("%s(%d)\n", __func__, ret);
return ret;
}
int sensor_4e5_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_S5K4E5_INSTANCE];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
module->id = SENSOR_NAME_S5K4E5;
module->subdev = subdev_module;
module->device = SENSOR_S5K4E5_INSTANCE;
module->client = client;
module->pixel_width = 2560 + 16;
module->pixel_height = 1920 + 10;
module->active_width = 2560;
module->active_height = 1920;
module->max_framerate = 30;
module->position = SENSOR_POSITION_REAR;
module->mode = CSI_MODE_CH0_ONLY;
module->lanes = CSI_DATA_LANES_4;
module->sensor_maker = "SLSI";
module->sensor_name = "S5K4E5";
module->setfile_name = "setfile_4e5.bin";
module->cfgs = 0;
module->cfg = NULL;
module->ops = NULL;
module->private_data = NULL;
ext = &module->ext;
ext->mipi_lane_num = module->lanes;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = 0;
ext->actuator_con.product_name = ACTUATOR_NAME_DWXXXX;
ext->actuator_con.peri_type = SE_I2C;
ext->actuator_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C1;
ext->flash_con.product_name = FLADRV_NAME_KTD267;
ext->flash_con.peri_type = SE_GPIO;
ext->flash_con.peri_setting.gpio.first_gpio_port_no = 17;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = 16;
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
ext->companion_con.product_name = COMPANION_NAME_NOTHING;
if (client)
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
else
v4l2_subdev_init(subdev_module, &subdev_ops);
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id);
p_err:
info("%s(%d)\n", __func__, ret);
return ret;
}
int fimc_is_csi_probe(void *parent, u32 instance)
{
int ret = 0;
struct v4l2_subdev *subdev_csi;
struct fimc_is_device_csi *csi;
struct fimc_is_device_sensor *device = parent;
BUG_ON(!device);
subdev_csi = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_csi) {
merr("subdev_csi is NULL", device);
ret = -ENOMEM;
goto p_err;
}
device->subdev_csi = subdev_csi;
csi = kzalloc(sizeof(struct fimc_is_device_csi), GFP_KERNEL);
if (!csi) {
merr("csi is NULL", device);
ret = -ENOMEM;
goto p_err_free1;
}
csi->instance = instance;
switch(instance) {
case CSI_ID_A:
csi->base_reg = (unsigned long *)MIPICSI0_REG_BASE;
#ifdef DBG_CSIISR
ret = request_irq(IRQ_MIPICSI0,
fimc_is_csi_isr,
IRQF_SHARED,
"mipi-csi0",
csi);
if (ret) {
err("request_irq(IRQ_MIPICSI0) is fail(%d)", ret);
goto p_err_free2;
}
#endif
break;
case CSI_ID_B:
csi->base_reg = (unsigned long *)MIPICSI1_REG_BASE;
#ifdef DBG_CSIISR
ret = request_irq(IRQ_MIPICSI1,
fimc_is_csi_isr,
IRQF_SHARED,
"mipi-csi1",
csi);
if (ret) {
err("request_irq(IRQ_MIPICSI1) is fail(%d)", ret);
goto p_err_free2;
}
#endif
break;
case CSI_ID_C:
csi->base_reg = (unsigned long *)MIPICSI2_REG_BASE;
break;
default:
err("instance is invalid(%d)", instance);
ret = -EINVAL;
goto p_err_free2;
}
v4l2_subdev_init(subdev_csi, &subdev_ops);
v4l2_set_subdevdata(subdev_csi, csi);
v4l2_set_subdev_hostdata(subdev_csi, device);
snprintf(subdev_csi->name, V4L2_SUBDEV_NAME_SIZE, "csi-subdev.%d", instance);
ret = v4l2_device_register_subdev(&device->v4l2_dev, subdev_csi);
if (ret) {
merr("v4l2_device_register_subdev is fail(%d)", device, ret);
goto p_err_free2;
}
info("[%d][FRT:D] %s(%d)\n", instance, __func__, ret);
return 0;
p_err_free2:
kfree(csi);
p_err_free1:
kfree(subdev_csi);
device->subdev_csi = NULL;
p_err:
err("[%d][FRT:D] %s(%d)\n", instance, __func__, ret);
return ret;
}
static int msm_vfe_stats_buf_ioctl(struct v4l2_subdev *sd,
unsigned int cmd,
struct msm_cam_media_controller *mctl,
void __user *arg)
{
struct msm_vfe_cfg_cmd cfgcmd;
int rc = 0;
v4l2_set_subdev_hostdata(sd, mctl);
switch (cmd) {
case MSM_CAM_IOCTL_STATS_REQBUF: {
struct msm_stats_reqbuf reqbuf;
if (copy_from_user(&reqbuf, arg,
sizeof(struct msm_stats_reqbuf))) {
ERR_COPY_FROM_USER();
return -EFAULT;
}
cfgcmd.cmd_type = VFE_CMD_STATS_REQBUF;
cfgcmd.value = (void *)&reqbuf;
cfgcmd.length = sizeof(struct msm_stats_reqbuf);
rc = msm_isp_subdev_ioctl(sd, &cfgcmd, (void *)mctl->client);
break;
}
case MSM_CAM_IOCTL_STATS_ENQUEUEBUF: {
struct msm_stats_buf_info buf_info;
if (copy_from_user(&buf_info, arg,
sizeof(struct msm_stats_buf_info))) {
ERR_COPY_FROM_USER();
return -EFAULT;
}
cfgcmd.cmd_type = VFE_CMD_STATS_ENQUEUEBUF;
cfgcmd.value = (void *)&buf_info;
cfgcmd.length = sizeof(struct msm_stats_buf_info);
rc = msm_isp_subdev_ioctl(sd, &cfgcmd, NULL);
break;
}
case MSM_CAM_IOCTL_STATS_FLUSH_BUFQ: {
struct msm_stats_flush_bufq bufq_info;
if (copy_from_user(&bufq_info, arg,
sizeof(struct msm_stats_flush_bufq))) {
ERR_COPY_FROM_USER();
return -EFAULT;
}
cfgcmd.cmd_type = VFE_CMD_STATS_FLUSH_BUFQ;
cfgcmd.value = (void *)&bufq_info;
cfgcmd.length = sizeof(struct msm_stats_flush_bufq);
rc = msm_isp_subdev_ioctl(sd, &cfgcmd, NULL);
break;
}
case MSM_CAM_IOCTL_STATS_UNREG_BUF: {
struct msm_stats_reqbuf reqbuf;
if (copy_from_user(&reqbuf, arg,
sizeof(struct msm_stats_reqbuf))) {
ERR_COPY_FROM_USER();
return -EFAULT;
}
cfgcmd.cmd_type = VFE_CMD_STATS_UNREGBUF;
cfgcmd.value = (void *)&reqbuf;
cfgcmd.length = sizeof(struct msm_stats_reqbuf);
rc = msm_isp_subdev_ioctl(sd, &cfgcmd, (void *)mctl->client);
break;
}
default:
rc = -1;
break;
}
CDBG("%s\n", __func__);
return rc;
}
