int muic_set_safeout(int safeout_path)
{
struct regulator *regulator;
int ret;
pr_info("%s:MUIC safeout path=%d\n", __func__, safeout_path);
if (safeout_path == MUIC_PATH_USB_CP) {
regulator = regulator_get(NULL, "safeout1_range");
if (IS_ERR(regulator) || regulator == NULL)
return -ENODEV;
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
regulator = regulator_get(NULL, "safeout2_range");
if (IS_ERR(regulator) || regulator == NULL)
return -ENODEV;
if (!regulator_is_enabled(regulator)) {
ret = regulator_enable(regulator);
if (ret)
goto err;
}
regulator_put(regulator);
} else if (safeout_path == MUIC_PATH_USB_AP) {
regulator = regulator_get(NULL, "safeout1_range");
if (IS_ERR(regulator) || regulator == NULL)
return -ENODEV;
if (!regulator_is_enabled(regulator)) {
ret = regulator_enable(regulator);
if (ret)
goto err;
}
regulator_put(regulator);
regulator = regulator_get(NULL, "safeout2_range");
if (IS_ERR(regulator) || regulator == NULL)
return -ENODEV;
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
} else {
pr_info("%s: not control safeout(%d)\n", __func__, safeout_path);
return -EINVAL;
}
return 0;
err:
pr_info("%s: cannot regulator_enable (%d)\n", __func__, ret);
regulator_put(regulator);
return ret;
}
static int db8131m_power_down(void)
{
struct regulator *regulator;
int ret = 0;
pr_debug("%s: in", __func__);
db8131m_gpio_request();
/* VT_CAM_nSTBY(1.3M EN) DIS */
ret = gpio_direction_output(GPIO_VT_CAM_nSTBY, 0);
CAM_CHECK_ERR_RET(ret, "low VT_CAM_nSTBY");
/* CAM_VT_nRST(1.3M RESET) DIS */
ret = gpio_direction_output(GPIO_CAM_VT_nRST, 0);
CAM_CHECK_ERR_RET(ret, "low CAM_VT_nRST");
/* MCLK */
ret = s3c_gpio_cfgpin(GPIO_CAM_MCLK, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_CAM_MCLK, S3C_GPIO_PULL_DOWN);
CAM_CHECK_ERR(ret, "cfg mclk");
/* CAM_DVDD_1.5V(1.3M Core 1.8V) */
regulator = regulator_get(NULL, "cam_dvdd_1.5v");
if (IS_ERR(regulator))
return -ENODEV;
if (regulator_is_enabled(regulator))
ret = regulator_force_disable(regulator);
regulator_put(regulator);
CAM_CHECK_ERR_RET(ret, "disable cam_dvdd_1.5v");
/* CAM_SENSOR_A2.8V */
regulator = regulator_get(NULL, "cam_sensor_a2.8v");
if (IS_ERR(regulator))
return -ENODEV;
if (regulator_is_enabled(regulator))
ret = regulator_force_disable(regulator);
regulator_put(regulator);
CAM_CHECK_ERR_RET(ret, "disable cam_sensor_a2.8v");
/* VT_CAM_1.8V(VDDIO) */
regulator = regulator_get(NULL, "vt_cam_1.8v");
if (IS_ERR(regulator))
return -ENODEV;
if (regulator_is_enabled(regulator))
ret = regulator_force_disable(regulator);
regulator_put(regulator);
CAM_CHECK_ERR_RET(ret, "disable vt_cam_1.8v");
gpio_free(GPIO_VT_CAM_nSTBY);
gpio_free(GPIO_CAM_VT_nRST);
gpio_free(GPIO_VT_CAM_ID);
return ret;
}
static int ts_power_off(void)
{
struct regulator *regulator;
regulator = regulator_get(NULL, "touch_avdd");
if (IS_ERR(regulator)) {
printk(KERN_ERR "[TSP]ts_power_off : regulator_get failed\n");
return -EIO;
}
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
/* CAUTION : EVT1 board has CHG_INT problem
* so it need a workaround code to ensure charging during sleep mode
*/
if (system_rev != 2) {
regulator = regulator_get(NULL, "touch_vdd_1.8v");
if (IS_ERR(regulator)) {
printk(KERN_ERR "[TSP]ts_power_on : regulator_get failed\n");
return -EIO;
}
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
}
/* touch interrupt pin */
s3c_gpio_cfgpin(GPIO_TOUCH_CHG, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_TOUCH_CHG, S3C_GPIO_PULL_NONE);
/* touch reset pin */
s3c_gpio_cfgpin(GPIO_TOUCH_RESET, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_TOUCH_RESET, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_TOUCH_RESET, 0);
/* touch xvdd en pin */
s3c_gpio_cfgpin(GPIO_TOUCH_EN, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_TOUCH_EN, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_TOUCH_EN, 0);
printk(KERN_ERR "mxt_power_off is finished\n");
return 0;
}
static void vibrator_work(struct work_struct *_work)
{
struct vibrator_drvdata *data =
container_of(_work, struct vibrator_drvdata, work);
printk(KERN_DEBUG "[VIB] time = %dms\n", data->timeout);
if (0 == data->timeout) {
if (!data->running)
return ;
regulator_force_disable(data->regulator);
pwm_disable(data->pwm);
i2c_max8997_hapticmotor(data, false);
if (data->pdata->motor_en)
data->pdata->motor_en(false);
data->running = false;
} else {
if (data->running)
return ;
if (data->pdata->motor_en)
data->pdata->motor_en(true);
i2c_max8997_hapticmotor(data, true);
pwm_config(data->pwm,
data->pdata->duty, data->pdata->period);
pwm_enable(data->pwm);
regulator_enable(data->regulator);
data->running = true;
}
}
int key_led_control(bool on)
{
struct regulator *regulator;
if (tsp_keyled_enabled == on)
return 0;
printk(KERN_DEBUG "[TSP] %s %s\n",
__func__, on ? "on" : "off");
regulator = regulator_get(NULL, "vtouch_3.3v");
if (IS_ERR(regulator))
return PTR_ERR(regulator);
if (on) {
regulator_enable(regulator);
} else {
if (regulator_is_enabled(regulator))
regulator_disable(regulator);
else
regulator_force_disable(regulator);
}
regulator_put(regulator);
tsp_keyled_enabled = on;
return 0;
}
static int vreg_diag_disable(int vreg_no)
{
printk(DIAG_LOG_06 "[%04d]:%s() start. vreg_no = %d\n", __LINE__,
__func__, vreg_no);
vreg_no -= 1;
if (!reg_store[vreg_no]) {
reg_store[vreg_no] = regulator_get(NULL, vreg_data[vreg_no].id);
if (IS_ERR(reg_store[vreg_no])) {
reg_store[vreg_no] = NULL;
printk(DIAG_LOG_01 "[%04d]:%s() ERR\n", __LINE__,
__func__);
return -ENODEV;
}
}
if (vreg_data[vreg_no].vreg_type != PMIC_VREG_VS) {
regulator_set_voltage(reg_store[vreg_no], 0,
vreg_data[vreg_no].max_uV);
regulator_force_disable(reg_store[vreg_no]);
}
else
regulator_disable(reg_store[vreg_no]);
regulator_put(reg_store[vreg_no]);
reg_store[vreg_no] = NULL;
reg_volt_set_check[vreg_no] = 0;
printk(DIAG_LOG_06 "[%04d]:%s() end.\n", __LINE__, __func__);
return 0;
}
static int touchkey_led_power_on(bool on)
{
#ifdef LED_LDO_WITH_REGULATOR
struct regulator *regulator;
if (on) {
regulator = regulator_get(NULL, TK_LED_REGULATOR_NAME);
if (IS_ERR(regulator)) {
printk(KERN_ERR
"[Touchkey] touchkey_led_power_on : TK_LED regulator_get failed\n");
return -EIO;
}
regulator_enable(regulator);
regulator_put(regulator);
} else {
regulator = regulator_get(NULL, TK_LED_REGULATOR_NAME);
if (IS_ERR(regulator)) {
printk(KERN_ERR
"[Touchkey] touchkey_led_power_on : TK_LED regulator_get failed\n");
return -EIO;
}
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
}
#else
if (on)
gpio_direction_output(GPIO_3_TOUCH_EN, 1);
else
gpio_direction_output(GPIO_3_TOUCH_EN, 0);
#endif
return 1;
}
int touchkey_ldo_on(bool on)
{
struct regulator *regulator;
if (on) {
regulator = regulator_get(NULL, "touch");
if (IS_ERR(regulator)){
printk(KERN_ERR "[TouchKey] touchkey_ldo_on(1): regulator error \n");
return 0;
}
regulator_enable(regulator);
regulator_put(regulator);
} else {
regulator = regulator_get(NULL, "touch");
if (IS_ERR(regulator)) {
printk(KERN_ERR "[TouchKey] touchkey_ldo_on(0): regulator error \n");
return 0;
}
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
}
return 1;
}
static int usi_bm01a_power_onoff(int onoff)
{
struct regulator* wifi_ldo = NULL;
static int first = 1;
#ifndef CONFIG_AW_AXP
usi_msg("AXP driver is disabled, pls check !!\n");
return 0;
#endif
usi_msg("usi_bm01a_power_onoff\n");
wifi_ldo = regulator_get(NULL, "axp20_pll");
if (!wifi_ldo)
usi_msg("Get power regulator failed\n");
if (first) {
usi_msg("first time\n");
regulator_force_disable(wifi_ldo);
first = 0;
}
if (onoff) {
usi_msg("regulator on\n");
regulator_set_voltage(wifi_ldo, 3300000, 3300000);
regulator_enable(wifi_ldo);
} else {
usi_msg("regulator off\n");
regulator_disable(wifi_ldo);
}
return 0;
}
static void pmic_safeout2(int onoff)
{
struct regulator *regulator;
regulator = regulator_get(NULL, "safeout2");
BUG_ON(IS_ERR_OR_NULL(regulator));
if (onoff) {
if (!regulator_is_enabled(regulator)) {
regulator_enable(regulator);
} else {
pr_err("%s: onoff:%d No change in safeout2\n",
__func__, onoff);
}
} else {
if (regulator_is_enabled(regulator)) {
regulator_force_disable(regulator);
} else {
pr_err("%s: onoff:%d No change in safeout2\n",
__func__, onoff);
}
}
regulator_put(regulator);
}
static int ts_led_power_on(bool on)
{
struct regulator *regulator;
if (on) {
regulator = regulator_get(NULL, "key_led_3.3v");
if (IS_ERR(regulator)) {
printk(KERN_ERR "[TSP_KEY] ts_led_power_on : TK_LED regulator_get failed\n");
return -EIO;
}
regulator_enable(regulator);
regulator_put(regulator);
} else {
regulator = regulator_get(NULL, "key_led_3.3v");
if (IS_ERR(regulator)) {
printk(KERN_ERR "[TSP_KEY] ts_led_power_on : TK_LED regulator_get failed\n");
return -EIO;
}
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
}
printk(KERN_ERR "[TSP_KEY] %s %s\n", __func__, on ? "on" : "off");
return 0;
}
static void vibrator_work(struct work_struct *_work)
{
struct vibrator_drvdata *data =
container_of(_work, struct vibrator_drvdata, work);
pr_debug("[VIB] time = %dms\n", data->timeout);
if (0 == data->timeout) {
if (!data->running)
return ;
pwm_disable(data->pwm);
i2c_max8997_hapticmotor(data, false);
if (data->pdata->motor_en)
data->pdata->motor_en(false);
else
regulator_force_disable(data->regulator);
data->running = false;
} else {
if (data->running)
return ;
if (data->pdata->motor_en)
data->pdata->motor_en(true);
else
regulator_enable(data->regulator);
i2c_max8997_hapticmotor(data, true);
pwm_config(data->pwm, pwm_duty, data->pdata->period);
pr_info("[VIB] %s: pwm_config duty=%d\n", __func__, pwm_duty);
pwm_enable(data->pwm);
data->running = true;
}
}
int wacom_power(bool on)
{
#ifdef GPIO_PEN_LDO_EN
gpio_direction_output(GPIO_PEN_LDO_EN, on);
#else
struct regulator *regulator_vdd;
if (wacom_power_enabled == on) {
printk(KERN_DEBUG "epen: %s %s\n",
__func__, on ? "on" : "off");
return 0;
}
regulator_vdd = regulator_get(NULL, "wacom_3.0v");
if (IS_ERR(regulator_vdd)) {
printk(KERN_ERR"epen: %s reg get err\n", __func__);
return PTR_ERR(regulator_vdd);
}
if (on) {
regulator_enable(regulator_vdd);
} else {
if (regulator_is_enabled(regulator_vdd))
regulator_disable(regulator_vdd);
else
regulator_force_disable(regulator_vdd);
}
regulator_put(regulator_vdd);
printk(KERN_DEBUG "epen: %s %s\n",
__func__, on ? "on" : "off");
wacom_power_enabled = on;
#endif
return 0;
}
void vibtonz_en(bool en)
{
struct vibrator_drvdata *data = g_data;
if (en) {
if (data->running)
return ;
if (data->pdata->motor_en)
data->pdata->motor_en(true);
else
regulator_enable(data->regulator);
i2c_max8997_hapticmotor(data, true);
pwm_enable(data->pwm);
data->running = true;
} else {
if (!data->running)
return ;
pwm_disable(data->pwm);
i2c_max8997_hapticmotor(data, false);
if (data->pdata->motor_en)
data->pdata->motor_en(false);
else
regulator_force_disable(data->regulator);
data->running = false;
}
}
static int lcd_power_on(struct lcd_device *ld, int enable)
{
struct regulator *regulator;
if (ld == NULL) {
printk(KERN_ERR "lcd device object is NULL.\n");
return 0;
}
if (enable) {
regulator = regulator_get(NULL, "vlcd_3.0v");
if (IS_ERR(regulator))
return 0;
regulator_enable(regulator);
regulator_put(regulator);
} else {
regulator = regulator_get(NULL, "vlcd_3.0v");
if (IS_ERR(regulator))
return 0;
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
}
return 1;
}
static int mxt_power_off(void)
{
struct regulator *regulator;
#if defined(TSP_DEBUG_LOG)
printk(KERN_DEBUG "[TSP] %s\n", __func__);
#endif
gpio_set_value(GPIO_TOUCH_RESET, 0);
/* disable XVDD */
gpio_set_value(GPIO_TOUCH_EN, 0);
usleep_range(3000, 3000);
gpio_set_value(GPIO_TOUCH_EN_1, 0);
usleep_range(3000, 3000);
/* disable I2C pullup */
regulator = regulator_get(NULL, "tsp_vdd_1.8v");
if (IS_ERR(regulator)) {
printk(KERN_ERR "[TSP] %s : regulator_get failed\n",
__func__);
return -EIO;
}
if (regulator_is_enabled(regulator))
regulator_disable(regulator);
else
regulator_force_disable(regulator);
regulator_put(regulator);
/* touch interrupt pin */
s3c_gpio_cfgpin(GPIO_TOUCH_CHG, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_TOUCH_CHG, S3C_GPIO_PULL_NONE);
return 0;
}
static int ts_led_power_on(bool on)
{
struct regulator *regulator;
if (on) {
regulator = regulator_get(NULL, "touchkey_led");
if (IS_ERR(regulator)) {
printk(KERN_ERR "[TSP_KEY] ts_led_power_on : TK_LED regulator_get failed\n");
return -EIO;
}
regulator_enable(regulator);
regulator_put(regulator);
} else {
regulator = regulator_get(NULL, "touchkey_led");
if (IS_ERR(regulator)) {
printk(KERN_ERR "[TSP_KEY] ts_led_power_on : TK_LED regulator_get failed\n");
return -EIO;
}
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
}
return 0;
}
static int rtl8723as_module_power(int onoff)
{
struct regulator* wifi_ldo = NULL;
static int first = 1;
int ret = 0;
rtl8723as_msg("rtl8723as module power set by axp.\n");
wifi_ldo = regulator_get(NULL, axp_name);
if (!wifi_ldo) {
rtl8723as_msg("get power regulator failed.\n");
return -ret;
}
if (first) {
rtl8723as_msg("first time\n");
ret = regulator_force_disable(wifi_ldo);
if (ret < 0) {
rtl8723as_msg("regulator_force_disable fail, return %d.\n", ret);
regulator_put(wifi_ldo);
return ret;
}
regulator_put(wifi_ldo);
first = 0;
return ret;
}
if (onoff) {
if (axp_power_on == false) {
rtl8723as_msg("regulator on.\n");
ret = regulator_set_voltage(wifi_ldo, 3300000, 3300000);
if (ret < 0) {
rtl8723as_msg("regulator_set_voltage fail, return %d.\n", ret);
regulator_put(wifi_ldo);
return ret;
}
ret = regulator_enable(wifi_ldo);
if (ret < 0) {
rtl8723as_msg("regulator_enable fail, return %d.\n", ret);
regulator_put(wifi_ldo);
return ret;
}
axp_power_on = true;
}
} else {
if (axp_power_on == true) {
rtl8723as_msg("regulator off.\n");
ret = regulator_disable(wifi_ldo);
if (ret < 0) {
rtl8723as_msg("regulator_disable fail, return %d.\n", ret);
regulator_put(wifi_ldo);
return ret;
}
axp_power_on = false;
}
}
regulator_put(wifi_ldo);
return ret;
}
static int lcd_power_on(void *ld, int enable)
{
struct regulator *regulator;
int err;
printk(KERN_INFO "%s : enable=%d\n", __func__, enable);
err = gpio_request(GPIO_LCD_BL_EN, "LCD_BL_EN");
if (err) {
printk(KERN_ERR "failed to request GPF0[5] for "
"LCD_BL_EN control\n");
return -EPERM;
}
err = gpio_request(GPIO_MLCD_RST, "MLCD_RST");
if (err) {
printk(KERN_ERR "failed to request GPY4[5] for "
"MLCD_RST control\n");
return -EPERM;
}
err = gpio_request(GPIO_LCD_22V_EN_00, "LCD_EN");
if (err) {
printk(KERN_ERR "failed to request GPM4[4] for "
"LCD_2.2V_EN control\n");
return -EPERM;
}
if (enable) {
gpio_set_value(GPIO_LCD_22V_EN_00, GPIO_LEVEL_HIGH);
msleep(25);
regulator = regulator_get(NULL, "vlcd_3.3v");
if (IS_ERR(regulator))
goto out;
regulator_enable(regulator);
regulator_put(regulator);
gpio_set_value(GPIO_LCD_BL_EN, 1);
} else {
regulator = regulator_get(NULL, "vlcd_3.3v");
if (IS_ERR(regulator))
goto out;
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
gpio_set_value(GPIO_LCD_22V_EN_00, GPIO_LEVEL_LOW);
gpio_set_value(GPIO_MLCD_RST, 0);
gpio_set_value(GPIO_LCD_BL_EN, 0);
}
out:
/* Release GPIO */
gpio_free(GPIO_MLCD_RST);
gpio_free(GPIO_LCD_22V_EN_00);
gpio_free(GPIO_LCD_BL_EN);
return 0;
}
static int set_vibetonz(int timeout)
{
#ifndef CONFIG_MACH_Q1_REV02
struct regulator *regulator;
#endif
if (!timeout) {
vibe_control_max8997(Immvib_pwm, 0);
if (regulator_hapticmotor_enabled == 1) {
#ifdef CONFIG_MACH_Q1_REV02
gpio_direction_output(GPIO_MOTOR_EN, 0);
#else
regulator = regulator_get(NULL, "vmotor");
if (IS_ERR(regulator)) {
DbgOut((KERN_ERR "Failed to get vmoter regulator.\n"));
return 0;
}
regulator_force_disable(regulator);
regulator_put(regulator);
regulator_hapticmotor_enabled = 0;
#endif
DbgOut((KERN_INFO "tspdrv: DISABLE\n"));
wake_unlock(&vib_wake_lock);
}
} else {
wake_lock(&vib_wake_lock);
_pwm_config(Immvib_pwm, VIBRATOR_DUTY, VIBRATOR_PERIOD);
vibe_control_max8997(Immvib_pwm, 1);
#ifdef CONFIG_MACH_Q1_REV02
gpio_direction_output(GPIO_MOTOR_EN, 1);
#else
regulator = regulator_get(NULL, "vmotor");
if (IS_ERR(regulator)) {
DbgOut((KERN_ERR "Failed to get vmoter regulator.\n"));
return 0;
}
regulator_enable(regulator);
regulator_put(regulator);
#endif
regulator_hapticmotor_enabled = 1;
DbgOut((KERN_INFO "tspdrv: ENABLE\n"));
}
vibrator_value = timeout;
printk(KERN_DEBUG "tspdrv: %s (%d)\n", __func__, regulator_hapticmotor_enabled);
return 0;
}
int a6xx_gmu_reset(struct a6xx_gpu *a6xx_gpu)
{
struct a6xx_gmu *gmu = &a6xx_gpu->gmu;
int ret;
u32 val;
/* Flush all the queues */
a6xx_hfi_stop(gmu);
/* Stop the interrupts */
a6xx_gmu_irq_disable(gmu);
/* Force off SPTP in case the GMU is managing it */
a6xx_sptprac_disable(gmu);
/* Make sure there are no outstanding RPMh votes */
gmu_poll_timeout(gmu, REG_A6XX_RSCC_TCS0_DRV0_STATUS, val,
(val & 1), 100, 10000);
gmu_poll_timeout(gmu, REG_A6XX_RSCC_TCS1_DRV0_STATUS, val,
(val & 1), 100, 10000);
gmu_poll_timeout(gmu, REG_A6XX_RSCC_TCS2_DRV0_STATUS, val,
(val & 1), 100, 10000);
gmu_poll_timeout(gmu, REG_A6XX_RSCC_TCS3_DRV0_STATUS, val,
(val & 1), 100, 1000);
/* Force off the GX GSDC */
regulator_force_disable(gmu->gx);
/* Disable the resources */
clk_bulk_disable_unprepare(gmu->nr_clocks, gmu->clocks);
pm_runtime_put_sync(gmu->dev);
/* Re-enable the resources */
pm_runtime_get_sync(gmu->dev);
/* Use a known rate to bring up the GMU */
clk_set_rate(gmu->core_clk, 200000000);
ret = clk_bulk_prepare_enable(gmu->nr_clocks, gmu->clocks);
if (ret)
goto out;
a6xx_gmu_irq_enable(gmu);
ret = a6xx_gmu_fw_start(gmu, GMU_RESET);
if (!ret)
ret = a6xx_hfi_start(gmu, GMU_COLD_BOOT);
/* Set the GPU back to the highest power frequency */
a6xx_gmu_set_freq(gmu, gmu->nr_gpu_freqs - 1);
out:
if (ret)
a6xx_gmu_clear_oob(gmu, GMU_OOB_BOOT_SLUMBER);
return ret;
}
static int hisi_pmic_sdcard_ocp_handler(char *power_name)
{
static struct regulator *power_sd = NULL;
static struct regulator *power_sdio = NULL;
int ret = 0;
if (NULL == power_sd) {
power_sd = regulator_get(NULL, SUPPLY_SD);
if (IS_ERR(power_sd)) {
pr_err("[%s]sd regulator found.\n", __func__);
return ENODEV;
}
}
if (IS_ERR(power_sd)) {
pr_err("[%s]sd regulator found.\n", __func__);
return ENODEV;
}
ret = regulator_force_disable(power_sd);
if (ret) {
pr_err("[%s]disable sd regulator error.\n", __func__);
return ret;
}
if (NULL == power_sdio) {
power_sdio = regulator_get(NULL, SUPPLY_SD_IO);
if (IS_ERR(power_sdio)) {
pr_err("[%s]sdio regulator found.\n", __func__);
return ENODEV;
}
}
if (IS_ERR(power_sdio)) {
pr_err("[%s]sdio regulator found.\n", __func__);
return ENODEV;
}
ret = regulator_force_disable(power_sdio);
if (ret) {
pr_err("[%s]disable sdio regulator error.\n", __func__);
return ret;
}
return ret;
}
static int set_vibetonz(int timeout)
{
struct regulator *regulator;
if (!timeout) {
vibe_control_max8997(Immvib_pwm, 0);
if (regulator_hapticmotor_enabled == 1) {
regulator = regulator_get(NULL, "vmotor");
if (IS_ERR(regulator)) {
DbgOut((KERN_ERR "Failed to get vmoter regulator.\n"));
return 0;
}
regulator_force_disable(regulator);
regulator_put(regulator);
regulator_hapticmotor_enabled = 0;
DbgOut((KERN_INFO "tspdrv: DISABLE\n"));
wake_unlock(&vib_wake_lock);
}
} else {
wake_lock(&vib_wake_lock);
#if defined(CONFIG_BUILD_TARGET_CM7)
_pwm_config(Immvib_pwm, vibrator_duty_levels[vibrator_level], VIBRATOR_PERIOD);
#else
_pwm_config(Immvib_pwm, VIBRATOR_DUTY, VIBRATOR_PERIOD);
#endif
vibe_control_max8997(Immvib_pwm, 1);
regulator = regulator_get(NULL, "vmotor");
if (IS_ERR(regulator)) {
DbgOut((KERN_ERR "Failed to get vmoter regulator.\n"));
return 0;
}
regulator_enable(regulator);
regulator_put(regulator);
regulator_hapticmotor_enabled = 1;
DbgOut((KERN_INFO "tspdrv: ENABLE\n"));
}
vibrator_value = timeout;
printk(KERN_DEBUG "tspdrv: %s (%d)\n", __func__, regulator_hapticmotor_enabled);
return 0;
}
int melfas_power(bool on)
{
struct regulator *regulator_vdd;
struct regulator *regulator_pullup;
if (tsp_power_enabled == on)
return 0;
printk(KERN_DEBUG "[TSP] %s %s\n",
__func__, on ? "on" : "off");
regulator_vdd = regulator_get(NULL, "tsp_vdd_3.3v");
if (IS_ERR(regulator_vdd))
return PTR_ERR(regulator_vdd);
regulator_pullup = regulator_get(NULL, "tsp_vdd_1.8v");
if (IS_ERR(regulator_pullup))
return PTR_ERR(regulator_pullup);
if (on) {
regulator_enable(regulator_vdd);
usleep_range(2500, 3000);
regulator_enable(regulator_pullup);
} else {
if (regulator_is_enabled(regulator_vdd))
regulator_disable(regulator_vdd);
else
regulator_force_disable(regulator_vdd);
if (regulator_is_enabled(regulator_pullup))
regulator_disable(regulator_pullup);
else
regulator_force_disable(regulator_pullup);
}
regulator_put(regulator_vdd);
regulator_put(regulator_pullup);
tsp_power_enabled = on;
return 0;
}
int max77693_muic_set_safeout(int path)
{
struct regulator *regulator;
MUIC_PRINT_LOG();
pr_info("MUIC safeout path=%d\n", path);
if (path == CP_USB_MODE) {
regulator = regulator_get(NULL, "safeout1");
if (IS_ERR(regulator))
return -ENODEV;
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
regulator = regulator_get(NULL, "safeout2");
if (IS_ERR(regulator))
return -ENODEV;
if (!regulator_is_enabled(regulator))
regulator_enable(regulator);
regulator_put(regulator);
} else {
/* AP_USB_MODE || AUDIO_MODE */
regulator = regulator_get(NULL, "safeout1");
if (IS_ERR(regulator))
return -ENODEV;
if (!regulator_is_enabled(regulator))
regulator_enable(regulator);
regulator_put(regulator);
regulator = regulator_get(NULL, "safeout2");
if (IS_ERR(regulator))
return -ENODEV;
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
}
return 0;
}
// power control by axp
static int ap6xxx_module_power(int onoff)
{
struct regulator* wifi_ldo = NULL;
static int first = 1;
int ret = 0;
ap6xxx_msg("ap6xxx module power set by axp.\n");
wifi_ldo = regulator_get(NULL, axp_name);
if (!wifi_ldo) {
ap6xxx_msg("get power regulator failed.\n");
return -ret;
}
if (first) {
ap6xxx_msg("first time\n");
ret = regulator_force_disable(wifi_ldo);
if (ret < 0) {
ap6xxx_msg("regulator_force_disable fail, return %d.\n", ret);
regulator_put(wifi_ldo);
return ret;
}
first = 0;
}
if (onoff) {
ap6xxx_msg("regulator on.\n");
ret = regulator_set_voltage(wifi_ldo, 3300000, 3300000);
if (ret < 0) {
ap6xxx_msg("regulator_set_voltage fail, return %d.\n", ret);
regulator_put(wifi_ldo);
return ret;
}
ret = regulator_enable(wifi_ldo);
if (ret < 0) {
ap6xxx_msg("regulator_enable fail, return %d.\n", ret);
regulator_put(wifi_ldo);
return ret;
}
} else {
ap6xxx_msg("regulator off.\n");
ret = regulator_disable(wifi_ldo);
if (ret < 0) {
ap6xxx_msg("regulator_disable fail, return %d.\n", ret);
regulator_put(wifi_ldo);
return ret;
}
}
regulator_put(wifi_ldo);
return ret;
}
static int archos_camera_glue_probe(struct platform_device * pdev)
{
cam_vdd = regulator_get(&pdev->dev, "cam_vdd");
if (IS_ERR(cam_vdd)) {
dev_err(&pdev->dev, "no cam_vdd rail, abort.\n");
return -ENODEV;
}
regulator_force_disable(cam_vdd);
cam_1v8 = regulator_get(&pdev->dev, "cam_1v8");
if (IS_ERR(cam_1v8))
dev_info(&pdev->dev, "no cam_1v8 rail, skip.\n");
else
regulator_force_disable(cam_1v8);
// assert that power rails are low
msleep(20);
enable(1);
return 0;
}
int max77803_muic_set_safeout(int path)
{
struct regulator *regulator;
if (path == CP_USB_MODE) {
regulator = regulator_get(NULL, "safeout1");
if (IS_ERR(regulator))
return -ENODEV;
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
regulator = regulator_get(NULL, "safeout2");
if (IS_ERR(regulator))
return -ENODEV;
if (!regulator_is_enabled(regulator))
regulator_enable(regulator);
regulator_put(regulator);
} else {
/* AP_USB_MODE || AUDIO_MODE */
regulator = regulator_get(NULL, "safeout1");
if (IS_ERR(regulator))
return -ENODEV;
if (!regulator_is_enabled(regulator))
regulator_enable(regulator);
regulator_put(regulator);
regulator = regulator_get(NULL, "safeout2");
if (IS_ERR(regulator))
return -ENODEV;
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
regulator_put(regulator);
}
return 0;
}
static ssize_t u1_switch_store_vbus(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int disable, ret, usb_mode;
struct regulator *regulator;
/* struct s3c_udc *udc = platform_get_drvdata(&s3c_device_usbgadget); */
MUIC_PRINT_LOG();
if (!strncmp(buf, "0", 1))
disable = 0;
else if (!strncmp(buf, "1", 1))
disable = 1;
else {
pr_warn("%s: Wrong command\n", __func__);
return count;
}
pr_info("%s: disable=%d\n", __func__, disable);
usb_mode =
disable ? USB_CABLE_DETACHED_WITHOUT_NOTI : USB_CABLE_ATTACHED;
/* ret = udc->change_usb_mode(usb_mode); */
ret = -1;
if (ret < 0)
pr_err("%s: fail to change mode!!!\n", __func__);
regulator = regulator_get(NULL, "safeout1");
if (IS_ERR(regulator)) {
pr_warn("%s: fail to get regulator\n", __func__);
return count;
}
if (disable) {
if (regulator_is_enabled(regulator))
regulator_force_disable(regulator);
if (!regulator_is_enabled(regulator))
regulator_enable(regulator);
} else {
if (!regulator_is_enabled(regulator))
regulator_enable(regulator);
}
regulator_put(regulator);
return count;
}
static void irda_vdd_onoff(bool onoff)
{
static struct regulator *vled_ic;
if (onoff) {
vled_ic = regulator_get(NULL, "vled_ic_1.9v");
if (IS_ERR(vled_ic)) {
pr_err("could not get regulator vled_ic_1.9v\n");
return;
}
regulator_enable(vled_ic);
vled_ic_onoff = 1;
} else if (vled_ic_onoff == 1) {
regulator_force_disable(vled_ic);
regulator_put(vled_ic);
vled_ic_onoff = 0;
}
}
