static int mt9v113_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	int ret;

	if (camera_power_down < 0) {
		ret = camera_sensor_gpio(-1, GP_CAMERA_1_POWER_DOWN,
					 GPIOF_DIR_OUT, 1);
		if (ret < 0) {
			pr_err("%s not available.", GP_CAMERA_1_POWER_DOWN);
			return ret;
		}
		camera_power_down = ret;
	}

	if (camera_1p8 < 0) {
		ret = camera_sensor_gpio(-1, GP_CAMERA_1P8,
					 GPIOF_DIR_OUT, 1);
		if (ret < 0) {
			pr_err("%s not available.", GP_CAMERA_1P8);
			return ret;
		}
		camera_1p8 = ret;
	}

	if (flag) {
		if (camera_power_down >= 0)
			gpio_set_value(camera_power_down, 0);
		if (camera_1p8 >= 0)
			gpio_set_value(camera_1p8, 0);
		if (!camera_vprog1_on) {
			camera_vprog1_on = 1;
			intel_scu_ipc_msic_vprog1(1);
		}
	} else {
		/* Put sensor into HW standby mode */
		if (camera_power_down >= 0)
			gpio_set_value(camera_power_down, 1);
		if (camera_vprog1_on) {
			camera_vprog1_on = 0;
			intel_scu_ipc_msic_vprog1(0);
		}
		if (camera_1p8 >= 0)
			gpio_set_value(camera_1p8, 1);
		/* Release the standby */
		if (camera_power_down >= 0)
			gpio_set_value(camera_power_down, 0);

		/*
		 * camera_1p8 is shared pin, so should free it
		 * when don't use it.
		 */
		gpio_free(camera_1p8);
		camera_1p8 = -1;
	}

	return 0;
}
static int imx134_power_ctrl(struct v4l2_subdev *sd, int flag)
{
#ifdef CONFIG_CRYSTAL_COVE
	struct i2c_client *client = v4l2_get_subdevdata(sd);
#endif
	int ret = 0;

	if (flag) {
		if (!camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			ret = camera_pmic_set(flag);
			if (ret) {
				dev_err(&client->dev,
						"Failed to enable regulator\n");
				return ret;
			}
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(1);
#else
			pr_err("imx134 power is not set.\n");
#endif
			if (!ret) {
				/* imx1x5 VDIG rise to XCLR release */
				usleep_range(1000, 1200);
				camera_vprog1_on = 1;
			}
			return ret;
		}
	} else {
		if (camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			ret = camera_pmic_set(flag);
			if (ret) {
				dev_err(&client->dev,
						"Failed to enable regulator\n");
				return ret;
			}
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(0);
#else
			pr_err("imx134 power is not set.\n");
#endif
			if (!ret)
				camera_vprog1_on = 0;
			return ret;
		}
	}
	return ret;
}
static int imx175_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	int ret = 0;

	if (flag) {
		if (!camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			/*
			 * This should call VRF APIs.
			 *
			 * VRF not implemented for BTY, so call this
			 * as WAs
			 */
			ret = camera_set_pmic_power(CAMERA_2P8V, true);
			if (ret)
				return ret;
			ret = camera_set_pmic_power(CAMERA_1P8V, true);
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(1);
#else
			pr_err("imx175 power is not set.\n");
#endif
			if (!ret) {
				/* imx1x5 VDIG rise to XCLR release */
				usleep_range(1000, 1200);
				camera_vprog1_on = 1;
			}
			return ret;
		}
	} else {
		if (camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			ret = camera_set_pmic_power(CAMERA_2P8V, false);
			if (ret)
				return ret;
			ret = camera_set_pmic_power(CAMERA_1P8V, false);
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(0);
#else
			pr_err("imx175 power is not set.\n");
#endif
			if (!ret)
				camera_vprog1_on = 0;
			return ret;
		}
	}
	return ret;
}
Beispiel #4
0
/*
 * Checking the SOC type is temporary workaround to enable OV8830
 * on Bodegabay (tangier) platform. Once standard regulator devices
 * (e.g. vprog1, vprog2) and control functions (pmic_avp) are added
 * for the platforms with tangier, then we can revert this change.
 * ([email protected])
 */
static int ov8830_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	int ret = 0;

	/* The camera powering is different on RedHookBay and VictoriaBay
	 * On RHB, vprog1 is at 2.8V and supplies both cameras
	 * On VB, vprog1 supplies the 2nd camera and must not rise over 1.2V
	 * Check if the RHB SW has accidentally been flashed to VB
	 * If yes, don't turn on the regulator. The VB secondary camera will
	 * be permanently damaged by the too high voltage
	 */
	if (INTEL_MID_BOARD(2, PHONE, CLVTP, VB, PRO) ||
	    INTEL_MID_BOARD(2, PHONE, CLVTP, VB, ENG)) {
		printk(KERN_ALERT \
		"Aborted vprog1 enable to protect VictoriaBay 2nd camera HW\n");
		return -ENODEV;
	}

	if (flag) {
		if (!camera_vprog1_on) {
			if (intel_mid_identify_cpu() ==
			   INTEL_MID_CPU_CHIP_TANGIER)
				ret = intel_scu_ipc_msic_vprog1(1);
			else
				ret = regulator_enable(vprog1_reg);
			if (!ret)
				camera_vprog1_on = 1;
			else
				printk(KERN_ALERT "Failed to enable regulator vprog1\n");
			return ret;
		}
	} else {
		if (camera_vprog1_on) {
			if (intel_mid_identify_cpu() ==
			   INTEL_MID_CPU_CHIP_TANGIER)
				ret = intel_scu_ipc_msic_vprog1(0);
			else
				ret = regulator_disable(vprog1_reg);

			if (!ret)
				camera_vprog1_on = 0;
			else
				printk(KERN_ALERT "Failed to disable regulator vprog1\n");
			return ret;
		}
	}
	return ret;
}
/*
 * The power_down gpio pin is to control OV2722's
 * internal power state.
 */
static int ov2722_power_ctrl(struct v4l2_subdev *sd, int flag)
{
#ifdef CONFIG_CRYSTAL_COVE
	struct i2c_client *client = v4l2_get_subdevdata(sd);
#endif
	int ret = 0;

	if (flag) {
		if (!camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			ret = camera_pmic_set(flag);
			if (ret) {
				dev_err(&client->dev,
						"Failed to enable regulator\n");
				return ret;
			}
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(1);
#else
			pr_err("ov2722 power is not set.\n");
#endif
			if (!ret)
				camera_vprog1_on = 1;
			return ret;
		}
	} else {
		if (camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			ret = camera_pmic_set(flag);
			if (ret) {
				dev_err(&client->dev,
						"Failed to enable regulator\n");
				return ret;
			}
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(0);
#else
			pr_err("ov2722 power is not set.\n");
#endif
			if (!ret)
				camera_vprog1_on = 0;
			return ret;
		}
	}

	return 0;
}
static int imx175_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	int ret = 0;

	if (flag) {
		if (!camera_vprog1_on) {
			if (intel_mid_identify_cpu() !=
			    INTEL_MID_CPU_CHIP_VALLEYVIEW2)
				ret = intel_scu_ipc_msic_vprog1(1);
#ifdef CONFIG_CRYSTAL_COVE
			/*
			 * This should call VRF APIs.
			 *
			 * VRF not implemented for BTY, so call this
			 * as WAs
			 */
			ret = camera_set_pmic_power(CAMERA_2P8V, true);
			if (ret)
				return ret;
			ret = camera_set_pmic_power(CAMERA_1P8V, true);
#endif
			if (!ret) {
				/* imx1x5 VDIG rise to XCLR release */
				usleep_range(1000, 1200);
				camera_vprog1_on = 1;
			}
			return ret;
		}
	} else {
		if (camera_vprog1_on) {
			if (intel_mid_identify_cpu() !=
			    INTEL_MID_CPU_CHIP_VALLEYVIEW2)
				ret = intel_scu_ipc_msic_vprog1(0);
#ifdef CONFIG_CRYSTAL_COVE
			ret = camera_set_pmic_power(CAMERA_2P8V, false);
			if (ret)
				return ret;
			ret = camera_set_pmic_power(CAMERA_1P8V, false);
#endif
			if (!ret)
				camera_vprog1_on = 0;
			return ret;
		}
	}
	return ret;
}
int camera_set_vprog_power(enum camera_vprog vprog, bool flag,
			   enum camera_vprog_voltage voltage)
{
	static struct vprog_status status[CAMERA_VPROG_NUM];
	static DEFINE_MUTEX(mutex_power);
	int ret = 0;

	if (vprog >= CAMERA_VPROG_NUM) {
		pr_err("%s: invalid vprog number: %d\n", __func__, vprog);
		return -EINVAL;
	}

	mutex_lock(&mutex_power);
	/*
	 * only set power at: first to power on last to power off
	 */
	if ((flag && status[vprog].user == 0)
	    || (!flag && status[vprog].user == 1)) {
		switch (vprog) {
		case CAMERA_VPROG1:
			if (voltage == DEFAULT_VOLTAGE) {
				ret = intel_scu_ipc_msic_vprog1(flag);
			} else {
				pr_err("Error: non-default vprog1 voltage\n");
				ret = -EINVAL;
			}
			break;
		case CAMERA_VPROG2:
			if (voltage == DEFAULT_VOLTAGE) {
				ret = intel_scu_ipc_msic_vprog2(flag);
			} else {
				pr_err("Error: non-default vprog2 voltage\n");
				ret = -EINVAL;
			}
			break;
		case CAMERA_VPROG3:
			ret = camera_set_vprog3(flag, voltage);
			break;
		default:
			pr_err("camera set vprog power: invalid pin number.\n");
			ret = -EINVAL;
		}
		if (ret)
			goto done;
	}

	if (flag)
		status[vprog].user++;
	else
		if (status[vprog].user)
			status[vprog].user--;
done:
	mutex_unlock(&mutex_power);
	return ret;
}
static int imx134_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	int ret = 0;

	if (flag) {
		if (!camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			ret = intel_mid_pmic_writeb(VPROG_2P8V, VPROG_ENABLE);
			if (ret)
				return ret;
			ret = intel_mid_pmic_writeb(VPROG_1P8V, VPROG_ENABLE);
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(1);
#else
			pr_err("imx134 power is not set.\n");
#endif
			if (!ret) {
				/* imx1x5 VDIG rise to XCLR release */
				usleep_range(1000, 1200);
				camera_vprog1_on = 1;
			}
			return ret;
		}
	} else {
		if (camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			ret = intel_mid_pmic_writeb(VPROG_2P8V, VPROG_DISABLE);
			if (ret)
				return ret;
			ret = intel_mid_pmic_writeb(VPROG_1P8V, VPROG_DISABLE);
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(0);
#else
			pr_err("imx134 power is not set.\n");
#endif
			if (!ret)
				camera_vprog1_on = 0;
			return ret;
		}
	}
	return ret;
}
static int imx135_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	int ret = 0;

	if (is_moorefield()) {
#ifdef CONFIG_INTEL_SCU_IPC_UTIL
		ret = intel_scu_ipc_msic_vprog1(flag);
		if (ret) {
			pr_err("imx135 power failed\n");
			return ret;
		}
		ret = intel_scu_ipc_msic_vprog3(flag);
#else
		ret = -ENODEV;
#endif
		if (ret)
			pr_err("imx135 power failed\n");
		if (flag)
			usleep_range(1000, 1200);

		return ret;
	}

	if (flag) {
		if (is_ctp()) {
			if (!camera_vemmc1_on) {

				camera_vemmc1_on = 1;
				ret = regulator_enable(vemmc1_reg);
				if (ret) {
					dev_err(&client->dev,
						"Failed to enable regulator vemmc1\n");
					return ret;
				}

			}
			if (vprog1_reg && !camera_vprog1_on) {
				camera_vprog1_on = 1;
				ret = regulator_enable(vprog1_reg);
				if (ret) {
					dev_err(&client->dev,
						"Failed to enable regulator vprog1\n");
					return ret;
				}

			}
			if (!is_victoriabay()) {
				if (camera_power < 0) {
					ret = camera_sensor_gpio(-1,
						GP_CAMERA_1_POWER_DOWN,
						GPIOF_DIR_OUT, 1);
					if (ret < 0)
						return ret;
					camera_power = ret;
				}
				gpio_set_value(camera_power, 1);
			}
			/* min 250us -Initializing time of silicon */
			usleep_range(250, 300);
		} else {
			if (!camera_vprog1_on) {
				ret = regulator_enable(vprog1_reg);
				if (!ret) {
					/* imx1x5 VDIG rise to XCLR release */
					usleep_range(1000, 1200);
					camera_vprog1_on = 1;
				}
				return ret;
			}
		}
	} else {
		if (is_ctp()) {
			if (camera_vemmc1_on) {
				camera_vemmc1_on = 0;

				ret = regulator_disable(vemmc1_reg);
				if (ret) {
					dev_err(&client->dev,
						"Failed to disable regulator vemmc1\n");
					return ret;
				}
			}
			if (vprog1_reg && camera_vprog1_on) {
				camera_vprog1_on = 0;

				ret = regulator_disable(vprog1_reg);
				if (ret) {
					dev_err(&client->dev,
						"Failed to disable regulator vprog1\n");
					return ret;
				}
			}
		} else {
			if (camera_vprog1_on) {
				ret = regulator_disable(vprog1_reg);
				if (!ret)
					camera_vprog1_on = 0;
				return ret;
			}
		}
	}
	return 0;
}
/*
 * The camera_v1p8_en gpio pin is to enable 1.8v power.
 */
static int ov2685f_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	int ret = 0;
	/* int pin = CAMERA_1P8_EN; */
	int val;

#if 0
	ret = gpio_request(pin, "camera_v1p8_en");
	if (ret) {
		pr_err("Request camera_v1p8_en failed.\n");
		gpio_free(pin);
		ret = gpio_request(pin, "camera_v1p8_en");
		if (ret) {
			pr_err("Request camera_v1p8_en still failed.\n");
			return ret;
		}
	}
	gpio_direction_output(pin, 0);
#endif

	if (flag) {
		if (!camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			/*
			 * This should call VRF APIs.
			 *
			 * VRF not implemented for BTY, so call this
			 * as WAs
			 */
			camera_set_pmic_power(CAMERA_2P8V, true);
			camera_set_pmic_power(CAMERA_1P8V, true);
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(1);
#else
			pr_err("ov2685f power is not set.\n");
#endif

#if 0
			/* enable 1.8v power */
			gpio_set_value(pin, 1);
#endif
			camera_vprog1_on = 1;
			usleep_range(10000, 11000);
		}
	} else {
		if (camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			camera_set_pmic_power(CAMERA_2P8V, false);
			camera_set_pmic_power(CAMERA_1P8V, false);
#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(0);
#else
			pr_err("ov2685f power is not set.\n");
#endif
#if 0
			/* disable 1.8v power */
			gpio_set_value(pin, 0);

#endif
			camera_vprog1_on = 0;
		}
	}

#if 0
	gpio_free(pin);
#endif
	return 0;
}
static int ov8865_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	int ret = 0;
	int value = 0;

	ov8865_power_pins();
	if (flag) {
		if (!camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			/* AVDD on First */
			value = intel_mid_pmic_readb(VPROG_3P3V);
			value = value | VPROG_ENABLE;
			OV8865_PLAT_LOG(1,"try to enable VPROG_3P3V: value=0x%x\n", value);
			ret = intel_mid_pmic_writeb(VPROG_3P3V, value);

			usleep_range(2000, 2100);
			/* power up sequence control via GPIO*/
			gpio_set_value(camera_avdd_en, 1);
			usleep_range(1000, 1500);
			/* DOVDD and DVDD On*/
			OV8865_PLAT_LOG(1,"try to enable VPROG_1P8V\n");
			ret = intel_mid_pmic_writeb(VPROG_1P8V, VPROG_ENABLE);
			if (ret)
				return ret;
			gpio_set_value(camera_reset, 1); /* reset is active low */
		      /* ov8865 reset pulse should be more than 2ms
		      */
		      usleep_range(3500, 4000);
			/* VCM 2P8 power on*/
			OV8865_PLAT_LOG(1,"try to enable VPROG_2P8V\n");
			ret = intel_mid_pmic_writeb(VPROG_2P8V, VPROG_ENABLE);
			if (ret)
				return ret;

		#if 0
			gpio_set_value(camera_power_down, 1);
			//gpio_set_value(camera_dovdd_en, 1);
			usleep_range(2500, 3500);
		#endif

			gpio_set_value(camera_dvdd_en, 1);
			gpio_set_value(camera_vcm_en, 1);
			usleep_range(1000, 1500);

			#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(1);
#else
			pr_err("ov8865 power is not set.\n");
#endif
			if (!ret) {
				/* ov8865 VDIG rise to XCLR release */
				usleep_range(1000, 1200);
				camera_vprog1_on = 1;
			}
			return ret;
		}
	} else {
		if (camera_vprog1_on) {
#ifdef CONFIG_CRYSTAL_COVE
			/* power down sequence control via GPIO*/
			gpio_set_value(camera_dvdd_en, 0);
			gpio_set_value(camera_vcm_en, 0);
			usleep_range(2500, 3500);
			//gpio_set_value(camera_power_down, 0);
			//gpio_set_value(camera_dovdd_en, 0);

			/* power down power rail*/
			ret = intel_mid_pmic_writeb(VPROG_2P8V, VPROG_DISABLE);
			if (ret)
				return ret;
			ret = intel_mid_pmic_writeb(VPROG_1P8V, VPROG_DISABLE);
			gpio_set_value(camera_reset, 0);
			gpio_set_value(camera_avdd_en, 0);

			
			/* WA: We don't know previous status of VPROG_3P3V
			 * So keep it ON here
			 */

#elif defined(CONFIG_INTEL_SCU_IPC_UTIL)
			ret = intel_scu_ipc_msic_vprog1(0);
#else
			pr_err("ov8865 power is not set.\n");
#endif
			if (!ret)
				camera_vprog1_on = 0;
			return ret;
		}
	}
	return ret;
}
static int mt9m114_power_ctrl(struct v4l2_subdev *sd, int flag)
{
#ifdef CONFIG_BOARD_CTP
	int reg_err;
#endif
#ifndef CONFIG_BOARD_CTP
	int ret;

	/* Note here, there maybe a workaround to avoid I2C SDA issue */
        if (mt9m114_camera_power_down < 0) {
		ret = camera_sensor_gpio(-1, GP_CAMERA_1_POWER_DOWN,
					GPIOF_DIR_OUT, 1);
#ifndef CONFIG_BOARD_REDRIDGE
		if (ret < 0)
			return ret;
#endif
                mt9m114_camera_power_down = ret;
	}

        if (mt9m114_camera_reset < 0) {
		ret = camera_sensor_gpio(-1, GP_CAMERA_1_RESET,
					 GPIOF_DIR_OUT, 1);
		if (ret < 0)
			return ret;
		mt9m114_camera_reset = ret;
	}
#endif
	if (flag) {
#ifndef CONFIG_BOARD_CTP
		if (!mt9e013_reset_value) {
			if (mt9e013_reset)
				mt9e013_reset(sd);
			mt9e013_reset_value = 1;
		}
#ifdef CONFIG_BOARD_REDRIDGE
		gpio_direction_output(mt9m114_camera_reset, 0);
#endif
		gpio_set_value(mt9m114_camera_reset, 0);
#endif
		if (!mt9e013_camera_vprog1_on) {
			mt9m114_camera_vprog1_on = 1;
#ifdef CONFIG_BOARD_CTP
			reg_err = regulator_enable(vprog1_reg);
			if (reg_err) {
				printk(KERN_ALERT, "Failed to enable regulator vprog1\n");
				return reg_err;
			}
#else
			intel_scu_ipc_msic_vprog1(1);
#endif
		}
#ifndef CONFIG_BOARD_CTP
#ifdef CONFIG_BOARD_REDRIDGE
		if (mt9m114_camera_power_down >= 0)
			gpio_set_value(mt9m114_camera_power_down, 1);
#else
		gpio_set_value(mt9m114_camera_power_down, 1);
#endif
#endif
	} else {
		if (mt9m114_camera_vprog1_on) {
			mt9m114_camera_vprog1_on = 0;
#ifdef CONFIG_BOARD_CTP
			reg_err = regulator_disable(vprog1_reg);
			if (reg_err) {
				printk(KERN_ALERT, "Failed to disable regulator vprog1\n");
				return reg_err;
			}
#else
			intel_scu_ipc_msic_vprog1(0);
#endif
		}
#ifndef CONFIG_BOARD_CTP
#ifdef CONFIG_BOARD_REDRIDGE
		if (mt9m114_camera_power_down >= 0)
			gpio_set_value(mt9m114_camera_power_down, 0);
#else
		gpio_set_value(mt9m114_camera_power_down, 0);
#endif

		mt9e013_reset_value = 0;
#endif
	}

	return 0;
}
static int t4k35_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	int ret = 0;
	int reset_gpio_pin, vcm_pd_gpio_pin;

	if (first_open) {
		camera_reset = -1;
		camera_power = -1;
		camera_vcm_pd = -1;
		camera_sensor_2_8v = -1;
		HW_ID = Read_HW_ID();
		first_open = false;
	}

	reset_gpio_pin = 177;
	vcm_pd_gpio_pin = 175;


	if (camera_reset < 0) {
		gpio_free(reset_gpio_pin);
		ret = camera_sensor_gpio(reset_gpio_pin, GP_CAMERA_0_RESET,
					GPIOF_DIR_OUT, 0);
		if (ret < 0) {
			pr_err("%s error\n", GP_CAMERA_0_RESET);
			return ret;
		}
		camera_reset = reset_gpio_pin;
	}
	
	if (camera_vcm_pd < 0) {
		ret = camera_sensor_gpio(vcm_pd_gpio_pin, GP_CAMERA_0_POWER_DOWN,
					GPIOF_DIR_OUT, 0);
		if (ret < 0) {
			pr_err("%s error\n", GP_CAMERA_0_POWER_DOWN);
			return ret;
		}
		camera_vcm_pd = reset_gpio_pin;
	}

	pr_info("[t4k35_platform] HW_ID = %d\n", HW_ID);
	if (camera_sensor_2_8v < 0 && HW_ID >= 3) { /*for PR HW change 2.8V*/
		ret = camera_sensor_gpio(-1, GP_CAMERA_1_2_8v,
				 GPIOF_DIR_OUT, 0);
		if (ret < 0) {
			pr_err("%s not available.\n", GP_CAMERA_1_2_8v);
			return ret;
		}
		camera_sensor_2_8v = GP_CORE_012;
	}
#if 0
	if (is_moorefield()) {
#ifdef CONFIG_INTEL_SCU_IPC_UTIL
		ret = intel_scu_ipc_msic_vprog1(flag);
		if (ret) {
			pr_err("t4k35 power failed\n");
			return ret;
		}
		ret = intel_scu_ipc_msic_vprog3(flag);
#else
		ret = -ENODEV;
#endif
		if (ret)
			pr_err("t4k35 power failed\n");
		if (flag)
			usleep_range(1000, 1200);

		return ret;
	}
#endif
	if (flag) {
		gpio_set_value(camera_reset, 0);
		usleep_range(200, 300);
		pr_info("%s camera_reset is low\n", __func__);
		/* turn on VCM power 2.85V */
		if (!camera_vemmc1_on) {
			camera_vemmc1_on = 1;
			ret = regulator_enable(vemmc1_reg);
			/* ret = regulator_enable(vemmc1_reg); */
			if (!ret) {
				pr_info("%s enable regulator vemmc1 2.85V\n", __func__);
			} else {
				pr_err("%s Failed to enable regulator vemmc1\n", __func__);
			return ret;
			}
		}
		if (!camera_vprog2_on) {
			camera_vprog2_on = 1;
			ret = regulator_enable(vprog2_reg);
			if (!ret) {
				pr_info("%s enable regulator vprog2 1.2V\n", __func__);
			} else {
				pr_err("%s Failed to enable regulator vprog2\n", __func__);
			return ret;
			}
		}
		if (!camera_vprog1_on) {
			camera_vprog1_on = 1;
			ret = regulator_enable(vprog1_reg);
			if (!ret) {
				pr_info("%s enable regulator vprog1 1.8V\n", __func__);
			} else {
				pr_err("%s Failed to enable regulator vprog1\n", __func__);
				return ret;
			}
		}
		if (camera_sensor_2_8v >= 0) {
			gpio_set_value(camera_sensor_2_8v, 1);
			pr_err("<<< 2.8v = 1\n");
		}
	} else {
		if (camera_sensor_2_8v >= 0) {
			gpio_set_value(camera_sensor_2_8v, 0);
			pr_err("<<< 2.8v = 0\n");
			gpio_free(camera_sensor_2_8v);
			camera_sensor_2_8v = -1;
		}

		if (camera_vprog1_on) {
			camera_vprog1_on = 0;
			ret = regulator_disable(vprog1_reg);
			if (!ret) {
				pr_info("%s disable regulator vprog1 1.8V\n", __func__);
			} else {
				pr_err("%s Failed to disable regulator vprog1\n", __func__);
			return ret;
			}
		}
		if (camera_vprog2_on) {
			camera_vprog2_on = 0;
			ret = regulator_disable(vprog2_reg);
			if (!ret) {
				pr_info("%s disable regulator vprog2 1.2V\n", __func__);
			} else {
				pr_err("%s Failed to disable regulator vprog2\n", __func__);
			return ret;
			}
		}
		/* turn off VCM power 2.85V */
		if (camera_vemmc1_on) {
			camera_vemmc1_on = 0;
			ret = regulator_disable(vemmc1_reg);
			if (!ret) {
				pr_info("%s disable regulator vemmc1 2.85V\n", __func__);
			} else {
				pr_err("%s Failed to disable regulator vemmc1\n", __func__);
			return ret;
			}
		}
	}
	return 0;
}
Beispiel #14
0
/*
 * Checking the SOC type is temporary workaround to enable OV5670
 * on Bodegabay (tangier) platform. Once standard regulator devices
 * (e.g. vprog2, vprog1) and control functions (pmic_avp) are added
 * for the platforms with tangier, then we can revert this change.
 * ([email protected])
 */
static int ov5670_power_ctrl(struct v4l2_subdev *sd, int flag)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);
	int ret = 0, gpio;

	if (offset_3 != 0) {
		if (camera_2v8_vcm_power_enable < 0) {
		
			gpio = camera_sensor_gpio(-1, "NFC-intr",
					GPIOF_DIR_OUT, 0);
			if (gpio < 0)
				return gpio;
		
			camera_2v8_vcm_power_enable = gpio;/*174*/
			/* set camera vcm power pin mode to gpio */
			lnw_gpio_set_alt(camera_2v8_vcm_power_enable, LNW_GPIO);
			pr_err("%s: set 2.8V vcm as GPIO\n", __func__);
		}
	}
	
	if (camera_1v2_power_enable < 0) {
		gpio = camera_sensor_gpio(-1, "GP_CAMERA_2_PD",
				GPIOF_DIR_OUT, 0);
		if (gpio < 0)
			return gpio;
		camera_1v2_power_enable = gpio;
		/* set camera vcm power pin mode to gpio */
		lnw_gpio_set_alt(camera_1v2_power_enable, LNW_GPIO);
		pr_err("%s: Set 1.2V as GPIO\n", __func__);
	}

	if (flag) {
		if (offset_3 == 0) {
			if (camera_reset < 0) {
		
				ret = camera_sensor_gpio(-1, "GP_SUB_CAM_PWDN",
							GPIOF_DIR_OUT, 0);
				printk("%s: request gpio camera_reset = %d, flag = %d\n", __func__, ret, flag);
				if (ret < 0)
					return ret;
		
				camera_reset = ret;/*48*/
				printk("%s: 8M sku offset_3 = %d\n", __func__, offset_3);
			}
		} else {
			if (camera_reset < 0) {
				ret = camera_sensor_gpio(-1, GP_CAMERA_0_RESET,
							GPIOF_DIR_OUT, 0);
				printk("%s: request gpio camera_reset = %d, flag = %d\n", __func__, ret, flag);
				if (ret < 0)
					return ret;
				camera_reset = ret; /*9*/
				printk("%s: 5M sku offset_3 = %d\n", __func__, offset_3);
			}
		}

		if (camera_reset >= 0){
			gpio_set_value(camera_reset, 0);
			printk("%s: camera_reset = 0\n", __func__);
			msleep(1);
		}
	}

	if (flag) {
		ret = intel_scu_ipc_msic_vprog1(flag);	//2.8V
		if (ret) {
			pr_err("%s: 2.8V power failed\n", __func__);
			return ret;
		}

		ret = intel_scu_ipc_msic_vprog2(flag);	//1.8V
		if (ret) {
			pr_err("%s: 1.8V power failed\n", __func__);
			return ret;
		}

		if (offset_3 != 0) {
			ret = control_vcm_phy_power(PMIC_VLDOCNT, flag);
			pr_err("%s: Set camera vcm 2.8V(V_SWITCH) on\n", __func__);
			if (ret) {
				pr_err("%s: VCM 3.3V power failed\n", __func__);
				return ret;
			}
		}

		if (offset_3 != 0) {
			pr_err("%s: Set camera vcm 2.8V on = %d\n", __func__, camera_2v8_vcm_power_enable);
			gpio_set_value(camera_2v8_vcm_power_enable, 1);
		}
		pr_err("%s: Set camera 1.2V on = %d\n", __func__, camera_1v2_power_enable);
		gpio_set_value(camera_1v2_power_enable, 1);
	}else {
		pr_err("%s: Set camera 1.2V off\n", __func__);
		gpio_set_value(camera_1v2_power_enable, 0);
		gpio_free(camera_1v2_power_enable);
		camera_1v2_power_enable = -1;
		if (offset_3 != 0) {
			pr_err("%s: Set camera vcm 2.8V off\n", __func__);
			gpio_set_value(camera_2v8_vcm_power_enable, 0);
			gpio_free(camera_2v8_vcm_power_enable);
			camera_2v8_vcm_power_enable = -1;
		}

		if (offset_3 != 0) {
			ret = control_vcm_phy_power(PMIC_VLDOCNT, flag);
			pr_err("%s: Set camera vcm 2.8V(V_SWITCH) off\n", __func__);
			if (ret) {
				pr_err("%s: VCM 3.3V power failed\n", __func__);
				return ret;
			}
		}
		
		ret = intel_scu_ipc_msic_vprog2(flag);	//1.8V
		if (ret) {
			pr_err("%s: 1.8V power failed\n", __func__);
			return ret;
		}
		
		ret = intel_scu_ipc_msic_vprog1(flag);	//2.8V
		if (ret) {
			pr_err("%s: 2.8V power failed\n", __func__);
			return ret;
		}
	}
	
	if (flag)
		usleep_range(1000, 1200);

	return ret;
}
static int mt9m114_power_ctrl(struct v4l2_subdev *sd, int flag)
{
#ifdef CONFIG_BOARD_CTP
	int reg_err;
#endif
#ifndef CONFIG_BOARD_CTP
	int ret;

	/* The camera powering is different on RedHookBay and VictoriaBay
	 * On RHB, vprog1 is at 2.8V and supplies both cameras
	 * On VB, vprog1 supplies the 2nd camera and must not rise over 1.2V
	 * Check if the RHB SW has accidentally been flashed to VB
	 * If yes, don't turn on the regulator. The VB secondary camera will
	 * be permanently damaged by the too high voltage
	 */
	if (INTEL_MID_BOARD(2, PHONE, CLVTP, VB, PRO) ||
	    INTEL_MID_BOARD(2, PHONE, CLVTP, VB, ENG)) {
		printk(KERN_ALERT \
		"Aborted vprog1 enable to protect VictoriaBay 2nd camera HW\n");
		return -ENODEV;
	}

	/* Note here, there maybe a workaround to avoid I2C SDA issue */
	if (camera_power_down < 0) {
		ret = camera_sensor_gpio(-1, GP_CAMERA_1_POWER_DOWN,
					GPIOF_DIR_OUT, 1);
#ifndef CONFIG_BOARD_REDRIDGE
		if (ret < 0)
			return ret;
#endif
		camera_power_down = ret;
	}

	if (camera_reset < 0) {
		ret = camera_sensor_gpio(-1, GP_CAMERA_1_RESET,
					 GPIOF_DIR_OUT, 1);
		if (ret < 0)
			return ret;
		camera_reset = ret;
	}
#endif
	if (flag) {
#ifndef CONFIG_BOARD_CTP
		if (!mt9e013_reset_value) {
			if (mt9e013_reset)
				mt9e013_reset(sd);
			mt9e013_reset_value = 1;
		}
#ifdef CONFIG_BOARD_REDRIDGE
		gpio_direction_output(camera_reset, 0);
#endif
		gpio_set_value(camera_reset, 0);
#endif
		if (!camera_vprog1_on) {
			camera_vprog1_on = 1;
#ifdef CONFIG_BOARD_CTP
			reg_err = regulator_enable(vprog1_reg);
			if (reg_err) {
				printk(KERN_ALERT "Failed to enable regulator vprog1\n");
				return reg_err;
			}
#else
			intel_scu_ipc_msic_vprog1(1);
#endif
		}
#ifndef CONFIG_BOARD_CTP
#ifdef CONFIG_BOARD_REDRIDGE
		if (camera_power_down >= 0)
			gpio_set_value(camera_power_down, 1);
#else
		gpio_set_value(camera_power_down, 1);
#endif
#endif
	} else {
		if (camera_vprog1_on) {
			camera_vprog1_on = 0;
#ifdef CONFIG_BOARD_CTP
			reg_err = regulator_disable(vprog1_reg);
			if (reg_err) {
				printk(KERN_ALERT "Failed to disable regulator vprog1\n");
				return reg_err;
			}
#else
			intel_scu_ipc_msic_vprog1(0);
#endif
		}
#ifndef CONFIG_BOARD_CTP
#ifdef CONFIG_BOARD_REDRIDGE
		if (camera_power_down >= 0)
			gpio_set_value(camera_power_down, 0);
#else
		gpio_set_value(camera_power_down, 0);
#endif

		mt9e013_reset_value = 0;
#endif
	}

	return 0;
}