Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4f5d66e1 authored by Karthik Anantha Ram's avatar Karthik Anantha Ram
Browse files

msm: camera: Handle out of sequence requests in KMD drivers 



The change handles out of sequence requests by performing
necessary state validation in sensor, actuator, csiphy, eeprom,
ois & flash submodules. In a given state a driver will be able
to support certain operations. Any other unsupported requests
in that state would be reported as an error.

Change-Id: I94582c24c94e8b8a262dc257dfbd44e99aa61e66
Signed-off-by: default avatarKarthik Anantha Ram <kartanan@codeaurora.org>
Signed-off-by: default avatarJigarkumar Zala <jzala@codeaurora.org>
parent 34dc2654

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

+24 −0
Original line number Diff line number Diff line
@@ -553,6 +553,14 @@ int32_t cam_actuator_driver_cmd(struct cam_actuator_ctrl_t *a_ctrl, 
	}

		break;

	case CAM_RELEASE_DEV: {

		if (a_ctrl->cam_act_state != CAM_ACTUATOR_ACQUIRE) {

			rc = -EINVAL;

			CAM_WARN(CAM_ACTUATOR,

			"Not in right state to release : %d",

			a_ctrl->cam_act_state);

			goto release_mutex;

		}



		if (a_ctrl->bridge_intf.device_hdl == -1) {

			CAM_ERR(CAM_ACTUATOR, "link hdl: %d device hdl: %d",

				a_ctrl->bridge_intf.device_hdl,
@@ -582,6 +590,14 @@ int32_t cam_actuator_driver_cmd(struct cam_actuator_ctrl_t *a_ctrl, 
	}

		break;

	case CAM_START_DEV: {

		if (a_ctrl->cam_act_state != CAM_ACTUATOR_ACQUIRE) {

			rc = -EINVAL;

			CAM_WARN(CAM_ACTUATOR,

			"Not in right state to start : %d",

			a_ctrl->cam_act_state);

			goto release_mutex;

		}



		rc = cam_actuator_power_up(a_ctrl);

		if (rc < 0) {

			CAM_ERR(CAM_ACTUATOR, " Actuator Power up failed");
@@ -613,6 +629,14 @@ int32_t cam_actuator_driver_cmd(struct cam_actuator_ctrl_t *a_ctrl, 
		struct i2c_settings_array *i2c_set = NULL;

		int i;



		if (a_ctrl->cam_act_state != CAM_ACTUATOR_START) {

			rc = -EINVAL;

			CAM_WARN(CAM_ACTUATOR,

			"Not in right state to stop : %d",

			a_ctrl->cam_act_state);

			goto release_mutex;

		}



		rc = camera_io_release(&a_ctrl->io_master_info);

		if (rc < 0)

			CAM_ERR(CAM_ACTUATOR, "Failed in releasing CCI");

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

+0 −1
Original line number Diff line number Diff line
@@ -57,7 +57,6 @@ enum cam_actator_state { 
	CAM_ACTUATOR_INIT,

	CAM_ACTUATOR_ACQUIRE,

	CAM_ACTUATOR_START,

	CAM_ACTUATOR_RELEASE,

};



/**

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

+18 −4
Original line number Diff line number Diff line
@@ -289,6 +289,8 @@ int32_t cam_eeprom_parse_read_memory_map(struct device_node *of_node, 
		CAM_ERR(CAM_EEPROM, "failed: eeprom power up rc %d", rc);

		goto data_mem_free;

	}



	e_ctrl->cam_eeprom_state = CAM_EEPROM_CONFIG;

	if (e_ctrl->eeprom_device_type == MSM_CAMERA_SPI_DEVICE) {

		rc = cam_eeprom_match_id(e_ctrl);

		if (rc) {
@@ -305,6 +307,8 @@ int32_t cam_eeprom_parse_read_memory_map(struct device_node *of_node, 
	rc = cam_eeprom_power_down(e_ctrl);

	if (rc)

		CAM_ERR(CAM_EEPROM, "failed: eeprom power down rc %d", rc);



	e_ctrl->cam_eeprom_state = CAM_EEPROM_ACQUIRE;

	return rc;

power_down:

	cam_eeprom_power_down(e_ctrl);
@@ -313,6 +317,7 @@ int32_t cam_eeprom_parse_read_memory_map(struct device_node *of_node, 
	kfree(e_ctrl->cal_data.map);

	e_ctrl->cal_data.num_data = 0;

	e_ctrl->cal_data.num_map = 0;

	e_ctrl->cam_eeprom_state = CAM_EEPROM_ACQUIRE;

	return rc;

}
@@ -704,6 +709,7 @@ static int32_t cam_eeprom_pkt_parse(struct cam_eeprom_ctrl_t *e_ctrl, void *arg) 
			goto memdata_free;

		}



		e_ctrl->cam_eeprom_state = CAM_EEPROM_CONFIG;

		rc = cam_eeprom_read_memory(e_ctrl, &e_ctrl->cal_data);

		if (rc) {

			CAM_ERR(CAM_EEPROM,
@@ -713,6 +719,7 @@ static int32_t cam_eeprom_pkt_parse(struct cam_eeprom_ctrl_t *e_ctrl, void *arg) 


		rc = cam_eeprom_get_cal_data(e_ctrl, csl_packet);

		rc = cam_eeprom_power_down(e_ctrl);

		e_ctrl->cam_eeprom_state = CAM_EEPROM_ACQUIRE;

		kfree(e_ctrl->cal_data.mapdata);

		kfree(e_ctrl->cal_data.map);

		e_ctrl->cal_data.num_data = 0;
@@ -730,6 +737,7 @@ static int32_t cam_eeprom_pkt_parse(struct cam_eeprom_ctrl_t *e_ctrl, void *arg) 
	kfree(e_ctrl->cal_data.map);

	e_ctrl->cal_data.num_data = 0;

	e_ctrl->cal_data.num_map = 0;

	e_ctrl->cam_eeprom_state = CAM_EEPROM_ACQUIRE;

	return rc;

}
@@ -740,10 +748,7 @@ void cam_eeprom_shutdown(struct cam_eeprom_ctrl_t *e_ctrl) 
	if (e_ctrl->cam_eeprom_state == CAM_EEPROM_INIT)

		return;



	if (e_ctrl->cam_eeprom_state == CAM_EEPROM_START) {

		rc = camera_io_release(&e_ctrl->io_master_info);

		if (rc < 0)

			CAM_ERR(CAM_EEPROM, "Failed in releasing CCI");

	if (e_ctrl->cam_eeprom_state == CAM_EEPROM_CONFIG) {

		rc = cam_eeprom_power_down(e_ctrl);

		if (rc < 0)

			CAM_ERR(CAM_EEPROM, "EEPROM Power down failed");
@@ -754,6 +759,7 @@ void cam_eeprom_shutdown(struct cam_eeprom_ctrl_t *e_ctrl) 
		rc = cam_destroy_device_hdl(e_ctrl->bridge_intf.device_hdl);

		if (rc < 0)

			CAM_ERR(CAM_EEPROM, "destroying the device hdl");



		e_ctrl->bridge_intf.device_hdl = -1;

		e_ctrl->bridge_intf.link_hdl = -1;

		e_ctrl->bridge_intf.session_hdl = -1;
@@ -807,6 +813,14 @@ int32_t cam_eeprom_driver_cmd(struct cam_eeprom_ctrl_t *e_ctrl, void *arg) 
		e_ctrl->cam_eeprom_state = CAM_EEPROM_ACQUIRE;

		break;

	case CAM_RELEASE_DEV:

		if (e_ctrl->cam_eeprom_state != CAM_EEPROM_ACQUIRE) {

			rc = -EINVAL;

			CAM_WARN(CAM_EEPROM,

			"Not in right state to release : %d",

			e_ctrl->cam_eeprom_state);

			goto release_mutex;

		}



		if (e_ctrl->bridge_intf.device_hdl == -1) {

			CAM_ERR(CAM_EEPROM,

				"Invalid Handles: link hdl: %d device hdl: %d",

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

+1 −2
Original line number Diff line number Diff line
@@ -40,8 +40,7 @@ 
enum cam_eeprom_state {

	CAM_EEPROM_INIT,

	CAM_EEPROM_ACQUIRE,

	CAM_EEPROM_START,

	CAM_EEPROM_RELEASE,

	CAM_EEPROM_CONFIG,

};



/**

drivers/media/platform/msm/camera/cam_sensor_module/cam_flash/cam_flash_core.c

+144 −112
Original line number Diff line number Diff line
@@ -25,7 +25,7 @@ int cam_flash_prepare(struct cam_flash_ctrl *flash_ctrl, 
		return -EINVAL;

	}



	if ((state == CAM_FLASH_STATE_INIT) &&

	if ((state == CAM_FLASH_STATE_START) &&

		(flash_ctrl->is_regulator_enabled == false)) {

		rc = qpnp_flash_led_prepare(flash_ctrl->switch_trigger,

			ENABLE_REGULATOR, NULL);
@@ -35,7 +35,8 @@ int cam_flash_prepare(struct cam_flash_ctrl *flash_ctrl, 
			return rc;

		}

		flash_ctrl->is_regulator_enabled = true;

	} else if ((state == CAM_FLASH_STATE_RELEASE) &&

		flash_ctrl->flash_state = CAM_FLASH_STATE_START;

	} else if ((state == CAM_FLASH_STATE_STOP) &&

		(flash_ctrl->is_regulator_enabled == true)) {

		rc = qpnp_flash_led_prepare(flash_ctrl->switch_trigger,

			DISABLE_REGULATOR, NULL);
@@ -45,7 +46,7 @@ int cam_flash_prepare(struct cam_flash_ctrl *flash_ctrl, 
			return rc;

		}

		flash_ctrl->is_regulator_enabled = false;

		flash_ctrl->flash_state = CAM_FLASH_STATE_RELEASE;

		flash_ctrl->flash_state = CAM_FLASH_STATE_ACQUIRE;

	} else {

		CAM_ERR(CAM_FLASH, "Wrong Flash State : %d",

			flash_ctrl->flash_state);
@@ -55,6 +56,74 @@ int cam_flash_prepare(struct cam_flash_ctrl *flash_ctrl, 
	return rc;

}



static int cam_flash_flush_nrt(struct cam_flash_ctrl *fctrl)

{

	int j = 0;

	struct cam_flash_frame_setting *nrt_settings;



	if (!fctrl)

		return -EINVAL;



	nrt_settings = &fctrl->nrt_info;



	if (nrt_settings->cmn_attr.cmd_type ==

		CAMERA_SENSOR_FLASH_CMD_TYPE_INIT) {

		fctrl->flash_init_setting.cmn_attr.is_settings_valid = false;

	} else if ((nrt_settings->cmn_attr.cmd_type ==

		CAMERA_SENSOR_FLASH_CMD_TYPE_WIDGET) ||

		(nrt_settings->cmn_attr.cmd_type ==

		CAMERA_SENSOR_FLASH_CMD_TYPE_RER)) {

		fctrl->nrt_info.cmn_attr.is_settings_valid = false;

		fctrl->nrt_info.cmn_attr.count = 0;

		fctrl->nrt_info.num_iterations = 0;

		fctrl->nrt_info.led_on_delay_ms = 0;

		fctrl->nrt_info.led_off_delay_ms = 0;

		for (j = 0; j < CAM_FLASH_MAX_LED_TRIGGERS; j++)

			fctrl->nrt_info.led_current_ma[j] = 0;

	}



	return 0;

}



int cam_flash_flush_request(struct cam_req_mgr_flush_request *flush)

{

	int rc = 0;

	int i = 0, j = 0;

	struct cam_flash_ctrl *fctrl = NULL;

	int frame_offset = 0;



	fctrl = (struct cam_flash_ctrl *) cam_get_device_priv(flush->dev_hdl);

	if (!fctrl) {

		CAM_ERR(CAM_FLASH, "Device data is NULL");

		return -EINVAL;

	}



	if (flush->type == CAM_REQ_MGR_FLUSH_TYPE_ALL) {

	/* flush all requests*/

		for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {

			fctrl->per_frame[i].cmn_attr.request_id = 0;

			fctrl->per_frame[i].cmn_attr.is_settings_valid = false;

			fctrl->per_frame[i].cmn_attr.count = 0;

			for (j = 0; j < CAM_FLASH_MAX_LED_TRIGGERS; j++)

				fctrl->per_frame[i].led_current_ma[j] = 0;

		}



		rc = cam_flash_flush_nrt(fctrl);

		if (rc)

			CAM_ERR(CAM_FLASH, "NonRealTime flush error");

	} else if (flush->type == CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ) {

	/* flush request with req_id*/

		frame_offset = flush->req_id % MAX_PER_FRAME_ARRAY;

		fctrl->per_frame[frame_offset].cmn_attr.request_id = 0;

		fctrl->per_frame[frame_offset].cmn_attr.is_settings_valid =

			false;

		fctrl->per_frame[frame_offset].cmn_attr.count = 0;

		for (i = 0; i < CAM_FLASH_MAX_LED_TRIGGERS; i++)

			fctrl->per_frame[frame_offset].led_current_ma[i] = 0;

	}

	return rc;

}



static int cam_flash_ops(struct cam_flash_ctrl *flash_ctrl,

	struct cam_flash_frame_setting *flash_data, enum camera_flash_opcode op)

{
@@ -138,6 +207,7 @@ int cam_flash_off(struct cam_flash_ctrl *flash_ctrl) 
		led_trigger_event(flash_ctrl->switch_trigger,

			LED_SWITCH_OFF);



	flash_ctrl->flash_state = CAM_FLASH_STATE_START;

	return 0;

}
@@ -239,15 +309,13 @@ int cam_flash_apply_setting(struct cam_flash_ctrl *fctrl, 
				CAMERA_SENSOR_FLASH_OP_FIRELOW) {

				if (!(fctrl->is_regulator_enabled)) {

					rc = cam_flash_prepare(fctrl,

						CAM_FLASH_STATE_INIT);

						CAM_FLASH_STATE_START);

					if (rc) {

						CAM_ERR(CAM_FLASH,

							"Reg Enable Failed %d",

							rc);

						goto nrt_del_req;

					}

					fctrl->flash_state =

						CAM_FLASH_STATE_INIT;

					rc = cam_flash_low(fctrl, flash_data);

					if (rc) {

						CAM_ERR(CAM_FLASH,
@@ -260,49 +328,41 @@ int cam_flash_apply_setting(struct cam_flash_ctrl *fctrl, 
				}

			} else if (flash_data->opcode ==

				CAMERA_SENSOR_FLASH_OP_OFF) {

				if (fctrl->flash_state !=

					CAM_FLASH_STATE_INIT) {

				if (fctrl->flash_state ==

					CAM_FLASH_STATE_LOW) {

					rc = cam_flash_off(fctrl);

					if (rc)

						CAM_ERR(CAM_FLASH,

							"LED off failed: %d",

							rc);

				}

				cam_flash_flush_nrt(fctrl);



				rc = cam_flash_prepare(fctrl,

					CAM_FLASH_STATE_RELEASE);

				if (rc) {

				rc = cam_flash_release_dev(fctrl);

				if (rc)

					CAM_ERR(CAM_FLASH,

						"Regulator Disable failed %d",

						rc);

					goto nrt_del_req;

				}



						"Release dev failed rc %d", rc);

				fctrl->flash_state =

					CAM_FLASH_STATE_RELEASE;

				fctrl->is_regulator_enabled = false;

					CAM_FLASH_STATE_INIT;

			}

		} else if (fctrl->nrt_info.cmn_attr.cmd_type ==

			CAMERA_SENSOR_FLASH_CMD_TYPE_RER) {

			flash_data = &fctrl->nrt_info;



			if (fctrl->flash_state != CAM_FLASH_STATE_INIT) {

			if (fctrl->flash_state != CAM_FLASH_STATE_START) {

				rc = cam_flash_off(fctrl);

				if (rc) {

					CAM_ERR(CAM_FLASH,

						"Flash off failed: %d",

						rc);

				} else {

					fctrl->flash_state =

						CAM_FLASH_STATE_INIT;

					goto nrt_del_req;

				}

			}



			num_iterations = flash_data->num_iterations;

			for (i = 0; i < num_iterations; i++) {

				/* Turn On Torch */

				if (fctrl->flash_state ==

					CAM_FLASH_STATE_INIT) {

					CAM_FLASH_STATE_START) {

					rc = cam_flash_low(fctrl, flash_data);

					if (rc) {

						CAM_ERR(CAM_FLASH,
@@ -311,11 +371,12 @@ int cam_flash_apply_setting(struct cam_flash_ctrl *fctrl, 
					}

					fctrl->flash_state =

						CAM_FLASH_STATE_LOW;

				}



					usleep_range(

					flash_data->led_on_delay_ms * 1000,

				flash_data->led_on_delay_ms * 1000 + 100);



					flash_data->led_on_delay_ms * 1000 +

						100);

				}

				/* Turn Off Torch */

				rc = cam_flash_off(fctrl);

				if (rc) {
@@ -324,7 +385,7 @@ int cam_flash_apply_setting(struct cam_flash_ctrl *fctrl, 
						rc);

					continue;

				}

				fctrl->flash_state = CAM_FLASH_STATE_INIT;

				fctrl->flash_state = CAM_FLASH_STATE_START;

				usleep_range(

				flash_data->led_off_delay_ms * 1000,

				flash_data->led_off_delay_ms * 1000 + 100);
@@ -338,7 +399,7 @@ int cam_flash_apply_setting(struct cam_flash_ctrl *fctrl, 
			(flash_data->cmn_attr.is_settings_valid) &&

			(flash_data->cmn_attr.request_id == req_id)) {

			/* Turn On Flash */

			if (fctrl->flash_state == CAM_FLASH_STATE_INIT) {

			if (fctrl->flash_state == CAM_FLASH_STATE_START) {

				rc = cam_flash_high(fctrl, flash_data);

				if (rc) {

					CAM_ERR(CAM_FLASH,
@@ -353,7 +414,7 @@ int cam_flash_apply_setting(struct cam_flash_ctrl *fctrl, 
			(flash_data->cmn_attr.is_settings_valid) &&

			(flash_data->cmn_attr.request_id == req_id)) {

			/* Turn On Torch */

			if (fctrl->flash_state == CAM_FLASH_STATE_INIT) {

			if (fctrl->flash_state == CAM_FLASH_STATE_START) {

				rc = cam_flash_low(fctrl, flash_data);

				if (rc) {

					CAM_ERR(CAM_FLASH,
@@ -366,15 +427,13 @@ int cam_flash_apply_setting(struct cam_flash_ctrl *fctrl, 
		} else if ((flash_data->opcode == CAMERA_SENSOR_FLASH_OP_OFF) &&

			(flash_data->cmn_attr.is_settings_valid) &&

			(flash_data->cmn_attr.request_id == req_id)) {

			if ((fctrl->flash_state != CAM_FLASH_STATE_RELEASE) ||

				(fctrl->flash_state != CAM_FLASH_STATE_INIT)) {

			if ((fctrl->flash_state == CAM_FLASH_STATE_LOW) ||

				(fctrl->flash_state == CAM_FLASH_STATE_HIGH)) {

				rc = cam_flash_off(fctrl);

				if (rc) {

					CAM_ERR(CAM_FLASH,

						"Flash off failed %d", rc);

				} else {

					fctrl->flash_state =

						CAM_FLASH_STATE_INIT;

					goto apply_setting_err;

				}

			}

		} else {
@@ -684,50 +743,15 @@ int cam_flash_establish_link(struct cam_req_mgr_core_dev_link_setup *link) 
	return 0;

}



static int cam_flash_flush_nrt(struct cam_flash_ctrl *fctrl)

{

	int j = 0;

	struct cam_flash_frame_setting *nrt_settings;



	if (!fctrl)

		return -EINVAL;



	nrt_settings = &fctrl->nrt_info;



	if (nrt_settings->cmn_attr.cmd_type ==

		CAMERA_SENSOR_FLASH_CMD_TYPE_INIT) {

		fctrl->flash_init_setting.cmn_attr.is_settings_valid = false;

	} else if ((nrt_settings->cmn_attr.cmd_type ==

		CAMERA_SENSOR_FLASH_CMD_TYPE_WIDGET) ||

		(nrt_settings->cmn_attr.cmd_type ==

		CAMERA_SENSOR_FLASH_CMD_TYPE_RER)) {

		fctrl->nrt_info.cmn_attr.is_settings_valid = false;

		fctrl->nrt_info.cmn_attr.count = 0;

		fctrl->nrt_info.num_iterations = 0;

		fctrl->nrt_info.led_on_delay_ms = 0;

		fctrl->nrt_info.led_off_delay_ms = 0;

		for (j = 0; j < CAM_FLASH_MAX_LED_TRIGGERS; j++)

			fctrl->nrt_info.led_current_ma[j] = 0;

	}



	return 0;

}



int cam_flash_flush_request(struct cam_req_mgr_flush_request *flush)

int cam_flash_stop_dev(struct cam_flash_ctrl *fctrl)

{

	int rc = 0;

	int i = 0, j = 0;

	struct cam_flash_ctrl *fctrl = NULL;

	int frame_offset = 0;

	int rc = 0, i, j;



	fctrl = (struct cam_flash_ctrl *) cam_get_device_priv(flush->dev_hdl);

	if (!fctrl) {

		CAM_ERR(CAM_FLASH, "Device data is NULL");

		return -EINVAL;

	}

	if ((fctrl->flash_state == CAM_FLASH_STATE_LOW) ||

		(fctrl->flash_state == CAM_FLASH_STATE_HIGH))

		cam_flash_off(fctrl);



	if (flush->type == CAM_REQ_MGR_FLUSH_TYPE_ALL) {

	/* flush all requests*/

	for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {

		fctrl->per_frame[i].cmn_attr.request_id = 0;

		fctrl->per_frame[i].cmn_attr.is_settings_valid = false;
@@ -737,54 +761,62 @@ int cam_flash_flush_request(struct cam_req_mgr_flush_request *flush) 
	}



	rc = cam_flash_flush_nrt(fctrl);

		if (rc)

			CAM_ERR(CAM_FLASH, "NonRealTime flush error");

	} else if (flush->type == CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ) {

	/* flush request with req_id*/

		frame_offset = flush->req_id % MAX_PER_FRAME_ARRAY;

		fctrl->per_frame[frame_offset].cmn_attr.request_id = 0;

		fctrl->per_frame[frame_offset].cmn_attr.is_settings_valid =

			false;

		fctrl->per_frame[frame_offset].cmn_attr.count = 0;

		for (i = 0; i < CAM_FLASH_MAX_LED_TRIGGERS; i++)

			fctrl->per_frame[frame_offset].led_current_ma[i] = 0;

	}

	if (rc) {

		CAM_ERR(CAM_FLASH,

			"NonRealTime Dev flush failed rc: %d", rc);

		return rc;

	}



void cam_flash_shutdown(struct cam_flash_ctrl *fctrl)

{

	int rc, i, j;



	for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {

		fctrl->per_frame[i].cmn_attr.request_id = 0;

		fctrl->per_frame[i].cmn_attr.is_settings_valid = false;

		fctrl->per_frame[i].cmn_attr.count = 0;

		for (j = 0; j < CAM_FLASH_MAX_LED_TRIGGERS; j++)

			fctrl->per_frame[i].led_current_ma[j] = 0;

	}



	cam_flash_flush_nrt(fctrl);



	if ((fctrl->flash_state != CAM_FLASH_STATE_RELEASE) &&

	if ((fctrl->flash_state == CAM_FLASH_STATE_START) &&

		(fctrl->is_regulator_enabled == true)) {

		rc = cam_flash_prepare(fctrl, CAM_FLASH_STATE_RELEASE);

		rc = cam_flash_prepare(fctrl, CAM_FLASH_STATE_STOP);

		if (rc)

			CAM_ERR(CAM_FLASH, "Disable Regulator Failed ret = %d",

			CAM_ERR(CAM_FLASH, "Disable Regulator Failed rc: %d",

				rc);

	}



	if (fctrl->bridge_intf.device_hdl != -1) {

		rc = cam_destroy_device_hdl(fctrl->bridge_intf.

			device_hdl);

	return rc;

}



int cam_flash_release_dev(struct cam_flash_ctrl *fctrl)

{

	int rc = 0;



	if (fctrl->bridge_intf.device_hdl != 1) {

		rc = cam_destroy_device_hdl(fctrl->bridge_intf.device_hdl);

		if (rc)

			CAM_ERR(CAM_FLASH,

				"Failed in destroying the device Handle rc= %d",

				"Failed in destroying device handle rc = %d",

				rc);

		fctrl->bridge_intf.device_hdl = -1;

		fctrl->bridge_intf.link_hdl = -1;

		fctrl->bridge_intf.session_hdl = -1;

	}



	return rc;

}



void cam_flash_shutdown(struct cam_flash_ctrl *fctrl)

{

	int rc;



	if (fctrl->flash_state == CAM_FLASH_STATE_INIT)

		return;



	if (fctrl->flash_state == CAM_FLASH_STATE_ACQUIRE) {

		cam_flash_release_dev(fctrl);

		return;

	}



	rc = cam_flash_stop_dev(fctrl);

	if (rc)

		CAM_ERR(CAM_FLASH, "Stop Failed rc: %d", rc);



	rc = cam_flash_release_dev(fctrl);

	if (rc)

		CAM_ERR(CAM_FLASH, "Release failed rc: %d", rc);



	fctrl->flash_state = CAM_FLASH_STATE_INIT;

}



int cam_flash_apply_request(struct cam_req_mgr_apply_request *apply)