自学教程：C++ v4l2_set_subdev_hostdata函数代码示例

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, 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;}

//.........这里部分代码省略.........	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;}