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));
}
Exemple #8
0
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);
}
Exemple #13
0
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;
}