static int32_t msm_camera_8960_ext_power_ctrl(int enable)
{
int rc = 0;
if (enable) {
rc = pm8xxx_mpp_config(PM8921_MPP_PM_TO_SYS(12),
&privacy_light_on_config);
} else {
rc = pm8xxx_mpp_config(PM8921_MPP_PM_TO_SYS(12),
&privacy_light_off_config);
}
return rc;
}
void active_reset(int high)
{
if (high) {
pm8xxx_mpp_config(
PM8921_MPP_PM_TO_SYS(MLCD_RST_MPP2),
&MLCD_RESET_HIGH_CONFIG);
} else {
pm8xxx_mpp_config(
PM8921_MPP_PM_TO_SYS(MLCD_RST_MPP2),
&MLCD_RESET_LOW_CONFIG);
}
}
void power_on_flash(void)
{
int temp = 0;
int ret = 0;
if(!isFlashCntlEn) {
temp = gpio_get_value(GPIO_MSM_FLASH_NOW);
if (isFlashCntlEn == 0 && temp == 0) {
/* FLASH_LED_UNLOCK*/
gpio_set_value_cansleep(PM8921_MPP_PM_TO_SYS
(PMIC_MPP_FLASH_LED_UNLOCK), 1);
/* GPIO_CAM_FLASH_SW : tourch */
gpio_set_value_cansleep(gpio_cam_flash_sw, 1);
temp = gpio_get_value(gpio_cam_flash_sw);
printk("[s5c73m3] check GPIO_CAM_FLASH_SW : %d\n", temp);
usleep(1*1000);
}
/* flash power 1.8V */
l28 = regulator_get(NULL, "8921_lvs4");
ret = regulator_enable(l28);
if (ret)
printk("error enabling regulator\n");
usleep(1*1000);
isFlashCntlEn = true;
}
}
static int mipi_dsi_power_octa_request(void)
{
int rc = 0;
reg_L30 = regulator_get(&msm_mipi_dsi1_device.dev,
"3000mV_LCD");
if (IS_ERR_OR_NULL(reg_L30)) {
pr_err("could not get 8917_L30, rc = %ld\n",
PTR_ERR(reg_L30));
return -ENODEV;
}
rc = regulator_set_voltage(reg_L30, 3000000, 3000000);
if (rc) {
pr_err("set_voltage L30 failed, rc=%d\n", rc);
return -EINVAL;
}
pm8xxx_mpp_config(PM8921_MPP_PM_TO_SYS(MLCD_RST_MPP2),
&MLCD_RESET_LOW_CONFIG);
msleep(100);
return rc;
}
static bool sec_fg_gpio_init(void)
{
struct pm_gpio param = {
.direction = PM_GPIO_DIR_IN,
.pull = PM_GPIO_PULL_NO,
.vin_sel = PM_GPIO_VIN_S4,
.function = PM_GPIO_FUNC_NORMAL,
};
/* FUEL_ALERT Setting */
if (system_rev == 0x0) {
sec_battery_pdata.fg_irq = PM8921_GPIO_IRQ(PM8921_IRQ_BASE,
GPIO_FUEL_INT_04A);
pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(GPIO_FUEL_INT_04A),
¶m);
#if defined(CONFIG_MACH_JF_ATT) || defined(CONFIG_MACH_JF_TMO)
} else if (system_rev >= 8) {
#else
} else if (system_rev >= 9) {
#endif
/* FUEL_ALERT Registration */
struct pm8xxx_mpp_config_data fuel_alert_mppcfg = {
.type = PM8XXX_MPP_TYPE_D_INPUT,
.level = PM8921_MPP_DIG_LEVEL_S4,
.control = PM8XXX_MPP_DOUT_CTRL_LOW,
};
sec_battery_pdata.fg_irq = PM8921_MPP_IRQ(PM8921_IRQ_BASE, 6);
pm8xxx_mpp_config(PM8921_MPP_PM_TO_SYS(6),
&fuel_alert_mppcfg);
}
else
static int aat1290a_freeGpio(void)
{
int ret;
printk(KERN_DEBUG "[%s : %d]!!\n", __func__, __LINE__);
if (pmic_gpio_msm_flash_cntl_en)
gpio_set_value_cansleep(pmic_gpio_msm_flash_cntl_en, 0);
else
gpio_set_value_cansleep(GPIO_MSM_FLASH_CNTL_EN, 0);
isFlashCntlEn = false;
usleep(1*1000);
gpio_set_value_cansleep(GPIO_MSM_FLASH_NOW, 0);
usleep(1*1000);
/* flash power 1.8V */
if (l28) {
ret = regulator_disable(l28);
if (ret)
cam_err("error disabling regulator\n");
}
usleep(1*1000);
/* GPIO_CAM_FLASH_SW : tourch */
gpio_set_value_cansleep(gpio_cam_flash_sw, 0);
usleep(1*1000);
#if defined(CONFIG_S5C73M3) && defined(CONFIG_S5K6A3YX) /* D2 */
/* FLASH_LED_LOCK*/
gpio_set_value_cansleep(PM8921_MPP_PM_TO_SYS
(PMIC_MPP_FLASH_LED_UNLOCK), 0);
#endif
return 0;
}
static void m7wl_audio_pmic_mpp_config(void)
{
unsigned ret;
struct pm8xxx_mpp_config_data m7wl_audio_pmic_mpp = {
.type = PM8XXX_MPP_TYPE_D_OUTPUT,
.level = PM8921_MPP_DIG_LEVEL_S4,
.control = PM8XXX_MPP_DOUT_CTRL_LOW,
};
ret = pm8xxx_mpp_config(PM8921_MPP_PM_TO_SYS(9),
&m7wl_audio_pmic_mpp);
if (ret < 0)
pr_err("%s:MPP_9 configuration failed\n", __func__);
}
static int aat1290a_setGpio(void)
{
int ret;
int temp = 0;
printk(KERN_DEBUG "[%s : %d]!!\n", __func__, __LINE__);
#if defined(CONFIG_S5C73M3) && defined(CONFIG_S5K6A3YX) /* D2 */
/* FLASH_LED_UNLOCK*/
gpio_set_value_cansleep(PM8921_MPP_PM_TO_SYS
(PMIC_MPP_FLASH_LED_UNLOCK), 1);
#endif
/* GPIO_CAM_FLASH_SW : tourch */
gpio_set_value_cansleep(gpio_cam_flash_sw, 0);
temp = gpio_get_value(gpio_cam_flash_sw);
printk(KERN_DEBUG "[s5c73m3] check GPIO_CAM_FLASH_SW : %d\n", temp);
usleep(1*1000);
/* flash power 1.8V */
l28 = regulator_get(NULL, "8921_lvs4");
ret = regulator_enable(l28);
if (ret)
cam_err("error enabling regulator\n");
usleep(1*1000);
if (pmic_gpio_msm_flash_cntl_en) {
gpio_set_value_cansleep(pmic_gpio_msm_flash_cntl_en, 1);
} else {
gpio_set_value_cansleep(GPIO_MSM_FLASH_CNTL_EN, 1);
temp = gpio_get_value(GPIO_MSM_FLASH_CNTL_EN);
printk(KERN_DEBUG "[s5c73m3] check Flash set GPIO : %d\n",
temp);
}
isFlashCntlEn = true;
usleep(1*1000);
gpio_set_value_cansleep(GPIO_MSM_FLASH_NOW, 1);
temp = gpio_get_value(GPIO_MSM_FLASH_NOW);
printk(KERN_DEBUG "[s5c73m3] check Flash enable GPIO : %d\n", temp);
usleep(1*1000);
return 0;
}
.consumer_supplies = vreg_consumers_##_id##_PC, \
.supply_regulator = _supply_regulator, \
}, \
.id = RPM_VREG_ID_PM8921_##_id##_PC, \
.pin_fn = RPM_VREG_PIN_FN_8960_##_pin_fn, \
.pin_ctrl = _pin_ctrl, \
}
/* GPIO regulator constraints.
* Must be in sync with corresponding platform_device structures in
* board_sony_fusion3.c
*/
struct gpio_regulator_platform_data
apq8064_gpio_regulator_pdata[] __devinitdata = {
/* ID vreg_name gpio_label gpio supply active_low*/
GPIO_VREG(EXT_5V, "ext_5v", "ext_5v_en", PM8921_MPP_PM_TO_SYS(7),
NULL, 0),
GPIO_VREG(EXT_SD_PWR, "ext_sd_pwr", "ext_sd_pwr_en",
PM8921_MPP_PM_TO_SYS(4), "8921_l6", 0),
GPIO_VREG(EXT_OTG_SW, "ext_otg_sw", "ext_otg_sw_en",
PM8921_GPIO_PM_TO_SYS(42), NULL, 1),
};
/* SAW regulator constraints */
struct regulator_init_data msm8064_saw_regulator_pdata_8921_s5 =
/* ID vreg_name min_uV max_uV */
SAW_VREG_INIT(S5, "8921_s5", 850000, 1300000);
struct regulator_init_data msm8064_saw_regulator_pdata_8921_s6 =
SAW_VREG_INIT(S6, "8921_s6", 850000, 1300000);
struct regulator_init_data msm8064_saw_regulator_pdata_8821_s0 =
.settings = {
[GPIOMUX_SUSPENDED] = &gpio_spi_cs2_config,
},
},
{
.gpio = 54, /* GSBI5 QUP SPI_CLK */
.settings = {
[GPIOMUX_SUSPENDED] = &gpio_spi_config,
},
},
#endif
};
static struct pm8xxx_mpp_platform_data
apq8064_pm8921_mpp_pdata __devinitdata = {
.mpp_base = PM8921_MPP_PM_TO_SYS(1),
};
static struct pm8xxx_gpio_platform_data
apq8064_pm8921_gpio_pdata __devinitdata = {
.gpio_base = PM8921_GPIO_PM_TO_SYS(1),
};
static struct pm8xxx_irq_platform_data
apq8064_pm8921_irq_pdata __devinitdata = {
.irq_base = PM8921_IRQ_BASE,
.devirq = PM8921_USR_IRQ_N,
.irq_trigger_flag = IRQF_TRIGGER_HIGH,
.dev_id = 0,
};
.valid_ops_mask = REGULATOR_CHANGE_STATUS, \
.always_on = _always_on, \
}, \
.num_consumer_supplies = \
ARRAY_SIZE(vreg_consumers_##_id##_PC), \
.consumer_supplies = vreg_consumers_##_id##_PC, \
.supply_regulator = _supply_regulator, \
}, \
.id = RPM_VREG_ID_PM8921_##_id##_PC, \
.pin_fn = RPM_VREG_PIN_FN_8960_##_pin_fn, \
.pin_ctrl = _pin_ctrl, \
}
/* GPIO regulator constraints */
struct gpio_regulator_platform_data msm_gpio_regulator_pdata[] __devinitdata = {
GPIO_VREG_INIT(EXT_5V, "ext_5v", "ext_5v_en", PM8921_MPP_PM_TO_SYS(7)),
GPIO_VREG_INIT(EXT_L2, "ext_l2", "ext_l2_en", 91),
};
struct platform_device msm8960_device_ext_5v_vreg __devinitdata = {
.name = GPIO_REGULATOR_DEV_NAME,
.id = PM8921_MPP_PM_TO_SYS(7),
.dev = {
.platform_data = &msm_gpio_regulator_pdata[GPIO_VREG_ID_EXT_5V],
},
};
struct platform_device msm8960_device_ext_l2_vreg __devinitdata = {
.name = GPIO_REGULATOR_DEV_NAME,
.id = 91,
.dev = {
static int lvds_panel_power(int on)
{
static struct regulator *reg_lvs7, *reg_l2, *reg_ext_3p3v;
static int gpio36, gpio26, mpp3;
int rc;
pr_debug("%s: on=%d\n", __func__, on);
if (!lvds_power_on) {
reg_lvs7 = regulator_get(&msm_lvds_device.dev,
"lvds_vdda");
if (IS_ERR_OR_NULL(reg_lvs7)) {
pr_err("could not get 8921_lvs7, rc = %ld\n",
PTR_ERR(reg_lvs7));
return -ENODEV;
}
reg_l2 = regulator_get(&msm_lvds_device.dev,
"lvds_pll_vdda");
if (IS_ERR_OR_NULL(reg_l2)) {
pr_err("could not get 8921_l2, rc = %ld\n",
PTR_ERR(reg_l2));
return -ENODEV;
}
rc = regulator_set_voltage(reg_l2, 1200000, 1200000);
if (rc) {
pr_err("set_voltage l2 failed, rc=%d\n", rc);
return -EINVAL;
}
reg_ext_3p3v = regulator_get(&msm_lvds_device.dev,
"lvds_vccs_3p3v");
if (IS_ERR_OR_NULL(reg_ext_3p3v)) {
pr_err("could not get reg_ext_3p3v, rc = %ld\n",
PTR_ERR(reg_ext_3p3v));
return -ENODEV;
}
gpio26 = PM8921_GPIO_PM_TO_SYS(26);
rc = gpio_request(gpio26, "pwm_backlight_ctrl");
if (rc) {
pr_err("request gpio 26 failed, rc=%d\n", rc);
return -ENODEV;
}
gpio36 = PM8921_GPIO_PM_TO_SYS(36); /* lcd1_pwr_en_n */
rc = gpio_request(gpio36, "lcd1_pwr_en_n");
if (rc) {
pr_err("request gpio 36 failed, rc=%d\n", rc);
return -ENODEV;
}
mpp3 = PM8921_MPP_PM_TO_SYS(3);
rc = gpio_request(mpp3, "backlight_en");
if (rc) {
pr_err("request mpp3 failed, rc=%d\n", rc);
return -ENODEV;
}
lvds_power_on = true;
}
if (on) {
rc = regulator_enable(reg_lvs7);
if (rc) {
pr_err("enable lvs7 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_set_optimum_mode(reg_l2, 100000);
if (rc < 0) {
pr_err("set_optimum_mode l2 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_l2);
if (rc) {
pr_err("enable l2 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_enable(reg_ext_3p3v);
if (rc) {
pr_err("enable reg_ext_3p3v failed, rc=%d\n", rc);
return -ENODEV;
}
gpio_set_value_cansleep(gpio36, 0);
gpio_set_value_cansleep(mpp3, 1);
} else {
gpio_set_value_cansleep(mpp3, 0);
gpio_set_value_cansleep(gpio36, 1);
rc = regulator_disable(reg_lvs7);
if (rc) {
pr_err("disable reg_lvs7 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_disable(reg_l2);
if (rc) {
pr_err("disable reg_l2 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_disable(reg_ext_3p3v);
if (rc) {
pr_err("disable reg_ext_3p3v failed, rc=%d\n", rc);
return -ENODEV;
}
}
return 0;
}
/* OPPO 2013-07-4 Neal Modify begin for LCD */
int mipi_dsi_panel_power(int on)
{
/* OPPO 2012-08-31 zhengzk Modify begin for LCD */
static struct regulator *reg_lvs7, *reg_l2, *reg_l11, *reg_ext_3p3v;
static int gpio36, gpio25, mpp3;
#ifdef CONFIG_VENDOR_EDIT
static struct regulator *reg_l22;
#else
static int gpio26;
#endif
/* OPPO 2013-07-4 Neal Modify end*/
int rc;
pr_debug("%s: on=%d\n", __func__, on);
if (!dsi_power_on) {
reg_lvs7 = regulator_get(&msm_mipi_dsi1_device.dev,
"dsi1_vddio");
if (IS_ERR_OR_NULL(reg_lvs7)) {
pr_err("could not get 8921_lvs7, rc = %ld\n",
PTR_ERR(reg_lvs7));
return -ENODEV;
}
reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev,
"dsi1_pll_vdda");
if (IS_ERR_OR_NULL(reg_l2)) {
pr_err("could not get 8921_l2, rc = %ld\n",
PTR_ERR(reg_l2));
return -ENODEV;
}
rc = regulator_set_voltage(reg_l2, 1200000, 1200000);
if (rc) {
pr_err("set_voltage l2 failed, rc=%d\n", rc);
return -EINVAL;
}
reg_l11 = regulator_get(&msm_mipi_dsi1_device.dev,
"dsi1_avdd");
if (IS_ERR(reg_l11)) {
pr_err("could not get 8921_l11, rc = %ld\n",
PTR_ERR(reg_l11));
return -ENODEV;
}
/* OPPO 2012-08-31 zhengzk Modify begin for LCD */
#ifndef CONFIG_VENDOR_EDIT
rc = regulator_set_voltage(reg_l11, 3000000, 3000000);
#else
rc = regulator_set_voltage(reg_l11, 3100000, 3100000);
#endif
/* OPPO 2012-08-31 zhengzk Modify end */
if (rc) {
pr_err("set_voltage l11 failed, rc=%d\n", rc);
return -EINVAL;
}
/* OPPO 2012-08-31 zhengzk Add begin for LCD */
#ifdef CONFIG_VENDOR_EDIT
reg_l22 = regulator_get(NULL, "8921_l22");
if (IS_ERR(reg_l22)) {
pr_err("could not get 8921_l22, rc = %ld\n",
PTR_ERR(reg_l22));
return -ENODEV;
}
rc = regulator_set_voltage(reg_l22, 1800000, 1800000);
if (rc) {
pr_err("set_voltage l22 failed, rc=%d\n", rc);
return -EINVAL;
}
#endif
/* OPPO 2012-08-31 zhengzk Modify end */
if (machine_is_apq8064_liquid()) {
reg_ext_3p3v = regulator_get(&msm_mipi_dsi1_device.dev,
"dsi1_vccs_3p3v");
if (IS_ERR_OR_NULL(reg_ext_3p3v)) {
pr_err("could not get reg_ext_3p3v, rc = %ld\n",
PTR_ERR(reg_ext_3p3v));
reg_ext_3p3v = NULL;
return -ENODEV;
}
mpp3 = PM8921_MPP_PM_TO_SYS(3);
rc = gpio_request(mpp3, "backlight_en");
if (rc) {
pr_err("request mpp3 failed, rc=%d\n", rc);
return -ENODEV;
}
}
gpio25 = PM8921_GPIO_PM_TO_SYS(25);
rc = gpio_request(gpio25, "disp_rst_n");
if (rc) {
pr_err("request gpio 25 failed, rc=%d\n", rc);
return -ENODEV;
}
#ifndef CONFIG_VENDOR_EDIT
gpio26 = PM8921_GPIO_PM_TO_SYS(26);
rc = gpio_request(gpio26, "pwm_backlight_ctrl");
if (rc) {
pr_err("request gpio 26 failed, rc=%d\n", rc);
return -ENODEV;
}
#endif
gpio36 = PM8921_GPIO_PM_TO_SYS(36); /* lcd1_pwr_en_n */
rc = gpio_request(gpio36, "lcd1_pwr_en_n");
if (rc) {
pr_err("request gpio 36 failed, rc=%d\n", rc);
return -ENODEV;
}
#ifdef CONFIG_VENDOR_EDIT
rc = gpio_request(LCD_5V_EN_DVT, "lcd_5v_en");
if (rc) {
pr_err("request gpio 86 failed, rc=%d\n", rc);
return -ENODEV;
}
#endif
dsi_power_on = true;
}
if (on) {
rc = regulator_enable(reg_lvs7);
if (rc) {
pr_err("enable lvs7 failed, rc=%d\n", rc);
return -ENODEV;
}
/* OPPO 2012-08-31 zhengzk Add begin for LCD */
#ifdef CONFIG_VENDOR_EDIT
rc = regulator_enable(reg_l22); //1.8v
if (rc) {
pr_err("enable l22 failed, rc=%d\n", rc);
return -ENODEV;
}
mdelay(5);
/* OPPO 2012-08-31 zhengzk Modify end */
rc = gpio_direction_output(LCD_5V_EN_DVT, 1);//5v
if (rc) {
pr_err("%s: unable to enable LCD_5V_EN!!!!!!!!!!!!\n", __func__);
return -ENODEV;
}
mdelay(5);
gpio_set_value_cansleep(gpio36, 0);
gpio_set_value_cansleep(gpio25, 1);
mdelay(10);
#endif
rc = regulator_set_optimum_mode(reg_l11, 110000);
if (rc < 0) {
pr_err("set_optimum_mode l11 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_l11);
if (rc) {
pr_err("enable l11 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_set_optimum_mode(reg_l2, 100000);
if (rc < 0) {
pr_err("set_optimum_mode l2 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_l2);
if (rc) {
pr_err("enable l2 failed, rc=%d\n", rc);
return -ENODEV;
}
if (machine_is_apq8064_liquid()) {
rc = regulator_enable(reg_ext_3p3v);
if (rc) {
pr_err("enable reg_ext_3p3v failed, rc=%d\n",
rc);
return -ENODEV;
}
gpio_set_value_cansleep(mpp3, 1);
}
gpio_set_value_cansleep(gpio36, 0);
gpio_set_value_cansleep(gpio25, 1);
#ifndef CONFIG_VENDOR_EDIT
if (socinfo_get_pmic_model() == PMIC_MODEL_PM8917)
gpio_set_value_cansleep(gpio26, 1);
#endif
} else {
#ifndef CONFIG_VENDOR_EDIT
if (socinfo_get_pmic_model() == PMIC_MODEL_PM8917)
gpio_set_value_cansleep(gpio26, 0);
#endif
gpio_set_value_cansleep(gpio25, 0);
gpio_set_value_cansleep(gpio36, 1);
if (machine_is_apq8064_liquid()) {
gpio_set_value_cansleep(mpp3, 0);
rc = regulator_disable(reg_ext_3p3v);
if (rc) {
pr_err("disable reg_ext_3p3v failed, rc=%d\n",
rc);
return -ENODEV;
}
}
rc = regulator_disable(reg_l11);
if (rc) {
pr_err("disable reg_l1 failed, rc=%d\n", rc);
return -ENODEV;
}
#ifdef CONFIG_VENDOR_EDIT
rc = gpio_direction_output(LCD_5V_EN_DVT, 0);
if (rc) {
pr_err("%s: unable to enable LCD_5V_EN!!!!!!!!!!!!\n", __func__);
return -ENODEV;
}
/* OPPO 2012-08-31 zhengzk Add begin for LCD */
mdelay(10);
rc = regulator_disable(reg_l22);
if (rc) {
pr_err("disable reg_l22 failed, rc=%d\n", rc);
return -ENODEV;
}
/* OPPO 2012-08-31 zhengzk Modify end */
#endif
rc = regulator_disable(reg_lvs7);
if (rc) {
pr_err("disable reg_lvs7 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_disable(reg_l2);
if (rc) {
pr_err("disable reg_l2 failed, rc=%d\n", rc);
return -ENODEV;
}
}
return 0;
}
.num_consumer_supplies = \
ARRAY_SIZE(vreg_consumers_##_id##_PC), \
.consumer_supplies = vreg_consumers_##_id##_PC, \
.supply_regulator = _supply_regulator, \
}, \
.id = RPM_VREG_ID_PM8921_##_id##_PC, \
.pin_fn = RPM_VREG_PIN_FN_8960_##_pin_fn, \
.pin_ctrl = _pin_ctrl, \
}
/* GPIO regulator constraints */
struct gpio_regulator_platform_data
apq8064_gpio_regulator_pdata[] __devinitdata = {
/* ID vreg_name gpio_label gpio supply active_low */
GPIO_VREG(EXT_5V, "ext_5v", "ext_5v_en",
PM8921_MPP_PM_TO_SYS(7), NULL, 0),
GPIO_VREG(EXT_3P3V, "ext_3p3v", "ext_3p3v_en",
APQ8064_EXT_3P3V_REG_EN_GPIO, NULL, 0),
GPIO_VREG(EXT_TS_SW, "ext_ts_sw", "ext_ts_sw_en",
PM8921_GPIO_PM_TO_SYS(23), "ext_3p3v", 0),
GPIO_VREG(EXT_MPP8, "ext_mpp8", "ext_mpp8_en",
PM8921_MPP_PM_TO_SYS(8), NULL, 0),
GPIO_VREG(EXT_SATA_PWR, "ext_sata_pwr", "ext_sata_pwr_en",
PM8921_MPP_PM_TO_SYS(4), "ext_3p3v", 1),
};
struct gpio_regulator_platform_data
mpq8064_gpio_regulator_pdata[] __devinitdata = {
GPIO_VREG(AVC_1P2V, "avc_1p2v", "avc_1p2v_en",
SX150X_GPIO(4, 2), NULL, 0),
GPIO_VREG(AVC_1P8V, "avc_1p8v", "avc_1p8v_en",
static int mipi_panel_power_tft(int enable)
{
int rc = 0;
#if defined(CONFIG_MACH_JACTIVE_ATT)
if(first_boot < 2) {
first_boot++;
printk("<0> First init Occurred ..... Finished Successfully \n");
return 0;
}
#endif
pr_info("%s %d", __func__, enable);
if (enable) {
#if defined(CONFIG_MACH_JACTIVE_EUR)
rc = regulator_set_optimum_mode(reg_LVS1, 100000); /*IOVDD */
if (rc < 0) {
pr_err("set_optimum_mode LVS1 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_LVS1);
if (rc) {
pr_err("enable LVS1 failed, rc=%d\n", rc);
return -ENODEV;
}
#elif defined(CONFIG_MACH_JACTIVE)
if (system_rev >= 11) {
rc = regulator_set_optimum_mode(reg_LVS1, 100000); /*IOVDD */
if (rc < 0) {
pr_err("set_optimum_mode LVS1 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_LVS1);
if (rc) {
pr_err("enable LVS1 failed, rc=%d\n", rc);
return -ENODEV;
}
}
#endif
rc = regulator_set_optimum_mode(reg_L15, 100000); /*IOVDD */
if (rc < 0) {
pr_err("set_optimum_mode L15 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_L15);
if (rc) {
pr_err("enable L15 failed, rc=%d\n", rc);
return -ENODEV;
}
#if defined(CONFIG_MACH_JACTIVE_ATT)
if(system_rev < 10)
gpio_direction_output(gpio33, 1);
else
gpio_direction_output(LCD_22V_EN, 1);
#else
gpio_direction_output(LCD_22V_EN, 1);
#if defined(CONFIG_FB_MSM_ENABLE_LCD_EN2)
if( system_rev >= 16 ) // rev0.6 + 10
{
mdelay(10);
gpio_direction_output(LCD_22V_EN_2, 1);
}
#endif
#endif
#if !defined(CONFIG_MACH_JACTIVE_ATT) && !defined(CONFIG_MACH_JACTIVE_EUR)
/*active_reset_ldi(gpio43);*/
if (system_rev == 0)
gpio_direction_output(gpio43, 1);
else
pm8xxx_mpp_config(
PM8921_MPP_PM_TO_SYS(MLCD_RST_MPP2),
&MLCD_RESET_HIGH_CONFIG);
msleep(20);
#endif
#if defined(CONFIG_MACH_JACTIVE_EUR)
if( system_rev >= 15 ) // rev0.5 + 10
{
rc = regulator_set_optimum_mode(reg_L16, 100000); /*IOVDD */
if (rc < 0) {
pr_err("set_optimum_mode L16 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_L16);
if (rc) {
pr_err("enable L16 failed, rc=%d\n", rc);
return -ENODEV;
}
msleep ( 10 );
}
#elif defined(CONFIG_MACH_JACTIVE_ATT)
if( system_rev >= 11 ) // rev0.3 + 8
{
rc = regulator_set_optimum_mode(reg_L16, 100000); /*IOVDD */
if (rc < 0) {
pr_err("set_optimum_mode L16 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_L16);
if (rc) {
pr_err("enable L16 failed, rc=%d\n", rc);
return -ENODEV;
}
msleep ( 10 );
}
#endif
gpio_direction_output(gpio27, 1);/*LED_DRIVER(gpio27);*/
} else {
if (system_rev == 0)
gpio_direction_output(gpio43, 0);
else
pm8xxx_mpp_config(
PM8921_MPP_PM_TO_SYS(MLCD_RST_MPP2),
&MLCD_RESET_LOW_CONFIG);
#if defined(CONFIG_MACH_JACTIVE_ATT)
if(system_rev < 10)
gpio_direction_output(gpio33, 0);
else
gpio_direction_output(LCD_22V_EN, 0);
#else
#if defined(CONFIG_FB_MSM_ENABLE_LCD_EN2)
if( system_rev >= 16 ) // rev0.6 + 10
{
gpio_direction_output(LCD_22V_EN_2, 0);
mdelay(10);
}
#endif
gpio_direction_output(LCD_22V_EN, 0);
#endif
usleep(2000); /*1ms delay(minimum) required between VDD off and AVDD off*/
rc = regulator_set_optimum_mode(reg_L15, 100);
if (rc < 0) {
pr_err("set_optimum_mode L15 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_disable(reg_L15);
if (rc) {
pr_err("disable reg_L15 failed, rc=%d\n", rc);
return -ENODEV;
}
gpio_direction_output(gpio27, 0);/*LED_DRIVER(gpio27);*/
#if defined(CONFIG_MACH_JACTIVE_EUR)
if( system_rev >= 15 ) // rev0.5 + 10
{
msleep ( 10 );
rc = regulator_set_optimum_mode(reg_L16, 100);
if (rc < 0) {
pr_err("set_optimum_mode L16 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_disable(reg_L16);
if (rc) {
pr_err("disable reg_L16 failed, rc=%d\n", rc);
return -ENODEV;
}
}
#elif defined(CONFIG_MACH_JACTIVE_ATT)
if( system_rev >= 11 ) // rev0.3 + 8
{
msleep ( 10 );
rc = regulator_set_optimum_mode(reg_L16, 100);
if (rc < 0) {
pr_err("set_optimum_mode L16 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_disable(reg_L16);
if (rc) {
pr_err("disable reg_L16 failed, rc=%d\n", rc);
return -ENODEV;
}
}
#endif
#if defined(CONFIG_MACH_JACTIVE_EUR)
rc = regulator_set_optimum_mode(reg_LVS1, 100);
if (rc < 0) {
pr_err("set_optimum_mode LVS1 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_disable(reg_LVS1);
if (rc) {
pr_err("disable reg_LVS1 failed, rc=%d\n", rc);
return -ENODEV;
}
#elif defined(CONFIG_MACH_JACTIVE)
if (system_rev >= 11) {
rc = regulator_set_optimum_mode(reg_LVS1, 100);
if (rc < 0) {
pr_err("set_optimum_mode LVS1 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_disable(reg_LVS1);
if (rc) {
pr_err("disable reg_LVS1 failed, rc=%d\n", rc);
return -ENODEV;
}
}
#endif
msleep(20);
}
return rc;
}
static int mipi_dsi_power_tft_request(void)
{
int rc = 0;
#if defined(CONFIG_MACH_JACTIVE_ATT)
if (system_rev < 10){
gpio33 = PM8921_GPIO_PM_TO_SYS(LCD_22V_EN);
rc = gpio_request(gpio33, "led_dirver");
if (rc) {
pr_err("request gpio lcd_22v_en failed, rc=%d\n", rc);
return -ENODEV;
}
rc = pm8xxx_gpio_config(gpio33, &gpio43_param);
if (rc) {
pr_err("gpio_config lcd_22v_en failed (3), rc=%d\n", rc);
return -EINVAL;
}
}
else{
pr_info("[lcd] request gpio lcd_22v_en\n");
rc = gpio_request(LCD_22V_EN, "lcd_22v_en");
if (rc) {
gpio_free(LCD_22V_EN);
rc = gpio_request(LCD_22V_EN, "lcd_22v_en");
if(rc){
pr_err("request gpio lcd_22v_en failed, rc=%d\n", rc);
return -ENODEV;
}
}
pr_info("[lcd] configure LCD_22V_EN\n");
gpio_tlmm_config(GPIO_CFG(LCD_22V_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
}
#else
pr_info("[lcd] request gpio lcd_22v_en\n");
rc = gpio_request(LCD_22V_EN, "lcd_22v_en");
if (rc) {
pr_err("request gpio lcd_22v_en failed, rc=%d\n", rc);
return -ENODEV;
}
pr_info("[lcd] configure LCD_22V_EN\n");
gpio_tlmm_config(GPIO_CFG(LCD_22V_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
#if defined(CONFIG_FB_MSM_ENABLE_LCD_EN2)
if( system_rev >= 16 ) // rev0.6 + 10
{
pr_info("[lcd] request gpio lcd_22v_en_2\n");
rc = gpio_request(LCD_22V_EN_2, "lcd_22v_en_2");
if (rc) {
pr_err("request gpio lcd_22v_en_2 failed, rc=%d\n", rc);
return -ENODEV;
}
pr_info("[lcd] configure LCD_22V_EN_2\n");
gpio_tlmm_config(GPIO_CFG(LCD_22V_EN_2, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
}
#endif
#endif
if (system_rev == 0) {
gpio43 = PM8921_GPIO_PM_TO_SYS(
PMIC_GPIO_LCD_RST);
rc = gpio_request(gpio43, "mlcd_rst");
if (rc) {
pr_err("request gpio mlcd_rst failed, rc=%d\n", rc);
return -ENODEV;
}
rc = pm8xxx_gpio_config(gpio43, &gpio43_param);
if (rc) {
pr_err("gpio_config mlcd_rst failed (3), rc=%d\n", rc);
return -EINVAL;
}
}
#if defined(CONFIG_MACH_JACTIVE_ATT)
if (system_rev < 10)
gpio27 = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_LED_DRIVER_REV00);
else
gpio27 = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_LED_DRIVER_REV10);
#else
gpio27 = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_LED_DRIVER);
#endif
rc = gpio_request(gpio27, "led_dirver");
if (rc) {
pr_err("request gpio led_dirver failed, rc=%d\n", rc);
return -ENODEV;
}
rc = pm8xxx_gpio_config(gpio27, &gpio43_param);
if (rc) {
pr_err("gpio_config led_dirver failed (3), rc=%d\n", rc);
return -EINVAL;
}
#if !defined(CONFIG_MACH_JACTIVE_ATT) && !defined(CONFIG_MACH_JACTIVE_EUR)
#if defined(CONFIG_MACH_JACTIVE_ATT)
if(system_rev < 10)
gpio_direction_output(gpio33, 0);
else
gpio_direction_output(LCD_22V_EN, 0);
#else
gpio_direction_output(LCD_22V_EN, 0);
#endif
if (system_rev == 0)
gpio_direction_output(gpio43, 0);
else
pm8xxx_mpp_config(
PM8921_MPP_PM_TO_SYS(MLCD_RST_MPP2),
&MLCD_RESET_LOW_CONFIG);
msleep(1000);
#endif
gpio_direction_output(gpio27, 0);
return rc;
}
static int mipi_dsi_panel_power(int on)
{
static struct regulator *reg_lvs7, *reg_l2, *reg_l11, *reg_ext_3p3v;
static int gpio36, gpio25, gpio26, mpp3;
int rc;
pr_debug("%s: on=%d\n", __func__, on);
if (!dsi_power_on) {
reg_lvs7 = regulator_get(&msm_mipi_dsi1_device.dev,
"dsi1_vddio");
if (IS_ERR_OR_NULL(reg_lvs7)) {
pr_err("could not get 8921_lvs7, rc = %ld\n",
PTR_ERR(reg_lvs7));
return -ENODEV;
}
reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev,
"dsi1_pll_vdda");
if (IS_ERR_OR_NULL(reg_l2)) {
pr_err("could not get 8921_l2, rc = %ld\n",
PTR_ERR(reg_l2));
return -ENODEV;
}
rc = regulator_set_voltage(reg_l2, 1200000, 1200000);
if (rc) {
pr_err("set_voltage l2 failed, rc=%d\n", rc);
return -EINVAL;
}
reg_l11 = regulator_get(&msm_mipi_dsi1_device.dev,
"dsi1_avdd");
if (IS_ERR(reg_l11)) {
pr_err("could not get 8921_l11, rc = %ld\n",
PTR_ERR(reg_l11));
return -ENODEV;
}
rc = regulator_set_voltage(reg_l11, 3000000, 3000000);
if (rc) {
pr_err("set_voltage l11 failed, rc=%d\n", rc);
return -EINVAL;
}
if (machine_is_apq8064_liquid()) {
reg_ext_3p3v = regulator_get(&msm_mipi_dsi1_device.dev,
"dsi1_vccs_3p3v");
if (IS_ERR_OR_NULL(reg_ext_3p3v)) {
pr_err("could not get reg_ext_3p3v, rc = %ld\n",
PTR_ERR(reg_ext_3p3v));
reg_ext_3p3v = NULL;
return -ENODEV;
}
mpp3 = PM8921_MPP_PM_TO_SYS(3);
rc = gpio_request(mpp3, "backlight_en");
if (rc) {
pr_err("request mpp3 failed, rc=%d\n", rc);
return -ENODEV;
}
}
gpio25 = PM8921_GPIO_PM_TO_SYS(25);
rc = gpio_request(gpio25, "disp_rst_n");
if (rc) {
pr_err("request gpio 25 failed, rc=%d\n", rc);
return -ENODEV;
}
gpio26 = PM8921_GPIO_PM_TO_SYS(26);
rc = gpio_request(gpio26, "pwm_backlight_ctrl");
if (rc) {
pr_err("request gpio 26 failed, rc=%d\n", rc);
return -ENODEV;
}
gpio36 = PM8921_GPIO_PM_TO_SYS(36); /* lcd1_pwr_en_n */
rc = gpio_request(gpio36, "lcd1_pwr_en_n");
if (rc) {
pr_err("request gpio 36 failed, rc=%d\n", rc);
return -ENODEV;
}
dsi_power_on = true;
}
if (on) {
rc = regulator_enable(reg_lvs7);
if (rc) {
pr_err("enable lvs7 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_set_optimum_mode(reg_l11, 110000);
if (rc < 0) {
pr_err("set_optimum_mode l11 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_l11);
if (rc) {
pr_err("enable l11 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_set_optimum_mode(reg_l2, 100000);
if (rc < 0) {
pr_err("set_optimum_mode l2 failed, rc=%d\n", rc);
return -EINVAL;
}
rc = regulator_enable(reg_l2);
if (rc) {
pr_err("enable l2 failed, rc=%d\n", rc);
return -ENODEV;
}
if (machine_is_apq8064_liquid()) {
rc = regulator_enable(reg_ext_3p3v);
if (rc) {
pr_err("enable reg_ext_3p3v failed, rc=%d\n",
rc);
return -ENODEV;
}
gpio_set_value_cansleep(mpp3, 1);
}
gpio_set_value_cansleep(gpio36, 0);
gpio_set_value_cansleep(gpio25, 1);
if (socinfo_get_pmic_model() == PMIC_MODEL_PM8917)
gpio_set_value_cansleep(gpio26, 1);
} else {
if (socinfo_get_pmic_model() == PMIC_MODEL_PM8917)
gpio_set_value_cansleep(gpio26, 0);
gpio_set_value_cansleep(gpio25, 0);
gpio_set_value_cansleep(gpio36, 1);
if (machine_is_apq8064_liquid()) {
gpio_set_value_cansleep(mpp3, 0);
rc = regulator_disable(reg_ext_3p3v);
if (rc) {
pr_err("disable reg_ext_3p3v failed, rc=%d\n",
rc);
return -ENODEV;
}
}
rc = regulator_disable(reg_l11);
if (rc) {
pr_err("disable reg_l1 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_disable(reg_lvs7);
if (rc) {
pr_err("disable reg_lvs7 failed, rc=%d\n", rc);
return -ENODEV;
}
rc = regulator_disable(reg_l2);
if (rc) {
pr_err("disable reg_l2 failed, rc=%d\n", rc);
return -ENODEV;
}
}
return 0;
}
.id = -1,
};
static struct persistent_ram_descriptor ram_console_pram_desc[] = {
{
.name = "ram_console",
.size = MSM_RAM_CONSOLE_SIZE,
}
};
struct persistent_ram mmi_ram_console_pram = {
.start = MSM_RAM_CONSOLE_START,
.size = MSM_RAM_CONSOLE_SIZE,
.num_descs = ARRAY_SIZE(ram_console_pram_desc),
.descs = ram_console_pram_desc,
};
#endif
struct platform_device mmi_device_ext_5v_vreg __devinitdata = {
.name = GPIO_REGULATOR_DEV_NAME,
.id = PM8921_MPP_PM_TO_SYS(7),
.dev = {
.platform_data = &msm_gpio_regulator_pdata[GPIO_VREG_ID_EXT_5V],
},
};
struct platform_device mmi_alsa_to_h2w_hs_device = {
.name = "alsa-to-h2w",
};
.num_consumer_supplies = \
ARRAY_SIZE(vreg_consumers_##_id##_PC), \
.consumer_supplies = vreg_consumers_##_id##_PC, \
.supply_regulator = _supply_regulator, \
}, \
.id = RPM_VREG_ID_PM8921_##_id##_PC, \
.pin_fn = RPM_VREG_PIN_FN_8960_##_pin_fn, \
.pin_ctrl = _pin_ctrl, \
}
/* GPIO regulator constraints */
struct gpio_regulator_platform_data
monarudo_gpio_regulator_pdata[] __devinitdata = {
/* ID vreg_name gpio_label gpio supply */
GPIO_VREG(EXT_5V, "ext_5v", "ext_5v_en",
PM8921_MPP_PM_TO_SYS(7), NULL),
GPIO_VREG(EXT_3P3V, "ext_3p3v", "ext_3p3v_en",
monarudo_EXT_3P3V_REG_EN_GPIO, NULL),
//GPIO_VREG(EXT_TS_SW, "ext_ts_sw", "ext_ts_sw_en",
// PM8921_GPIO_PM_TO_SYS(23), "ext_3p3v"),
GPIO_VREG(EXT_MPP8, "ext_mpp8", "ext_mpp8_en",
PM8921_MPP_PM_TO_SYS(8), NULL),
};
/* SAW regulator constraints */
struct regulator_init_data monarudo_saw_regulator_pdata_8921_s5 =
/* ID vreg_name min_uV max_uV */
#ifdef CONFIG_CPU_OVERCLOCK
SAW_VREG_INIT(S5, "8921_s5", 850000, 1450000);
#else
SAW_VREG_INIT(S5, "8921_s5", 850000, 1300000);
static void cam_ldo_power_off(int mode)
{
int ret = 0;
int temp = 0;
printk(KERN_DEBUG "[%s : %d] %s CAMERA POWER OFF!!\n",
__func__, __LINE__, mode ? "FRONT" : "REAR");
if (mode) { /* front camera */
/* VT_RESET */
#if defined(CONFIG_MACH_M2_DCM) || defined(CONFIG_MACH_K2_KDI)
gpio_set_value_cansleep(gpio_rev(CAM2_RST_N), 0);
usleep(1*1000);
#else
gpio_set_value_cansleep(CAM2_RST_N, 0);
usleep(1*1000);
#endif
/* ISP 8M MIPI 1.2V */
/* delete for unnecessary power */
/* ISP 8M HOST 1.8V */
if (l29) {
ret = regulator_disable(l29);
if (ret)
cam_err("error disabling regulator\n");
}
usleep(1*1000);
/* MCLK 24MHz*/
/* 8M AVDD 2.8V */
gpio_set_value_cansleep(GPIO_CAM_A_EN, 0);
usleep(1*1000);
/* ISP CORE 1.2V */
/* delete for unnecessary power */
} else { /* rear camera */
/* ISP_STANDBY */
gpio_set_value_cansleep(PM8921_GPIO_PM_TO_SYS(24), 0);
usleep(1*1000);
/* ISP_RESET */
gpio_set_value_cansleep(ISP_RESET, 0);
usleep(1*1000);
/* AF 2.8V */
gpio_set_value_cansleep(gpio_rev(CAM_AF_EN), 0);
usleep(1*1000);
/* ISP 8M MIPI 1.2V */
gpio_set_value_cansleep(CAM_MIPI_EN, 0);
usleep(1*1000);
/* ISP 8M HOST 1.8V */
if (l29) {
ret = regulator_disable(l29);
if (ret)
cam_err("error disabling regulator\n");
}
usleep(1*1000);
/* 8M DVDD 1.2V */
gpio_set_value_cansleep(GPIO_CAM_SENSOR_EN, 0);
usleep(1*1000);
/* 8M AVDD 2.8V */
gpio_set_value_cansleep(GPIO_CAM_A_EN, 0);
usleep(1*1000);
/* ISP CORE 1.2V */
#if defined(CONFIG_MACH_M2)
if (system_rev >= BOARD_REV08)
ret = regulator_disable(isp_core);
if (ret)
cam_err("error disabling regulator");
regulator_put(isp_core);
#elif defined(CONFIG_MACH_M2_DCM) || defined(CONFIG_MACH_K2_KDI)
gpio_set_value_cansleep(gpio_rev(CAM_CORE_EN), 0);
#else
gpio_set_value_cansleep(CAM_CORE_EN, 0);
#endif
usleep(1*1000);
/* flash power 1.8V */
if (l28) {
ret = regulator_disable(l28);
if (ret)
cam_err("error disabling regulator\n");
}
usleep(1*1000);
/* GPIO_CAM_FLASH_SW : tourch */
temp = gpio_get_value(GPIO_MSM_FLASH_NOW);
if (isFlashCntlEn == 0 && temp == 0) {
/* GPIO_CAM_FLASH_SW : tourch */
gpio_set_value_cansleep(gpio_cam_flash_sw, 0);
temp = gpio_get_value(gpio_cam_flash_sw);
printk(KERN_DEBUG "[s5c73m3] check"
" GPIO_CAM_FLASH_SW : %d\n", temp);
/* FLASH_LED_LOCK*/
gpio_set_value_cansleep(PM8921_MPP_PM_TO_SYS
(PMIC_MPP_FLASH_LED_UNLOCK), 0);
usleep(1*1000);
}
}
}
static void cam_ldo_power_on(int mode, int num)
{
int ret = 0;
int temp = 0;
printk(KERN_DEBUG "[%s : %d] %s CAMERA POWER ON!!\n",
__func__, __LINE__, mode ? "FRONT" : "REAR");
if (mode) { /* front camera */
if (num == 0) {
/* ISP CORE 1.2V */
/* delete for unnecessary power */
/* 8M AVDD 2.8V */
gpio_set_value_cansleep(GPIO_CAM_A_EN, 1);
temp = gpio_get_value(GPIO_CAM_A_EN);
printk(KERN_DEBUG "[s5k6a3yx] check GPIO_CAM_A_EN : %d\n",
temp);
usleep(1*1000);
} else {
/* VT_RESET */
#if defined(CONFIG_MACH_M2_DCM) || defined(CONFIG_MACH_K2_KDI)
gpio_set_value_cansleep(gpio_rev(CAM2_RST_N), 1);
temp = gpio_get_value(gpio_rev(CAM2_RST_N));
#else
gpio_set_value_cansleep(CAM2_RST_N, 1);
temp = gpio_get_value(CAM2_RST_N);
#endif
printk(KERN_DEBUG "[s5k6a3yx] check CAM2_RST_N : %d\n",
temp);
usleep(1*1000);
/* ISP 8M HOST 1.8V */
l29 = regulator_get(NULL, "8921_lvs5");
ret = regulator_enable(l29);
if (ret)
cam_err("error enabling regulator\n");
usleep(1*1000);
/* ISP 8M MIPI 1.2V */
/* delete for unnecessary power */
}
} else { /* rear camera */
if (num == 0) {
printk(KERN_DEBUG "[s5c73m3] rear camera on 1\n");
temp = gpio_get_value(GPIO_MSM_FLASH_NOW);
if (isFlashCntlEn == 0 && temp == 0) {
/* FLASH_LED_UNLOCK*/
gpio_set_value_cansleep(PM8921_MPP_PM_TO_SYS
(PMIC_MPP_FLASH_LED_UNLOCK), 1);
/* GPIO_CAM_FLASH_SW : tourch */
gpio_set_value_cansleep(gpio_cam_flash_sw, 1);
temp = gpio_get_value(gpio_cam_flash_sw);
printk(KERN_DEBUG "[s5c73m3] check"
" GPIO_CAM_FLASH_SW : %d\n", temp);
usleep(1*1000);
}
/* flash power 1.8V */
l28 = regulator_get(NULL, "8921_lvs4");
ret = regulator_enable(l28);
if (ret)
cam_err("error enabling regulator\n");
usleep(1*1000);
/* ISP CORE 1.2V */
#if defined(CONFIG_MACH_M2)
if (system_rev >= BOARD_REV08) {
printk(KERN_DEBUG "[s5c73m3] m2 check vddCore : %d\n",
vddCore);
isp_core = regulator_get(NULL, "cam_isp_core");
ret = regulator_set_voltage(isp_core,
vddCore, vddCore);
if (ret)
cam_err("error setting voltage\n");
ret = regulator_enable(isp_core);
if (ret)
cam_err("error enabling regulator.");
} else
gpio_set_value_cansleep(CAM_CORE_EN, 1);
#elif defined(CONFIG_MACH_M2_DCM) || defined(CONFIG_MACH_K2_KDI)
gpio_set_value_cansleep(gpio_rev(CAM_CORE_EN), 1);
#else
gpio_set_value_cansleep(CAM_CORE_EN, 1);
#endif
usleep(1200);
/* 8M AVDD 2.8V */
gpio_set_value_cansleep(GPIO_CAM_A_EN, 1);
temp = gpio_get_value(GPIO_CAM_A_EN);
printk(KERN_DEBUG "[s5c73m3] check GPIO_CAM_A_EN : %d\n",
temp);
usleep(1*1000);
/* 8M DVDD 1.2V */
gpio_set_value_cansleep(GPIO_CAM_SENSOR_EN, 1);
temp = gpio_get_value(GPIO_CAM_SENSOR_EN);
printk(KERN_DEBUG "[s5c73m3] check GPIO_CAM_SENSOR_EN : %d\n",
temp);
usleep(1*1000);
} else {
printk(KERN_DEBUG "[s5c73m3] rear camera on 2\n");
/* AF 2.8V */
gpio_set_value_cansleep(gpio_rev(CAM_AF_EN), 1);
temp = gpio_get_value(gpio_rev(CAM_AF_EN));
printk(KERN_DEBUG "[s5c73m3] check CAM_AF_EN : %d\n",
temp);
usleep(3*1000);
/* ISP 8M HOST 1.8V */
l29 = regulator_get(NULL, "8921_lvs5");
ret = regulator_enable(l29);
if (ret)
cam_err("error enabling regulator\n");
/* ISP 8M MIPI 1.2V */
gpio_set_value_cansleep(CAM_MIPI_EN, 1);
temp = gpio_get_value(CAM_MIPI_EN);
printk(KERN_DEBUG "[s5c73m3] check CAM_MIPI_EN : %d\n",
temp);
usleep(1*1000);
/* ISP_STANDBY */
gpio_set_value_cansleep(PM8921_GPIO_PM_TO_SYS(24), 1);
usleep(1*1000);
/* ISP_RESET */
gpio_set_value_cansleep(ISP_RESET, 1);
temp = gpio_get_value(ISP_RESET);
printk(KERN_DEBUG "[s5c73m3] check ISP_RESET : %d\n",
temp);
usleep(1*1000);
}
}
}
.always_on = _always_on, \
}, \
.num_consumer_supplies = \
ARRAY_SIZE(vreg_consumers_##_id##_PC), \
.consumer_supplies = vreg_consumers_##_id##_PC, \
.supply_regulator = _supply_regulator, \
}, \
.id = RPM_VREG_ID_PM8921_##_id##_PC, \
.pin_fn = RPM_VREG_PIN_FN_8960_##_pin_fn, \
.pin_ctrl = _pin_ctrl, \
}
/* GPIO regulator constraints */
struct gpio_regulator_platform_data msm_gpio_regulator_pdata[] __devinitdata = {
/* ID vreg_name gpio_label gpio supply */
GPIO_VREG(EXT_5V, "ext_5v", "ext_5v_en", PM8921_MPP_PM_TO_SYS(7), NULL),
GPIO_VREG(EXT_L2, "ext_l2", "ext_l2_en", 91, NULL),
GPIO_VREG(EXT_3P3V, "ext_3p3v", "ext_3p3v_en",
PM8921_GPIO_PM_TO_SYS(17), NULL),
GPIO_VREG(EXT_OTG_SW, "ext_otg_sw", "ext_otg_sw_en",
PM8921_GPIO_PM_TO_SYS(42), "8921_usb_otg"),
};
/* SAW regulator constraints */
struct regulator_init_data msm_saw_regulator_pdata_s5 =
/* ID vreg_name min_uV max_uV */
SAW_VREG_INIT(S5, "8921_s5", 850000, 1300000);
struct regulator_init_data msm_saw_regulator_pdata_s6 =
SAW_VREG_INIT(S6, "8921_s6", 850000, 1300000);
/* PM8921 regulator constraints */
static long ncdiagd_power_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
int ret = 0;
void __user *pArg = (void __user *)arg;
printk(KERN_INFO "[%s] cmd:%d",__func__, cmd);
switch(cmd)
{
case IOCTL_PW_RG_LP_CTL:
{
unsigned char enable;
unsigned char vreg_id;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
vreg_id = buf.req_buf[1];
printk(KERN_INFO "DIAG_PW_RG_LP_CTL enable:%x vreg_id:%x", enable, vreg_id);
ret = nc_pm8xxx_lp_mode_control(PM8XXX_VERSION_8921, vreg_id, enable);
}
break;
case IOCTL_PW_RG_CTL:
{
unsigned char enable;
unsigned char vreg_id;
unsigned int min_volt, max_volt;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
vreg_id = buf.req_buf[1];
min_volt = cvt_val(buf.req_buf[3]);
min_volt += cvt_val(buf.req_buf[2]) * 100;
min_volt *= 1000;
max_volt = cvt_val(buf.req_buf[5]);
max_volt += cvt_val(buf.req_buf[4]) * 100;
max_volt *= 1000;
printk(KERN_INFO "DIAG_PW_RG_CTL enable :%x vreg_id :%x", enable, vreg_id);
printk(KERN_INFO " min_volt:%x max_volt:%x", min_volt, max_volt);
ret = nc_pm8xxx_vreg_control(PM8XXX_VERSION_8921, enable, vreg_id, min_volt, max_volt);
}
break;
case IOCTL_PW_RG_SET_LVL:
{
unsigned char vreg_id;
unsigned int min_volt, max_volt;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
vreg_id = buf.req_buf[0];
min_volt = cvt_val(buf.req_buf[2]);
min_volt += cvt_val(buf.req_buf[1]) * 100;
min_volt *= 1000;
max_volt = cvt_val(buf.req_buf[4]);
max_volt += cvt_val(buf.req_buf[3]) * 100;
max_volt *= 1000;
printk(KERN_INFO "DIAG_PW_RG_SET_LVL vreg_id:%x min_volt:%d max_volt:%d", vreg_id, min_volt, max_volt);
ret = nc_pm8xxx_vreg_set_level(PM8XXX_VERSION_8921, vreg_id, min_volt, max_volt);
}
break;
case IOCTL_PW_VT_PLDWN_SW:
{
unsigned char enable;
unsigned char vreg_id;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
vreg_id = buf.req_buf[1];
printk(KERN_INFO "DIAG_PW_RG_SMPS_PSK enable:%x vreg_id:%x", enable, vreg_id);
ret = nc_pm8xxx_vreg_pull_down_switch(PM8XXX_VERSION_8921, vreg_id, enable);
}
break;
case IOCTL_PW_CHG_COIN_SW:
{
struct pm8xxx_coincell_chg param;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
param.state = buf.req_buf[0];
param.voltage = PM8XXX_COINCELL_VOLTAGE_3p2V;
param.resistor = PM8XXX_COINCELL_RESISTOR_800_OHMS;
ret = pm8xxx_coincell_chg_config(¶m);
printk(KERN_INFO "DIAG_PW_CHG_COIN_SW enable:%x", param.state);
}
break;
case IOCTL_PW_CHG_BAT_EBL:
{
bool enable;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = (buf.req_buf[0]&0x01);
ret = nc_pm8921_charger_enable(enable);
printk(KERN_INFO "DIAG_PW_CHG_BAT_EBL enable:%x", enable);
}
break;
case IOCTL_PW_CHG_DSBL:
{
unsigned char enable;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
enable = enable ? 0x00 : 0x01;
ret = pm8921_disable_source_current(enable);
printk(KERN_INFO "DIAG_PW_CHG_DSBL enable:%x", enable);
}
break;
case IOCTL_PW_CHG_WCG_GET_STATE:
{
unsigned int rt_id = 0x00;
unsigned int rt_status = 0x00;
ioctl_pw_value_type buf;
rt_id = PM8921_IRQ_BASE + PM8921_CABLE_IRQ;
ret = nc_pm8921_get_rt_status(rt_id, &rt_status);
if (ret != 0) {
printk(KERN_ERR "nc_pm8921_get_rt_status failed \n");
return PM_ERR_FLAG__SBI_OPT_ERR;
}
buf.rsp_buf[0] = (u8)rt_status;
if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_to_user failed");
return PM_ERR_FLAG__SBI_OPT_ERR;
}
printk(KERN_INFO "IOCTL_PW_CHG_WCG_GET_STATE rt_id:%x rt_status:%x", rt_id, rt_status);
}
break;
case IOCTL_PW_CHG_WCG_SW:
{
ioctl_pw_value_type buf;
struct pm_gpio param;
int gpio_port;
unsigned char enable = 0x00;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__SBI_OPT_ERR;
}
gpio_port = PM8921_GPIO_PM_TO_SYS(PM_DIAG_GPIO_32);
param.direction = PM_GPIO_DIR_OUT;
param.output_buffer = PM_GPIO_OUT_BUF_CMOS;
param.output_value = 0;
param.pull = PM_GPIO_PULL_NO;
param.vin_sel = PM_GPIO_VIN_S4;
param.out_strength = PM_GPIO_STRENGTH_LOW;
param.function = PM_GPIO_FUNC_NORMAL;
param.inv_int_pol = 0;
param.disable_pin = 0;
enable = buf.req_buf[0];
param.output_value = enable ? 0 : 1;
ret = pm8xxx_gpio_config(gpio_port, ¶m);
if (ret != 0) {
printk(KERN_ERR "pm8xxx_gpio_config failed");
return PM_ERR_FLAG__SBI_OPT_ERR;
}
printk(KERN_INFO "IOCTL_PW_CHG_WCG_SW enable:%x param.output_value:%x ", enable, param.output_value);
}
break;
case IOCTL_PW_CHG_VMAX_SET:
{
unsigned short voltage;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
voltage = buf.req_buf[1];
voltage += buf.req_buf[0] * 0x100;
ret = nc_pm8921_chg_vmaxsel_set(voltage);
printk(KERN_INFO "DIAG_PW_CHG_VMAX_SET voltage:%x", voltage);
}
break;
case IOCTL_PW_CHG_IMAX_SET:
{
unsigned short cur_val;
ioctl_pw_value_type buf;
int ibat = 0;
unsigned int iusb = 0;
const int ibat_min = 325;
const int ibat_max = 2000;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
cur_val = buf.req_buf[1];
cur_val += buf.req_buf[0] * 0x100;
if (cur_val < ibat_min) {
ibat = ibat_min;
} else if (cur_val > ibat_max) {
ibat = ibat_max;
} else {
ibat = (int)cur_val;
}
iusb = (unsigned int)(cur_val | PM8921_DIAG_IUSB_SET);
pm8921_set_max_battery_charge_current(ibat);
pm8921_charger_vbus_draw(iusb);
printk(KERN_INFO "DIAG_PW_CHG_IMAX_SET cur_val:0x%04x", cur_val);
}
break;
case IOCTL_PW_CHG_STATE_GET:
{
unsigned char chg_state = 0x00;
ioctl_pw_value_type buf;
ret = nc_pm8921_get_fsm_status((u64 *)&chg_state);
buf.rsp_buf[0] = chg_state;
if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_to_user failed");
return PM_ERR_FLAG__INVALID;
}
printk(KERN_INFO "DIAG_PW_CHG_STATE_GET chg_state:%x", chg_state);
}
break;
case IOCTL_PW_CHG_USB_DSBL:
{
unsigned char enable;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
enable = enable ? 0x00 : 0x01;
ret = nc_pm8921_chg_usb_suspend_enable(enable);
printk(KERN_INFO "DIAG_PW_CHG_USB_DSBL enable:%x", enable);
}
break;
case IOCTL_PW_ADC_RD_CHANNEL:
{
unsigned char analog_chnl, mpp_chnl;
struct pm8xxx_adc_chan_result result;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
analog_chnl = buf.req_buf[0];
if (analog_chnl == CHANNEL_BATT_THERM) {
analog_chnl = CHANNEL_BATT_THERM_UV;
ret = pm8xxx_adc_read(analog_chnl, &result);
} else if ((analog_chnl < PM8XXX_CHANNEL_MPP_SCALE1_IDX) ||
(analog_chnl == ADC_MPP_1_AMUX8 ) ||
(analog_chnl == ADC_MPP_1_AMUX3 ) ||
(analog_chnl == ADC_MPP_1_AMUX3_UV))
{
ret = pm8xxx_adc_read(analog_chnl, &result);
} else if ((analog_chnl >= PM8XXX_CHANNEL_MPP_SCALE1_IDX) &&
(analog_chnl <= ADC_MPP_1_ATEST_7 ) )
{
mpp_chnl = analog_chnl - PM8XXX_CHANNEL_MPP_SCALE1_IDX;
ret = pm8xxx_adc_mpp_config_read(mpp_chnl, CHANNEL_MPP_1, &result);
} else if ((analog_chnl >= PM8XXX_CHANNEL_MPP_SCALE3_IDX) &&
(analog_chnl <= ADC_MPP_2_ATEST_7 ) )
{
mpp_chnl = analog_chnl - PM8XXX_CHANNEL_MPP_SCALE3_IDX;
ret = pm8xxx_adc_mpp_config_read(mpp_chnl, CHANNEL_MPP_2, &result);
} else
{
printk(KERN_ERR "ADC_channel failed");
return PM_ERR_FLAG__FEATURE_NOT_SUPPORTED;
}
if(ret == PM_ERR_FLAG__SUCCESS)
{
if ((analog_chnl != CHANNEL_BATT_THERM) &&
(analog_chnl != ADC_MPP_1_AMUX8 ) &&
(analog_chnl != CHANNEL_MUXOFF ) &&
(analog_chnl != ADC_MPP_1_AMUX3 ))
{
if (result.physical != 0)
{
result.physical = div_u64(result.physical, 1000);
}
if (result.physical >= 0xFFFF)
{
result.physical = 0xFFFF;
}
}
buf.rsp_buf[0] = (result.physical >> 8) & 0xff;
buf.rsp_buf[1] = result.physical & 0xff;
}
if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_to_user failed");
return PM_ERR_FLAG__INVALID;
}
printk(KERN_INFO "DIAG_PW_ADC_RD_CHANNEL analog_chnl :%x", analog_chnl);
printk(KERN_INFO " adc_read_val[0]:%x", (int)((result.physical >> 8) & 0xff));
printk(KERN_INFO " adc_read_val[1]:%x", (int)(result.physical & 0xff));
}
break;
case IOCTL_PW_SP_SMPLD_SW:
{
unsigned char enable;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
ret = pm8xxx_smpl_control(enable);
printk(KERN_INFO "DIAG_PW_SP_SMPLD_SW enable:%x", enable);
}
break;
case IOCTL_PW_SP_SMPLD_TM_SET:
{
unsigned char timer_set;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
timer_set = buf.req_buf[0];
ret = pm8xxx_smpl_set_delay(timer_set);
printk(KERN_INFO "DIAG_PW_SP_SMPLD_TM_SET timer_set:%x", timer_set);
}
break;
case IOCTL_PW_MPP_CNFDG_IPUT:
{
unsigned char mpp_port;
unsigned char logi_level;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
logi_level = buf.req_buf[1];
ret = nc_pm8xxx_mpp_config_digital_in(PM8921_MPP_PM_TO_SYS(mpp_port), logi_level, PM8XXX_MPP_DIN_TO_INT);
printk(KERN_INFO "DIAG_PW_MPP_CNFDG_IPUT mpp_port:%x logi_level:%x", mpp_port +1, logi_level);
}
break;
case IOCTL_PW_MPP_CNFDG_OPUT:
{
unsigned char mpp_port;
unsigned char logi_level;
unsigned char out_ctl;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
logi_level = buf.req_buf[1];
out_ctl = buf.req_buf[2];
ret = nc_pm8xxx_mpp_config_digital_out(PM8921_MPP_PM_TO_SYS(mpp_port), logi_level, out_ctl);
printk(KERN_INFO "DIAG_PW_MPP_CNFDG_OPUT mpp_port:%x logi_level:%x out_ctl:%x", mpp_port +1, logi_level, out_ctl);
}
break;
case IOCTL_PW_MPP_CNFDG_IOPUT:
{
unsigned char mpp_port;
unsigned char logi_level;
unsigned char pull_set;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
logi_level = buf.req_buf[1];
pull_set = buf.req_buf[2];
ret = nc_pm8xxx_mpp_config_bi_dir(PM8921_MPP_PM_TO_SYS(mpp_port), logi_level, pull_set);
printk(KERN_INFO "DIAG_PW_MPP_CNFDG_IOPUT mpp_port:%x logi_level:%x pull_set:%x", mpp_port +1, logi_level, pull_set);
}
break;
case IOCTL_PW_MPP_CNFAN_IPUT:
{
unsigned char mpp_port;
unsigned char ain_chn;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
ain_chn = buf.req_buf[1];
ret = nc_pm8xxx_mpp_config_analog_input(PM8921_MPP_PM_TO_SYS(mpp_port), ain_chn, PM8XXX_MPP_AOUT_CTRL_DISABLE);
printk(KERN_INFO "DIAG_PW_MPP_CNFAN_IPUT mpp_port:%x ain_chn:%x", mpp_port + 1, ain_chn);
}
break;
case IOCTL_PW_MPP_CNFAN_OPUT:
{
unsigned char mpp_port;
unsigned char aout_level;
unsigned char pm_onoff;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
aout_level = buf.req_buf[1];
pm_onoff = buf.req_buf[2];
ret = nc_pm8xxx_mpp_config_analog_output(PM8921_MPP_PM_TO_SYS(mpp_port), aout_level, pm_onoff);
printk(KERN_INFO "DIAG_PW_MPP_CNFAN_OPUT mpp_port:%x aout_level:%x pm_onoff:%x", mpp_port +1 , aout_level, pm_onoff);
}
break;
case IOCTL_PW_MPP_CNF_I_SINK:
{
unsigned char mpp_port;
unsigned char sink_level;
unsigned char pm_onoff;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
sink_level = buf.req_buf[1];
pm_onoff = buf.req_buf[2];
ret = nc_pm8xxx_mpp_config_current_sink(PM8921_MPP_PM_TO_SYS(mpp_port), sink_level, pm_onoff);
printk(KERN_INFO "DIAG_PW_MPP_CNF_I_SINK mpp_port:%x sink_level:%x pm_onoff:%x", mpp_port + 1, sink_level, pm_onoff);
}
break;
case IOCTL_PW_GPIO_CONFIG_SET:
{
ioctl_pw_value_type buf;
struct pm_gpio param ;
int gpio_port;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
gpio_port = PM8921_GPIO_PM_TO_SYS(buf.req_buf[0]);
param.direction = buf.req_buf[1];
param.output_buffer = buf.req_buf[2];
param.output_value = buf.req_buf[3];
param.pull = buf.req_buf[4];
param.vin_sel = buf.req_buf[5];
param.out_strength = buf.req_buf[6];
param.function = buf.req_buf[7];
param.inv_int_pol = buf.req_buf[8];
param.disable_pin = buf.req_buf[9];
ret = pm8xxx_gpio_config(gpio_port, ¶m);
printk(KERN_INFO "IOCTL_PW_GPIO_CONFIG_SET gpio_port :%x direction:%x output_buffer:%x", gpio_port, param.direction, param.output_buffer);
printk(KERN_INFO " output_value:%x pull :%x vin_sel :%x", param.output_value, param.pull, param.vin_sel);
printk(KERN_INFO " out_strength:%x function :%x inv_int_pol :%x", param.out_strength, param.function, param.inv_int_pol);
printk(KERN_INFO " pin_disable :%x ", param.disable_pin);
}
break;
case IOCTL_PW_GPIO_GET_STATE:
{
unsigned int gpio_id = 0x00;
unsigned int gpio_state = 0x00;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
gpio_id = (unsigned int)buf.req_buf[0];
ret = nc_pm8921_gpio_get_state(gpio_id, &gpio_state);
buf.rsp_buf[0] = (u8)gpio_state;
if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_to_user failed");
return PM_ERR_FLAG__INVALID;
}
printk(KERN_INFO "DIAG_PW_GPIO_GET_STATE GPIO :%d value :%d", gpio_id+1, gpio_state);
}
break;
case IOCTL_PW_PCT_OTP_STAGE_GET:
{
unsigned char itemp_stage = 0x00;
ioctl_pw_value_type buf;
ret = nc_pm8921_itemp_get_stage(&itemp_stage);
buf.rsp_buf[0] = itemp_stage;
if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_to_user failed");
return PM_ERR_FLAG__INVALID;
}
printk(KERN_INFO "DIAG_PW_PCT_OTP_STAGE_GET itemp_stage:%x", itemp_stage);
}
break;
case IOCTL_PW_PCT_OTP_STG_OVD:
{
unsigned char enable;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
ret = nc_pm8921_itemp_stage_override(enable);
printk(KERN_INFO "DIAG_PW_PCT_OTP_STG_OVD enable:%x", enable);
}
break;
case IOCTL_PW_IR_RT_STATUS_GET:
{
unsigned int rt_id = 0x00;
unsigned int rt_status = 0x00;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
rt_id = (unsigned int)buf.req_buf[0];
rt_id += PM8921_IRQ_BASE;
nc_pm8921_get_rt_status(rt_id, &rt_status);
buf.rsp_buf[0] = (u8)rt_status;
if(copy_to_user((void *)pArg, &buf, sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_to_user failed");
return PM_ERR_FLAG__INVALID;
}
printk(KERN_INFO "DIAG_PW_IR_RT_STATUS_GET rt_id:%x rt_status:%x", rt_id, rt_status);
}
break;
case IOCTL_PW8821_RG_LP_CTL:
{
unsigned char enable;
unsigned char vreg_id;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
vreg_id = buf.req_buf[1];
printk(KERN_INFO "DIAG_PW8821_RG_LP_CTL enable:%x vreg_id:%x", enable, vreg_id);
ret = nc_pm8xxx_lp_mode_control(PM8XXX_VERSION_8821, vreg_id, enable);
}
break;
case IOCTL_PW8821_RG_CTL:
{
unsigned char enable;
unsigned char vreg_id;
unsigned int min_volt, max_volt;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
vreg_id = buf.req_buf[1];
min_volt = cvt_val(buf.req_buf[3]);
min_volt += cvt_val(buf.req_buf[2]) * 100;
min_volt *= 1000;
max_volt = cvt_val(buf.req_buf[5]);
max_volt += cvt_val(buf.req_buf[4]) * 100;
max_volt *= 1000;
printk(KERN_INFO "DIAG_PW8821_RG_CTL enable :%x vreg_id :%x", enable, vreg_id);
printk(KERN_INFO " min_volt:%x max_volt:%x", min_volt, max_volt);
ret = nc_pm8xxx_vreg_control(PM8XXX_VERSION_8821, enable, vreg_id, min_volt, max_volt);
}
break;
case IOCTL_PW8821_RG_SET_LVL:
{
unsigned char vreg_id;
unsigned int min_volt, max_volt;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
vreg_id = buf.req_buf[0];
min_volt = cvt_val(buf.req_buf[2]);
min_volt += cvt_val(buf.req_buf[1]) * 100;
min_volt *= 1000;
max_volt = cvt_val(buf.req_buf[4]);
max_volt += cvt_val(buf.req_buf[3]) * 100;
max_volt *= 1000;
printk(KERN_INFO "DIAG_PW8821_RG_SET_LVL vreg_id:%x min_volt:%x max_volt:%x", vreg_id, min_volt, max_volt);
ret = nc_pm8xxx_vreg_set_level(PM8XXX_VERSION_8821, vreg_id, min_volt, max_volt);
}
break;
case IOCTL_PW8821_VT_PLDWN_SW:
{
unsigned char enable;
unsigned char vreg_id;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
enable = buf.req_buf[0];
vreg_id = buf.req_buf[1];
printk(KERN_INFO "DIAG_PW8821_RG_SMPS_PSK enable:%x vreg_id:%x", enable, vreg_id);
ret = nc_pm8xxx_vreg_pull_down_switch(PM8XXX_VERSION_8821, vreg_id, enable);
}
break;
case IOCTL_PW8821_MPP_CNFDG_IPUT:
{
unsigned char mpp_port;
unsigned char logi_level;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
logi_level = buf.req_buf[1];
ret = nc_pm8xxx_mpp_config_digital_in(PM8821_MPP_PM_TO_SYS(mpp_port), logi_level, PM8XXX_MPP_DIN_TO_INT);
printk(KERN_INFO "DIAG_PW8821_MPP_CNFDG_IPUT mpp_port:%x logi_level:%x", mpp_port, logi_level);
}
break;
case IOCTL_PW8821_MPP_CNFDG_OPUT:
{
unsigned char mpp_port;
unsigned char logi_level;
unsigned char out_ctl;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
logi_level = buf.req_buf[1];
out_ctl = buf.req_buf[2];
ret = nc_pm8xxx_mpp_config_digital_out(PM8821_MPP_PM_TO_SYS(mpp_port), logi_level, out_ctl);
printk(KERN_INFO "DIAG_PW8821_MPP_CNFDG_OPUT mpp_port:%x logi_level:%x out_ctl:%x", mpp_port, logi_level, out_ctl);
}
break;
case IOCTL_PW8821_MPP_CNFDG_IOPUT:
{
unsigned char mpp_port;
unsigned char logi_level;
unsigned char pull_set;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
logi_level = buf.req_buf[1];
pull_set = buf.req_buf[2];
ret = nc_pm8xxx_mpp_config_bi_dir(PM8821_MPP_PM_TO_SYS(mpp_port), logi_level, pull_set);
printk(KERN_INFO "DIAG_PW8821_MPP_CNFDG_IOPUT mpp_port:%x logi_level:%x pull_set:%x", mpp_port, logi_level, pull_set);
}
break;
case IOCTL_PW8821_MPP_CNFAN_IPUT:
{
unsigned char mpp_port;
unsigned char ain_chn;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
ain_chn = buf.req_buf[1];
ret = nc_pm8xxx_mpp_config_analog_input(PM8821_MPP_PM_TO_SYS(mpp_port), ain_chn, PM8XXX_MPP_AOUT_CTRL_DISABLE);
printk(KERN_INFO "DIAG_PW8821_MPP_CNFAN_IPUT mpp_port:%x ain_chn:%x", mpp_port, ain_chn);
}
break;
case IOCTL_PW8821_MPP_CNFAN_OPUT:
{
unsigned char mpp_port;
unsigned char aout_level;
unsigned char pm_onoff;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
aout_level = buf.req_buf[1];
pm_onoff = buf.req_buf[2];
ret = nc_pm8xxx_mpp_config_analog_output(PM8821_MPP_PM_TO_SYS(mpp_port), aout_level, pm_onoff);
printk(KERN_INFO "DIAG_PW8821_MPP_CNFAN_OPUT mpp_port:%x aout_level:%x pm_onoff:%x", mpp_port, aout_level, pm_onoff);
}
break;
case IOCTL_PW8821_MPP_CNF_I_SINK:
{
unsigned char mpp_port;
unsigned char sink_level;
unsigned char pm_onoff;
ioctl_pw_value_type buf;
if(copy_from_user(&buf,pArg,sizeof(ioctl_pw_value_type)))
{
printk(KERN_ERR "copy_from_user failed");
return PM_ERR_FLAG__INVALID;
}
mpp_port = buf.req_buf[0];
sink_level = buf.req_buf[1];
pm_onoff = buf.req_buf[2];
ret = nc_pm8xxx_mpp_config_current_sink(PM8821_MPP_PM_TO_SYS(mpp_port), sink_level, pm_onoff);
printk(KERN_INFO "DIAG_PW8821_MPP_CNF_I_SINK mpp_port:%x sink_level:%x pm_onoff:%x", mpp_port, sink_level, pm_onoff);
}
break;
case IOCTL_PW_HW_RESET:
printk(KERN_INFO "DVE005_FACTORY_DIAG_FTM_ONLINE_RESET_MODE");
printk(KERN_DEBUG "[ncdiagd_power.c]%s: Goto arm_pm_restart() in \n", __func__ );
arm_pm_restart(0, NULL);
break;
default:
printk(KERN_ERR "Invalid Parameter");
return PM_ERR_FLAG__INVALID;
}
return ret;
}
