Merge "msm: camera: flash: Add support for I2C flash" into camera-kernel.qclinux.1.0

Author: Camera Software Integration

camera/drivers/cam_sensor_module/cam_flash/cam_flash_core.c

@@ -455,6 +455,8 @@ static int cam_flash_ops(struct cam_flash_ctrl *flash_ctrl,
 
 int cam_flash_off(struct cam_flash_ctrl *flash_ctrl)
 {
+	int rc = 0;
+
 	if (!flash_ctrl) {
 		CAM_ERR(CAM_FLASH, "Flash control Null");
 		return -EINVAL;
@@ -463,7 +465,17 @@ int cam_flash_off(struct cam_flash_ctrl *flash_ctrl)
 	if (flash_ctrl->switch_trigger)
 		cam_res_mgr_led_trigger_event(flash_ctrl->switch_trigger,
 			(enum led_brightness)LED_SWITCH_OFF);
-	return 0;
+
+	if ((flash_ctrl->i2c_data.streamoff_settings.is_settings_valid) &&
+		(flash_ctrl->i2c_data.streamoff_settings.request_id == 0)) {
+		flash_ctrl->apply_streamoff = true;
+		rc = cam_flash_i2c_apply_setting(flash_ctrl, 0);
+		if (rc < 0) {
+			CAM_ERR(CAM_SENSOR,
+			"cannot apply streamoff settings");
+		}
+	}
+	return rc;
 }
 
 static int cam_flash_low(
@@ -572,11 +584,26 @@ static int cam_flash_i2c_delete_req(struct cam_flash_ctrl *fctrl,
 
 		CAM_DBG(CAM_FLASH, "top: %llu, del_req_id:%llu",
 			top, del_req_id);
+
+		for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {
+			if ((del_req_id >
+				 fctrl->i2c_data.per_frame[i].request_id) && (
+				 fctrl->i2c_data.per_frame[i].is_settings_valid
+					== 1)) {
+				fctrl->i2c_data.per_frame[i].request_id = 0;
+				rc = delete_request(
+					&(fctrl->i2c_data.per_frame[i]));
+				if (rc < 0)
+					CAM_ERR(CAM_SENSOR,
+						"Delete request Fail:%lld rc:%d",
+						del_req_id, rc);
+			}
+		}
 	}
 
 	cam_flash_i2c_flush_nrt(fctrl);
 
-	return 0;
+	return rc;
 }
 
 static int cam_flash_pmic_delete_req(struct cam_flash_ctrl *fctrl,
@@ -672,9 +699,28 @@ int cam_flash_i2c_apply_setting(struct cam_flash_ctrl *fctrl,
 	struct i2c_settings_array *i2c_set = NULL;
 	int frame_offset = 0, rc = 0;
 
+	if (!fctrl) {
+		CAM_ERR(CAM_FLASH, "fctrl is NULL");
+		return -EINVAL;
+	}
 	if (req_id == 0) {
 		/* NonRealTime Init settings*/
-		if (fctrl->i2c_data.init_settings.is_settings_valid == true) {
+		if (fctrl->apply_streamoff == true) {
+			fctrl->apply_streamoff = false;
+			i2c_set = &fctrl->i2c_data.streamoff_settings;
+			list_for_each_entry(i2c_list,
+				&(i2c_set->list_head),
+				list) {
+				rc = cam_sensor_util_i2c_apply_setting
+					(&(fctrl->io_master_info), i2c_list);
+				if (rc) {
+					CAM_ERR(CAM_FLASH,
+					"Failed to apply stream on settings: %d", rc);
+					return rc;
+				}
+				break;
+			}
+		} else if (fctrl->i2c_data.init_settings.is_settings_valid == true) {
 			list_for_each_entry(i2c_list,
 				&(fctrl->i2c_data.init_settings.list_head),
 				list) {
@@ -936,6 +982,7 @@ int cam_flash_i2c_pkt_parser(struct cam_flash_ctrl *fctrl, void *arg)
 	uint32_t *cmd_buf =  NULL;
 	uint32_t *offset = NULL;
 	uint32_t frm_offset = 0;
+	uint32_t csl_req_id = 0;
 	size_t len_of_buffer;
 	size_t remain_len;
 	struct cam_flash_init *flash_init = NULL;
@@ -947,6 +994,7 @@ int cam_flash_i2c_pkt_parser(struct cam_flash_ctrl *fctrl, void *arg)
 	struct cam_req_mgr_add_request add_req;
 	struct i2c_settings_array *i2c_reg_settings = NULL;
 	struct cam_sensor_power_ctrl_t *power_info = NULL;
+	struct i2c_data_settings *i2c_data = NULL;
 
 	if (!fctrl || !arg) {
 		CAM_ERR(CAM_FLASH, "fctrl/arg is NULL");
@@ -1170,6 +1218,7 @@ int cam_flash_i2c_pkt_parser(struct cam_flash_ctrl *fctrl, void *arg)
 			csl_packet->cmd_buf_offset);
 		frm_offset = csl_packet->header.request_id %
 			MAX_PER_FRAME_ARRAY;
+		csl_req_id = csl_packet->header.request_id;
 		/* add support for handling i2c_data*/
 		i2c_reg_settings =
 			&fctrl->i2c_data.per_frame[frm_offset];
@@ -1191,8 +1240,49 @@ int cam_flash_i2c_pkt_parser(struct cam_flash_ctrl *fctrl, void *arg)
 			cam_mem_put_cpu_buf(config.packet_handle);
 			return rc;
 		}
+		if ((fctrl->flash_state == CAM_FLASH_STATE_ACQUIRE) ||
+			(fctrl->flash_state == CAM_FLASH_STATE_CONFIG)) {
+			fctrl->flash_state = CAM_FLASH_STATE_CONFIG;
+			rc = fctrl->func_tbl.apply_setting(fctrl, csl_req_id);
+			if (rc) {
+				CAM_ERR(CAM_FLASH, "cannot apply fire settings rc = %d", rc);
+				return rc;
+			}
+			return rc;
+		}
 		break;
 	}
+	case CAM_FLASH_PACKET_OPCODE_INIT_FIRE: {
+		frm_offset = csl_packet->header.request_id %
+			MAX_PER_FRAME_ARRAY;
+		csl_req_id = csl_packet->header.request_id;
+		CAM_DBG(CAM_FLASH, "Flash pkt init fire opcode received");
+		/* add support for handling i2c_data*/
+		i2c_reg_settings =
+			&fctrl->i2c_data.per_frame[frm_offset];
+		if (i2c_reg_settings->is_settings_valid == true) {
+			i2c_reg_settings->request_id = 0;
+			i2c_reg_settings->is_settings_valid = false;
+			goto update_req_mgr;
+		}
+		i2c_reg_settings->is_settings_valid = true;
+		i2c_reg_settings->request_id =
+			csl_packet->header.request_id;
+		rc = cam_sensor_i2c_command_parser(
+			&fctrl->io_master_info,
+			i2c_reg_settings, cmd_desc, 1, NULL);
+		if (rc) {
+			CAM_ERR(CAM_FLASH,
+			"Failed in parsing i2c packets");
+			return rc;
+		}
+
+		/* Apply the settings immediately as it is an EPR Req*/
+		rc = fctrl->func_tbl.apply_setting(fctrl, csl_req_id);
+		if (rc)
+			CAM_ERR(CAM_FLASH, "cannot apply init fire cmd rc = %d", rc);
+		return rc;
+	}
 	case CAM_FLASH_PACKET_OPCODE_NON_REALTIME_SET_OPS: {
 		offset = (uint32_t *)((uint8_t *)&csl_packet->payload_flex +
 			csl_packet->cmd_buf_offset);
@@ -1232,6 +1322,8 @@ int cam_flash_i2c_pkt_parser(struct cam_flash_ctrl *fctrl, void *arg)
 		return rc;
 	}
 	case CAM_PKT_NOP_OPCODE: {
+		frm_offset = csl_packet->header.request_id %
+			MAX_PER_FRAME_ARRAY;
 		if ((fctrl->flash_state == CAM_FLASH_STATE_INIT) ||
 			(fctrl->flash_state == CAM_FLASH_STATE_ACQUIRE)) {
 			CAM_WARN(CAM_FLASH,
@@ -1243,11 +1335,39 @@ int cam_flash_i2c_pkt_parser(struct cam_flash_ctrl *fctrl, void *arg)
 			cam_mem_put_cpu_buf(config.packet_handle);
 			return 0;
 		}
+		i2c_reg_settings =
+			&fctrl->i2c_data.per_frame[frm_offset];
+		i2c_reg_settings->is_settings_valid = true;
+		i2c_reg_settings->request_id =
+			csl_packet->header.request_id;
 
 		CAM_DBG(CAM_FLASH, "NOP Packet is Received: req_id: %u",
 			csl_packet->header.request_id);
 		goto update_req_mgr;
 	}
+	case CAM_FLASH_PACKET_OPCODE_STREAM_OFF: {
+		if (fctrl->streamoff_count > 0)
+			return rc;
+
+		CAM_DBG(CAM_FLASH, "Received Stream off Settings");
+		i2c_data = &(fctrl->i2c_data);
+		fctrl->streamoff_count = fctrl->streamoff_count + 1;
+		i2c_reg_settings       = &i2c_data->streamoff_settings;
+		i2c_reg_settings->request_id = 0;
+		i2c_reg_settings->is_settings_valid = 1;
+		offset = (uint32_t *)((uint8_t *)&csl_packet->payload +
+			csl_packet->cmd_buf_offset);
+		cmd_desc = (struct cam_cmd_buf_desc *)(offset);
+		rc = cam_sensor_i2c_command_parser(&fctrl->io_master_info,
+				i2c_reg_settings,
+				cmd_desc, 1, NULL);
+		if (rc) {
+			CAM_ERR(CAM_FLASH,
+			"Failed in parsing i2c Stream off packets");
+			return rc;
+		}
+		break;
+	}
 	default:
 		CAM_ERR(CAM_FLASH, "Wrong Opcode : %d",
 			(csl_packet->header.op_code & 0xFFFFFF));
@@ -1985,6 +2105,16 @@ int cam_flash_release_dev(struct cam_flash_ctrl *fctrl)
 {
 	int rc = 0;
 
+	if (fctrl->i2c_data.streamoff_settings.is_settings_valid == true) {
+		fctrl->i2c_data.streamoff_settings.is_settings_valid = false;
+		rc = delete_request(&fctrl->i2c_data.streamoff_settings);
+		if (rc) {
+			CAM_WARN(CAM_FLASH,
+				"Failed to delete Stream off i2c_setting: %d",
+				rc);
+		}
+	}
+
 	if (fctrl->bridge_intf.device_hdl != 1) {
 		rc = cam_destroy_device_hdl(fctrl->bridge_intf.device_hdl);
 		if (rc)
@@ -1995,6 +2125,7 @@ int cam_flash_release_dev(struct cam_flash_ctrl *fctrl)
 		fctrl->bridge_intf.link_hdl = -1;
 		fctrl->bridge_intf.session_hdl = -1;
 		fctrl->last_flush_req = 0;
+		fctrl->streamoff_count = 0;
 	}
 
 	return rc;

camera/drivers/cam_sensor_module/cam_flash/cam_flash_dev.c

@@ -77,6 +77,7 @@ static int32_t cam_flash_driver_cmd(struct cam_flash_ctrl *fctrl,
 			flash_acq_dev.device_handle;
 		fctrl->bridge_intf.session_hdl =
 			flash_acq_dev.session_handle;
+		fctrl->apply_streamoff = false;
 
 		rc = copy_to_user(u64_to_user_ptr(cmd->handle),
 			&flash_acq_dev,
@@ -135,14 +136,15 @@ static int32_t cam_flash_driver_cmd(struct cam_flash_ctrl *fctrl,
 				CAM_WARN(CAM_FLASH, "Power Down Failed");
 		}
 
+		fctrl->streamoff_count = 0;
 		fctrl->flash_state = CAM_FLASH_STATE_INIT;
 		break;
 	}
 	case CAM_QUERY_CAP: {
 		struct cam_flash_query_cap_info flash_cap = {0};
 
-		CAM_DBG(CAM_FLASH, "CAM_QUERY_CAP");
-		flash_cap.slot_info = fctrl->soc_info.index;
+		CAM_DBG(CAM_FLASH, "CAM_QUERY_CAP_V1");
+		flash_cap.slot_info  = fctrl->soc_info.index;
 		for (i = 0; i < fctrl->flash_num_sources; i++) {
 			flash_cap.max_current_flash[i] =
 				soc_private->flash_max_current[i];
@@ -160,8 +162,39 @@ static int32_t cam_flash_driver_cmd(struct cam_flash_ctrl *fctrl,
 			rc = -EFAULT;
 			goto release_mutex;
 		}
+		fctrl->apply_streamoff = false;
 		break;
 	}
+
+	case CAM_QUERY_CAP_V2: {
+		struct cam_flash_query_cap_info_v2 flash_cap = {0};
+
+		CAM_DBG(CAM_FLASH, "CAM_QUERY_CAP_V2");
+		flash_cap.slot_info  = fctrl->soc_info.index;
+		flash_cap.flash_type = soc_private->flash_type;
+		flash_cap.version = 1;
+		flash_cap.num_valid_params = 0;
+		for (i = 0; i < fctrl->flash_num_sources; i++) {
+			flash_cap.max_current_flash[i] =
+				soc_private->flash_max_current[i];
+			flash_cap.max_duration_flash[i] =
+				soc_private->flash_max_duration[i];
+		}
+
+		for (i = 0; i < fctrl->torch_num_sources; i++)
+			flash_cap.max_current_torch[i] =
+				soc_private->torch_max_current[i];
+
+		if (copy_to_user(u64_to_user_ptr(cmd->handle),
+			&flash_cap, sizeof(struct cam_flash_query_cap_info_v2))) {
+			CAM_ERR(CAM_FLASH, "Failed Copy to User");
+			rc = -EFAULT;
+			goto release_mutex;
+		}
+		break;
+	}
+
+
 	case CAM_START_DEV: {
 		CAM_INFO(CAM_FLASH, "CAM_START_DEV for dev_hdl: 0x%x",
 			fctrl->bridge_intf.device_hdl);
@@ -174,6 +207,7 @@ static int32_t cam_flash_driver_cmd(struct cam_flash_ctrl *fctrl,
 			goto release_mutex;
 		}
 
+		fctrl->apply_streamoff = false;
 		fctrl->flash_state = CAM_FLASH_STATE_START;
 		break;
 	}
@@ -419,6 +453,7 @@ static int cam_flash_component_bind(struct device *dev,
 	struct device_node *of_parent = NULL;
 	bool i3c_i2c_target;
 	struct platform_device *pdev = to_platform_device(dev);
+	struct cam_hw_soc_info *soc_info = NULL;
 
 	CAM_DBG(CAM_FLASH, "Binding flash component");
 	if (!pdev->dev.of_node) {
@@ -478,6 +513,15 @@ static int cam_flash_component_bind(struct device *dev,
 		fctrl->io_master_info.cci_client->cci_device = fctrl->cci_num;
 		CAM_DBG(CAM_FLASH, "cci-index %d", fctrl->cci_num, rc);
 
+		soc_info = &fctrl->soc_info;
+
+		rc = cam_sensor_util_init_gpio_pin_tbl(soc_info,
+				&fctrl->power_info.gpio_num_info);
+		if ((rc < 0) || (!fctrl->power_info.gpio_num_info)) {
+			/* In Current target no GPIO required for flash */
+			CAM_WARN(CAM_FLASH, "No Flash GPIOs configured");
+		}
+
 		fctrl->i2c_data.per_frame =
 			kzalloc(sizeof(struct i2c_settings_array) *
 			MAX_PER_FRAME_ARRAY, GFP_KERNEL);
@@ -489,6 +533,7 @@ static int cam_flash_component_bind(struct device *dev,
 
 		INIT_LIST_HEAD(&(fctrl->i2c_data.init_settings.list_head));
 		INIT_LIST_HEAD(&(fctrl->i2c_data.config_settings.list_head));
+		INIT_LIST_HEAD(&(fctrl->i2c_data.streamoff_settings.list_head));
 		for (i = 0; i < MAX_PER_FRAME_ARRAY; i++)
 			INIT_LIST_HEAD(
 				&(fctrl->i2c_data.per_frame[i].list_head));
@@ -497,6 +542,21 @@ static int cam_flash_component_bind(struct device *dev,
 		fctrl->func_tbl.apply_setting = cam_flash_i2c_apply_setting;
 		fctrl->func_tbl.power_ops = cam_flash_i2c_power_ops;
 		fctrl->func_tbl.flush_req = cam_flash_i2c_flush_request;
+
+			/* Initialize regulators to default parameters */
+		for (i = 0; i < soc_info->num_rgltr; i++) {
+			soc_info->rgltr[i] = devm_regulator_get(soc_info->dev,
+				soc_info->rgltr_name[i]);
+			if (IS_ERR_OR_NULL(soc_info->rgltr[i])) {
+				rc = PTR_ERR(soc_info->rgltr[i]);
+				rc  = rc ? rc : -EINVAL;
+				CAM_ERR(CAM_FLASH, "Get failed for regulator %s %d",
+					soc_info->rgltr_name[i], rc);
+				goto free_cci_resource;
+			}
+			CAM_DBG(CAM_FLASH, "Get for regulator %s",
+				soc_info->rgltr_name[i]);
+		}
 	} else {
 		/* PMIC Flash */
 		fctrl->func_tbl.parser = cam_flash_pmic_pkt_parser;
@@ -686,6 +746,7 @@ static int cam_flash_i2c_component_bind(struct device *dev,
 
 	INIT_LIST_HEAD(&(fctrl->i2c_data.init_settings.list_head));
 	INIT_LIST_HEAD(&(fctrl->i2c_data.config_settings.list_head));
+	INIT_LIST_HEAD(&(fctrl->i2c_data.streamoff_settings.list_head));
 	for (i = 0; i < MAX_PER_FRAME_ARRAY; i++)
 		INIT_LIST_HEAD(&(fctrl->i2c_data.per_frame[i].list_head));