void __init pm8921_gpio_mpp_init(struct pm8xxx_gpio_init *pm8921_gpios,
unsigned gpio_size,
struct pm8xxx_mpp_init *pm8921_mpps,
unsigned mpp_size)
{
int i, rc;
for (i = 0; i < gpio_size; i++) {
rc = pm8xxx_gpio_config(pm8921_gpios[i].gpio,
&pm8921_gpios[i].config);
if (rc) {
pr_err("%s: pm8xxx_gpio_config: rc=%d\n", __func__, rc);
break;
}
}
for (i = 0; i < mpp_size; i++) {
rc = pm8xxx_mpp_config(pm8921_mpps[i].mpp,
&pm8921_mpps[i].config);
if (rc) {
pr_err("%s: pm8xxx_mpp_config: rc=%d\n", __func__, rc);
break;
}
}
}
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 msm_otg_pmic_gpio_config(
int gpio, int direction, int pullup, int value)
{
struct pm_gpio param;
int rc = 0;
int out_strength = 0;
if (direction == PM_GPIO_DIR_IN)
out_strength = PM_GPIO_STRENGTH_NO;
else
out_strength = PM_GPIO_STRENGTH_HIGH;
param.direction = direction;
param.output_buffer = PM_GPIO_OUT_BUF_CMOS;
param.output_value = value;
param.pull = pullup;
param.vin_sel = PM_GPIO_VIN_S4;
param.out_strength = out_strength;
param.function = PM_GPIO_FUNC_NORMAL;
param.inv_int_pol = 0;
param.disable_pin = 0;
rc = pm8xxx_gpio_config(
PM8921_GPIO_PM_TO_SYS(gpio), ¶m);
if (rc < 0) {
pr_err("failed to configure vbus_in gpio\n");
return rc;
}
return rc;
}
void __init apq8064_init_mmc(void)
{
if (apq8064_sdc1_pdata) {
/* 8064 v2 supports upto 200MHz clock on SDC1 slot */
if (SOCINFO_VERSION_MAJOR(socinfo_get_version()) >= 2) {
apq8064_sdc1_pdata->sup_clk_table =
sdc1_sup_clk_rates_all;
apq8064_sdc1_pdata->sup_clk_cnt =
ARRAY_SIZE(sdc1_sup_clk_rates_all);
}
apq8064_add_sdcc(1, apq8064_sdc1_pdata);
}
if (apq8064_sdc2_pdata)
apq8064_add_sdcc(2, apq8064_sdc2_pdata);
if (apq8064_sdc3_pdata) {
if (!machine_is_apq8064_cdp()) {
apq8064_sdc3_pdata->wpswitch_gpio = 0;
apq8064_sdc3_pdata->is_wpswitch_active_low = false;
}
if (machine_is_mpq8064_cdp() || machine_is_mpq8064_hrd() ||
machine_is_mpq8064_dtv()) {
int rc;
struct pm_gpio sd_card_det_init_cfg = {
.direction = PM_GPIO_DIR_IN,
.output_buffer = PM_GPIO_OUT_BUF_CMOS,
.pull = PM_GPIO_PULL_UP_30,
.vin_sel = PM_GPIO_VIN_S4,
.out_strength = PM_GPIO_STRENGTH_NO,
.function = PM_GPIO_FUNC_NORMAL,
};
apq8064_sdc3_pdata->status_gpio =
PM8921_GPIO_PM_TO_SYS(31);
apq8064_sdc3_pdata->status_irq =
PM8921_GPIO_IRQ(PM8921_IRQ_BASE, 31);
rc = pm8xxx_gpio_config(apq8064_sdc3_pdata->status_gpio,
&sd_card_det_init_cfg);
if (rc) {
pr_info("%s: SD_CARD_DET GPIO%d config "
"failed(%d)\n", __func__,
apq8064_sdc3_pdata->status_gpio, rc);
apq8064_sdc3_pdata->status_gpio = 0;
apq8064_sdc3_pdata->status_irq = 0;
}
}
if (machine_is_apq8064_cdp()) {
int i;
for (i = 0;
i < apq8064_sdc3_pdata->pin_data->pad_data->\
drv->size;
i++)
apq8064_sdc3_pdata->pin_data->pad_data->\
drv->on[i].val = GPIO_CFG_10MA;
}
apq8064_add_sdcc(3, apq8064_sdc3_pdata);
}
static int ncp6924_en(bool onoff)
{
int ret = 0;
if (onoff) {
ncp6924_gpio_en.output_value = 1;
ncp6924_gpio_en.pull = PM_GPIO_PULL_UP_30;
ret = pm8xxx_gpio_config(en_gpio, &ncp6924_gpio_en);
} else {
ncp6924_gpio_en.output_value = 0;
ncp6924_gpio_en.pull = PM_GPIO_PULL_DN;
ret = pm8xxx_gpio_config(en_gpio, &ncp6924_gpio_en);
}
mdelay(10);
return ret;
}
static int elite_stereo_voice_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret = 0;
struct pm_gpio param = {
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_CMOS,
.output_value = 1,
.pull = PM_GPIO_PULL_NO,
.vin_sel = PM_GPIO_VIN_L17,
.out_strength = PM_GPIO_STRENGTH_MED,
.function = PM_GPIO_FUNC_NORMAL,
};
if (elite_stereo_control == ucontrol->value.integer.value[0])
return 0;
elite_stereo_control = ucontrol->value.integer.value[0];
pr_aud_info("%s: elite_stereo_control = %d\n", __func__,
elite_stereo_control);
switch (ucontrol->value.integer.value[0]) {
case 0:
/* turn off selected pin of stereo mic to bypass A1028 */
gpio_direction_output(ELITE_AUD_STEREO_REC, 1);
gpio_free(ELITE_AUD_STEREO_REC);
break;
case 1:
/* turn on selection of stereo mic to enable A1028 */
ret = gpio_request(ELITE_AUD_STEREO_REC, "A1028_SWITCH");
if (ret) {
pr_aud_err("%s: Failed to request gpio %d\n", __func__,
ELITE_AUD_STEREO_REC);
return ret;
}
ret = pm8xxx_gpio_config(ELITE_AUD_STEREO_REC, ¶m);
if (ret)
pr_aud_err("%s: Failed to configure gpio %d\n", __func__,
ELITE_AUD_STEREO_REC);
else
gpio_direction_output(ELITE_AUD_STEREO_REC, 0);
break;
}
return ret;
}
static int msm8960_btsco_rate_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
pr_debug("%s: msm8960_btsco_rate = %d", __func__,
msm8960_btsco_rate);
ucontrol->value.integer.value[0] = msm8960_btsco_rate;
return 0;
}
static int jet_stereo_voice_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret = 0;
struct pm_gpio param = {
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_CMOS,
.output_value = 1,
.pull = PM_GPIO_PULL_NO,
.vin_sel = PM_GPIO_VIN_L17,
.out_strength = PM_GPIO_STRENGTH_MED,
.function = PM_GPIO_FUNC_NORMAL,
};
if (jet_stereo_control == ucontrol->value.integer.value[0])
return 0;
jet_stereo_control = ucontrol->value.integer.value[0];
pr_debug("%s: jet_stereo_control = %d\n", __func__,
jet_stereo_control);
switch (ucontrol->value.integer.value[0]) {
case 0:
gpio_direction_output(JET_AUD_STEREO_REC, 1);
gpio_free(JET_AUD_STEREO_REC);
break;
case 1:
ret = gpio_request(JET_AUD_STEREO_REC, "A1028_SWITCH");
if (ret) {
pr_err("%s: Failed to request gpio %d\n", __func__,
JET_AUD_STEREO_REC);
return ret;
}
ret = pm8xxx_gpio_config(JET_AUD_STEREO_REC, ¶m);
if (ret)
pr_err("%s: Failed to configure gpio %d\n", __func__,
JET_AUD_STEREO_REC);
else
gpio_direction_output(JET_AUD_STEREO_REC, 0);
break;
}
return ret;
}
static int msm_btsco_rate_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
pr_debug("%s: msm_btsco_rate = %d", __func__, msm_btsco_rate);
ucontrol->value.integer.value[0] = msm_btsco_rate;
return 0;
}
int snfc_pwr_probe_func(struct felica_device *pdevice)
{
int rc;
static struct pm_gpio hvdd_enable = {
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_CMOS,
.output_value = 0,
.pull = PM_GPIO_PULL_NO,
.vin_sel = PM_GPIO_VIN_L4,
.out_strength = PM_GPIO_STRENGTH_HIGH,
.function = PM_GPIO_FUNC_NORMAL,
.inv_int_pol = 0,
.disable_pin = 0,
};
pr_debug(PRT_NAME ": %s\n", __func__);
/* pm8xxx: gpio-44, NFC HVDD Enable */
rc = pm8xxx_gpio_config(NFC_HVDD_PM_GPIO,&hvdd_enable);
if (rc != 0){
pr_err("%s: sim_enabled failed\n", __func__);
return -EINVAL;
}
rc = gpio_request(NFC_HVDD_PM_GPIO, "hvdd_power_en");
if (rc) {
pr_err("request pm gpio 44 failed, rc=%d\n", rc);
return -EINVAL;
}
/* Create Felica Uart character device (/dev/snfc_pwr) */
if (misc_register(&snfc_pwr_device)) {
pr_err(PRT_NAME ": Error. Cannot register SNFC.\n");
return -ENOMEM;
}
return 0;
}
/**
* @brief Terminate sony NFC & USIM PWR(HVDD) controller
* @details This function executes;\n
* # Deregister sony NFC character device (/dev/snfc)\n
* # Release snfc controller's data
* @param N/A
* @retval N/A
* @note
*/
void snfc_pwr_remove_func(void)
{
pr_debug(PRT_NAME ": %s\n", __func__);
misc_deregister(&snfc_pwr_device);
gpio_free(NFC_HVDD_PM_GPIO);
}
static void shooter_3Dpanel_on(bool bLandscape)
{
struct pm8058_pwm_period pwm_conf;
int rc;
led_brightness_switch("lcd-backlight", 255);
if (system_rev >= 1) {
pwm_gpio_config.output_value = 1;
rc = pm8xxx_gpio_config(PM8058_GPIO_PM_TO_SYS(SHOOTER_3DLCM_PD), &pwm_gpio_config);
if (rc < 0)
pr_err("%s pmic gpio config gpio %d failed\n", __func__, PM8058_GPIO_PM_TO_SYS(SHOOTER_3DLCM_PD));
}
rc = pm8xxx_gpio_config(PM8058_GPIO_PM_TO_SYS(SHOOTER_3DCLK), &clk_gpio_config_on);
if (rc < 0)
pr_err("%s pmic gpio config gpio %d failed\n", __func__, SHOOTER_3DCLK);
pwm_disable(pwm_3d);
pwm_conf.pwm_size = 9;
pwm_conf.clk = PM_PWM_CLK_19P2MHZ;
pwm_conf.pre_div = PM_PWM_PREDIVIDE_3;
pwm_conf.pre_div_exp = 6;
rc = pwm_configure(pwm_3d, &pwm_conf, 1, 255);
if (rc < 0)
pr_err("%s pmic configure %d\n", __func__, rc);
pwm_enable(pwm_3d);
if (bLandscape) {
mdp4_dsi_color_enhancement(mdp_sharp_barrier_on, ARRAY_SIZE(mdp_sharp_barrier_on));
gpio_set_value(SHOOTER_CTL_3D_1, 1);
gpio_set_value(SHOOTER_CTL_3D_2, 1);
gpio_set_value(SHOOTER_CTL_3D_3, 1);
gpio_set_value(SHOOTER_CTL_3D_4, 0);
} else {
mdp4_dsi_color_enhancement(mdp_sharp_barrier_on, ARRAY_SIZE(mdp_sharp_barrier_on));
gpio_set_value(SHOOTER_CTL_3D_1, 1);
gpio_set_value(SHOOTER_CTL_3D_2, 1);
gpio_set_value(SHOOTER_CTL_3D_3, 0);
gpio_set_value(SHOOTER_CTL_3D_4, 1);
}
}
void __init deluxe_u_init_mmc(void)
{
wifi_status_cb = NULL;
printk(KERN_INFO "deluxe_u: %s\n", __func__);
/* initial WL_REG_ON */
wl_reg_on_gpio.config.output_value = 0;
pm8xxx_gpio_config(wl_reg_on_gpio.gpio, &wl_reg_on_gpio.config);
wl_dev_wake_gpio.config.output_value = 0;
pm8xxx_gpio_config(wl_dev_wake_gpio.gpio, &wl_dev_wake_gpio.config);
/* PM QoS for wifi*/
deluxe_u_wifi_data.cpu_dma_latency = msm_rpm_get_swfi_latency();
apq8064_add_sdcc(1, deluxe_u_sdc1_pdata);
apq8064_add_sdcc(3, &deluxe_u_wifi_data);
//reg_set_l7_optimum_mode();
}
static void config_gpio_table(struct pm8xxx_gpio_init *table, int len)
{
int n, rc;
for (n = 0; n < len; n++) {
rc = pm8xxx_gpio_config(table[n].gpio, &table[n].config);
if (rc) {
pr_err("%s: pm8xxx_gpio_config(%u)=%d\n", __func__, table[n].gpio, rc);
break;
}
}
}
void __init deluxe_ub1_init_mmc(void)
{
wifi_status_cb = NULL;
printk(KERN_INFO "deluxe_ub1: %s\n", __func__);
wl_reg_on_gpio.config.output_value = 0;
pm8xxx_gpio_config(wl_reg_on_gpio.gpio, &wl_reg_on_gpio.config);
wl_dev_wake_gpio.config.output_value = 0;
pm8xxx_gpio_config(wl_dev_wake_gpio.gpio, &wl_dev_wake_gpio.config);
deluxe_ub1_wifi_data.cpu_dma_latency = msm_rpm_get_swfi_latency();
apq8064_add_sdcc(1, deluxe_ub1_sdc1_pdata);
apq8064_add_sdcc(3, deluxe_ub1_sdc3_pdata);
apq8064_add_sdcc(4, &deluxe_ub1_wifi_data);
}
int m7wl_wifi_power(int on)
{
const unsigned SDC3_HDRV_PULL_CTL_ADDR = (unsigned) MSM_TLMM_BASE + 0x20A4;
#ifdef ENABLE_4335BT_WAR
int lock_cookie_wifi = 'W' | 'i'<<8 | 'F'<<16 | 'i'<<24;
printk("WiFi: trying to acquire BT lock\n");
if (bcm_bt_lock(lock_cookie_wifi) != 0)
printk("** WiFi: timeout in acquiring bt lock**\n");
else
printk("** WiFi: btlock acquired**\n");
#endif
printk(KERN_INFO "%s: %d\n", __func__, on);
if (on) {
#if 0
writel(0x1FDB, SDC3_HDRV_PULL_CTL_ADDR);
#else
sdc_pad_gpio_config(SDC3_HDRV_PULL_CTL_ADDR,
BIT_HDRIV_PULL_UP, BIT_HDRIV_PULL_UP,
HDRIV_STR_14MA, HDRIV_STR_12MA, HDRIV_STR_12MA);
#endif
config_gpio_table(wifi_on_gpio_table,
ARRAY_SIZE(wifi_on_gpio_table));
} else {
#if 0
writel(0x0BDB, SDC3_HDRV_PULL_CTL_ADDR);
#else
sdc_pad_gpio_config(SDC3_HDRV_PULL_CTL_ADDR,
BIT_HDRIV_PULL_UP, BIT_HDRIV_PULL_UP,
HDRIV_STR_2MA, HDRIV_STR_2MA, HDRIV_STR_2MA);
#endif
config_gpio_table(wifi_off_gpio_table,
ARRAY_SIZE(wifi_off_gpio_table));
}
mdelay(1);
htc_BCM4335_wl_reg_ctl((on)?BCM4335_WL_REG_ON:BCM4335_WL_REG_OFF, ID_WIFI);
mdelay(1);
#if 0
wl_dev_wake_gpio.config.output_value = on? 1: 0;
pm8xxx_gpio_config(wl_dev_wake_gpio.gpio, &wl_dev_wake_gpio.config);
#endif
mdelay(120);
#ifdef ENABLE_4335BT_WAR
bcm_bt_unlock(lock_cookie_wifi);
#endif
return 0;
}
static void shooter_u_3Dpanel_off(void)
{
int rc;
pwm_gpio_config.output_value = 0;
rc = pm8xxx_gpio_config(PM8058_GPIO_PM_TO_SYS(SHOOTER_U_3DLCM_PD), &pwm_gpio_config);
if (rc < 0)
pr_err("%s pmic gpio config gpio %d failed\n", __func__, SHOOTER_U_3DLCM_PD);
mdp4_dsi_color_enhancement(mdp_sharp_barrier_off, ARRAY_SIZE(mdp_sharp_barrier_off));
pwm_disable(pwm_3d);
rc = pm8xxx_gpio_config(PM8058_GPIO_PM_TO_SYS(SHOOTER_U_3DCLK), &clk_gpio_config_off);
if (rc < 0)
pr_err("%s pmic gpio config gpio %d failed\n", __func__, SHOOTER_U_3DCLK);
gpio_set_value(SHOOTER_U_CTL_3D_1, 0);
gpio_set_value(SHOOTER_U_CTL_3D_2, 0);
gpio_set_value(SHOOTER_U_CTL_3D_3, 0);
gpio_set_value(SHOOTER_U_CTL_3D_4, 0);
led_brightness_switch("lcd-backlight", last_br_2d);
}
void __init apq8064_init_mmc(void)
{
if (apq8064_sdc1_pdata) {
apq8064_add_sdcc(1, apq8064_sdc1_pdata);
apq8064_add_uio();
}
if (apq8064_sdc2_pdata)
apq8064_add_sdcc(2, apq8064_sdc2_pdata);
if (apq8064_sdc3_pdata) {
if (!machine_is_apq8064_cdp()) {
apq8064_sdc3_pdata->wpswitch_gpio = 0;
apq8064_sdc3_pdata->is_wpswitch_active_low = false;
}
if (machine_is_mpq8064_cdp() || machine_is_mpq8064_hrd() ||
machine_is_mpq8064_dtv()) {
int rc;
struct pm_gpio sd_card_det_init_cfg = {
.direction = PM_GPIO_DIR_IN,
.output_buffer = PM_GPIO_OUT_BUF_CMOS,
.pull = PM_GPIO_PULL_UP_30,
.vin_sel = PM_GPIO_VIN_S4,
.out_strength = PM_GPIO_STRENGTH_NO,
.function = PM_GPIO_FUNC_NORMAL,
};
apq8064_sdc3_pdata->status_gpio =
PM8921_GPIO_PM_TO_SYS(31);
apq8064_sdc3_pdata->status_irq =
PM8921_GPIO_IRQ(PM8921_IRQ_BASE, 31);
rc = pm8xxx_gpio_config(apq8064_sdc3_pdata->status_gpio,
&sd_card_det_init_cfg);
if (rc) {
pr_info("%s: SD_CARD_DET GPIO%d config "
"failed(%d)\n", __func__,
apq8064_sdc3_pdata->status_gpio, rc);
apq8064_sdc3_pdata->status_gpio = 0;
apq8064_sdc3_pdata->status_irq = 0;
}
}
if (machine_is_apq8064_cdp()) {
int i;
for (i = 0;
i < apq8064_sdc3_pdata->pin_data->pad_data->\
drv->size;
i++)
apq8064_sdc3_pdata->pin_data->pad_data->\
drv->on[i].val = GPIO_CFG_10MA;
}
apq8064_add_sdcc(3, apq8064_sdc3_pdata);
}
static void doubleshot_setup_matrix_gpio(void)
{
int rc = 0, id = 0;
int index = 0;
for (index = 0; index < KEYMAP_NUM_COLS; index++) {
id = doubleshot_sns_gpios[index];
rc = pm8xxx_gpio_config(id, &matrix_sns_config);
if (rc)
KEY_LOGE("%s: pm8058_gpio_config(%d): rc=%d\n",
__func__, id, rc);
}
}
int deluxe_u_wifi_power(int on)
{
const unsigned SDC3_HDRV_PULL_CTL_ADDR = (unsigned) MSM_TLMM_BASE + 0x20A4;
printk(KERN_INFO "%s: %d\n", __func__, on);
if (on) {
#if 0
writel(0x1FDB, SDC3_HDRV_PULL_CTL_ADDR);
#else
sdc_pad_gpio_config(SDC3_HDRV_PULL_CTL_ADDR,
BIT_HDRIV_PULL_UP, BIT_HDRIV_PULL_UP,
HDRIV_STR_8MA, HDRIV_STR_8MA, HDRIV_STR_8MA);
#endif
config_gpio_table(wifi_on_gpio_table,
ARRAY_SIZE(wifi_on_gpio_table));
} else {
#if 0
writel(0x0BDB, SDC3_HDRV_PULL_CTL_ADDR);
#else
sdc_pad_gpio_config(SDC3_HDRV_PULL_CTL_ADDR,
BIT_HDRIV_PULL_UP, BIT_HDRIV_PULL_UP,
HDRIV_STR_2MA, HDRIV_STR_2MA, HDRIV_STR_2MA);
#endif
config_gpio_table(wifi_off_gpio_table,
ARRAY_SIZE(wifi_off_gpio_table));
}
mdelay(1); /* delay 1 ms, recommanded by hardware */
wl_reg_on_gpio.config.output_value = on? 1: 0;
pm8xxx_gpio_config(wl_reg_on_gpio.gpio, &wl_reg_on_gpio.config);
mdelay(1); /* delay 1 ms, recommanded by hardware */
wl_dev_wake_gpio.config.output_value = on? 1: 0;
pm8xxx_gpio_config(wl_dev_wake_gpio.gpio, &wl_dev_wake_gpio.config);
mdelay(120);
return 0;
}
/* ---- MMC ---- */
int __init k2_ul_init_mmc()
{
uint32_t id;
struct pm_gpio pm_config;
wifi_status_cb = NULL;
printk(KERN_INFO "k2_ul: %s\n", __func__);
/* SDC4: WiFi */
#if 1 /* Temp solution to turn on sleep clock, remove this after GPIO conflict is resolved */
pm_config.direction = PM_GPIO_DIR_OUT;
pm_config.output_buffer = PM_GPIO_OUT_BUF_CMOS;
pm_config.output_value = 0;
pm_config.pull = PM_GPIO_PULL_NO;
pm_config.vin_sel = PM8038_GPIO_VIN_L11;
pm_config.out_strength = PM_GPIO_STRENGTH_HIGH;
pm_config.function = PM_GPIO_FUNC_1;
pm_config.inv_int_pol = 0;
pm_config.disable_pin = 0;
pm8xxx_gpio_config(PM8038_GPIO_PM_TO_SYS(8), &pm_config);
mdelay(5);
#endif
/* initial WIFI IO 1V8 */
/*
id = GPIO_CFG(MSM_V_WL_IO_1V8_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA);
gpio_tlmm_config(id, 0);
gpio_set_value(MSM_V_WL_IO_1V8_EN, 1);
*/
/* initial WL_DEV_WAKE (CPU wakeup wifi) */
id = GPIO_CFG(MSM_WL_DEV_WAKE, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA);
gpio_tlmm_config(id, 0);
gpio_set_value(MSM_WL_DEV_WAKE, 1);
/* initial WL_REG_ON (wifi wakeup CPU) */
id = GPIO_CFG(MSM_WL_REG_ON, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA);
gpio_tlmm_config(id, 0);
gpio_set_value(MSM_WL_REG_ON, 0);
/* PM QoS for wifi*/
k2_ul_wifi_data.cpu_dma_latency = msm_rpmrs_levels[0].latency_us;
msm_add_sdcc(4, &k2_ul_wifi_data);
return 0;
}
static int mipi_samsung_disp_on_in_video_engine(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
mfd = platform_get_drvdata(pdev);
if (unlikely(!mfd))
return -ENODEV;
if (unlikely(mfd->key != MFD_KEY))
return -EINVAL;
mipi_samsung_disp_send_cmd(mfd, PANEL_ON, false);
mfd->resume_state = MIPI_RESUME_STATE;
touch_display_status = MIPI_RESUME_STATE;
if ((msd.mpd->manufacture_id & 0xFF) == 0)
mipi_samsung_disp_send_cmd(mfd, PANEL_NEED_FLIP, false);
#if defined(RUMTIME_MIPI_CLK_CHANGE)
current_fps = mfd->panel_info.mipi.frame_rate;
#endif
/* To setting gpio_configuration under wake-up condition */
if (get_ldi_chip() == LDI_LSI) {
gpio_get_param.pull = PM_GPIO_PULL_NO;
pm8xxx_gpio_config(pm_gpio8, &gpio_get_param); /* ERR_FG */
gpio_get_param.pull = PM_GPIO_PULL_UP_1P5_30;
pm8xxx_gpio_config(pm_gpio5, &gpio_get_param); /* LDI DET */
} else {
gpio_get_param.pull = PM_GPIO_PULL_NO;
pm8xxx_gpio_config(pm_gpio8, &gpio_get_param);
pm8xxx_gpio_config(pm_gpio5, &gpio_get_param);
}
pr_info("[%s] ID : 0x%x LDI : %s", __func__, msd.mpd->manufacture_id,
ldi_manupacture == LDI_MAGNA ? "LDI_MAGNA" : "LDI_LSI");
return 0;
}
void __init m7_init_mmc(void)
{
wifi_status_cb = NULL;
printk(KERN_INFO "m7: %s\n", __func__);
wl_reg_on_gpio.config.output_value = 0;
pm8xxx_gpio_config(wl_reg_on_gpio.gpio, &wl_reg_on_gpio.config);
#if 0
wl_dev_wake_gpio.config.output_value = 0;
pm8xxx_gpio_config(wl_dev_wake_gpio.gpio, &wl_dev_wake_gpio.config);
#endif
#if 0
m7_wifi_data.swfi_latency = msm_rpm_get_swfi_latency();
#endif
apq8064_add_sdcc(1, m7_sdc1_pdata);
apq8064_add_sdcc(3, &m7_wifi_data);
}
int __init k2_plc_cl_init_mmc()
{
uint32_t id;
struct pm_gpio pm_config;
wifi_status_cb = NULL;
printk(KERN_INFO "k2_plc_cl: %s\n", __func__);
#if 1
pm_config.direction = PM_GPIO_DIR_OUT;
pm_config.output_buffer = PM_GPIO_OUT_BUF_CMOS;
pm_config.output_value = 0;
pm_config.pull = PM_GPIO_PULL_NO;
pm_config.vin_sel = PM8038_GPIO_VIN_L11;
pm_config.out_strength = PM_GPIO_STRENGTH_HIGH;
pm_config.function = PM_GPIO_FUNC_1;
pm_config.inv_int_pol = 0;
pm_config.disable_pin = 0;
pm8xxx_gpio_config(PM8038_GPIO_PM_TO_SYS(8), &pm_config);
mdelay(5);
#endif
id = GPIO_CFG(MSM_V_WL_IO_1V8_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA);
gpio_tlmm_config(id, 0);
gpio_set_value(MSM_V_WL_IO_1V8_EN, 1);
id = GPIO_CFG(MSM_WL_DEV_WAKE, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA);
gpio_tlmm_config(id, 0);
gpio_set_value(MSM_WL_DEV_WAKE, 1);
id = GPIO_CFG(MSM_WL_REG_ON, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA);
gpio_tlmm_config(id, 0);
gpio_set_value(MSM_WL_REG_ON, 0);
k2_plc_cl_wifi_data.cpu_dma_latency = msm_rpmrs_levels[0].latency_us;
msm_add_sdcc(4, &k2_plc_cl_wifi_data);
return 0;
}
void __init vivow_audio_init(void)
{
static struct pm_gpio tpa2051_pwr = {
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_CMOS,
.output_value = 0,
.pull = PM_GPIO_PULL_NO,
.vin_sel = 6, /* S3 1.8 V */
.out_strength = PM_GPIO_STRENGTH_HIGH,
.function = PM_GPIO_FUNC_NORMAL,
};
mutex_init(&bt_sco_lock);
#ifdef CONFIG_MSM7KV2_AUDIO
htc_7x30_register_analog_ops(&ops);
htc_7x30_register_icodec_ops(&iops);
htc_7x30_register_ecodec_ops(&eops);
htc_7x30_register_voice_ops(&vops);
acoustic_register_ops(&acoustic);
acdb_register_ops(&acdb);
#endif
aic3254_register_ctl_ops(&cops);
pm8xxx_gpio_config(PM8058_GPIO_PM_TO_SYS(VIVOW_AUD_SPK_SD), &tpa2051_pwr);
pm8xxx_gpio_config(PM8058_GPIO_PM_TO_SYS(VIVOW_AUD_AMP_EN), &tpa2051_pwr);
gpio_request(VIVOW_AUD_MICPATH_SEL, "aud_mic_sel");
gpio_direction_output(VIVOW_AUD_MICPATH_SEL, 1);
gpio_set_value(VIVOW_AUD_MICPATH_SEL, 0);
mutex_lock(&bt_sco_lock);
config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
gpio_set_value(VIVOW_GPIO_BT_PCM_OUT, 0);
gpio_set_value(VIVOW_GPIO_BT_PCM_SYNC, 0);
gpio_set_value(VIVOW_GPIO_BT_PCM_CLK, 0);
mutex_unlock(&bt_sco_lock);
}
static int ldi_chip(void)
{
int rc;
gpio_get_param.pull = PM_GPIO_PULL_UP_1P5_30;
rc = pm8xxx_gpio_config(pm_gpio5, &gpio_get_param);
if (rc) {
pr_err("gpio_config pm_gpio5 failed, rc=%d\n", rc);
}
ldi_manupacture = gpio_get_value(pm_gpio5);
return ldi_manupacture;
}
static int lcd_gpio_setup(int request)
{
int rc = 0;
if (!gpio_lcd_reset)
gpio_lcd_reset = PM8921_GPIO_PM_TO_SYS(MLCD_RESET_N);
if (request) {
/* LCD_PWR_EN */
rc = gpio_request(LCD_PWR_EN, "lcd power gpio");
if (rc) {
pr_err("%s: GPIO %d: request failed. rc=%d\n",
__func__, LCD_PWR_EN, rc);
return rc;
}
rc = gpio_direction_output(LCD_PWR_EN, 0);
if (rc) {
pr_err("%s: GPIO %d: direction out failed. rc=%d\n",
__func__, LCD_PWR_EN, rc);
goto out_pwr;
}
rc = pm8xxx_gpio_config(gpio_lcd_reset, &gpio43_param);
if (rc) {
pr_err("gpio_config 43 failed, rc=%d\n", rc);
return -EINVAL;
}
/* gpio_lcd_reset */
rc = gpio_request(gpio_lcd_reset, "lcd reset");
if (rc) {
pr_err("%s: GPIO %d: request failed. rc=%d\n",
__func__, gpio_lcd_reset, rc);
goto out_pwr;
}
} else {
gpio_free(LCD_PWR_EN);
gpio_free(gpio_lcd_reset);
gpio_lcd_reset = 0;
}
return rc;
out_pwr:
gpio_free(LCD_PWR_EN);
return rc;
}
static void msm8960_ext_spk_power_amp_off(u32 spk)
{
int ret = 0;
if (spk & (SPK_AMP_POS | SPK_AMP_NEG)) {
if (!msm8930_ext_spk_pamp)
return;
if (socinfo_get_pmic_model() == PMIC_MODEL_PM8917) {
gpio_free(LEFT_SPKR_AMPL_GPIO);
msm8930_ext_spk_pamp = 0;
return;
}
if (machine_is_msm8930_mtp()
|| machine_is_msm8930_fluid()) {
pr_debug("%s: Free speaker boost gpio %u\n",
__func__, SPKR_BOOST_GPIO);
gpio_direction_output(SPKR_BOOST_GPIO, 0);
gpio_free(SPKR_BOOST_GPIO);
} else if (socinfo_get_platform_subtype() ==
PLATFORM_SUBTYPE_SGLTE) {
ret = pm8xxx_gpio_config(spkr_boost_enable_gpio,
&SPKR_OFF);
if (ret) {
pr_err("%s: Failure: spkr boost gpio OFF %u\n",
__func__, spkr_boost_enable_gpio);
return;
} else {
pr_debug("%s:Config PMIC8038 gpio for speaker" \
" OFF successfully\n", __func__);
}
}
pm8xxx_spk_enable(MSM8930_SPK_OFF);
msm8930_ext_spk_pamp = 0;
pr_debug("%s: slepping 4 ms after turning on external "
" Left Speaker Ampl\n", __func__);
usleep_range(4000, 4000);
} else {
pr_err("%s: ERROR : Invalid External Speaker Ampl. spk = 0x%08x\n",
__func__, spk);
return;
}
}
void __init apq8064_init_cam(void)
{
printk(KERN_DEBUG "[JC] %s: In\n", __func__);
msm_gpiomux_install(apq8064_cam_common_configs,
ARRAY_SIZE(apq8064_cam_common_configs));
/*config gpio*/
/*pm gpio config for sleep state*/
pm8xxx_gpio_config(GPIO_VT_CAM_ID, &cam_init_in_cfg);
pm8xxx_gpio_config(GPIO_13M_CAM_RESET, &cam_init_out_cfg);
pm8xxx_gpio_config(GPIO_CAM_AF_EN, &cam_init_out_cfg);
pm8xxx_gpio_config(GPIO_VT_CAM_STBY, &cam_init_out_cfg);
#if defined(CONFIG_MACH_JACTIVE_ATT) || defined(CONFIG_MACH_JACTIVE_EUR)
#else
pm8xxx_gpio_config(GPIO_CAM_ISP_INT, &cam_init_in_cfg);
#endif
pm8xxx_gpio_config(GPIO_CAM_A_EN2, &cam_init_out_cfg);
pm8xxx_gpio_config(GPIO_CAM_SENSOR_DET, &cam_rear_det);
/* temp: need to set low because bootloader make high signal. */
pmic_gpio_ctrl(GPIO_CAM_VT_EN, 0);
printk(KERN_DEBUG "[S5K6B2YX] %s: GPIO_CAM_VT_EN: 0\n", __func__);
if (machine_is_apq8064_cdp()) {
sensor_board_info_imx074.mount_angle = 0;
sensor_board_info_mt9m114.mount_angle = 0;
} else if (machine_is_apq8064_liquid())
sensor_board_info_imx074.mount_angle = 180;
spi_register_board_info(jc_spi_info,
ARRAY_SIZE(jc_spi_info));
platform_device_register(&msm_camera_server);
#if !defined (CONFIG_CAMERA_USE_GSBI7)
platform_device_register(&msm8960_device_i2c_mux_gsbi4);
#endif
platform_device_register(&msm8960_device_csiphy0);
platform_device_register(&msm8960_device_csiphy1);
platform_device_register(&msm8960_device_csid0);
platform_device_register(&msm8960_device_csid1);
platform_device_register(&msm8960_device_ispif);
platform_device_register(&msm8960_device_vfe);
platform_device_register(&msm8960_device_vpe);
}
static int __devinit pmic8xxx_kp_config_gpio(int gpio_start, int num_gpios,
struct pmic8xxx_kp *kp, struct pm_gpio *gpio_config)
{
int rc, i;
if (gpio_start < 0 || num_gpios < 0)
return -EINVAL;
for (i = 0; i < num_gpios; i++) {
rc = pm8xxx_gpio_config(gpio_start + i, gpio_config);
if (rc) {
dev_err(kp->dev, "%s: FAIL pm8xxx_gpio_config():"
"for PM GPIO [%d] rc=%d.\n",
__func__, gpio_start + i, rc);
return rc;
}
}
return 0;
}
static void msm8x26_cable_detect_register(void)
{
#if 0
FIXME USB PORTING
int rc;
rc = pm8xxx_gpio_config(usb_id_pmic_gpio[0].gpio, &usb_id_pmic_gpio[0].config);
if (rc)
pr_info("[USB BOARD] %s: Config ERROR: GPIO=%u, rc=%d\n",
__func__, usb_id_pmic_gpio[0].gpio, rc);
cable_detect_pdata.usb_id_pin_gpio = PM8921_GPIO_PM_TO_SYS(USB1_HS_ID_GPIO);
cable_detect_pdata.mhl_reset_gpio = PM8921_GPIO_PM_TO_SYS(MHL_RSTz);
if (board_mfg_mode() == 4)
cable_detect_pdata.usb_id_pin_gpio = 0;
#endif
platform_device_register(&cable_detect_device);
}
static int msm_uart_aux_chg_uart( void )
{
int rc = 0;
// TX -> Low
uart_tx2_en_22.function = PM_GPIO_FUNC_NORMAL;
/* FUJITSU:2011-10-21 gpio chg start */
#if defined(CONFIG_MACH_F11APO) || defined(CONFIG_MACH_F12APON)
if((system_rev != 0x08) || (system_rev != 0x0F))
{
uart_tx2_en_22.out_strength = PM_GPIO_STRENGTH_MED;
}
#elif defined(CONFIG_MACH_FJI12)
if((system_rev != 0x00) || (system_rev != 0x07))
{
uart_tx2_en_22.out_strength = PM_GPIO_STRENGTH_MED;
}
#endif
/* FUJITSU:2011-10-21 gpio chg end */
/* FUJITSU:2011-12-01 mod irda start */
#if 0
rc = pm8058_gpio_config( PM8058_UART_TX2_22, &uart_tx2_en_22 );
#else
rc = pm8xxx_gpio_config( PM8058_UART_TX2_22, &uart_tx2_en_22 );
#endif
/* FUJITSU:2011-12-01 mod irda end */
if ( rc )
{
printk( KERN_ERR "%s: PM8058_UART_TX config failed\n", __func__ );
return -EIO;
}
/* FUJITSU:2011-12-01 mod irda start */
#if 0
gpio_set_value_cansleep( PM8058_GPIO_PM_TO_SYS( PM8058_UART_TX2_22 ), 0 );
#else
gpio_set_value_cansleep( PM8058_UART_TX2_22, 0 );
#endif
/* FUJITSU:2011-12-01 mod irda end */
printk( KERN_INFO DEV_NAME " %s: IRDA GPIO TX -> Low\n", __func__ );
return 0;
}
static int set_wifi_bt_fast_clk(int on)
{
int err = 0;
printk(KERN_DEBUG "%s pin=%d\n", __func__, htc_fast_clk_pin);
if (on) {
if (vreg_osc) {
err = regulator_enable(vreg_osc);
if (err)
pr_err("%s: regulator_enable error: %d", __func__, err);
}
printk(KERN_DEBUG "EN FAST CLK\n");
pmic_gpio_fast_clk_output.output_value = 1;
} else {
if (vreg_osc) {
err = regulator_disable(vreg_osc);
if (err)
pr_err("%s: regulator_disable error: %d", __func__, err);
}
printk(KERN_DEBUG "DIS FAST CLK\n");
pmic_gpio_fast_clk_output.output_value = 0;
}
err = pm8xxx_gpio_config(htc_fast_clk_pin,
&pmic_gpio_fast_clk_output);
if (err) {
if (on)
printk(KERN_DEBUG "ERR EN FAST CLK, ERR=%d\n", err);
else
printk(KERN_DEBUG "ERR DIS FAST CLK, ERR=%d\n", err);
}
return err;
}
