int msm_flash_led_release(struct msm_led_flash_ctrl_t *fctrl)
{
	int rc = 0;
	struct msm_camera_sensor_board_info *flashdata = NULL;

	flashdata = fctrl->flashdata;
	CDBG("%s:%d called\n", __func__, __LINE__);
	if (!fctrl) {
		pr_err("%s:%d fctrl NULL\n", __func__, __LINE__);
		return -EINVAL;
	}
	gpio_set_value_cansleep(
		flashdata->gpio_conf->gpio_num_info->gpio_num[0],
		GPIO_OUT_LOW);
	gpio_set_value_cansleep(
		flashdata->gpio_conf->gpio_num_info->gpio_num[1],
		GPIO_OUT_LOW);
	rc = msm_camera_request_gpio_table(
		flashdata->gpio_conf->cam_gpio_req_tbl,
		flashdata->gpio_conf->cam_gpio_req_tbl_size, 0);
	if (rc < 0) {
		pr_err("%s: request gpio failed\n", __func__);
		return rc;
	}
	return 0;
}
Exemple #2
0
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	CDBG("%s\n", __func__);
	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		msm_sensor_disable_i2c_mux(
			data->sensor_platform_info->i2c_conf);

	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
	msm_camera_config_gpio_table(data, 0);
	msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_request_gpio_table(data, 0);
	kfree(s_ctrl->reg_ptr);
	return 0;
}
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	CDBG("%s\n", __func__);
	pr_err("%s: E: %s\n", __func__, data->sensor_name); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */

	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		msm_sensor_disable_i2c_mux(
			data->sensor_platform_info->i2c_conf);

	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
	msm_camera_config_gpio_table(data, 0);
	msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_request_gpio_table(data, 0);
	kfree(s_ctrl->reg_ptr);
	pr_err("%s: X\n", __func__); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */
	return 0;
}
Exemple #4
0
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	CDBG("%s\n", __func__);

	s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
	msleep(20);
	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
#ifndef CONFIG_PANTECH_CAMERA
	msm_camera_config_gpio_table(data, 0);
#endif
	msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_request_gpio_table(data, 0);
	kfree(s_ctrl->reg_ptr);
	return 0;
}
static int msm_flash_lm3642_i2c_remove(struct i2c_client *client)
{
	struct msm_camera_sensor_board_info *flashdata = NULL;
	struct msm_camera_power_ctrl_t *power_info = NULL;
	int rc = 0 ;
	LM3642_DBG("%s entry\n", __func__);
	flashdata = fctrl.flashdata;
	power_info = &flashdata->power_info;

	rc = msm_camera_request_gpio_table(
		power_info->gpio_conf->cam_gpio_req_tbl,
		power_info->gpio_conf->cam_gpio_req_tbl_size, 0);
	if (rc < 0) {
		pr_err("%s: request gpio failed\n", __func__);
		return rc;
	}

	if (fctrl.pinctrl_info.use_pinctrl == true) {
		rc = pinctrl_select_state(fctrl.pinctrl_info.pinctrl,
				fctrl.pinctrl_info.gpio_state_suspend);
		if (rc)
			pr_err("%s:%d cannot set pin to suspend state",
				__func__, __LINE__);
	}
	return rc;
}
Exemple #6
0
static int32_t s5k4e1_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	printk("%s: E, %d\n", __func__, __LINE__); /*                                                                */


	/*                                                       */
		#ifdef LGIT_IEF_SWITCH
		if(system_state != SYSTEM_BOOTING){
			printk("[IEF_ON] Camera \n");
				mipi_lgd_lcd_ief_on();
		}
		#endif
		/*                                                      */

	s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
	msleep(20);
	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
	msm_camera_config_gpio_table(data, 0);
	msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_request_gpio_table(data, 0);
	kfree(s_ctrl->reg_ptr);
	printk("%s: X, %d\n", __func__, __LINE__); /*                                                                */
	return 0;
}
Exemple #7
0
static int msm_ois_close(struct v4l2_subdev *sd,
	struct v4l2_subdev_fh *fh) {
	int rc = 0;
	struct msm_ois_ctrl_t *a_ctrl =  v4l2_get_subdevdata(sd);
	CDBG_I("Enter\n");
	if (!a_ctrl) {
		pr_err("failed\n");
		return -EINVAL;
	}
	if (a_ctrl->gpio_conf && a_ctrl->gpio_conf->cam_gpio_req_tbl) {
		CDBG("%s:%d release gpio\n", __func__, __LINE__);
		msm_camera_request_gpio_table(
			a_ctrl->gpio_conf->cam_gpio_req_tbl,
			a_ctrl->gpio_conf->cam_gpio_req_tbl_size, 0);
	}
	if (a_ctrl->ois_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
		rc = a_ctrl->i2c_client.i2c_func_tbl->i2c_util(
			&a_ctrl->i2c_client, MSM_CCI_RELEASE);
		if (rc < 0)
			pr_err("cci_init failed\n");
	}

	CDBG("Exit\n");
	return rc;
}
Exemple #8
0
int32_t t8ev4_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	int32_t rc = 0;

	printk("%s : E\n", __func__);

	/* RESET LOW*/
	if (data->sensor_reset_enable) {
		rc = gpio_direction_output(data->sensor_reset, 0);
		if (rc < 0)
			pr_err("%s: gpio:CAM_RESET %d direction can't be set\n", __func__, data->sensor_reset);
		gpio_free(data->sensor_reset);
	}

	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
	msm_camera_config_gpio_table(data, 0);
	msm_camera_request_gpio_table(data, 0);
	kfree(s_ctrl->reg_ptr);
	printk("%s : X\n", __func__);
	return 0;
}
Exemple #9
0
int32_t hm03d5_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
    struct msm_camera_sensor_info *data = s_ctrl->sensordata;
    struct device *dev = NULL;
    if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE)
        dev = &s_ctrl->pdev->dev;
    else
        dev = &s_ctrl->sensor_i2c_client->client->dev;
    if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE) {
        msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
                            MSM_CCI_RELEASE);
    }

    if (data->sensor_platform_info->i2c_conf &&
            data->sensor_platform_info->i2c_conf->use_i2c_mux)
        msm_sensor_disable_i2c_mux(
            data->sensor_platform_info->i2c_conf);

    if (data->sensor_platform_info->ext_power_ctrl != NULL)
        data->sensor_platform_info->ext_power_ctrl(0);
    if (s_ctrl->sensor_device_type == MSM_SENSOR_I2C_DEVICE)
        msm_cam_clk_enable(dev, cam_8960_clk_info, s_ctrl->cam_clk,
                           ARRAY_SIZE(cam_8960_clk_info), 0);
    else
        msm_cam_clk_enable(dev, cam_8974_clk_info, s_ctrl->cam_clk,
                           ARRAY_SIZE(cam_8974_clk_info), 0);
    msm_camera_config_gpio_table(data, 0);

    msm_camera_request_gpio_table(data, 0);

    return 0;
}
Exemple #10
0
static int32_t s5k4e1_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	printk("%s: E, %d\n", __func__, __LINE__); /*                                                                */

	s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
	msleep(20);
	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
	msm_camera_config_gpio_table(data, 0);
	msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_request_gpio_table(data, 0);
	kfree(s_ctrl->reg_ptr);
	printk("%s: X, %d\n", __func__, __LINE__); /*                                                                */
	return 0;
}
Exemple #11
0
static int s5k6b2yx_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	int rc = 0;
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	CAM_DEBUG("E");

	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		msm_sensor_disable_i2c_mux(
			data->sensor_platform_info->i2c_conf);

	/* MCLK */
	rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);

	/* VT_CAM_RESET */
	data->sensor_platform_info->
		sensor_pmic_gpio_ctrl(data->sensor_platform_info->reset, 0);

	/* STBY */
	data->sensor_platform_info->
		sensor_pmic_gpio_ctrl(data->sensor_platform_info->stby, 0);

	/* Power off */
	data->sensor_platform_info->sensor_power_off();

	msm_camera_request_gpio_table(data, 0);
	s_ctrl->vision_mode_flag=0;

	CAM_DEBUG("X");

	return rc;
}
int msm_flash_led_init(struct msm_led_flash_ctrl_t *fctrl)
{
	int rc = 0;
	struct msm_camera_sensor_board_info *flashdata = NULL;
	struct msm_camera_power_ctrl_t *power_info = NULL;
	CDBG("%s:%d called\n", __func__, __LINE__);

	flashdata = fctrl->flashdata;
	power_info = &flashdata->power_info;
	if (power_info->gpio_conf->cam_gpiomux_conf_tbl != NULL) {
		pr_err("%s:%d mux install\n", __func__, __LINE__);
		msm_gpiomux_install(
			(struct msm_gpiomux_config *)
			power_info->gpio_conf->cam_gpiomux_conf_tbl,
			power_info->gpio_conf->cam_gpiomux_conf_tbl_size);
	}

	/* CCI Init */
	if (fctrl->flash_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
		rc = fctrl->flash_i2c_client->i2c_func_tbl->i2c_util(
			fctrl->flash_i2c_client, MSM_CCI_INIT);
		if (rc < 0)
			pr_err("cci_init failed\n");
	}

	rc = msm_camera_request_gpio_table(
		power_info->gpio_conf->cam_gpio_req_tbl,
		power_info->gpio_conf->cam_gpio_req_tbl_size, 1);
	if (rc < 0) {
		pr_err("%s: request gpio failed\n", __func__);
		return rc;
	}

	msleep(20);
	if (power_info->gpio_conf->gpio_num_info->valid[SENSOR_GPIO_FL_EN]) {
		gpio_set_value_cansleep(
			power_info->gpio_conf->gpio_num_info->
			gpio_num[SENSOR_GPIO_FL_EN],
			GPIO_OUT_HIGH);
	}

	/* Don't need to set FL_NOW gpio high during init */
#if 0
	gpio_set_value_cansleep(
		power_info->gpio_conf->gpio_num_info->
		gpio_num[SENSOR_GPIO_FL_NOW],
		GPIO_OUT_HIGH);
#endif

	if (fctrl->flash_i2c_client && fctrl->reg_setting) {
		rc = fctrl->flash_i2c_client->i2c_func_tbl->i2c_write_table(
			fctrl->flash_i2c_client,
			fctrl->reg_setting->init_setting);
		if (rc < 0)
			pr_err("%s:%d failed\n", __func__, __LINE__);
	}
	return rc;
}
Exemple #13
0
static int32_t imx135_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	int32_t rc = 0;
	struct msm_camera_sensor_board_info *info = s_ctrl->sensordata;
	struct device *dev = s_ctrl->dev;

	pr_debug("%s: Enter\n", __func__);

	if (s_ctrl->sensor_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
		s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_util(
			s_ctrl->sensor_i2c_client, MSM_CCI_RELEASE);
	}

	if (imx135_devboard_config == true)
		return imx135_sensor_power_down_devboard(s_ctrl);

	/* Disable MCLK */
	msm_cam_clk_enable(dev, &s_ctrl->clk_info[0],
			(struct clk **)&imx135_cam_mclk[0],
			s_ctrl->clk_info_size, CLK_OFF);
	usleep_range(500, 600);

	/* Set reset low */
	gpio_set_value_cansleep(info->gpio_conf->cam_gpio_req_tbl[4].gpio,
			GPIO_OUT_LOW);
	usleep_range(1000, 2000);

	/* Disable VAF */
	msm_camera_config_single_vreg(dev,
			&info->cam_vreg[IMX135_CAM_VAF],
			&imx135_cam_vaf, VREG_OFF);

	/* Disable AVDD */
	gpio_set_value_cansleep(info->gpio_conf->cam_gpio_req_tbl[1].gpio,
			GPIO_OUT_LOW);
	usleep_range(1000, 2000);

	/* Disable VDD_EN */
	gpio_set_value_cansleep(info->gpio_conf->cam_gpio_req_tbl[3].gpio,
			GPIO_OUT_LOW);
	usleep_range(500, 600);

	msm_camera_config_single_vreg(dev,
			&info->cam_vreg[IMX135_CAM_VDIG],
			&imx135_cam_vdd, VREG_OFF);
	usleep_range(1000, 2000);

	/* Disable I/O Supply(Vddio) */
	msm_camera_config_single_vreg(dev,
			&info->cam_vreg[IMX135_CAM_VIO],
			&imx135_cam_vddio, VREG_OFF);
	usleep_range(1000, 2000);

	msm_camera_request_gpio_table(
		info->gpio_conf->cam_gpio_req_tbl,
		info->gpio_conf->cam_gpio_req_tbl_size, GPIO_REQUEST_NO_USE);
	return rc;
}
int32_t imx175_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
	int32_t rc = 0;
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	printk("%s: %d\n", __func__, __LINE__);

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



	printk("imx175_sensor_power_up(1) : i2c_scl: %d, i2c_sda: %d\n",
	 gpio_get_value(13), gpio_get_value(12));
	/* Power on */
	data->sensor_platform_info->sensor_power_on();
	mdelay(3);

	/* MCLK */
	printk("MCLK ON!!!");
	if (s_ctrl->clk_rate != 0)
		cam_clk_info->clk_rate = s_ctrl->clk_rate;

	rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);

	mdelay(5);
	

	/* Power on */
	data->sensor_platform_info->sensor_power_on_sub();
	mdelay(5);

    rc = msm_camera_request_gpio_table(data, 1);
	if (rc < 0)
		pr_err("%s: request gpio failed\n", __func__);

	printk("imx175_sensor_power_up(2) : i2c_scl: %d, i2c_sda: %d\n",
		 gpio_get_value(13), gpio_get_value(12));
	
	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		msm_sensor_enable_i2c_mux(data->sensor_platform_info->i2c_conf);

	printk("imx175_sensor_power_up(3) : i2c_scl: %d, i2c_sda: %d\n",
		 gpio_get_value(13), gpio_get_value(12));

	
	/* MAIN_CAM_RESET */
	printk("MAIN_CAM_RESET!!!");
	data->sensor_platform_info->
		sensor_pmic_gpio_ctrl(data->sensor_platform_info->reset, 1);

	usleep(50);

	printk("imx175_sensor_power_up(4) : i2c_scl: %d, i2c_sda: %d\n",
		 gpio_get_value(13), gpio_get_value(12));	

	return 0;
}
int sr130pc10_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	int rc = 0;
	int temp = 0;
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;

	pr_info("=== POWER DOWN Start ===");

	sr130pc10_sensor_write(0x03, 0x02);
	sr130pc10_sensor_write(0x55, 0x10);
	mdelay(1);
	udelay(50);

	gpio_set_value_cansleep(data->sensor_platform_info->sensor_reset, 0);
	temp = __gpio_get_value(data->sensor_platform_info->sensor_reset);
	pr_info("[%s]check sensor_reset : %d\n", __func__, temp);

	gpio_set_value_cansleep(data->sensor_platform_info->sensor_stby, 0);
	temp = __gpio_get_value(data->sensor_platform_info->sensor_stby);
	pr_info("[%s]check sensor_stby : %d\n", __func__, temp);

	gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_reset, 0);
	temp = __gpio_get_value(data->sensor_platform_info->vt_sensor_reset);
	pr_info("[%s]check vt_sensor_reset : %d\n", __func__, temp);

	mdelay(2);

	/*CAM_MCLK0*/
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
			cam_clk_info, &s_ctrl->cam_clk, \
			ARRAY_SIZE(cam_clk_info), 0);

	gpio_tlmm_config(GPIO_CFG(data->sensor_platform_info->mclk, 0,
				GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, \
				GPIO_CFG_2MA),
			GPIO_CFG_ENABLE);

	udelay(10);

	gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_stby, 0);
	temp = __gpio_get_value(data->sensor_platform_info->vt_sensor_stby);
	pr_info("[%s] check VT standby : %d", __func__, temp);

	udelay(10);

	data->sensor_platform_info->sensor_power_off(1);

	msm_camera_request_gpio_table(data, 0);

	sr130pc10_ctrl->op_mode = 0;
	sr130pc10_ctrl->dtp_mode = 0;
	sr130pc10_ctrl->settings.exposure = 0;
#ifdef CONFIG_LOAD_FILE
	sr130pc10_regs_table_exit();
#endif
	return rc;
}
int32_t imx119_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	int32_t rc = 0;
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	struct device *dev = NULL;
	CDBG("%s\n", __func__);
	pr_err("%s\n", __func__);

	pr_err( " %s : E sensor name is %s \n",__func__, s_ctrl->sensordata->sensor_name);
	if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE)
		dev = &s_ctrl->pdev->dev;
	else
		dev = &s_ctrl->sensor_i2c_client->client->dev;
	if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE) {
		msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
			MSM_CCI_RELEASE);
	}

	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		imx119_msm_sensor_disable_i2c_mux(
			data->sensor_platform_info->i2c_conf);

	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);

	msm_cam_clk_enable(dev, imx119_cam_clk_info, s_ctrl->cam_clk,
		ARRAY_SIZE(imx119_cam_clk_info), 0);

	    usleep(5);

	LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
	rc = gpio_direction_output(MSM_CAM2_RST_EN, 0 );
	msm_camera_config_gpio_table(data, 0);

	msm_camera_enable_vreg(dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->vreg_seq,
		s_ctrl->num_vreg_seq,
		s_ctrl->reg_ptr, 0);
	msm_camera_config_vreg(dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->vreg_seq,
		s_ctrl->num_vreg_seq,
		s_ctrl->reg_ptr, 0);

	msm_camera_request_gpio_table(data, 0);
	kfree(s_ctrl->reg_ptr);
	s_ctrl->curr_res = MSM_SENSOR_INVALID_RES;
	pr_err( " %s : X sensor name is %s \n",__func__, s_ctrl->sensordata->sensor_name);
	gpio_free(MSM_CAM2_RST_EN);
	return 0;
}
Exemple #17
0
static int s5k6b2yx_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
	int rc = 0;
/*	int err;
	u32 int_factor;
	int temp = 0; */
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	CAM_DEBUG("E");
	CAM_DEBUG("s5k6b2yx_sensor_power_up(1) : i2c_scl: %d, i2c_sda: %d\n",
		 gpio_get_value(85), gpio_get_value(84));


	rc = msm_camera_request_gpio_table(data, 1);
	if (rc < 0)
		pr_err("%s: request gpio failed\n", __func__);

	CAM_DEBUG("s5k6b2yx_sensor_power_up(2) : i2c_scl: %d, i2c_sda: %d\n",
		 gpio_get_value(85), gpio_get_value(84));

	/* Power on */
	data->sensor_platform_info->sensor_power_on();

	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		msm_sensor_enable_i2c_mux(data->sensor_platform_info->i2c_conf);

	usleep(1200);

	CAM_DEBUG("s5k6b2yx_sensor_power_up(3) : i2c_scl: %d, i2c_sda: %d\n",
		 gpio_get_value(85), gpio_get_value(84));

	/* VT_CAM_RESET */
	data->sensor_platform_info->
		sensor_pmic_gpio_ctrl(data->sensor_platform_info->reset, 1);

	usleep(50);

	/* MCLK */
	if (s_ctrl->clk_rate != 0)
		cam_clk_info->clk_rate = s_ctrl->clk_rate;

	rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);
	if (rc < 0)
		pr_err("%s: clk enable failed\n", __func__);

	CAM_DEBUG("s5k6b2yx_sensor_power_up(4) : i2c_scl: %d, i2c_sda: %d\n",
		 gpio_get_value(85), gpio_get_value(84));

	usleep(5000);
	CAM_DEBUG("X");

	return rc;
}
int msm_flash_led_init(struct msm_led_flash_ctrl_t *fctrl)
{
	int rc = 0;
	struct msm_camera_sensor_board_info *flashdata = NULL;
	CDBG("%s:%d called\n", __func__, __LINE__);

	flashdata = fctrl->flashdata;
	if (flashdata->gpio_conf->cam_gpiomux_conf_tbl != NULL) {
		pr_err("%s:%d mux install\n", __func__, __LINE__);
		msm_gpiomux_install(
			(struct msm_gpiomux_config *)
			flashdata->gpio_conf->cam_gpiomux_conf_tbl,
			flashdata->gpio_conf->cam_gpiomux_conf_tbl_size);
	}

	/* CCI Init */
	if (fctrl->flash_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
		rc = fctrl->flash_i2c_client->i2c_func_tbl->i2c_util(
			fctrl->flash_i2c_client, MSM_CCI_INIT);
		if (rc < 0)
			pr_err("cci_init failed\n");
	}


	rc = msm_camera_request_gpio_table(
		flashdata->gpio_conf->cam_gpio_req_tbl,
		flashdata->gpio_conf->cam_gpio_req_tbl_size, 1);
	if (rc < 0) {
		pr_err("%s: request gpio failed\n", __func__);
		return rc;
	}

	msleep(20);
	if (fctrl->flash_en_support)
		gpio_set_value_cansleep(
			flashdata->gpio_conf->gpio_num_info->gpio_num[0],
			GPIO_OUT_HIGH);

	if (fctrl->flash_now_support)
		gpio_set_value_cansleep(
			flashdata->gpio_conf->gpio_num_info->
			gpio_num[1],
			GPIO_OUT_HIGH);

	if (fctrl->flash_i2c_client && fctrl->reg_setting) {
		rc = fctrl->flash_i2c_client->i2c_func_tbl->i2c_write_table(
			fctrl->flash_i2c_client,
			fctrl->reg_setting->init_setting);
		if (rc < 0)
			pr_err("%s:%d failed\n", __func__, __LINE__);
	}
	return rc;
}
Exemple #19
0
static int32_t imx135_sensor_power_down_devboard(
		struct msm_sensor_ctrl_t *s_ctrl)
{
	int32_t rc = 0;
	struct msm_camera_sensor_board_info *info = s_ctrl->sensordata;
	struct device *dev = s_ctrl->dev;

	pr_debug("%s: Enter\n", __func__);

	/* Disable MCLK */
	msm_cam_clk_enable(dev, &s_ctrl->clk_info[0],
			(struct clk **)&imx135_cam_mclk[0],
			s_ctrl->clk_info_size, CLK_OFF);
	usleep_range(500, 600);

	/* Put into Reset State */
	gpio_set_value_cansleep(info->gpio_conf->cam_gpio_req_tbl[2].gpio,
			GPIO_OUT_LOW);
	usleep_range(5000, 6000);

	/* Disable VAF */
	msm_camera_config_single_vreg(dev,
			&info->cam_vreg[IMX135_CAM_VAF],
			&imx135_cam_vaf, VREG_OFF);

	/* Disable Avdd */
	gpio_set_value_cansleep(info->gpio_conf->cam_gpio_req_tbl[1].gpio,
			GPIO_OUT_LOW);
	usleep_range(1000, 2000);

	/* Disable VDIG */
	msm_camera_config_single_vreg(dev,
			&info->cam_vreg[IMX135_CAM_VDIG],
			&imx135_cam_vdd, VREG_OFF);
	usleep_range(1000, 2000);

	/* Disable VDDIO */
	gpio_set_value_cansleep(info->gpio_conf->cam_gpio_req_tbl[3].gpio,
			GPIO_OUT_LOW);

	msm_camera_config_single_vreg(dev,
			&info->cam_vreg[IMX135_CAM_VIO],
			&imx135_cam_vddio, VREG_OFF);
	usleep_range(1000, 2000);

	/* Disable GPIO's */
	msm_camera_request_gpio_table(
		info->gpio_conf->cam_gpio_req_tbl,
		info->gpio_conf->cam_gpio_req_tbl_size, GPIO_REQUEST_NO_USE);

	return rc;
}
static int msm_flash_lm3642_i2c_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
{
	struct msm_camera_sensor_board_info *flashdata = NULL;
	struct msm_camera_power_ctrl_t *power_info = NULL;
	int rc = 0 ;
	LM3642_DBG("%s entry\n", __func__);
	if (!id) {
		pr_err("msm_flash_lm3642_i2c_probe: id is NULL");
		id = lm3642_i2c_id;
	}
	rc = msm_flash_i2c_probe(client, id);
	if(rc < 0){
		pr_err("%s: probe failed\n", __func__);
		return rc;
	} else {
		/*when the flashlight open background, hold power key for more than 10s*/
		/*would enter HW reset, without turn off the light. So we need to close*/
		/*light after we reboot*/
		msm_flash_lm3642_led_off(&fctrl);
	}
	/*if the high current defined in dts, use the current value*/
	if(fctrl.flash_high_current){
		fctrl.reg_setting->high_setting->reg_setting[0].reg_data = fctrl.flash_high_current;
	}

	flashdata = fctrl.flashdata;
	power_info = &flashdata->power_info;

	rc = msm_camera_request_gpio_table(
		power_info->gpio_conf->cam_gpio_req_tbl,
		power_info->gpio_conf->cam_gpio_req_tbl_size, 1);
	if (rc < 0) {
		pr_err("%s: request gpio failed\n", __func__);
		return rc;
	}

	if (fctrl.pinctrl_info.use_pinctrl == true) {
		pr_err("%s:%d PC:: flash pins setting to active state",
				__func__, __LINE__);
		rc = pinctrl_select_state(fctrl.pinctrl_info.pinctrl,
				fctrl.pinctrl_info.gpio_state_active);
		if (rc)
			pr_err("%s:%d cannot set pin to active state",
					__func__, __LINE__);
	}

	if (!rc)
		msm_lm3642_torch_create_classdev(&(client->dev),NULL);
	return rc;
}
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	CDBG("%s\n", __func__);
	pr_err("%s: E: %s\n", __func__, data->sensor_name); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */

/* LGE_CHANGE_S, Turn IEF off in camera mode, 2012-10-23 */
#ifdef LGIT_IEF_SWITCH_L1V
	if(system_state != SYSTEM_BOOTING){
		printk("[IEF_ON] Camera \n");
		mipi_lgd_lcd_ief_on();
	}
#endif
/* LGE_CHANGE_E, Turn IEF off in camera mode, 2012-10-23*/

/* LGE_CHANGE_S, Turn IEF off in camera mode except KeepScreenOn, 2012-09-13, [email protected] */
#ifdef LGIT_IEF_SWITCH_VU2
	sub_cam_id_for_keep_screen_on = -1;
	if(system_state != SYSTEM_BOOTING){
		printk("[IEF_ON] Camera \n");
		mipi_lgit_lcd_ief_on();
	}
#endif
/* LGE_CHANGE_E, Turn IEF off in camera mode except KeepScreenOn, 2012-09-13, [email protected] */
	
	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		msm_sensor_disable_i2c_mux(
			data->sensor_platform_info->i2c_conf);
#ifdef CONFIG_S5K4E1
	msleep(20);
#endif

	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
	msm_camera_config_gpio_table(data, 0);
	msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_request_gpio_table(data, 0);
	kfree(s_ctrl->reg_ptr);
	pr_err("%s: X\n", __func__); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */
	return 0;
}
int ov680_power_down(struct msm_sensor_ctrl_t *s_ctrl, struct msm_sensor_power_setting* power_setting_table, int size)
{
	int index;
	struct msm_sensor_power_setting* power_setting;
	struct msm_camera_sensor_board_info *data = s_ctrl->sensordata;
	ov680_info("%s line %d", __func__, __LINE__);

	/* call CCI RELEASE */
	ov680_dbg("call CCI REL");
	s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_util(
		s_ctrl->sensor_i2c_client, MSM_CCI_RELEASE);

	for (index = size-1; index >= 0; index--) {
		ov680_dbg("%s index %d\n", __func__, index);
		power_setting = &power_setting_table[index];
		ov680_dbg("%s type %d\n", __func__, power_setting->seq_type);
		switch (power_setting->seq_type) {
		case SENSOR_CLK:
			ov680_dbg("%s Disable MCLK %d", __func__, __LINE__);
			msm_cam_clk_enable(s_ctrl->dev,
				&s_ctrl->clk_info[0],
				(struct clk **)&power_setting->data[0],
				s_ctrl->clk_info_size,
				0);
			break;
		case SENSOR_VREG:
			ov680_dbg("%s Disable VREG %d", __func__, __LINE__);
			msm_camera_config_single_vreg(s_ctrl->dev,
				&data->cam_vreg[power_setting->seq_val],
				(struct regulator **)&power_setting->data[0],
				0);
			break;
		case SENSOR_GPIO:
		case SENSOR_I2C_MUX:
		default:
			ov680_info("Not handled");
			break;
		}
		if (power_setting->delay > 20) {
			msleep(power_setting->delay);
		} else if (power_setting->delay) {
			usleep_range(power_setting->delay * 1000,
				(power_setting->delay * 1000) + 1000);
		}
	}
	/* de-request GPIO table */
	msm_camera_request_gpio_table(standby_gpios, sizeof(standby_gpios)/sizeof(standby_gpios[0]), 0);

return 0;
}
Exemple #23
0
int32_t mt9m114_msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	struct device *dev = NULL;
	if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE)
		dev = &s_ctrl->pdev->dev;
	else
		dev = &s_ctrl->sensor_i2c_client->client->dev;
	if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE) {
		msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
			MSM_CCI_RELEASE);
	}

	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		msm_sensor_disable_i2c_mux(
			data->sensor_platform_info->i2c_conf);

	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);
	if (s_ctrl->sensor_device_type == MSM_SENSOR_I2C_DEVICE)
		msm_cam_clk_enable(dev, cam_8960_clk_info, s_ctrl->cam_clk,
			ARRAY_SIZE(cam_8960_clk_info), 0);
	else
		msm_cam_clk_enable(dev, cam_8974_clk_info, s_ctrl->cam_clk,
			ARRAY_SIZE(cam_8974_clk_info), 0);
	msm_camera_config_gpio_table(data, 0);

if(!mt9m114_IsPowered){
       pr_err("%s: power down\n", __func__);

	msm_camera_enable_vreg(dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->vreg_seq,
		s_ctrl->num_vreg_seq,
		s_ctrl->reg_ptr, 0);
	msm_camera_config_vreg(dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->vreg_seq,
		s_ctrl->num_vreg_seq,
		s_ctrl->reg_ptr, 0);
	kfree(s_ctrl->reg_ptr);
}
	msm_camera_request_gpio_table(data, 0);
	
	s_ctrl->curr_res = MSM_SENSOR_INVALID_RES;
	return 0;
}
Exemple #24
0
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	CDBG("%s\n", __func__);
	pr_err("%s: E: %s\n", __func__, data->sensor_name); /*                                                              */

/*                                                       */
#ifdef LGIT_IEF_SWITCH_L1V
	if(system_state != SYSTEM_BOOTING){
		printk("[IEF_ON] Camera \n");
		mipi_lgd_lcd_ief_on();
	}
#endif
/*                                                      */

/*                                                                                                */
#ifdef LGIT_IEF_SWITCH_VU2
	sub_cam_id_for_keep_screen_on = -1;
	if(system_state != SYSTEM_BOOTING){
		printk("[IEF_ON] Camera \n");
		mipi_lgit_lcd_ief_on();
	}
#endif
/*                                                                                                */
	
	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		msm_sensor_disable_i2c_mux(
			data->sensor_platform_info->i2c_conf);

	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(0);
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
	msm_camera_config_gpio_table(data, 0);
	msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
		s_ctrl->sensordata->sensor_platform_info->cam_vreg,
		s_ctrl->sensordata->sensor_platform_info->num_vreg,
		s_ctrl->reg_ptr, 0);
	msm_camera_request_gpio_table(data, 0);
	kfree(s_ctrl->reg_ptr);
	pr_err("%s: X\n", __func__); /*                                                              */
	return 0;
}
int ov680_sensor_standby_power_down(struct
				    msm_sensor_ctrl_t
				    *s_ctrl)
{
#ifndef OV680_SUPPORT_STANDBY
	ov680_info("%s line %d", __func__, __LINE__);
	return msm_sensor_power_down(s_ctrl);
#else
	int rc = 0;
	ov680_info("%s line %d", __func__, __LINE__);
	if (ov680_props.state != OV680_STATE_IDLE) {
		ov680_err("%s Standby has bad state: %d %d, forcing to idle", __func__, ov680_props.state, __LINE__);
		ov680_fwi_run(OV680_FWI_IDLE, 0);
		// do it anyways? typically want shutdown procedures to always work.
	}

	if (ov680_props.fw_state == OV680_FW_MISSING) {
		ov680_dbg("%s firmware not loaded regular power_down %d", __func__, __LINE__);
		/* Release PWDN gpio, it's not part of the DTS GPIO list */
		msm_camera_request_gpio_table(standby_gpios, 1, 0);
		rc = msm_sensor_power_down(s_ctrl);
		goto end;
	}

	ov680_dbg("%s Entering standby %d", __func__, __LINE__);
	rc = ov680_fwi_run_force(OV680_FWI_FIRMWARE, OV680_FIRMWARE_STANDBY);

	if (rc) {
		ov680_err("%s standby enter failed %d", __func__, __LINE__);
	}

	rc = ov680_power_down(s_ctrl, ov680_standby_power_setting, ARRAY_SIZE(ov680_standby_power_setting));

	if (rc) {
		ov680_err("%s power down failed %d", __func__, __LINE__);
		goto end;

	}


	ov680_props.state = OV680_STATE_STANDBY;

end:
	return rc;
#endif
}
Exemple #26
0
int32_t msm_ov9740_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{

    int32_t rc = 0;

    pr_err("%s: E\n", __func__);
    s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *)
                              * s_ctrl->sensordata->sensor_platform_info->num_vreg, GFP_KERNEL);
    if (!s_ctrl->reg_ptr) {
        pr_err("%s: could not allocate mem for regulators\n",
               __func__);
        return -ENOMEM;
    }

    msm_camera_power_on(&s_ctrl->sensor_i2c_client->client->dev,s_ctrl->sensordata,s_ctrl->reg_ptr);
    pr_err("%s: %d\n", __func__, __LINE__);
    if (s_ctrl->clk_rate != 0)
        cam_clk_info->clk_rate = s_ctrl->clk_rate;

    rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
                            cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);
    if (rc < 0) {
        pr_err("%s: clk enable failed\n", __func__);
        goto enable_clk_failed;
    }
    mdelay(1);


    rc = msm_camera_request_gpio_table(s_ctrl->sensordata, 1);

    rc = msm_camera_config_gpio_table(s_ctrl->sensordata, 1);
    rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,   0x3014, 0x05, MSM_CAMERA_I2C_WORD_DATA);
    if (rc < 0) {
        pr_err("%s: i2c write failed\n", __func__);
        return rc;
    }

    return rc;

enable_clk_failed:
    msm_camera_config_gpio_table(s_ctrl->sensordata, 0);

    return rc;
}
Exemple #27
0
static int s5k8aay_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	int rc = 0;
	int temp = 0;
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;

	CAM_DEBUG(" E");

#ifdef CONFIG_LOAD_FILE
	s5k8aay_regs_table_exit();
#endif

	gpio_set_value_cansleep(data->sensor_platform_info->sensor_reset, 0);
	temp = gpio_get_value(data->sensor_platform_info->sensor_reset);

	gpio_set_value_cansleep(data->sensor_platform_info->sensor_stby, 0);
	temp = gpio_get_value(data->sensor_platform_info->sensor_stby);

	gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_reset, 0);
	temp = gpio_get_value(data->sensor_platform_info->vt_sensor_reset);
	usleep(10); /* 20clk = 0.833us */

	gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_stby, 0);
	temp = gpio_get_value(data->sensor_platform_info->vt_sensor_stby);

	/*CAM_MCLK0*/
	msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
		cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);

	gpio_tlmm_config(GPIO_CFG(data->sensor_platform_info->mclk, 0,
			GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
			GPIO_CFG_ENABLE);

	data->sensor_platform_info->sensor_power_off(1);

	rc = msm_camera_request_gpio_table(data, 0);
	if (rc < 0)
		cam_err(" request gpio failed");

	CAM_DEBUG(" X");

	return rc;
}
int32_t imx175_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
    int32_t rc = 0;
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	printk("%s\n", __func__);


	data->sensor_platform_info->sensor_power_off_sub();

	/* MCLK */
	printk("MCLK OFF!!!");

	/* MAIN_CAM_RESET */
	printk("MAIN_CAM_RESET OFF!!!");
	data->sensor_platform_info->
		sensor_pmic_gpio_ctrl(data->sensor_platform_info->reset, 0);

	usleep(50);


	printk("imx175_sensor_power_down(1) : i2c_scl: %d, i2c_sda: %d\n",
		 gpio_get_value(13), gpio_get_value(12));
	

	rc = msm_camera_request_gpio_table(data, 0);
	if (rc < 0)
		pr_err("%s: request gpio failed\n", __func__);

	printk("imx175_sensor_power_down(2) : i2c_scl: %d, i2c_sda: %d\n",
		 gpio_get_value(13), gpio_get_value(12));

	/* Power off */
	data->sensor_platform_info->sensor_power_off();


	if (data->sensor_platform_info->i2c_conf &&
		data->sensor_platform_info->i2c_conf->use_i2c_mux)
		msm_sensor_disable_i2c_mux(
			data->sensor_platform_info->i2c_conf);


	return 0;
}
int msm_flash_led_init(struct msm_led_flash_ctrl_t *fctrl)
{
	int rc = 0;
/*                                                                               */
	CDBG("%s:%d called\n", __func__, __LINE__);

#ifdef USE_GPIO
	struct msm_camera_sensor_board_info *flashdata = NULL;

	flashdata = fctrl->flashdata;
	if (flashdata->gpio_conf->cam_gpiomux_conf_tbl != NULL) {
		pr_err("%s:%d mux install\n", __func__, __LINE__);
		msm_gpiomux_install(
			(struct msm_gpiomux_config *)
			flashdata->gpio_conf->cam_gpiomux_conf_tbl,
			flashdata->gpio_conf->cam_gpiomux_conf_tbl_size);
	}

	rc = msm_camera_request_gpio_table(
		flashdata->gpio_conf->cam_gpio_req_tbl,
		flashdata->gpio_conf->cam_gpio_req_tbl_size, 1);
	if (rc < 0) {
		pr_err("%s: request gpio failed\n", __func__);
		return rc;
	}
	msleep(20);
	gpio_set_value_cansleep(
		flashdata->gpio_conf->gpio_num_info->gpio_num[0],
		GPIO_OUT_HIGH);
#endif
/*                                                                               */

#if 0 /*                                                         */
	if (fctrl->flash_i2c_client && fctrl->reg_setting) {
		rc = fctrl->flash_i2c_client->i2c_func_tbl->i2c_write_table(
			fctrl->flash_i2c_client,
			fctrl->reg_setting->init_setting);
		if (rc < 0)
			pr_err("%s:%d failed\n", __func__, __LINE__);
	}
#endif
	return rc;
}
int msm_flash_led_release(struct msm_led_flash_ctrl_t *fctrl)
{
	int rc = 0;
	struct msm_camera_sensor_board_info *flashdata = NULL;
	struct msm_camera_power_ctrl_t *power_info = NULL;

	if (!fctrl) {
		pr_err("%s:%d fctrl NULL\n", __func__, __LINE__);
		return -EINVAL;
	}
	flashdata = fctrl->flashdata;
	power_info = &flashdata->power_info;
	CDBG("%s:%d called\n", __func__, __LINE__);
	if (power_info->gpio_conf->gpio_num_info->valid[SENSOR_GPIO_FL_EN]) {
		gpio_set_value_cansleep(
			power_info->gpio_conf->gpio_num_info->
			gpio_num[SENSOR_GPIO_FL_EN],
			GPIO_OUT_LOW);
	}
	if (power_info->gpio_conf->gpio_num_info->valid[SENSOR_GPIO_FL_NOW]) {
		gpio_set_value_cansleep(
			power_info->gpio_conf->gpio_num_info->
			gpio_num[SENSOR_GPIO_FL_NOW],
			GPIO_OUT_LOW);
	}
	rc = msm_camera_request_gpio_table(
		power_info->gpio_conf->cam_gpio_req_tbl,
		power_info->gpio_conf->cam_gpio_req_tbl_size, 0);
	if (rc < 0) {
		pr_err("%s: request gpio failed\n", __func__);
		return rc;
	}

	/* CCI deInit */
	if (fctrl->flash_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
		rc = fctrl->flash_i2c_client->i2c_func_tbl->i2c_util(
			fctrl->flash_i2c_client, MSM_CCI_RELEASE);
		if (rc < 0)
			pr_err("cci_deinit failed\n");
	}
	return 0;
}