Merge "msm: camera: sensor: Remove unused code" (f0bf6428) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/media/platform/msm/camera_v2/sensor/flash/msm_flash.c

+1 −9

Original line number	Diff line number	Diff line
		@@ -726,19 +726,13 @@ static int32_t msm_flash_get_gpio_dt_data(struct device_node *of_node,
		goto free_gpio_array;
		}

		rc = msm_camera_get_dt_gpio_set_tbl(of_node, gconf,
		rc = msm_camera_init_gpio_pin_tbl(of_node, gconf,
		gpio_array, gpio_array_size);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto free_cam_gpio_req_tbl;
		}

		rc = msm_camera_init_gpio_pin_tbl(of_node, gconf,
		gpio_array, gpio_array_size);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto free_cam_gpio_set_tbl;
		}
		if (fctrl->flash_driver_type == FLASH_DRIVER_DEFAULT)
		fctrl->flash_driver_type = FLASH_DRIVER_GPIO;
		CDBG("%s:%d fctrl->flash_driver_type = %d", __func__, __LINE__,
		@@ -747,8 +741,6 @@ static int32_t msm_flash_get_gpio_dt_data(struct device_node *of_node,

		return 0;

		free_cam_gpio_set_tbl:
		kfree(gconf->cam_gpio_set_tbl);
		free_cam_gpio_req_tbl:
		kfree(gconf->cam_gpio_req_tbl);
		free_gpio_array:

drivers/media/platform/msm/camera_v2/sensor/io/msm_camera_dt_util.c

+0 −84

Original line number	Diff line number	Diff line
		@@ -749,90 +749,6 @@ ERROR1:
		return rc;
		}

		int msm_camera_get_dt_gpio_set_tbl(struct device_node *of_node,
		struct msm_camera_gpio_conf gconf, uint16_t gpio_array,
		uint16_t gpio_array_size)
		{
		int rc = 0, i = 0;
		uint32_t count = 0;
		uint32_t *val_array = NULL;

		if (!of_get_property(of_node, "qcom,gpio-set-tbl-num", &count))
		return 0;

		count /= sizeof(uint32_t);
		if (!count) {
		pr_err("%s qcom,gpio-set-tbl-num 0\n", __func__);
		return 0;
		}

		val_array = kzalloc(sizeof(uint32_t) * count, GFP_KERNEL);
		if (!val_array) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		return -ENOMEM;
		}

		gconf->cam_gpio_set_tbl = kzalloc(sizeof(struct msm_gpio_set_tbl) *
		count, GFP_KERNEL);
		if (!gconf->cam_gpio_set_tbl) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		rc = -ENOMEM;
		goto ERROR1;
		}
		gconf->cam_gpio_set_tbl_size = count;

		rc = of_property_read_u32_array(of_node, "qcom,gpio-set-tbl-num",
		val_array, count);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto ERROR2;
		}
		for (i = 0; i < count; i++) {
		if (val_array[i] >= gpio_array_size) {
		pr_err("%s gpio set tbl index %d invalid\n",
		__func__, val_array[i]);
		return -EINVAL;
		}
		gconf->cam_gpio_set_tbl[i].gpio = gpio_array[val_array[i]];
		CDBG("%s cam_gpio_set_tbl[%d].gpio = %d\n", __func__, i,
		gconf->cam_gpio_set_tbl[i].gpio);
		}

		rc = of_property_read_u32_array(of_node, "qcom,gpio-set-tbl-flags",
		val_array, count);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto ERROR2;
		}
		for (i = 0; i < count; i++) {
		gconf->cam_gpio_set_tbl[i].flags = val_array[i];
		CDBG("%s cam_gpio_set_tbl[%d].flags = %ld\n", __func__, i,
		gconf->cam_gpio_set_tbl[i].flags);
		}

		rc = of_property_read_u32_array(of_node, "qcom,gpio-set-tbl-delay",
		val_array, count);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto ERROR2;
		}
		for (i = 0; i < count; i++) {
		gconf->cam_gpio_set_tbl[i].delay = val_array[i];
		CDBG("%s cam_gpio_set_tbl[%d].delay = %d\n", __func__, i,
		gconf->cam_gpio_set_tbl[i].delay);
		}

		kfree(val_array);
		return rc;

		ERROR2:
		kfree(gconf->cam_gpio_set_tbl);
		ERROR1:
		kfree(val_array);
		gconf->cam_gpio_set_tbl_size = 0;
		return rc;
		}

		int msm_camera_init_gpio_pin_tbl(struct device_node *of_node,
		struct msm_camera_gpio_conf gconf, uint16_t gpio_array,
		uint16_t gpio_array_size)

drivers/media/platform/msm/camera_v2/sensor/io/msm_camera_dt_util.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -37,10 +37,6 @@ int msm_camera_get_dt_gpio_req_tbl(struct device_node *of_node,
		struct msm_camera_gpio_conf gconf, uint16_t gpio_array,
		uint16_t gpio_array_size);

		int msm_camera_get_dt_gpio_set_tbl(struct device_node *of_node,
		struct msm_camera_gpio_conf gconf, uint16_t gpio_array,
		uint16_t gpio_array_size);

		int msm_camera_init_gpio_pin_tbl(struct device_node *of_node,
		struct msm_camera_gpio_conf gconf, uint16_t gpio_array,
		uint16_t gpio_array_size);

drivers/media/platform/msm/camera_v2/sensor/msm_sensor.c

+0 −554

Original line number	Diff line number	Diff line
		@@ -21,7 +21,6 @@
		#undef CDBG
		#define CDBG(fmt, args...) pr_debug(fmt, ##args)

		static struct v4l2_file_operations msm_sensor_v4l2_subdev_fops;
		static void msm_sensor_adjust_mclk(struct msm_camera_power_ctrl_t *ctrl)
		{
		int idx;
		@@ -42,326 +41,6 @@ static void msm_sensor_adjust_mclk(struct msm_camera_power_ctrl_t *ctrl)
		return;
		}

		static int32_t msm_camera_get_power_settimgs_from_sensor_lib(
		struct msm_camera_power_ctrl_t *power_info,
		struct msm_sensor_power_setting_array *power_setting_array)
		{
		int32_t rc = 0;
		uint32_t size;
		struct msm_sensor_power_setting *ps;
		bool need_reverse = 0;

		if ((NULL == power_info->power_setting) \|\|
		(0 == power_info->power_setting_size)) {

		ps = power_setting_array->power_setting;
		size = power_setting_array->size;
		if ((NULL == ps) \|\| (0 == size)) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		rc = -EINVAL;
		goto FAILED_1;
		}

		power_info->power_setting =
		kzalloc(sizeof(ps) size, GFP_KERNEL);
		if (!power_info->power_setting) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		rc = -ENOMEM;
		goto FAILED_1;
		}
		memcpy(power_info->power_setting,
		power_setting_array->power_setting,
		sizeof(ps) size);
		power_info->power_setting_size = size;
		}

		ps = power_setting_array->power_down_setting;
		size = power_setting_array->size_down;
		if (NULL == ps \|\| 0 == size) {
		ps = power_info->power_setting;
		size = power_info->power_setting_size;
		need_reverse = 1;
		}

		power_info->power_down_setting =
		kzalloc(sizeof(ps) size, GFP_KERNEL);
		if (!power_info->power_down_setting) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_UP;
		}
		memcpy(power_info->power_down_setting,
		ps,
		sizeof(ps) size);
		power_info->power_down_setting_size = size;

		if (need_reverse) {
		int c, end = size - 1;
		struct msm_sensor_power_setting power_down_setting_t;
		for (c = 0; c < size/2; c++) {
		power_down_setting_t =
		power_info->power_down_setting[c];
		power_info->power_down_setting[c] =
		power_info->power_down_setting[end];
		power_info->power_down_setting[end] =
		power_down_setting_t;
		end--;
		}
		}

		return 0;
		FREE_UP:
		kfree(power_info->power_setting);
		FAILED_1:
		return rc;
		}

		static int32_t msm_sensor_get_dt_data(struct device_node *of_node,
		struct msm_sensor_ctrl_t *s_ctrl)
		{
		int32_t rc = 0, i = 0, ret = 0;
		struct msm_camera_gpio_conf *gconf = NULL;
		struct msm_camera_sensor_board_info *sensordata = NULL;
		uint16_t *gpio_array = NULL;
		uint16_t gpio_array_size = 0;
		uint32_t id_info[MSM_SENSOR_NUM_ID_INFO_DATA];
		uint32_t count;
		const uint32_t *p;
		struct msm_camera_slave_info *slave_info;

		s_ctrl->sensordata = kzalloc(sizeof(
		struct msm_camera_sensor_board_info),
		GFP_KERNEL);
		if (!s_ctrl->sensordata) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		return -ENOMEM;
		}

		sensordata = s_ctrl->sensordata;

		rc = of_property_read_string(of_node, "qcom,sensor-name",
		&sensordata->sensor_name);
		CDBG("%s qcom,sensor-name %s, rc %d\n", __func__,
		sensordata->sensor_name, rc);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_SENSORDATA;
		}

		rc = of_property_read_u32(of_node, "qcom,cci-master",
		&s_ctrl->cci_i2c_master);
		CDBG("%s qcom,cci-master %d, rc %d\n", __func__, s_ctrl->cci_i2c_master,
		rc);
		if (rc < 0) {
		/* Set default master 0 */
		s_ctrl->cci_i2c_master = MASTER_0;
		rc = 0;
		}

		rc = msm_sensor_get_sub_module_index(of_node, &sensordata->sensor_info);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_SENSORDATA;
		}

		/* Get sensor mount angle */
		if (0 > of_property_read_u32(of_node, "qcom,mount-angle",
		&sensordata->sensor_info->sensor_mount_angle)) {
		/* Invalidate mount angle flag */
		CDBG("%s:%d Default sensor mount angle\n",
		__func__, __LINE__);
		sensordata->sensor_info->is_mount_angle_valid = 0;
		sensordata->sensor_info->sensor_mount_angle = 0;
		} else {
		sensordata->sensor_info->is_mount_angle_valid = 1;
		}
		CDBG("%s qcom,mount-angle %d\n", __func__,
		sensordata->sensor_info->sensor_mount_angle);
		if (0 > of_property_read_u32(of_node, "qcom,sensor-position",
		&sensordata->sensor_info->position)) {
		CDBG("%s:%d Default sensor position\n", __func__, __LINE__);
		sensordata->sensor_info->position = 0;
		}
		CDBG("%s qcom,sensor-position %d\n", __func__,
		sensordata->sensor_info->position);
		if (0 > of_property_read_u32(of_node, "qcom,sensor-mode",
		&sensordata->sensor_info->modes_supported)) {
		CDBG("%s:%d Default sensor mode\n", __func__, __LINE__);
		sensordata->sensor_info->modes_supported = 0;
		}
		CDBG("%s qcom,sensor-mode %d\n", __func__,
		sensordata->sensor_info->modes_supported);

		s_ctrl->set_mclk_23880000 = of_property_read_bool(of_node,
		"qcom,mclk-23880000");

		CDBG("%s qcom,mclk-23880000 %d\n", __func__,
		s_ctrl->set_mclk_23880000);

		rc = msm_sensor_get_dt_csi_data(of_node, &sensordata->csi_lane_params);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_SENSOR_INFO;
		}

		rc = msm_camera_get_dt_vreg_data(of_node,
		&sensordata->power_info.cam_vreg,
		&sensordata->power_info.num_vreg);
		if (rc < 0)
		goto FREE_CSI;

		rc = msm_camera_get_dt_power_setting_data(of_node,
		sensordata->power_info.cam_vreg,
		sensordata->power_info.num_vreg,
		&sensordata->power_info);


		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_VREG;
		}


		rc = msm_camera_get_power_settimgs_from_sensor_lib(
		&sensordata->power_info,
		&s_ctrl->power_setting_array);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_VREG;
		}

		sensordata->power_info.gpio_conf = kzalloc(
		sizeof(struct msm_camera_gpio_conf), GFP_KERNEL);
		if (!sensordata->power_info.gpio_conf) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		rc = -ENOMEM;
		goto FREE_PS;
		}
		gconf = sensordata->power_info.gpio_conf;

		gpio_array_size = of_gpio_count(of_node);
		CDBG("%s gpio count %d\n", __func__, gpio_array_size);

		if (gpio_array_size) {
		gpio_array = kzalloc(sizeof(uint16_t) * gpio_array_size,
		GFP_KERNEL);
		if (!gpio_array) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_GPIO_CONF;
		}
		for (i = 0; i < gpio_array_size; i++) {
		gpio_array[i] = of_get_gpio(of_node, i);
		CDBG("%s gpio_array[%d] = %d\n", __func__, i,
		gpio_array[i]);
		}

		rc = msm_camera_get_dt_gpio_req_tbl(of_node, gconf,
		gpio_array, gpio_array_size);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_GPIO_CONF;
		}

		rc = msm_camera_get_dt_gpio_set_tbl(of_node, gconf,
		gpio_array, gpio_array_size);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_GPIO_REQ_TBL;
		}

		rc = msm_camera_init_gpio_pin_tbl(of_node, gconf,
		gpio_array, gpio_array_size);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_GPIO_SET_TBL;
		}
		}
		rc = msm_sensor_get_dt_actuator_data(of_node,
		&sensordata->actuator_info);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_GPIO_PIN_TBL;
		}

		sensordata->slave_info = kzalloc(sizeof(struct msm_camera_slave_info),
		GFP_KERNEL);
		if (!sensordata->slave_info) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		rc = -ENOMEM;
		goto FREE_ACTUATOR_INFO;
		}

		slave_info = sensordata->slave_info;

		p = of_get_property(of_node, "qcom,slave-id", &count);
		if (!p \|\| !count) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_SLAVE_INFO;
		}

		count /= sizeof(uint32_t);

		if (count > MSM_SENSOR_NUM_ID_INFO_DATA) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_SLAVE_INFO;
		}

		memset(id_info, 0, sizeof(id_info)MSM_SENSOR_NUM_ID_INFO_DATA);

		rc = of_property_read_u32_array(of_node, "qcom,slave-id",
		id_info, count);
		if (rc < 0) {
		pr_err("%s failed %d\n", __func__, __LINE__);
		goto FREE_SLAVE_INFO;
		}

		slave_info->sensor_slave_addr = id_info[MSM_SENSOR_SLAVEADDR_DATA];
		slave_info->sensor_id_reg_addr = id_info[MSM_SENSOR_IDREGADDR_DATA];
		slave_info->sensor_id = id_info[MSM_SENSOR_SENSOR_ID_DATA];
		slave_info->sensor_id_mask = id_info[MSM_SENSOR_SENIDMASK_DATA];
		CDBG("%s:%d slave addr 0x%x sensor reg 0x%x id 0x%x mask 0x%x\n",
		__func__, __LINE__,
		slave_info->sensor_slave_addr,
		slave_info->sensor_id_reg_addr,
		slave_info->sensor_id,
		slave_info->sensor_id_mask);

		/Optional property, don't return error if absent /
		ret = of_property_read_string(of_node, "qcom,vdd-cx-name",
		&sensordata->misc_regulator);
		CDBG("%s qcom,misc_regulator %s, rc %d\n", __func__,
		sensordata->misc_regulator, ret);

		kfree(gpio_array);

		return rc;

		FREE_SLAVE_INFO:
		kfree(s_ctrl->sensordata->slave_info);
		FREE_ACTUATOR_INFO:
		kfree(s_ctrl->sensordata->actuator_info);
		FREE_GPIO_PIN_TBL:
		kfree(s_ctrl->sensordata->power_info.gpio_conf->gpio_num_info);
		FREE_GPIO_SET_TBL:
		kfree(s_ctrl->sensordata->power_info.gpio_conf->cam_gpio_set_tbl);
		FREE_GPIO_REQ_TBL:
		kfree(s_ctrl->sensordata->power_info.gpio_conf->cam_gpio_req_tbl);
		FREE_GPIO_CONF:
		kfree(s_ctrl->sensordata->power_info.gpio_conf);
		FREE_PS:
		kfree(s_ctrl->sensordata->power_info.power_setting);
		kfree(s_ctrl->sensordata->power_info.power_down_setting);
		FREE_VREG:
		kfree(s_ctrl->sensordata->power_info.cam_vreg);
		FREE_CSI:
		kfree(s_ctrl->sensordata->csi_lane_params);
		FREE_SENSOR_INFO:
		kfree(s_ctrl->sensordata->sensor_info);
		FREE_SENSORDATA:
		kfree(s_ctrl->sensordata);
		kfree(gpio_array);
		return rc;
		}

		static void msm_sensor_misc_regulator(
		struct msm_sensor_ctrl_t *sctrl, uint32_t enable)
		{
		@@ -405,7 +84,6 @@ int32_t msm_sensor_free_sensor_data(struct msm_sensor_ctrl_t *s_ctrl)
		kfree(s_ctrl->sensordata->cam_slave_info);
		kfree(s_ctrl->sensordata->actuator_info);
		kfree(s_ctrl->sensordata->power_info.gpio_conf->gpio_num_info);
		kfree(s_ctrl->sensordata->power_info.gpio_conf->cam_gpio_set_tbl);
		kfree(s_ctrl->sensordata->power_info.gpio_conf->cam_gpio_req_tbl);
		kfree(s_ctrl->sensordata->power_info.gpio_conf);
		kfree(s_ctrl->sensordata->power_info.cam_vreg);
		@@ -418,15 +96,6 @@ int32_t msm_sensor_free_sensor_data(struct msm_sensor_ctrl_t *s_ctrl)
		return 0;
		}

		static struct msm_cam_clk_info cam_8960_clk_info[] = {
		[SENSOR_CAM_MCLK] = {"cam_clk", 24000000},
		};

		static struct msm_cam_clk_info cam_8610_clk_info[] = {
		[SENSOR_CAM_MCLK] = {"cam_src_clk", 24000000},
		[SENSOR_CAM_CLK] = {"cam_clk", 0},
		};

		static struct msm_cam_clk_info cam_8974_clk_info[] = {
		[SENSOR_CAM_MCLK] = {"cam_src_clk", 24000000},
		[SENSOR_CAM_CLK] = {"cam_clk", 0},
		@@ -1627,229 +1296,6 @@ static struct msm_camera_i2c_fn_t msm_sensor_qup_func_tbl = {
		.i2c_write_table_sync_block = msm_camera_qup_i2c_write_table,
		};

		int32_t msm_sensor_platform_probe(struct platform_device *pdev,
		const void *data)
		{
		int rc = 0;
		struct msm_sensor_ctrl_t *s_ctrl =
		(struct msm_sensor_ctrl_t *)data;
		struct msm_camera_cci_client *cci_client = NULL;
		uint32_t session_id;
		unsigned long mount_pos = 0;
		s_ctrl->pdev = pdev;
		CDBG("%s called data %p\n", __func__, data);
		CDBG("%s pdev name %s\n", __func__, pdev->id_entry->name);
		if (pdev->dev.of_node) {
		rc = msm_sensor_get_dt_data(pdev->dev.of_node, s_ctrl);
		if (rc < 0) {
		pr_err("%s failed line %d\n", __func__, __LINE__);
		return rc;
		}
		}
		s_ctrl->sensordata->power_info.dev = &pdev->dev;
		s_ctrl->sensor_device_type = MSM_CAMERA_PLATFORM_DEVICE;
		s_ctrl->sensor_i2c_client->cci_client = kzalloc(sizeof(
		struct msm_camera_cci_client), GFP_KERNEL);
		if (!s_ctrl->sensor_i2c_client->cci_client) {
		pr_err("%s failed line %d\n", __func__, __LINE__);
		return rc;
		}
		/* TODO: get CCI subdev */
		cci_client = s_ctrl->sensor_i2c_client->cci_client;
		cci_client->cci_subdev = msm_cci_get_subdev();
		cci_client->cci_i2c_master = s_ctrl->cci_i2c_master;
		cci_client->sid =
		s_ctrl->sensordata->slave_info->sensor_slave_addr >> 1;
		cci_client->cid = 0;
		cci_client->retries = 3;
		cci_client->id_map = 0;
		if (!s_ctrl->func_tbl)
		s_ctrl->func_tbl = &msm_sensor_func_tbl;
		if (!s_ctrl->sensor_i2c_client->i2c_func_tbl)
		s_ctrl->sensor_i2c_client->i2c_func_tbl =
		&msm_sensor_cci_func_tbl;
		if (!s_ctrl->sensor_v4l2_subdev_ops)
		s_ctrl->sensor_v4l2_subdev_ops = &msm_sensor_subdev_ops;
		s_ctrl->sensordata->power_info.clk_info =
		kzalloc(sizeof(cam_8974_clk_info), GFP_KERNEL);
		if (!s_ctrl->sensordata->power_info.clk_info) {
		pr_err("%s:%d failed nomem\n", __func__, __LINE__);
		kfree(cci_client);
		return -ENOMEM;
		}
		memcpy(s_ctrl->sensordata->power_info.clk_info, cam_8974_clk_info,
		sizeof(cam_8974_clk_info));
		s_ctrl->sensordata->power_info.clk_info_size =
		ARRAY_SIZE(cam_8974_clk_info);
		rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
		if (rc < 0) {
		pr_err("%s %s power up failed\n", __func__,
		s_ctrl->sensordata->sensor_name);
		kfree(s_ctrl->sensordata->power_info.clk_info);
		kfree(cci_client);
		return rc;
		}

		pr_info("%s %s probe succeeded\n", __func__,
		s_ctrl->sensordata->sensor_name);
		v4l2_subdev_init(&s_ctrl->msm_sd.sd,
		s_ctrl->sensor_v4l2_subdev_ops);
		snprintf(s_ctrl->msm_sd.sd.name,
		sizeof(s_ctrl->msm_sd.sd.name), "%s",
		s_ctrl->sensordata->sensor_name);
		v4l2_set_subdevdata(&s_ctrl->msm_sd.sd, pdev);
		s_ctrl->msm_sd.sd.flags \|= V4L2_SUBDEV_FL_HAS_DEVNODE;
		media_entity_init(&s_ctrl->msm_sd.sd.entity, 0, NULL, 0);
		s_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
		s_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR;
		s_ctrl->msm_sd.sd.entity.name =
		s_ctrl->msm_sd.sd.name;

		mount_pos = s_ctrl->sensordata->sensor_info->position << 16;
		mount_pos = mount_pos \| ((s_ctrl->sensordata->sensor_info->
		sensor_mount_angle / 90) << 8);
		s_ctrl->msm_sd.sd.entity.flags = mount_pos \| MEDIA_ENT_FL_DEFAULT;

		rc = camera_init_v4l2(&s_ctrl->pdev->dev, &session_id);
		CDBG("%s rc %d session_id %d\n", __func__, rc, session_id);
		s_ctrl->sensordata->sensor_info->session_id = session_id;
		s_ctrl->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY \| 0x3;
		msm_sd_register(&s_ctrl->msm_sd);
		msm_sensor_v4l2_subdev_fops = v4l2_subdev_fops;
		#ifdef CONFIG_COMPAT
		msm_sensor_v4l2_subdev_fops.compat_ioctl32 =
		msm_sensor_subdev_fops_ioctl;
		#endif
		s_ctrl->msm_sd.sd.devnode->fops =
		&msm_sensor_v4l2_subdev_fops;

		CDBG("%s:%d\n", __func__, __LINE__);

		s_ctrl->func_tbl->sensor_power_down(s_ctrl);
		CDBG("%s:%d\n", __func__, __LINE__);
		return rc;
		}

		int msm_sensor_i2c_probe(struct i2c_client *client,
		const struct i2c_device_id id, struct msm_sensor_ctrl_t s_ctrl)
		{
		int rc = 0;
		uint32_t session_id;
		unsigned long mount_pos = 0;
		CDBG("%s %s_i2c_probe called\n", __func__, client->name);
		if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		pr_err("%s %s i2c_check_functionality failed\n",
		__func__, client->name);
		rc = -EFAULT;
		return rc;
		}

		if (!client->dev.of_node) {
		CDBG("msm_sensor_i2c_probe: of_node is NULL");
		s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
		if (!s_ctrl) {
		pr_err("%s:%d sensor ctrl structure NULL\n", __func__,
		__LINE__);
		return -EINVAL;
		}
		s_ctrl->sensordata = client->dev.platform_data;
		} else {
		CDBG("msm_sensor_i2c_probe: of_node exisists");
		rc = msm_sensor_get_dt_data(client->dev.of_node, s_ctrl);
		if (rc < 0) {
		pr_err("%s failed line %d\n", __func__, __LINE__);
		return rc;
		}
		}

		s_ctrl->sensor_device_type = MSM_CAMERA_I2C_DEVICE;
		if (s_ctrl->sensordata == NULL) {
		pr_err("%s %s NULL sensor data\n", __func__, client->name);
		return -EFAULT;
		}

		if (s_ctrl->sensor_i2c_client != NULL) {
		s_ctrl->sensor_i2c_client->client = client;
		s_ctrl->sensordata->power_info.dev = &client->dev;
		if (s_ctrl->sensordata->slave_info->sensor_slave_addr)
		s_ctrl->sensor_i2c_client->client->addr =
		s_ctrl->sensordata->slave_info->
		sensor_slave_addr;
		} else {
		pr_err("%s %s sensor_i2c_client NULL\n",
		__func__, client->name);
		rc = -EFAULT;
		return rc;
		}

		if (!s_ctrl->func_tbl)
		s_ctrl->func_tbl = &msm_sensor_func_tbl;
		if (!s_ctrl->sensor_i2c_client->i2c_func_tbl)
		s_ctrl->sensor_i2c_client->i2c_func_tbl =
		&msm_sensor_qup_func_tbl;
		if (!s_ctrl->sensor_v4l2_subdev_ops)
		s_ctrl->sensor_v4l2_subdev_ops = &msm_sensor_subdev_ops;

		if (!client->dev.of_node) {
		s_ctrl->sensordata->power_info.clk_info =
		kzalloc(sizeof(cam_8960_clk_info), GFP_KERNEL);
		if (!s_ctrl->sensordata->power_info.clk_info) {
		pr_err("%s:%d failed nomem\n", __func__, __LINE__);
		return -ENOMEM;
		}
		memcpy(s_ctrl->sensordata->power_info.clk_info,
		cam_8960_clk_info, sizeof(cam_8960_clk_info));
		s_ctrl->sensordata->power_info.clk_info_size =
		ARRAY_SIZE(cam_8960_clk_info);
		} else {
		s_ctrl->sensordata->power_info.clk_info =
		kzalloc(sizeof(cam_8610_clk_info), GFP_KERNEL);
		if (!s_ctrl->sensordata->power_info.clk_info) {
		pr_err("%s:%d failed nomem\n", __func__, __LINE__);
		return -ENOMEM;
		}
		memcpy(s_ctrl->sensordata->power_info.clk_info,
		cam_8610_clk_info, sizeof(cam_8610_clk_info));
		s_ctrl->sensordata->power_info.clk_info_size =
		ARRAY_SIZE(cam_8610_clk_info);
		}

		rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
		if (rc < 0) {
		pr_err("%s %s power up failed\n", __func__, client->name);
		kfree(s_ctrl->sensordata->power_info.clk_info);
		return rc;
		}

		CDBG("%s %s probe succeeded\n", __func__, client->name);
		snprintf(s_ctrl->msm_sd.sd.name,
		sizeof(s_ctrl->msm_sd.sd.name), "%s", id->name);
		v4l2_i2c_subdev_init(&s_ctrl->msm_sd.sd, client,
		s_ctrl->sensor_v4l2_subdev_ops);
		v4l2_set_subdevdata(&s_ctrl->msm_sd.sd, client);
		s_ctrl->msm_sd.sd.flags \|= V4L2_SUBDEV_FL_HAS_DEVNODE;
		media_entity_init(&s_ctrl->msm_sd.sd.entity, 0, NULL, 0);
		s_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
		s_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR;
		s_ctrl->msm_sd.sd.entity.name =
		s_ctrl->msm_sd.sd.name;
		mount_pos = s_ctrl->sensordata->sensor_info->position << 16;
		mount_pos = mount_pos \| ((s_ctrl->sensordata->sensor_info->
		sensor_mount_angle / 90) << 8);
		s_ctrl->msm_sd.sd.entity.flags = mount_pos \| MEDIA_ENT_FL_DEFAULT;

		rc = camera_init_v4l2(&s_ctrl->sensor_i2c_client->client->dev,
		&session_id);
		CDBG("%s rc %d session_id %d\n", __func__, rc, session_id);
		s_ctrl->sensordata->sensor_info->session_id = session_id;
		s_ctrl->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY \| 0x3;
		msm_sd_register(&s_ctrl->msm_sd);
		CDBG("%s:%d\n", __func__, __LINE__);

		s_ctrl->func_tbl->sensor_power_down(s_ctrl);
		return rc;
		}

		int32_t msm_sensor_init_default_params(struct msm_sensor_ctrl_t *s_ctrl)
		{
		int32_t rc = -ENOMEM;

drivers/media/platform/msm/camera_v2/sensor/msm_sensor.h

+0 −5

Original line number	Diff line number	Diff line
		@@ -100,13 +100,8 @@ int msm_sensor_check_id(struct msm_sensor_ctrl_t *s_ctrl);

		int msm_sensor_match_id(struct msm_sensor_ctrl_t *s_ctrl);

		int32_t msm_sensor_platform_probe(struct platform_device *pdev,
		const void *data);
		int msm_sensor_update_cfg(struct msm_sensor_ctrl_t *s_ctrl);

		int msm_sensor_i2c_probe(struct i2c_client *client,
		const struct i2c_device_id id, struct msm_sensor_ctrl_t s_ctrl);

		int msm_sensor_free_sensor_data(struct msm_sensor_ctrl_t *s_ctrl);

		int32_t msm_sensor_init_default_params(struct msm_sensor_ctrl_t *s_ctrl);