static void charger_gpio_init(void)
{
int ret;
s3c_gpio_cfgpin(GPIO_TA_INT, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_TA_INT, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_OTG_VBUS_SENSE, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_OTG_VBUS_SENSE, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_VBUS_POGO_5V, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_VBUS_POGO_5V, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_OTG_VBUS_SENSE_FAC, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_OTG_VBUS_SENSE_FAC, S3C_GPIO_PULL_NONE);
s5p_gpio_set_pd_cfg(GPIO_OTG_VBUS_SENSE_FAC, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_pull(GPIO_OTG_VBUS_SENSE_FAC,
S5P_GPIO_PD_UPDOWN_DISABLE);
s3c_gpio_cfgpin(GPIO_TA_NCHG, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_TA_NCHG, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_TA_EN, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_TA_EN, S3C_GPIO_PULL_NONE);
s5p_gpio_set_pd_cfg(GPIO_TA_EN, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_pull(GPIO_TA_EN, S5P_GPIO_PD_UPDOWN_DISABLE);
s3c_gpio_cfgpin(GPIO_USB_SEL1, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_USB_SEL1, S3C_GPIO_PULL_NONE);
s5p_gpio_set_pd_pull(GPIO_USB_SEL1, S5P_GPIO_PD_UPDOWN_DISABLE);
ret = gpio_request_one(GPIO_USB_SEL1, GPIOF_OUT_INIT_HIGH, "usb_sel1");
if (ret)
pr_err("%s: cannot request gpio%d\n", __func__, GPIO_USB_SEL1);
}
static int brcm_wlan_power(int onoff)
{
printk(KERN_INFO"------------------------------------------------");
printk(KERN_INFO"------------------------------------------------\n");
printk(KERN_INFO"%s Enter: power %s\n", __func__, onoff ? "on" : "off");
if (onoff) {
s3c_config_gpio_alive_table
(ARRAY_SIZE(wlan_on_gpio_table), wlan_on_gpio_table);
s5p_gpio_set_pd_cfg(GPIO_WLAN_EN, S5P_GPIO_PD_PREV_STATE);
udelay(200);
gpio_set_value(GPIO_WLAN_EN, GPIO_LEVEL_HIGH);
printk(KERN_DEBUG"WLAN: GPIO_WLAN_EN = %d\n",
gpio_get_value(GPIO_WLAN_EN));
} else {
gpio_set_value(GPIO_WLAN_EN, GPIO_LEVEL_LOW);
s3c_config_gpio_alive_table
(ARRAY_SIZE(wlan_off_gpio_table), wlan_off_gpio_table);
s5p_gpio_set_pd_cfg(GPIO_WLAN_EN, S5P_GPIO_PD_OUTPUT0);
printk(KERN_DEBUG"WLAN: GPIO_WLAN_EN = %d\n",
gpio_get_value(GPIO_WLAN_EN));
}
return 0;
}
static void mxt_gpio_init(void)
{
/* touch interrupt */
gpio_request(GPIO_TOUCH_CHG, "TSP_INT");
s3c_gpio_cfgpin(GPIO_TOUCH_CHG, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_TOUCH_CHG, S3C_GPIO_PULL_NONE);
s5p_register_gpio_interrupt(GPIO_TOUCH_CHG);
s3c_gpio_setpull(GPIO_TSP_SCL_18V, S3C_GPIO_PULL_NONE);
s3c_gpio_setpull(GPIO_TSP_SDA_18V, S3C_GPIO_PULL_NONE);
gpio_request_one(GPIO_TOUCH_RESET, GPIOF_OUT_INIT_LOW, "atmel_mxt_ts nRESET");
gpio_request(GPIO_TOUCH_EN, "GPIO_TOUCH_EN");
s3c_gpio_cfgpin(GPIO_TOUCH_EN, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_TOUCH_EN, S3C_GPIO_PULL_NONE);
gpio_request(GPIO_TOUCH_EN_1, "GPIO_TOUCH_EN_1");
s3c_gpio_cfgpin(GPIO_TOUCH_EN_1, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_TOUCH_EN_1, S3C_GPIO_PULL_NONE);
s5p_gpio_set_pd_cfg(GPIO_TOUCH_CHG, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_pull(GPIO_TOUCH_CHG, S5P_GPIO_PD_UPDOWN_DISABLE);
s5p_gpio_set_pd_cfg(GPIO_TOUCH_RESET, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_cfg(GPIO_TOUCH_EN, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_cfg(GPIO_TOUCH_EN_1, S5P_GPIO_PD_PREV_STATE);
}
void __init exynos5_manta_display_init(void)
{
struct resource *res;
/* LCD_EN , XMMC2CDN => GPC2_2 */
gpio_request_one(GPIO_LCD_EN, GPIOF_OUT_INIT_LOW, "LCD_EN");
/* LED_BACKLIGHT_RESET: XCI1RGB_5 => GPG0_5 */
gpio_request_one(GPIO_LED_BL_RST, GPIOF_OUT_INIT_LOW, "LED_BL_RST");
s5p_gpio_set_pd_cfg(GPIO_LED_BL_RST, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_pull(GPIO_LED_BL_RST, S5P_GPIO_PD_UPDOWN_DISABLE);
gpio_request_one(GPIO_LCD_PWM_IN_18V, GPIOF_OUT_INIT_LOW, "PWM_IN_18V");
s5p_gpio_set_pd_cfg(GPIO_LCD_PWM_IN_18V, S5P_GPIO_PD_INPUT);
s5p_gpio_set_pd_pull(GPIO_LCD_PWM_IN_18V, S5P_GPIO_PD_UP_ENABLE);
gpio_free(GPIO_LCD_PWM_IN_18V);
gpio_request_one(GPIO_APS_EN_18V, GPIOF_OUT_INIT_LOW, "APS_EN_18V");
s5p_gpio_set_pd_cfg(GPIO_APS_EN_18V, S5P_GPIO_PD_INPUT);
s5p_gpio_set_pd_pull(GPIO_APS_EN_18V, S5P_GPIO_PD_UP_ENABLE);
gpio_export(GPIO_APS_EN_18V, true);
samsung_bl_set(&manta_bl_gpio_info, &manta_bl_data);
s5p_fimd1_set_platdata(&manta_lcd1_pdata);
dev_set_name(&s5p_device_fimd1.dev, "exynos5-fb.1");
clk_add_alias("lcd", "exynos5-fb.1", "fimd", &s5p_device_fimd1.dev);
s5p_dp_set_platdata(&manta_dp_data);
gpio_request_one(GPIO_HDMI_HPD, GPIOF_IN, "HDMI_HPD");
/* HDMI Companion DC/DC converter and HPD circuitry */
gpio_request_one(GPIO_HDMI_DCDC_EN, GPIOF_OUT_INIT_HIGH, "HDMI_DCDC_EN");
/* HDMI Companion level shifters and LDO */
gpio_request_one(GPIO_HDMI_LS_EN, GPIOF_OUT_INIT_HIGH, "HDMI_LS_EN");
s5p_hdmi_set_platdata(&hdmi_platdata);
dev_set_name(&s5p_device_hdmi.dev, "exynos5-hdmi");
clk_add_alias("hdmi", "s5p-hdmi", "hdmi", &s5p_device_hdmi.dev);
platform_set_sysmmu(&SYSMMU_PLATDEV(tv).dev, &s5p_device_mixer.dev);
s5p_i2c_hdmiphy_set_platdata(NULL);
platform_add_devices(manta_display_devices,
ARRAY_SIZE(manta_display_devices));
exynos5_fimd1_setup_clock(&s5p_device_fimd1.dev,
"sclk_fimd", "sclk_vpll", 268 * MHZ);
res = platform_get_resource(&s5p_device_fimd1, IORESOURCE_MEM, 1);
if (res) {
res->start = manta_bootloader_fb_start;
res->end = res->start + manta_bootloader_fb_size - 1;
pr_info("bootloader fb located at %8X-%8X\n", res->start,
res->end);
} else {
pr_err("failed to find bootloader fb resource\n");
}
}
void exynos5410_c2c_cfg_gpio(enum c2c_buswidth rx_width,
enum c2c_buswidth tx_width, void __iomem *etc8drv_addr)
{
int i;
s5p_gpio_drvstr_t lv1 = S5P_GPIO_DRVSTR_LV1;
s5p_gpio_drvstr_t lv3 = S5P_GPIO_DRVSTR_LV3;
s5p_gpio_pd_cfg_t pd_cfg = S5P_GPIO_PD_INPUT;
s5p_gpio_pd_pull_t pd_pull = S5P_GPIO_PD_DOWN_ENABLE;
/* Set GPIO for C2C Rx */
s3c_gpio_cfgrange_nopull(EXYNOS5410_GPV0(0), 8, C2C_SFN);
for (i = 0; i < 8; i++) {
s5p_gpio_set_drvstr(EXYNOS5410_GPV0(i), lv1);
s5p_gpio_set_pd_cfg(EXYNOS5410_GPV0(i), pd_cfg);
s5p_gpio_set_pd_pull(EXYNOS5410_GPV0(i), pd_pull);
}
if (rx_width == C2C_BUSWIDTH_16) {
s3c_gpio_cfgrange_nopull(EXYNOS5410_GPV1(0), 8, C2C_SFN);
for (i = 0; i < 8; i++) {
s5p_gpio_set_drvstr(EXYNOS5410_GPV1(i), lv1);
s5p_gpio_set_pd_cfg(EXYNOS5410_GPV1(i), pd_cfg);
s5p_gpio_set_pd_pull(EXYNOS5410_GPV1(i), pd_pull);
}
} else if (rx_width == C2C_BUSWIDTH_10) {
s3c_gpio_cfgrange_nopull(EXYNOS5410_GPV1(0), 2, C2C_SFN);
for (i = 0; i < 2; i++) {
s5p_gpio_set_drvstr(EXYNOS5410_GPV1(i), lv1);
s5p_gpio_set_pd_cfg(EXYNOS5410_GPV1(i), pd_cfg);
s5p_gpio_set_pd_pull(EXYNOS5410_GPV1(i), pd_pull);
}
}
/* Set GPIO for C2C Tx */
s3c_gpio_cfgrange_nopull(EXYNOS5410_GPV2(0), 8, C2C_SFN);
for (i = 0; i < 8; i++)
s5p_gpio_set_drvstr(EXYNOS5410_GPV2(i), lv3);
if (tx_width == C2C_BUSWIDTH_16) {
s3c_gpio_cfgrange_nopull(EXYNOS5410_GPV3(0), 8, C2C_SFN);
for (i = 0; i < 8; i++)
s5p_gpio_set_drvstr(EXYNOS5410_GPV3(i), lv3);
} else if (tx_width == C2C_BUSWIDTH_10) {
s3c_gpio_cfgrange_nopull(EXYNOS5410_GPV3(0), 2, C2C_SFN);
for (i = 0; i < 2; i++)
s5p_gpio_set_drvstr(EXYNOS5410_GPV3(i), lv3);
}
/* Set GPIO for WakeReqOut/In */
s3c_gpio_cfgrange_nopull(EXYNOS5410_GPV4(0), 2, C2C_SFN);
s5p_gpio_set_pd_cfg(EXYNOS5410_GPV4(0), pd_cfg);
s5p_gpio_set_pd_pull(EXYNOS5410_GPV4(0), pd_pull);
writel(0x5, etc8drv_addr);
}
/* Define this function in accordance with the specification of each BB vendor */
void setgpio_for_sleepdebug(int gpionum, unsigned char io_pdpu_lh)
{
unsigned char temp_io, temp_pdpu, temp_lh;
int temp_data = io_pdpu_lh;
int gpio;
temp_io = (0xF0 & io_pdpu_lh) >> 4;
temp_pdpu = (0x0E & io_pdpu_lh) >> 1;
temp_lh = 0x01 & io_pdpu_lh;
pr_info("[GPIO_DVS][%s] gpionum=%d, io_pdpu_lh=%d\n",
__func__, gpionum, io_pdpu_lh);
gpio = exynos3_gpio_num[gpionum];
/* in case of 'INPUT', set PD/PU */
if (temp_io == 0x01) {
/* 0x0:NP, 0x1:PD, 0x2:PU */
if ((gpio >= EXYNOS3_GPX0(0)) &&
(gpio <= EXYNOS3_GPX3(7))) {
if (temp_pdpu == 0x0)
temp_data = S3C_GPIO_PULL_NONE;
else if (temp_pdpu == 0x1)
temp_data = S3C_GPIO_PULL_DOWN;
else if (temp_pdpu == 0x2)
temp_data = S3C_GPIO_PULL_UP;
} else {
if (temp_pdpu == 0x0)
temp_data = S5P_GPIO_PD_UPDOWN_DISABLE;
else if (temp_pdpu == 0x1)
temp_data = S5P_GPIO_PD_DOWN_ENABLE;
else if (temp_pdpu == 0x2)
temp_data = S5P_GPIO_PD_UP_ENABLE;
}
set_gpio_pdpu(gpionum, temp_data);
}
/* in case of 'OUTPUT', set L/H */
else if (temp_io == 0x02) {
pr_info("[GPIO_DVS][%s] %d gpio set %d\n",
__func__, gpionum, temp_lh);
if ((gpio >= EXYNOS3_GPX0(0)) && (gpio <= EXYNOS3_GPX3(7)))
gpio_set_value(gpio, temp_lh);
else {
if (temp_lh == 0x0)
s5p_gpio_set_pd_cfg(gpio, S5P_GPIO_PD_OUTPUT0);
else
s5p_gpio_set_pd_cfg(gpio, S5P_GPIO_PD_OUTPUT1);
}
}
}
void __init exynos5_manta_audio_init(void)
{
manta_audio_setup_clocks();
s5p_gpio_set_pd_cfg(GPIO_ES305_WAKEUP, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_cfg(GPIO_ES305_RESET, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_cfg(GPIO_ES305_CLK_EN, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_cfg(GPIO_CODEC_LDO_EN, S5P_GPIO_PD_PREV_STATE);
i2c_register_board_info(4, i2c_devs4, ARRAY_SIZE(i2c_devs4));
i2c_register_board_info(7, i2c_devs7, ARRAY_SIZE(i2c_devs7));
platform_add_devices(manta_audio_devices,
ARRAY_SIZE(manta_audio_devices));
}
int exynos4_pmu_cp_init(void)
{
u32 cp_ctrl;
int ret = 0;
unsigned int gpio;
pr_info("%s\n", __func__);
if (samsung_rev() == EXYNOS3470_REV_2_0) {
gpio = EXYNOS4_GPM2(3);
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(1));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_pd_cfg(gpio, S5P_GPIO_PD_OUTPUT1);
s5p_gpio_set_data(gpio, 1);
s5p_gpio_set_pd_pull(gpio, S3C_GPIO_PULL_NONE);
}
cp_ctrl = __raw_readl(EXYNOS3470_CP_CTRL);
cp_ctrl |= MASK_CP_PWRDN_DONE;
__raw_writel(cp_ctrl, EXYNOS3470_CP_CTRL);
#ifdef DEBUG_SLEEP_WITHOUT_CP
/* test purpose */
exynos4_set_cp_power_onoff(CP_POWER_ON);
exynos4_cp_reset();
exynos4_clear_cp_reset_req();
exynos4_set_cp_power_onoff(CP_POWER_OFF);
exynos4_set_cp_power_onoff(CP_POWER_ON);
#endif
return ret;
}
void __init exynos5_manta_battery_init(void)
{
int hw_rev = exynos5_manta_get_revision();
charger_gpio_init();
INIT_DELAYED_WORK(&redetect_work, redetect_work_proc);
wake_lock_init(&manta_bat_chgdetect_wakelock, WAKE_LOCK_SUSPEND,
"manta-chgdetect");
wake_lock_init(&manta_bat_redetect_wl, WAKE_LOCK_SUSPEND,
"manta-chgredetect");
if (hw_rev >= MANTA_REV_DOGFOOD02) {
s3c_gpio_cfgpin(GPIO_1WIRE_SLEEP, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_1WIRE_SLEEP, S3C_GPIO_PULL_NONE);
s5p_gpio_set_pd_cfg(GPIO_1WIRE_SLEEP, S5P_GPIO_PD_INPUT);
s5p_gpio_set_pd_pull(GPIO_1WIRE_SLEEP,
S5P_GPIO_PD_UPDOWN_DISABLE);
ds2483_pdata.slpz_gpio = GPIO_1WIRE_SLEEP;
}
i2c_register_board_info(2, i2c_devs2, ARRAY_SIZE(i2c_devs2));
ta_adc_client =
s3c_adc_register(&manta_bat_s3c_client_dev, NULL, NULL, 0);
if (IS_ERR_OR_NULL(debugfs_create_file("manta-power", S_IRUGO, NULL,
NULL, &manta_power_debug_fops)))
pr_err("failed to create manta-power debugfs entry\n");
if (IS_ERR_OR_NULL(debugfs_create_file("manta-power-adc", S_IRUGO, NULL,
NULL,
&manta_power_adc_debug_fops)))
pr_err("failed to create manta-power-adc debugfs entry\n");
}
static void config_sleep_gpio(struct gpio_sleep_data *table, u32 arr_size)
{
u32 i;
for (i = 0; i < arr_size; i++) {
s5p_gpio_set_pd_pull(table[i].num, table[i].pud);
s5p_gpio_set_pd_cfg(table[i].num, table[i].cfg);
}
}
static int sec_cfg_pm_wrst(void)
{
int gpio = UNIVERSAL5260_GPIO_WRST;
if (gpio_request(gpio, "PM_WRST")) {
pr_err("%s : PM_WRST request port erron", __func__);
}
gpio_direction_output(gpio, 1);
s5p_gpio_set_pd_cfg(gpio, S5P_GPIO_PD_PREV_STATE);
return 0;
}
static void synaptics_dsx_gpio_init(void)
{
/* touch interrupt */
gpio_request(DSX_ATTN_GPIO, "TSP_INT");
s3c_gpio_cfgpin(DSX_ATTN_GPIO, S3C_GPIO_INPUT);
s3c_gpio_setpull(DSX_ATTN_GPIO, S3C_GPIO_PULL_NONE);
s5p_register_gpio_interrupt(DSX_ATTN_GPIO);
s3c_gpio_setpull(GPIO_TSP_SCL_18V, S3C_GPIO_PULL_NONE);
s3c_gpio_setpull(GPIO_TSP_SDA_18V, S3C_GPIO_PULL_NONE);
gpio_request_one(DSX_RESET_GPIO,
GPIOF_OUT_INIT_LOW, "synaptics_dsx_i2c nRESET");
gpio_request(DSX_AVDD_GPIO, "GPIO_TOUCH_EN");
s3c_gpio_cfgpin(DSX_AVDD_GPIO, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(DSX_AVDD_GPIO, S3C_GPIO_PULL_NONE);
s5p_gpio_set_pd_cfg(DSX_ATTN_GPIO, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_pull(DSX_ATTN_GPIO, S5P_GPIO_PD_UPDOWN_DISABLE);
s5p_gpio_set_pd_cfg(DSX_RESET_GPIO, S5P_GPIO_PD_PREV_STATE);
s5p_gpio_set_pd_cfg(DSX_AVDD_GPIO, S5P_GPIO_PD_PREV_STATE);
}
inline void mx_set_sleep_pin(unsigned int pin, s5p_gpio_pd_cfg_t conpdn, s5p_gpio_pd_pull_t pudpdn)
{
s5p_gpio_set_pd_cfg(pin, conpdn);
s5p_gpio_set_pd_pull(pin, pudpdn);
}
static void umts_modem_cfg_gpio(void)
{
int err = 0;
unsigned gpio_reset_req_n = umts_modem_data.gpio_reset_req_n;
unsigned gpio_cp_on = umts_modem_data.gpio_cp_on;
unsigned gpio_cp_rst = umts_modem_data.gpio_cp_reset;
unsigned gpio_pda_active = umts_modem_data.gpio_pda_active;
unsigned gpio_phone_active = umts_modem_data.gpio_phone_active;
unsigned gpio_cp_dump_int = umts_modem_data.gpio_cp_dump_int;
unsigned gpio_ap_dump_int = umts_modem_data.gpio_ap_dump_int;
unsigned gpio_flm_uart_sel = umts_modem_data.gpio_flm_uart_sel;
unsigned gpio_sim_detect = umts_modem_data.gpio_sim_detect;
unsigned irq_phone_active = umts_modem_res[0].start;
if (gpio_reset_req_n) {
err = gpio_request(gpio_reset_req_n, "RESET_REQ_N");
if (err) {
pr_err(LOG_TAG "fail to request gpio %s : %d\n",
"RESET_REQ_N", err);
}
s5p_gpio_set_pd_cfg(gpio_reset_req_n, S5P_GPIO_PD_OUTPUT1);
gpio_direction_output(gpio_reset_req_n, 0);
}
if (gpio_cp_on) {
err = gpio_request(gpio_cp_on, "CP_ON");
if (err) {
pr_err(LOG_TAG "fail to request gpio %s : %d\n",
"CP_ON", err);
}
gpio_direction_output(gpio_cp_on, 0);
}
if (gpio_cp_rst) {
err = gpio_request(gpio_cp_rst, "CP_RST");
if (err) {
pr_err(LOG_TAG "fail to request gpio %s : %d\n",
"CP_RST", err);
}
s5p_gpio_set_pd_cfg(gpio_cp_rst, S5P_GPIO_PD_OUTPUT1);
gpio_direction_output(gpio_cp_rst, 0);
}
if (gpio_pda_active) {
err = gpio_request(gpio_pda_active, "PDA_ACTIVE");
if (err) {
pr_err(LOG_TAG "fail to request gpio %s : %d\n",
"PDA_ACTIVE", err);
}
gpio_direction_output(gpio_pda_active, 0);
}
if (gpio_phone_active) {
err = gpio_request(gpio_phone_active, "PHONE_ACTIVE");
if (err) {
pr_err(LOG_TAG "fail to request gpio %s : %d\n",
"PHONE_ACTIVE", err);
}
gpio_direction_input(gpio_phone_active);
pr_err(LOG_TAG "check phone active = %d\n", irq_phone_active);
}
if (gpio_sim_detect) {
err = gpio_request(gpio_sim_detect, "SIM_DETECT");
if (err)
printk(KERN_ERR "fail to request gpio %s: %d\n",
"SIM_DETECT", err);
/* gpio_direction_input(gpio_sim_detect); */
s3c_gpio_cfgpin(gpio_sim_detect, S3C_GPIO_SFN(0xF));
s3c_gpio_setpull(gpio_sim_detect, S3C_GPIO_PULL_NONE);
irq_set_irq_type(gpio_to_irq(gpio_sim_detect),
IRQ_TYPE_EDGE_BOTH);
}
if (gpio_cp_dump_int) {
err = gpio_request(gpio_cp_dump_int, "CP_DUMP_INT");
if (err) {
pr_err(LOG_TAG "fail to request gpio %s : %d\n",
"CP_DUMP_INT", err);
}
gpio_direction_input(gpio_cp_dump_int);
}
if (gpio_ap_dump_int) {
err = gpio_request(gpio_ap_dump_int, "AP_DUMP_INT");
if (err) {
pr_err(LOG_TAG "fail to request gpio %s : %d\n",
"AP_DUMP_INT", err);
}
gpio_direction_output(gpio_ap_dump_int, 0);
}
if (gpio_flm_uart_sel) {
err = gpio_request(gpio_flm_uart_sel, "GPS_UART_SEL");
if (err) {
pr_err(LOG_TAG "fail to request gpio %s : %d\n",
"GPS_UART_SEL", err);
}
gpio_direction_output(gpio_reset_req_n, 0);
}
if (gpio_phone_active)
irq_set_irq_type(gpio_to_irq(gpio_phone_active),
IRQ_TYPE_LEVEL_HIGH);
/* set low unused gpios between AP and CP */
err = gpio_request(GPIO_SUSPEND_REQUEST, "SUS_REQ");
if (err)
pr_err(LOG_TAG "fail to request gpio %s : %d\n", "SUS_REQ",
err);
else {
gpio_direction_output(GPIO_SUSPEND_REQUEST, 0);
s3c_gpio_setpull(GPIO_SUSPEND_REQUEST, S3C_GPIO_PULL_NONE);
}
pr_info(LOG_TAG "umts_modem_cfg_gpio done\n");
}
int bcm4329_wifi_power(int on)
{
int ret;
struct regulator *wlan32k_regulator;
static int regulator_flag = 0;
printk("%s: %d\n", __func__, on);
/*stuttgart, enable max77676 32khz for wlan*/
wlan32k_regulator = regulator_get(NULL, "wlan_32khz");
if(IS_ERR(wlan32k_regulator)){
pr_err("%s: failed to get %s\n", __func__, "wlan_32khz");
return -1;
};
/*end*/
mdelay(100);
if(on)
{
/*stuttgart, enable max77676 32khz for wlan*/
if(!regulator_flag) {
regulator_enable(wlan32k_regulator);
regulator_flag = 1;
}
/*end*/
/* ret = gpio_request(WL_REG_ON, WL_REG_ON_DES);
if (ret)
printk(KERN_ERR "#### failed to request GPK3-2\n ");
*/ s3c_gpio_cfgpin(WL_REG_ON, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(WL_REG_ON, S3C_GPIO_PULL_NONE);
gpio_set_value(WL_REG_ON, 1);
s5p_gpio_set_pd_cfg(WL_REG_ON, S5P_GPIO_PD_OUTPUT1);
s5p_gpio_set_pd_pull(WL_REG_ON, S5P_GPIO_PD_UPDOWN_DISABLE);
/*
ret = gpio_request(EXYNOS4_GPX2(7), "GPX2");
if (ret)
printk(KERN_ERR "#### failed to request GPX2-7\n ");
s3c_gpio_cfgpin(EXYNOS4_GPX2(7), S3C_GPIO_SFN(0x2));
s3c_gpio_setpull (EXYNOS4_GPX2(7),S3C_GPIO_PULL_NONE);
*/
//irq_set_irq_wake(gpio_to_irq(EXYNOS4_GPX2(7)), 1);
}
else
{
s3c_gpio_cfgpin(WL_REG_ON, S3C_GPIO_INPUT);
s3c_gpio_setpull(WL_REG_ON, S3C_GPIO_PULL_DOWN);
s5p_gpio_set_pd_cfg(WL_REG_ON, S5P_GPIO_PD_INPUT);
s5p_gpio_set_pd_pull(WL_REG_ON, S5P_GPIO_PD_DOWN_ENABLE);
//irq_set_irq_wake(gpio_to_irq(EXYNOS4_GPX2(7)), 0);
/*
s3c_gpio_cfgpin(EXYNOS4_GPX2(7), S3C_GPIO_INPUT);
s3c_gpio_setpull (EXYNOS4_GPX2(7),S3C_GPIO_PULL_DOWN);
*/
/*gpio_free(WL_REG_ON);*/
/*gpio_free(EXYNOS4_GPX2(7));*/
/*stuttgart, disable max77676 32khz for wlan*/
if(regulator_flag) {
regulator_disable(wlan32k_regulator);
regulator_flag = 0;
}
/*end*/
}
/*stuttgart, put regulator*/
regulator_put(wlan32k_regulator);
/*end*/
mdelay(200);
bcm4329_wifi_power_state = on;
return 0;
}