Merge "msm: camera: util: add support for i2c and spi device" into dev/msm-4.9-camx (0ca771c6) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/media/platform/msm/camera/cam_sensor_module/cam_actuator/cam_actuator_core.c

+15 −6

Original line number	Diff line number	Diff line
		@@ -28,12 +28,21 @@ int32_t cam_actuator_slaveInfo_pkt_parser(struct cam_actuator_ctrl_t *a_ctrl,
		}

		i2c_info = (struct cam_cmd_i2c_info *)cmd_buf;
		if (a_ctrl->io_master_info.master_type == CCI_MASTER) {
		a_ctrl->io_master_info.cci_client->i2c_freq_mode =
		i2c_info->i2c_freq_mode;
		a_ctrl->io_master_info.cci_client->sid =
		i2c_info->slave_addr >> 1;
		CAM_DBG(CAM_ACTUATOR, "Slave addr: 0x%x Freq Mode: %d",
		i2c_info->slave_addr, i2c_info->i2c_freq_mode);
		} else if (a_ctrl->io_master_info.master_type == I2C_MASTER) {
		a_ctrl->io_master_info.client->addr = i2c_info->slave_addr;
		CAM_DBG(CAM_ACTUATOR, "Slave addr: 0x%x", i2c_info->slave_addr);
		} else {
		CAM_ERR(CAM_ACTUATOR, "Invalid Master type: %d",
		a_ctrl->io_master_info.master_type);
		rc = -EINVAL;
		}

		return rc;
		}

drivers/media/platform/msm/camera/cam_sensor_module/cam_actuator/cam_actuator_dev.c

+120 −82

Original line number	Diff line number	Diff line
		@@ -35,11 +35,94 @@ static long cam_actuator_subdev_ioctl(struct v4l2_subdev *sd,
		return rc;
		}

		#ifdef CONFIG_COMPAT
		static long cam_actuator_init_subdev_do_ioctl(struct v4l2_subdev *sd,
		unsigned int cmd, unsigned long arg)
		{
		struct cam_control cmd_data;
		int32_t rc = 0;

		if (copy_from_user(&cmd_data, (void __user *)arg,
		sizeof(cmd_data))) {
		CAM_ERR(CAM_ACTUATOR,
		"Failed to copy from user_ptr=%pK size=%zu",
		(void __user *)arg, sizeof(cmd_data));
		return -EFAULT;
		}

		switch (cmd) {
		case VIDIOC_CAM_CONTROL:
		cmd = VIDIOC_CAM_CONTROL;
		rc = cam_actuator_subdev_ioctl(sd, cmd, &cmd_data);
		if (rc) {
		CAM_ERR(CAM_ACTUATOR,
		"Failed in actuator subdev handling rc: %d",
		rc);
		return rc;
		}
		break;
		default:
		CAM_ERR(CAM_ACTUATOR, "Invalid compat ioctl: %d", cmd);
		rc = -EINVAL;
		}

		if (!rc) {
		if (copy_to_user((void __user *)arg, &cmd_data,
		sizeof(cmd_data))) {
		CAM_ERR(CAM_ACTUATOR,
		"Failed to copy to user_ptr=%pK size=%zu",
		(void __user *)arg, sizeof(cmd_data));
		rc = -EFAULT;
		}
		}
		return rc;
		}
		#endif

		static struct v4l2_subdev_core_ops cam_actuator_subdev_core_ops = {
		.ioctl = cam_actuator_subdev_ioctl,
		#ifdef CONFIG_COMPAT
		.compat_ioctl32 = cam_actuator_init_subdev_do_ioctl,
		#endif
		};

		static struct v4l2_subdev_ops cam_actuator_subdev_ops = {
		.core = &cam_actuator_subdev_core_ops,
		};

		static const struct v4l2_subdev_internal_ops cam_actuator_internal_ops;

		static int cam_actuator_init_subdev(struct cam_actuator_ctrl_t *a_ctrl)
		{
		int rc = 0;

		a_ctrl->v4l2_dev_str.internal_ops =
		&cam_actuator_internal_ops;
		a_ctrl->v4l2_dev_str.ops =
		&cam_actuator_subdev_ops;
		strlcpy(a_ctrl->device_name, CAMX_ACTUATOR_DEV_NAME,
		sizeof(a_ctrl->device_name));
		a_ctrl->v4l2_dev_str.name =
		a_ctrl->device_name;
		a_ctrl->v4l2_dev_str.sd_flags =
		(V4L2_SUBDEV_FL_HAS_DEVNODE \| V4L2_SUBDEV_FL_HAS_EVENTS);
		a_ctrl->v4l2_dev_str.ent_function =
		CAM_ACTUATOR_DEVICE_TYPE;
		a_ctrl->v4l2_dev_str.token = a_ctrl;

		rc = cam_register_subdev(&(a_ctrl->v4l2_dev_str));
		if (rc)
		CAM_ERR(CAM_SENSOR, "Fail with cam_register_subdev rc: %d", rc);

		return rc;
		}

		static int32_t cam_actuator_driver_i2c_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
		{
		int32_t rc = 0, i = 0;
		struct cam_actuator_ctrl_t *a_ctrl;
		struct cam_hw_soc_info *soc_info = NULL;

		if (client == NULL \|\| id == NULL) {
		CAM_ERR(CAM_ACTUATOR, "Invalid Args client: %pK id: %pK",
		@@ -61,13 +144,29 @@ static int32_t cam_actuator_driver_i2c_probe(struct i2c_client *client,

		i2c_set_clientdata(client, a_ctrl);

		a_ctrl->io_master_info.client = client;
		soc_info = &a_ctrl->soc_info;
		soc_info->i2c_dev = client;
		soc_info->is_i2c_dev = true;
		a_ctrl->io_master_info.master_type = I2C_MASTER;

		rc = cam_actuator_parse_dt(a_ctrl, &client->dev);
		if (rc < 0) {
		CAM_ERR(CAM_ACTUATOR, "failed: cam_sensor_parse_dt rc %d", rc);
		goto free_ctrl;
		}

		rc = cam_actuator_init_subdev(a_ctrl);
		if (rc)
		goto free_ctrl;

		a_ctrl->i2c_data.per_frame =
		(struct i2c_settings_array *)
		kzalloc(sizeof(struct i2c_settings_array) *
		MAX_PER_FRAME_ARRAY, GFP_KERNEL);
		if (a_ctrl->i2c_data.per_frame == NULL) {
		rc = -ENOMEM;
		goto free_ctrl;
		goto unreg_subdev;
		}

		INIT_LIST_HEAD(&(a_ctrl->i2c_data.init_settings.list_head));
		@@ -75,18 +174,28 @@ static int32_t cam_actuator_driver_i2c_probe(struct i2c_client *client,
		for (i = 0; i < MAX_PER_FRAME_ARRAY; i++)
		INIT_LIST_HEAD(&(a_ctrl->i2c_data.per_frame[i].list_head));

		/* Initialize sensor device type */
		a_ctrl->io_master_info.master_type = I2C_MASTER;

		rc = cam_actuator_parse_dt(a_ctrl, &client->dev);
		rc = cam_soc_util_request_platform_resource(&a_ctrl->soc_info,
		NULL, NULL);
		if (rc < 0) {
		CAM_ERR(CAM_ACTUATOR, "failed: cam_sensor_parse_dt rc %d", rc);
		CAM_ERR(CAM_ACTUATOR,
		"Requesting Platform Resources failed rc %d", rc);
		goto free_mem;
		}

		a_ctrl->bridge_intf.device_hdl = -1;
		a_ctrl->bridge_intf.ops.get_dev_info =
		cam_actuator_publish_dev_info;
		a_ctrl->bridge_intf.ops.link_setup =
		cam_actuator_establish_link;
		a_ctrl->bridge_intf.ops.apply_req =
		cam_actuator_apply_request;

		v4l2_set_subdevdata(&(a_ctrl->v4l2_dev_str.sd), a_ctrl);
		return rc;
		free_mem:
		kfree(a_ctrl->i2c_data.per_frame);
		unreg_subdev:
		cam_unregister_subdev(&(a_ctrl->v4l2_dev_str));
		free_ctrl:
		kfree(a_ctrl);
		return rc;
		@@ -129,63 +238,6 @@ static int32_t cam_actuator_driver_i2c_remove(struct i2c_client *client)
		return rc;
		}

		#ifdef CONFIG_COMPAT
		static long cam_actuator_init_subdev_do_ioctl(struct v4l2_subdev *sd,
		unsigned int cmd, unsigned long arg)
		{
		struct cam_control cmd_data;
		int32_t rc = 0;

		if (copy_from_user(&cmd_data, (void __user *)arg,
		sizeof(cmd_data))) {
		CAM_ERR(CAM_ACTUATOR,
		"Failed to copy from user_ptr=%pK size=%zu\n",
		(void __user *)arg, sizeof(cmd_data));
		return -EFAULT;
		}

		switch (cmd) {
		case VIDIOC_CAM_CONTROL:
		cmd = VIDIOC_CAM_CONTROL;
		rc = cam_actuator_subdev_ioctl(sd, cmd, &cmd_data);
		if (rc < 0) {
		CAM_ERR(CAM_ACTUATOR,
		"Failed in actuator suddev handling");
		return rc;
		}
		break;
		default:
		CAM_ERR(CAM_ACTUATOR, "Invalid compat ioctl: %d", cmd);
		rc = -EINVAL;
		}

		if (!rc) {
		if (copy_to_user((void __user *)arg, &cmd_data,
		sizeof(cmd_data))) {
		CAM_ERR(CAM_ACTUATOR,
		"Failed to copy to user_ptr=%pK size=%zu\n",
		(void __user *)arg, sizeof(cmd_data));
		rc = -EFAULT;
		}
		}
		return rc;
		}

		#endif

		static struct v4l2_subdev_core_ops cam_actuator_subdev_core_ops = {
		.ioctl = cam_actuator_subdev_ioctl,
		#ifdef CONFIG_COMPAT
		.compat_ioctl32 = cam_actuator_init_subdev_do_ioctl,
		#endif
		};

		static struct v4l2_subdev_ops cam_actuator_subdev_ops = {
		.core = &cam_actuator_subdev_core_ops,
		};

		static const struct v4l2_subdev_internal_ops cam_actuator_internal_ops;

		static const struct of_device_id cam_actuator_driver_dt_match[] = {
		{.compatible = "qcom,actuator"},
		{}
		@@ -235,32 +287,16 @@ static int32_t cam_actuator_driver_platform_probe(
		/* Fill platform device id*/
		pdev->id = a_ctrl->id;

		a_ctrl->v4l2_dev_str.internal_ops =
		&cam_actuator_internal_ops;
		a_ctrl->v4l2_dev_str.ops =
		&cam_actuator_subdev_ops;
		strlcpy(a_ctrl->device_name, CAMX_ACTUATOR_DEV_NAME,
		sizeof(a_ctrl->device_name));
		a_ctrl->v4l2_dev_str.name =
		a_ctrl->device_name;
		a_ctrl->v4l2_dev_str.sd_flags =
		(V4L2_SUBDEV_FL_HAS_DEVNODE \| V4L2_SUBDEV_FL_HAS_EVENTS);
		a_ctrl->v4l2_dev_str.ent_function =
		CAM_ACTUATOR_DEVICE_TYPE;
		a_ctrl->v4l2_dev_str.token = a_ctrl;

		rc = cam_register_subdev(&(a_ctrl->v4l2_dev_str));
		if (rc < 0) {
		CAM_ERR(CAM_ACTUATOR, "Fail with cam_register_subdev");
		rc = cam_actuator_init_subdev(a_ctrl);
		if (rc)
		goto free_mem;
		}

		rc = cam_soc_util_request_platform_resource(&a_ctrl->soc_info,
		NULL, NULL);
		if (rc < 0) {
		CAM_ERR(CAM_ACTUATOR,
		"Requesting Platform Resources failed rc %d", rc);
		goto free_ctrl;
		goto unreg_subdev;
		}

		a_ctrl->bridge_intf.device_hdl = -1;
		@@ -275,6 +311,8 @@ static int32_t cam_actuator_driver_platform_probe(
		v4l2_set_subdevdata(&a_ctrl->v4l2_dev_str.sd, a_ctrl);

		return rc;
		unreg_subdev:
		cam_unregister_subdev(&(a_ctrl->v4l2_dev_str));
		free_mem:
		kfree(a_ctrl->i2c_data.per_frame);
		free_ctrl:

drivers/media/platform/msm/camera/cam_sensor_module/cam_actuator/cam_actuator_soc.c

+13 −17

Original line number	Diff line number	Diff line
		@@ -25,15 +25,6 @@ int32_t cam_actuator_parse_dt(struct cam_actuator_ctrl_t *a_ctrl,
		int32_t rc = 0;
		struct cam_hw_soc_info *soc_info = &a_ctrl->soc_info;
		struct device_node *of_node = NULL;
		struct platform_device *pdev = NULL;

		if (!soc_info->pdev) {
		CAM_ERR(CAM_ACTUATOR, "soc_info is not initialized");
		return -EINVAL;
		}

		pdev = soc_info->pdev;
		of_node = pdev->dev.of_node;

		/* Initialize mutex */
		mutex_init(&(a_ctrl->actuator_mutex));
		@@ -43,15 +34,20 @@ int32_t cam_actuator_parse_dt(struct cam_actuator_ctrl_t *a_ctrl,
		CAM_ERR(CAM_ACTUATOR, "parsing common soc dt(rc %d)", rc);
		return rc;
		}

		of_node = soc_info->dev->of_node;

		if (!(a_ctrl->soc_info.is_i2c_dev)) {
		rc = of_property_read_u32(of_node, "cci-master",
		&(a_ctrl->cci_i2c_master));
		CAM_DBG(CAM_ACTUATOR, "cci-master %d, rc %d",
		a_ctrl->cci_i2c_master, rc);
		if (rc < 0 \|\| a_ctrl->cci_i2c_master >= MASTER_MAX) {
		CAM_ERR(CAM_ACTUATOR, "Wrong info from dt CCI master as : %d",
		if ((rc < 0) \|\| (a_ctrl->cci_i2c_master >= MASTER_MAX)) {
		CAM_ERR(CAM_ACTUATOR, "Wrong info: dt CCI master:%d",
		a_ctrl->cci_i2c_master);
		return rc;
		}
		}

		if (!soc_info->gpio_data) {
		CAM_INFO(CAM_ACTUATOR, "No GPIO found");

drivers/media/platform/msm/camera/cam_sensor_module/cam_eeprom/cam_eeprom_core.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -617,7 +617,7 @@ static int32_t cam_eeprom_get_cal_data(struct cam_eeprom_ctrl_t *e_ctrl,
		return -EINVAL;
		}

		CAM_ERR(CAM_EEPROM, "copy the data, len:%d",
		CAM_DBG(CAM_EEPROM, "copy the data, len:%d",
		e_ctrl->cal_data.num_data);
		memcpy(read_buffer, e_ctrl->cal_data.mapdata,
		e_ctrl->cal_data.num_data);

drivers/media/platform/msm/camera/cam_sensor_module/cam_eeprom/cam_eeprom_dev.c

+89 −23

Original line number	Diff line number	Diff line
		@@ -111,12 +111,34 @@ static struct v4l2_subdev_ops cam_eeprom_subdev_ops = {
		.core = &cam_eeprom_subdev_core_ops,
		};

		static int cam_eeprom_init_subdev(struct cam_eeprom_ctrl_t *e_ctrl)
		{
		int rc = 0;

		e_ctrl->v4l2_dev_str.internal_ops = &cam_eeprom_internal_ops;
		e_ctrl->v4l2_dev_str.ops = &cam_eeprom_subdev_ops;
		strlcpy(e_ctrl->device_name, CAM_EEPROM_NAME,
		sizeof(e_ctrl->device_name));
		e_ctrl->v4l2_dev_str.name = e_ctrl->device_name;
		e_ctrl->v4l2_dev_str.sd_flags =
		(V4L2_SUBDEV_FL_HAS_DEVNODE \| V4L2_SUBDEV_FL_HAS_EVENTS);
		e_ctrl->v4l2_dev_str.ent_function = CAM_EEPROM_DEVICE_TYPE;
		e_ctrl->v4l2_dev_str.token = e_ctrl;

		rc = cam_register_subdev(&(e_ctrl->v4l2_dev_str));
		if (rc)
		CAM_ERR(CAM_SENSOR, "Fail with cam_register_subdev");

		return rc;
		}

		static int cam_eeprom_i2c_driver_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
		{
		int rc = 0;
		struct cam_eeprom_ctrl_t *e_ctrl = NULL;
		struct cam_eeprom_soc_private *soc_private = NULL;
		struct cam_hw_soc_info *soc_info = NULL;

		if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		CAM_ERR(CAM_EEPROM, "i2c_check_functionality failed");
		@@ -129,27 +151,68 @@ static int cam_eeprom_i2c_driver_probe(struct i2c_client *client,
		rc = -ENOMEM;
		goto probe_failure;
		}
		e_ctrl->v4l2_dev_str.ops = &cam_eeprom_subdev_ops;

		i2c_set_clientdata(client, e_ctrl);

		mutex_init(&(e_ctrl->eeprom_mutex));

		soc_info = &e_ctrl->soc_info;
		soc_info->i2c_dev = client;
		soc_info->dev = &client->dev;
		e_ctrl->io_master_info.master_type = I2C_MASTER;
		e_ctrl->io_master_info.client = client;
		e_ctrl->eeprom_device_type = MSM_CAMERA_I2C_DEVICE;
		e_ctrl->soc_info.is_i2c_dev = true;

		rc = cam_eeprom_parse_dt(e_ctrl);
		if (rc) {
		CAM_ERR(CAM_EEPROM, "failed: soc init rc %d", rc);
		goto free_soc;
		}

		rc = cam_eeprom_update_i2c_info(e_ctrl, &soc_private->i2c_info);
		if (rc) {
		CAM_ERR(CAM_EEPROM, "failed: to update i2c info rc %d", rc);
		goto free_soc;
		}

		if (e_ctrl->userspace_probe == false) {
		rc = cam_eeprom_parse_read_memory_map(soc_info->dev->of_node,
		e_ctrl);
		if (rc) {
		CAM_ERR(CAM_EEPROM, "failed: read mem map rc %d", rc);
		goto free_soc;
		}
		}

		soc_private = (struct cam_eeprom_soc_private *)(id->driver_data);
		if (!soc_private) {
		CAM_ERR(CAM_EEPROM, "board info NULL");
		rc = -EINVAL;
		goto ectrl_free;
		}

		rc = cam_eeprom_init_subdev(e_ctrl);
		if (rc)
		goto free_soc;

		e_ctrl->cal_data.mapdata = NULL;
		e_ctrl->cal_data.map = NULL;
		e_ctrl->userspace_probe = false;

		e_ctrl->eeprom_device_type = MSM_CAMERA_I2C_DEVICE;
		e_ctrl->io_master_info.master_type = I2C_MASTER;
		e_ctrl->io_master_info.client = client;

		if (soc_private->i2c_info.slave_addr != 0)
		e_ctrl->io_master_info.client->addr =
		soc_private->i2c_info.slave_addr;

		return rc;
		e_ctrl->bridge_intf.device_hdl = -1;
		e_ctrl->bridge_intf.ops.get_dev_info = NULL;
		e_ctrl->bridge_intf.ops.link_setup = NULL;
		e_ctrl->bridge_intf.ops.apply_req = NULL;
		v4l2_set_subdevdata(&e_ctrl->v4l2_dev_str.sd, e_ctrl);

		return rc;
		free_soc:
		kfree(soc_private);
		ectrl_free:
		kfree(e_ctrl);
		probe_failure:
		@@ -194,6 +257,7 @@ static int cam_eeprom_i2c_driver_remove(struct i2c_client *client)
		static int cam_eeprom_spi_setup(struct spi_device *spi)
		{
		struct cam_eeprom_ctrl_t *e_ctrl = NULL;
		struct cam_hw_soc_info *soc_info = NULL;
		struct cam_sensor_spi_client *spi_client;
		struct cam_eeprom_soc_private *eb_info;
		struct cam_sensor_power_ctrl_t *power_info = NULL;
		@@ -203,6 +267,10 @@ static int cam_eeprom_spi_setup(struct spi_device *spi)
		if (!e_ctrl)
		return -ENOMEM;

		soc_info = &e_ctrl->soc_info;
		soc_info->spi_dev = spi;
		soc_info->is_spi_dev = true;

		e_ctrl->v4l2_dev_str.ops = &cam_eeprom_subdev_ops;
		e_ctrl->userspace_probe = false;
		e_ctrl->cal_data.mapdata = NULL;
		@@ -234,14 +302,14 @@ static int cam_eeprom_spi_setup(struct spi_device *spi)
		/* Initialize mutex */
		mutex_init(&(e_ctrl->eeprom_mutex));

		rc = cam_eeprom_spi_driver_soc_init(e_ctrl);
		rc = cam_eeprom_parse_dt(e_ctrl);
		if (rc) {
		CAM_ERR(CAM_EEPROM, "failed: spi soc init rc %d", rc);
		goto board_free;
		}

		if (e_ctrl->userspace_probe == false) {
		rc = cam_eeprom_parse_read_memory_map(spi->dev.of_node,
		rc = cam_eeprom_parse_read_memory_map(soc_info->dev->of_node,
		e_ctrl);
		if (rc) {
		CAM_ERR(CAM_EEPROM, "failed: read mem map rc %d", rc);
		@@ -249,6 +317,16 @@ static int cam_eeprom_spi_setup(struct spi_device *spi)
		}
		}

		rc = cam_eeprom_init_subdev(e_ctrl);
		if (rc)
		goto board_free;

		e_ctrl->bridge_intf.device_hdl = -1;
		e_ctrl->bridge_intf.ops.get_dev_info = NULL;
		e_ctrl->bridge_intf.ops.link_setup = NULL;
		e_ctrl->bridge_intf.ops.apply_req = NULL;

		v4l2_set_subdevdata(&e_ctrl->v4l2_dev_str.sd, e_ctrl);
		return rc;

		board_free:
		@@ -338,7 +416,7 @@ static int32_t cam_eeprom_platform_driver_probe(

		/* Initialize mutex */
		mutex_init(&(e_ctrl->eeprom_mutex));
		rc = cam_eeprom_platform_driver_soc_init(e_ctrl);
		rc = cam_eeprom_parse_dt(e_ctrl);
		if (rc) {
		CAM_ERR(CAM_EEPROM, "failed: soc init rc %d", rc);
		goto free_soc;
		@@ -358,21 +436,9 @@ static int32_t cam_eeprom_platform_driver_probe(
		}
		}

		e_ctrl->v4l2_dev_str.internal_ops = &cam_eeprom_internal_ops;
		e_ctrl->v4l2_dev_str.ops = &cam_eeprom_subdev_ops;
		strlcpy(e_ctrl->device_name, CAM_EEPROM_NAME,
		sizeof(e_ctrl->device_name));
		e_ctrl->v4l2_dev_str.name = e_ctrl->device_name;
		e_ctrl->v4l2_dev_str.sd_flags =
		(V4L2_SUBDEV_FL_HAS_DEVNODE \| V4L2_SUBDEV_FL_HAS_EVENTS);
		e_ctrl->v4l2_dev_str.ent_function = CAM_EEPROM_DEVICE_TYPE;
		e_ctrl->v4l2_dev_str.token = e_ctrl;

		rc = cam_register_subdev(&(e_ctrl->v4l2_dev_str));
		if (rc) {
		CAM_ERR(CAM_EEPROM, "fail to create subdev");
		rc = cam_eeprom_init_subdev(e_ctrl);
		if (rc)
		goto free_soc;
		}

		e_ctrl->bridge_intf.device_hdl = -1;
		e_ctrl->bridge_intf.ops.get_dev_info = NULL;