Exemple #1
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 #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;
}
Exemple #3
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;
}
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;
}
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;
}
Exemple #6
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 #7
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;
}
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;
}
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__); /* LGE_CHANGE, Show log always, 2012-05-24, [email protected] */


	/* LGE_CHANGE_S, Turn IEF off in camera mode, 2012-10-23 */
		#ifdef LGIT_IEF_SWITCH
		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*/

	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);

	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__); /* LGE_CHANGE, Show log always, 2012-05-24, [email protected] */
	return 0;
}
Exemple #10
0
int32_t iu091_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
    struct msm_camera_sensor_info *data = s_ctrl->sensordata;
    IU091_LOG_INF("START\n");

    
    if(camera_iu091_i2c)
    {
	    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);
	        IU091_LOG_DBG("msm_sensor_disable_i2c_mux()\n");
	    }

	    
	    IU091_LOG_DBG("wait %d[ms]\n",IU091_WAIT_PWOFF_I2C_STOP);
	    mdelay(IU091_WAIT_PWOFF_I2C_STOP);
	    camera_iu091_i2c = false;
    }


    
    if(camera_iu091_mclk)
    {




	    msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
	        iu091_cam_clk_info, s_ctrl->cam_clk, ARRAY_SIZE(iu091_cam_clk_info), 0);

    	    msm_camera_request_gpio_table(data, 0);

	    
	    IU091_LOG_DBG("wait %d[ms]\n",IU091_WAIT_PWOFF_MCLK);
	    mdelay(IU091_WAIT_PWOFF_MCLK);
	    camera_iu091_mclk = false;
    }


    
    if(camera_iu091_pmgpio_28)
    {
	    pm8xxx_gpio_config(IU091_PMGPIO_CAM_RST_N, &iu091_cam_v_en_off);

	    IU091_LOG_DBG("PMGPIO[28]:OFF\n");

	    
	    IU091_LOG_DBG("wait %d[ms]\n",IU091_WAIT_PWOFF_RST_N);
	    mdelay(IU091_WAIT_PWOFF_RST_N);
	    camera_iu091_pmgpio_28 = false;
    }


    
    if(camera_iu091_pm_vana)
    {
	    if (cam_vana){
	        regulator_set_optimum_mode(cam_vana, 0);
	        regulator_set_voltage(cam_vana, 0, CAM_VANA_MAXUV);
	        regulator_disable(cam_vana);
	        regulator_put(cam_vana);

	        IU091_LOG_DBG("cam_vana:%d [ON/OFF]",regulator_is_enabled(cam_vana));
	        IU091_LOG_DBG("cam_vana:%d [V]",regulator_get_voltage(cam_vana));

	        cam_vana = NULL;
	    }

	    
	    IU091_LOG_DBG("wait %d[ms]\n",IU091_WAIT_PWOFF_VREG_L11);
	    mdelay(IU091_WAIT_PWOFF_VREG_L11);
	    camera_iu091_pm_vana = false;
    }


    
    if(camera_iu091_pmgpio_13)
    {
	    pm8xxx_gpio_config(IU091_PMGPIO_CAM_V_EN1, &iu091_cam_v_en_off);

	    IU091_LOG_DBG("PMGPIO[13]:OFF\n");

	    
	    IU091_LOG_DBG("wait %d[ms]\n",IU091_WAIT_PWOFF_V_EN1);
	    mdelay(IU091_WAIT_PWOFF_V_EN1);
	    camera_iu091_pmgpio_13 = false;
    }


    
    if(camera_iu091_pmgpio_26)
    {
	    pm8xxx_gpio_config(IU091_PMGPIO_CAM_V_EN2, &iu091_cam_v_en_off);

	    IU091_LOG_DBG("PMGPIO[26]:OFF\n");

	    
	    IU091_LOG_DBG("wait %d[ms]\n",IU091_WAIT_PWOFF_V_EN2);
	    mdelay(IU091_WAIT_PWOFF_V_EN2);
	    camera_iu091_pmgpio_26 = false;
    }

    
    if(camera_iu091_pm_vdig)
    {
	    if (cam_vdig) {
	        regulator_set_voltage(cam_vdig, 0, CAM_VDIG_MAXUV);
	        regulator_set_optimum_mode(cam_vdig, 0);
	        regulator_disable(cam_vdig);
	        regulator_put(cam_vdig);

	        IU091_LOG_DBG("cam_vdig:%d [ON/OFF]",regulator_is_enabled(cam_vdig));
	        IU091_LOG_DBG("cam_vdig:%d [V]",regulator_get_voltage(cam_vdig));

	        cam_vdig = NULL;
	    }

	    
	    IU091_LOG_DBG("wait %d[ms]\n",IU091_WAIT_PWOFF_VREG_L12);
	    mdelay(IU091_WAIT_PWOFF_VREG_L12);
	    camera_iu091_pm_vdig = false;
    }

    IU091_LOG_INF("END\n");
    return 0;
}
Exemple #11
0
int32_t mt9m114_msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
	int32_t rc = 0;
	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;

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

if(!mt9m114_IsPowered){
	s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *)
			* data->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;
	}

	pr_err("%s: power up\n", __func__);

	rc = 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, 1);
	if (rc < 0) {
		pr_err("%s: regulator on failed\n", __func__);
		goto config_vreg_failed;
	}

	rc = 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, 1);
	if (rc < 0) {
		pr_err("%s: enable regulator failed\n", __func__);
		goto enable_vreg_failed;
	}

	mt9m114_IsPowered=1;
}

	rc = msm_camera_config_gpio_table(data, 1);
	if (rc < 0) {
		pr_err("%s: config gpio failed\n", __func__);
		goto config_gpio_failed;
	}

	if (s_ctrl->sensor_device_type == MSM_SENSOR_I2C_DEVICE) {
		if (s_ctrl->clk_rate != 0)
			cam_8960_clk_info->clk_rate = s_ctrl->clk_rate;

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

	if (!s_ctrl->power_seq_delay)
		usleep_range(1000, 2000);
	else if (s_ctrl->power_seq_delay < 20)
		usleep_range((s_ctrl->power_seq_delay * 1000),
			((s_ctrl->power_seq_delay * 1000) + 1000));
	else
		msleep(s_ctrl->power_seq_delay);

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

	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);

	if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE) {
		rc = msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
			MSM_CCI_INIT);
		if (rc < 0) {
			pr_err("%s cci_init failed\n", __func__);
			goto cci_init_failed;
		}
	}
	s_ctrl->curr_res = MSM_SENSOR_INVALID_RES;
	return rc;

cci_init_failed:
	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);
enable_clk_failed:
		msm_camera_config_gpio_table(data, 0);
config_gpio_failed:
	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);

enable_vreg_failed:
	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);

 		if(mt9m114_IsPowered==1)
			mt9m114_IsPowered=0;      
	
config_vreg_failed:
	msm_camera_request_gpio_table(data, 0);
request_gpio_failed:
	kfree(s_ctrl->reg_ptr);
	return rc;
}
Exemple #12
0
int32_t hm03d5_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
    int32_t rc = 0;
    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;

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

    rc = msm_camera_config_gpio_table(data, 1);
    if (rc < 0) {
        pr_err("%s: config gpio failed\n", __func__);
        goto config_gpio_failed;
    }

    if (s_ctrl->sensor_device_type == MSM_SENSOR_I2C_DEVICE) {
        if (s_ctrl->clk_rate != 0)
            cam_8960_clk_info->clk_rate = s_ctrl->clk_rate;

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

    if (!s_ctrl->power_seq_delay)
        usleep_range(1000, 2000);
    else if (s_ctrl->power_seq_delay < 20)
        usleep_range((s_ctrl->power_seq_delay * 1000),
                     ((s_ctrl->power_seq_delay * 1000) + 1000));
    else
        msleep(s_ctrl->power_seq_delay);

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

    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);

    if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE) {
        rc = msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
                                 MSM_CCI_INIT);
        if (rc < 0) {
            pr_err("%s cci_init failed\n", __func__);
            goto cci_init_failed;
        }
    }
    s_ctrl->curr_res = MSM_SENSOR_INVALID_RES;
    return rc;

cci_init_failed:
    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);
enable_clk_failed:
    msm_camera_config_gpio_table(data, 0);
config_gpio_failed:
    msm_camera_request_gpio_table(data, 0);
request_gpio_failed:

    return rc;
}
Exemple #13
0
int32_t msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
	int32_t rc = 0;
	struct msm_camera_sensor_info *data = s_ctrl->sensordata;
	CDBG("%s: %d\n", __func__, __LINE__);
	s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *)
			* data->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;
	}

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

	rc = 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, 1);
	if (rc < 0) {
		pr_err("%s: regulator on failed\n", __func__);
		goto config_vreg_failed;
	}

	rc = 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, 1);
	if (rc < 0) {
		pr_err("%s: enable regulator failed\n", __func__);
		goto enable_vreg_failed;
	}

	rc = msm_camera_config_gpio_table(data, 1);
	if (rc < 0) {
		pr_err("%s: config gpio failed\n", __func__);
		goto config_gpio_failed;
	}

	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;
	}

	usleep_range(1000, 2000);
	if (data->sensor_platform_info->ext_power_ctrl != NULL)
		data->sensor_platform_info->ext_power_ctrl(1);

	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);

	if (s_ctrl->sensor_i2c_client->cci_client) {
		rc = msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
			MSM_CCI_INIT);
		if (rc < 0) {
			pr_err("%s cci_init failed\n", __func__);
			goto cci_init_failed;
		}
	}
	return rc;

cci_init_failed:
	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);
enable_clk_failed:
		msm_camera_config_gpio_table(data, 0);
config_gpio_failed:
	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);

enable_vreg_failed:
	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);
config_vreg_failed:
	msm_camera_request_gpio_table(data, 0);
request_gpio_failed:
	kfree(s_ctrl->reg_ptr);
	return rc;
}