void s3c_setup_cdmauart_cfg_gpio(unsigned char port)
{
if (port == 1)
{
s3c_gpio_cfgpin(GPIO_CDMADATA_RXD, S3C_GPIO_SFN(GPIO_CDMADATA_RXD_AF));
s3c_gpio_setpull(GPIO_CDMADATA_RXD, S3C_GPIO_PULL_UP);
s3c_gpio_slp_cfgpin(GPIO_CDMADATA_RXD, S3C_GPIO_SLP_INPUT);
s3c_gpio_slp_setpull_updown(GPIO_CDMADATA_RXD, S3C_GPIO_PULL_UP);
s3c_gpio_cfgpin(GPIO_CDMADATA_TXD, S3C_GPIO_SFN(GPIO_CDMADATA_TXD_AF));
s3c_gpio_setpull(GPIO_CDMADATA_TXD, S3C_GPIO_PULL_UP);
//s3c_gpio_slp_cfgpin(GPIO_CDMADATA_TXD, S3C_GPIO_SLP_OUT1);
//s3c_gpio_slp_setpull_updown(GPIO_CDMADATA_TXD, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_CDMADATA_CTS, S3C_GPIO_SFN(GPIO_CDMADATA_CTS_AF));
s3c_gpio_setpull(GPIO_CDMADATA_CTS, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_CDMADATA_RTS, S3C_GPIO_SFN(GPIO_CDMADATA_RTS_AF));
s3c_gpio_setpull(GPIO_CDMADATA_RTS, S3C_GPIO_PULL_NONE);
}
else if (port == 3)
{
s3c_gpio_cfgpin(GPIO_CDMACTRL_RXD, S3C_GPIO_SFN(GPIO_CDMACTRL_RXD_AF));
s3c_gpio_setpull(GPIO_CDMACTRL_RXD, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(GPIO_CDMACTRL_RXD, S3C_GPIO_SLP_INPUT);
s3c_gpio_slp_setpull_updown(GPIO_CDMACTRL_RXD, S3C_GPIO_PULL_UP);
s3c_gpio_cfgpin(GPIO_CDMACTRL_TXD, S3C_GPIO_SFN(GPIO_CDMACTRL_TXD_AF));
s3c_gpio_setpull(GPIO_CDMACTRL_TXD, S3C_GPIO_PULL_UP);
}
}
s3c_setup_keypad_cfg_gpio_sleep(int rows, int columns)
{
unsigned int gpio;
unsigned int end;
/* set KBR */
end = S5PV210_GPH3(rows);
for (gpio = S5PV210_GPH3(0); gpio < end; gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT);
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
}
/* set KBC */
/* KEYPAD SCAN/COLUMN */
columns -= 2 ; /* except scan[6~7] */
end = S5PV210_GPH2(columns);
for (gpio = S5PV210_GPH2(0); gpio < end; gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT);
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP);
}
s3c_gpio_slp_cfgpin(GPIO_KEYSCAN6, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_KEYSCAN6, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(GPIO_KEYSCAN7, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_KEYSCAN7, S3C_GPIO_PULL_NONE);
}
void s3c_config_gpio_table(int array_size, int (*gpio_table)[6])
{
u32 i, gpio;
pr_debug("%s: ++\n", __func__);
for (i = 0; i < array_size; i++) {
gpio = gpio_table[i][0];
if (gpio < S3C64XX_GPIO_ALIVE_PART_BASE) { /* Off Part */
pr_debug("%s: Off gpio=%d,%d\n", __func__, gpio,
S3C64XX_GPIO_ALIVE_PART_BASE);
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(gpio_table[i][1]));
s3c_gpio_setpull(gpio, gpio_table[i][3]);
s3c_gpio_slp_cfgpin(gpio, gpio_table[i][4]);
s3c_gpio_slp_setpull_updown(gpio, gpio_table[i][5]);
if (gpio_table[i][2] != GPIO_LEVEL_NONE)
gpio_set_value(gpio, gpio_table[i][2]);
} else if (gpio < S3C64XX_GPIO_MEM_PART_BASE) { /* Alive Part */
pr_debug("%s: Alive gpio=%d\n", __func__, gpio);
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(gpio_table[i][1]));
s3c_gpio_setpull(gpio, gpio_table[i][3]);
if (gpio_table[i][2] != GPIO_LEVEL_NONE)
gpio_set_value(gpio, gpio_table[i][2]);
} else { /* Memory Part */
pr_debug("%s: Memory gpio=%d\n", __func__, gpio);
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(gpio_table[i][1]));
s3c_gpio_setpull(gpio, gpio_table[i][3]);
s3c_gpio_slp_cfgpin(gpio, gpio_table[i][4]);
s3c_gpio_slp_setpull_updown(gpio, gpio_table[i][5]);
if (gpio_table[i][2] != GPIO_LEVEL_NONE)
gpio_set_value(gpio, gpio_table[i][2]);
}
}
pr_debug("%s: --\n", __func__);
}
static int lcd_power_on(void *ld, int enable)
{
int ret = 0;
pr_info("%s: enable=%d\n", __func__, enable);
#ifdef CONFIG_FB_SUPPORT_ALPM
if (enable) {
if (get_alpm_mode()) {
pr_info("%s : skip lcd power on : alpm mode : on\n", __func__);
alpm_status = LCD_STATUS_ALPM_LCD_ON;
} else {
pr_info("%s : panel on\n", __func__);
if (alpm_status == LCD_STATUS_OFF) {
pr_info("%s power on include reset\n", __func__);
ret = s6e63j0x03_power_on();
reset_lcd();
} else if (alpm_status == LCD_STATUS_KNOWN) {
pr_info("%s power on not include reset\n", __func__);
ret = s6e63j0x03_power_on();
}
alpm_status = LCD_STATUS_ON;
}
} else {
if (get_alpm_mode()) {
pr_info("%s : skip lcd power off : alpm mode : on\n", __func__);
alpm_status = LCD_STATUS_ALPM_LCD_OFF;
/*To keep high in sleep mode when alpm on */
s3c_gpio_slp_cfgpin(GPIO_MLCD_RST, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_MLCD_RST, S3C_GPIO_PULL_NONE);
} else {
pr_info("%s : panel off\n", __func__);
ret = s6e63j0x03_power_off();
s3c_gpio_slp_cfgpin(GPIO_MLCD_RST, S3C_GPIO_SLP_INPUT);
s3c_gpio_slp_setpull_updown(GPIO_MLCD_RST, S3C_GPIO_PULL_DOWN);
alpm_status = LCD_STATUS_OFF;
}
}
#else
if (enable)
ret = s6e63j0x03_power_on();
else
ret = s6e63j0x03_power_off();
#endif
return ret;
}
int mic_set_path(int path)
{
/* NLAS3158 - H : MAIN, L : SUB */
if (path == AK4671_MIC_PATH_MAIN) {
P("MIC PATH : MAIN(1)");
gpio_set_value(GPIO_MIC_SEL, 1);
s3c_gpio_slp_cfgpin(GPIO_MIC_SEL, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_MIC_SEL, S3C_GPIO_PULL_NONE);
} else {
P("MIC PATH : SUB(0)");
gpio_set_value(GPIO_MIC_SEL, 0);
s3c_gpio_slp_cfgpin(GPIO_MIC_SEL, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_MIC_SEL, S3C_GPIO_PULL_NONE);
}
return 0;
}
static void config_sleep_gpio_table(int array_size,
unsigned int (*gpio_table)[3])
{
u32 i, gpio;
for (i = 0; i < array_size; i++) {
gpio = gpio_table[i][0];
s3c_gpio_slp_cfgpin(gpio, gpio_table[i][1]);
s3c_gpio_slp_setpull_updown(gpio, gpio_table[i][2]);
}
}
static int __init aries_init_touchkey_led(void)
{
int i;
int ret = 0;
u32 gpio;
down(&i2c_sem);
if (!machine_is_aries() || !aries_is_tft_dev())
return 0;
for (i = 0; i < ARRAY_SIZE(led_gpios); i++) {
gpio = S5PV210_GPJ3(led_gpios[i]);
ret = gpio_request(gpio, "touchkey led");
if (ret) {
pr_err("Failed to request touchkey led gpio %d\n", i);
goto err_req;
}
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(gpio, S3C_GPIO_SLP_PREV);
s3c_gpio_slp_setpull_updown(gpio, S3C_GPIO_PULL_NONE);
}
aries_touchkey_led_onoff(1);
register_early_suspend(&early_suspend);
#ifdef CONFIG_BLD
register_bld_implementation(&aries_touchkey_bld);
#endif
if (misc_register(&bl_led_device))
printk("%s misc_register(%s) failed\n", __FUNCTION__, bl_led_device.name);
else {
if (sysfs_create_group(&bl_led_device.this_device->kobj, &bl_led_group) < 0)
pr_err("failed to create sysfs group for device %s\n", bl_led_device.name);
}
/* Initialize wake locks */
wake_lock_init(&sBlinkWakeLock, WAKE_LOCK_SUSPEND, "blink_wake");
setup_timer(&blink_timer, blink_timer_callback, 0);
up(&i2c_sem);
return 0;
err_req:
while (--i >= 0)
gpio_free(S5PV210_GPJ3(led_gpios[i]));
up(&i2c_sem);
return ret;
}
BOOLEAN hwGPIOInit(void)
{
ENTER;
// Init each pin -> set function and pull disable
s3c_gpio_cfgpin(WIMAX_WAKEUP, S3C_GPIO_SFN(1)); // set MEM0 interface
s3c_gpio_setpull(WIMAX_WAKEUP, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(WIMAX_IF_MODE0, S3C_GPIO_SFN(1));
s3c_gpio_setpull(WIMAX_IF_MODE0, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(WIMAX_IF_MODE1, S3C_GPIO_SFN(1));
s3c_gpio_setpull(WIMAX_IF_MODE1, S3C_GPIO_PULL_NONE);
gpio_set_value(WIMAX_IF_MODE1, GPIO_LEVEL_LOW);
s3c_gpio_cfgpin(WIMAX_CON0, S3C_GPIO_INPUT);
s3c_gpio_setpull(WIMAX_CON0, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(WIMAX_CON2, S3C_GPIO_SFN(1));
s3c_gpio_setpull(WIMAX_CON2, S3C_GPIO_PULL_NONE);
gpio_set_value(WIMAX_CON2, GPIO_LEVEL_HIGH); // the other PDA active for cmc730 int.
// WIMAX_INT set Input and Pull up
s3c_gpio_cfgpin(WIMAX_INT, S3C_GPIO_INPUT);
s3c_gpio_setpull(WIMAX_INT, S3C_GPIO_PULL_NONE);
// Set Interface
hwSetInterface();
// PDA Active
s3c_gpio_cfgpin(WIMAX_CON1, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(WIMAX_CON1, S3C_GPIO_PULL_NONE);
gpio_set_value(WIMAX_CON1, GPIO_LEVEL_HIGH);
// gpio sleep status
s3c_gpio_slp_cfgpin(WIMAX_WAKEUP, S3C_GPIO_SLP_PREV);
s3c_gpio_slp_setpull_updown(WIMAX_WAKEUP, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_IF_MODE0, S3C_GPIO_SLP_PREV);
s3c_gpio_slp_setpull_updown(WIMAX_IF_MODE0, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_IF_MODE1, S3C_GPIO_SLP_PREV); // not used
s3c_gpio_slp_setpull_updown(WIMAX_IF_MODE1, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_CON0, S3C_GPIO_SLP_PREV);
s3c_gpio_slp_setpull_updown(WIMAX_CON0, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_CON1, S3C_GPIO_SLP_OUT0); // PDA Active low
s3c_gpio_slp_setpull_updown(WIMAX_CON1, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_CON2, S3C_GPIO_SLP_OUT0); // Active Low PDA sleep int. (Make modem goes to idle or VI)
s3c_gpio_slp_setpull_updown(WIMAX_CON2, S3C_GPIO_PULL_NONE);
LEAVE;
return TRUE;
}
static int cdma_manager_suspend(struct platform_device *dev, pm_message_t state) {
printk("cdma suspend,disable cdma power\n");
mx100_cdma_sleep(0);//not used now
//ril_set_wakeup(0);
//s3c_setup_cdmauart_cfg_gpio(1);
//s3c_setup_cdmauart_cfg_gpio(3);
s3c_gpio_slp_cfgpin(GPIO_CDMA_RESET_OUT, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_CDMA_RESET_OUT, S3C_GPIO_PULL_NONE);
printk("__%s done \n", __func__);
msleep(100);
return 0;
}
void bt_uart_rts_ctrl(int flag)
{
if (!gpio_get_value(GPIO_BT_EN))
return;
if (flag) {
/* BT RTS Set to HIGH */
s3c_gpio_cfgpin(EXYNOS4_GPA0(3), S3C_GPIO_OUTPUT);
s3c_gpio_setpull(EXYNOS4_GPA0(3), S3C_GPIO_PULL_NONE);
gpio_set_value(EXYNOS4_GPA0(3), 1);
s3c_gpio_slp_cfgpin(EXYNOS4_GPA0(3), S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(EXYNOS4_GPA0(3), S3C_GPIO_PULL_NONE);
} else {
/* BT RTS Set to LOW */
s3c_gpio_cfgpin(EXYNOS4_GPA0(3), S3C_GPIO_OUTPUT);
gpio_set_value(EXYNOS4_GPA0(3), 0);
s3c_gpio_cfgpin(EXYNOS4_GPA0(3), S3C_GPIO_SFN(2));
s3c_gpio_setpull(EXYNOS4_GPA0(3), S3C_GPIO_PULL_NONE);
}
}
void gt3_config_sleep_gpio_table(void)
{
int i;
int index = min(ARRAY_SIZE(gt3_sleep_table), system_rev + 1);
for (i = 0; i < index; i++) {
if (gt3_sleep_table[i].ptr == NULL)
continue;
config_sleep_gpio_table(gt3_sleep_table[i].size,
gt3_sleep_table[i].ptr);
}
#if defined(CONFIG_TARGET_TAB3_WIFI8) || defined(CONFIG_TARGET_TAB3_3G8) || \
defined(CONFIG_TARGET_TAB3_LTE8)
if (system_rev > 5) {
s3c_gpio_slp_cfgpin(EXYNOS4_GPX1(4), S3C_GPIO_INPUT);
s3c_gpio_slp_setpull_updown(EXYNOS4_GPX1(4), S3C_GPIO_PULL_DOWN);
}
#endif
}
static void config_sleep_gpio_table(int array_size,
unsigned int (*gpio_table)[3])
{
u32 i, gpio;
for (i = 0; i < array_size; i++) {
gpio = gpio_table[i][0];
s3c_gpio_slp_cfgpin(gpio, gpio_table[i][1]);
s3c_gpio_slp_setpull_updown(gpio, gpio_table[i][2]);
}
/* GPX GPIO setting */
s3c_gpio_cfgpin(EXYNOS4_GPX1(7), S3C_GPIO_INPUT);
s3c_gpio_setpull(EXYNOS4_GPX1(7), S3C_GPIO_PULL_DOWN);
#if defined(CONFIG_MACH_Q1_CMCC_BD)
s3c_gpio_cfgpin(EXYNOS4_GPX0(5), S3C_GPIO_OUTPUT);
s3c_gpio_setpull(EXYNOS4_GPX0(5), S3C_GPIO_PULL_NONE);
gpio_set_value(EXYNOS4_GPX0(5), GPIO_LEVEL_LOW);
#endif
}
static int __init herring_init_touchkey_led(void)
{
int i;
int ret = 0;
u32 gpio;
if (!machine_is_herring() || !herring_is_tft_dev())
return 0;
for (i = 0; i < ARRAY_SIZE(led_gpios); i++) {
gpio = S5PV210_GPJ3(led_gpios[i]);
ret = gpio_request(gpio, "touchkey led");
if (ret) {
pr_err("Failed to request touchkey led gpio %d\n", i);
goto err_req;
}
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(gpio, S3C_GPIO_SLP_PREV);
s3c_gpio_slp_setpull_updown(gpio, S3C_GPIO_PULL_NONE);
}
herring_touchkey_led_onoff(1);
register_early_suspend(&early_suspend);
#ifdef CONFIG_GENERIC_BLN
register_bln_implementation(&herring_touchkey_bln);
#endif
#ifdef CONFIG_BLD
register_bld_implementation(&herring_touchkey_bld);
#endif
return 0;
err_req:
while (--i >= 0)
gpio_free(S5PV210_GPJ3(led_gpios[i]));
return ret;
}
void bt_uart_rts_ctrl(int flag)
{
if(!gpio_get_value(GPIO_BT_nRST))
return;
if(flag) {
// BT RTS Set to HIGH
s3c_gpio_cfgpin(S5PV210_GPA0(3), S3C_GPIO_OUTPUT);
s3c_gpio_setpull(S5PV210_GPA0(3), S3C_GPIO_PULL_NONE);
gpio_set_value(S5PV210_GPA0(3), 1);
s3c_gpio_slp_cfgpin(S5PV210_GPA0(3), S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(S5PV210_GPA0(3), S3C_GPIO_PULL_NONE);
}
else {
// BT RTS Set to LOW
s3c_gpio_cfgpin(S5PV210_GPA0(3), S3C_GPIO_OUTPUT);
gpio_set_value(S5PV210_GPA0(3), 0);
s3c_gpio_cfgpin(S5PV210_GPA0(3), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PV210_GPA0(3), S3C_GPIO_PULL_NONE);
}
}
BOOLEAN hwGPIODeInit()
{
ENTER;
// Init each pin -> set function output, low, and pull disable
s3c_gpio_cfgpin(WIMAX_WAKEUP, S3C_GPIO_SFN(1));
gpio_set_value(WIMAX_WAKEUP, GPIO_LEVEL_LOW);
s3c_gpio_setpull(WIMAX_WAKEUP, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(WIMAX_IF_MODE0, S3C_GPIO_SFN(1));
gpio_set_value(WIMAX_IF_MODE0, GPIO_LEVEL_LOW);
s3c_gpio_setpull(WIMAX_IF_MODE0, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(WIMAX_IF_MODE1, S3C_GPIO_SFN(1));
gpio_set_value(WIMAX_IF_MODE1, GPIO_LEVEL_LOW);
s3c_gpio_setpull(WIMAX_IF_MODE1, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(WIMAX_CON0, S3C_GPIO_SFN(1));
gpio_set_value(WIMAX_CON0, GPIO_LEVEL_LOW);
s3c_gpio_setpull(WIMAX_CON0, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(WIMAX_CON1, S3C_GPIO_SFN(1));
gpio_set_value(WIMAX_CON1, GPIO_LEVEL_LOW);
s3c_gpio_setpull(WIMAX_CON1, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(WIMAX_CON2, S3C_GPIO_SFN(1));
gpio_set_value(WIMAX_CON2, GPIO_LEVEL_LOW);
s3c_gpio_setpull(WIMAX_CON2, S3C_GPIO_PULL_NONE);
s3c_gpio_setpull(WIMAX_INT, S3C_GPIO_PULL_NONE);
gpio_set_value(WIMAX_INT, GPIO_LEVEL_LOW);
s3c_gpio_cfgpin(WIMAX_INT, S3C_GPIO_SFN(1));
// gpio sleep status
s3c_gpio_slp_cfgpin(WIMAX_WAKEUP, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(WIMAX_WAKEUP, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_IF_MODE0, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(WIMAX_IF_MODE0, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_IF_MODE1, S3C_GPIO_SLP_OUT0); // not used
s3c_gpio_slp_setpull_updown(WIMAX_IF_MODE1, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_CON0, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(WIMAX_CON0, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_CON1, S3C_GPIO_SLP_OUT0); // PDA Active low
s3c_gpio_slp_setpull_updown(WIMAX_CON1, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(WIMAX_CON2, S3C_GPIO_SLP_OUT0); // not used
s3c_gpio_slp_setpull_updown(WIMAX_CON2, S3C_GPIO_PULL_NONE);
// wimax_i2c_con
if (system_rev < 8)
{
s3c_gpio_cfgpin(I2C_SEL, S3C_GPIO_SFN(1));
gpio_set_value(I2C_SEL, GPIO_LEVEL_LOW); // active path to cmc730
s3c_gpio_slp_cfgpin(I2C_SEL, S3C_GPIO_SLP_OUT1); // suspend path to ap
}
else
{
s3c_gpio_cfgpin(I2C_SEL, S3C_GPIO_SFN(1));
gpio_set_value(I2C_SEL, GPIO_LEVEL_HIGH); // active path to cmc730
s3c_gpio_slp_cfgpin(I2C_SEL, S3C_GPIO_SLP_OUT0); // suspend path to ap
}
LEAVE;
return TRUE;
}
static int s5pc11x_pm_enter(suspend_state_t state)
{
unsigned long regs_save[16];
unsigned int tmp;
#ifdef CONFIG_HAS_WAKELOCK
//wake_unlock(&pm_wake_lock);
#endif
/* ensure the debug is initialised (if enabled) */
DBG("s5pc11x_pm_enter(%d)\n", state);
if (pm_cpu_prep == NULL || pm_cpu_sleep == NULL) {
printk(KERN_ERR PFX "error: no cpu sleep functions set\n");
return -EINVAL;
}
#ifdef CONFIG_CPU_FREQ
s5pc110_pm_target(BOOT_ARM_CLK);
#endif
/* store the physical address of the register recovery block */
s5pc110_sleep_save_phys = virt_to_phys(regs_save);
DBG("s5pc11x_sleep_save_phys=0x%08lx\n", s5pc110_sleep_save_phys);
s5pc11x_pm_do_save(gpio_save, ARRAY_SIZE(gpio_save));
#ifdef S5PC11X_ALIVEGPIO_STORE
s5pc11x_pm_do_save(gpio_save_alive, ARRAY_SIZE(gpio_save_alive));
#endif
s5pc11x_pm_do_save(irq_save, ARRAY_SIZE(irq_save));
s5pc11x_pm_do_save(core_save, ARRAY_SIZE(core_save));
s5pc11x_pm_do_save(sromc_save, ARRAY_SIZE(sromc_save));
s5pc11x_pm_do_save(uart_save, ARRAY_SIZE(uart_save));
/* ensure INF_REG0 has the resume address */
__raw_writel(virt_to_phys(s5pc110_cpu_resume), S5P_INFORM0);
/* call cpu specific preperation */
pm_cpu_prep();
/* flush cache back to ram */
flush_cache_all();
#if 0 // To preserve 24MHz clock.
/* USB & OSC Clock pad Enable */
tmp = __raw_readl(S5P_SLEEP_CFG);
//tmp |= (S5P_SLEEP_CFG_OSC_EN | S5P_SLEEP_CFG_USBOSC_EN);
tmp &= ~(S5P_SLEEP_CFG_OSC_EN | S5P_SLEEP_CFG_USBOSC_EN);
__raw_writel(tmp , S5P_SLEEP_CFG);
#endif
__raw_writel(0xffffffff , S5P_EINT_WAKEUP_MASK);
/* Power mode Config setting */
tmp = __raw_readl(S5P_PWR_CFG);
tmp &= S5P_CFG_WFI_CLEAN;
tmp |= S5P_CFG_WFI_SLEEP;
__raw_writel(tmp,S5P_PWR_CFG);
if (!hw_version_check()) {
/* Set wakeup mask regsiter */
__raw_writel(0xFFED, S5P_WAKEUP_MASK);
} else {
__raw_writel(0xFFFD, S5P_WAKEUP_MASK); //0xFFFD:, RTC_ALARM
// __raw_writel(0xFFDD, S5P_WAKEUP_MASK); //0xFFDD:key, RTC_ALARM
}
__raw_writel(0xffffffff, S5PC110_VIC0REG(VIC_INT_ENABLE_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC1REG(VIC_INT_ENABLE_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC2REG(VIC_INT_ENABLE_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC3REG(VIC_INT_ENABLE_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC0REG(VIC_INT_SOFT_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC1REG(VIC_INT_SOFT_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC2REG(VIC_INT_SOFT_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC3REG(VIC_INT_SOFT_CLEAR));
/* SYSC INT Disable */
tmp = __raw_readl(S5P_OTHERS);
tmp |= (S5P_OTHER_SYSC_INTOFF);
__raw_writel(tmp,S5P_OTHERS);
/* Clear WAKEUP_STAT register for next wakeup */
tmp = __raw_readl(S5P_WAKEUP_STAT);
__raw_writel(tmp, S5P_WAKEUP_STAT);
/* Wake up source setting */
//s5pc11x_pm_configure_extint();
// key pad direction control for evt0
//s5pc11x_set_keypad_sleep_gpio();
/*Set EINT 22 as wake up source*/
//hojun_kim 100526 [
if(system_rev >= 0x08)
{
s5pc11x_pm_set_eint(5, 0x4); //Hall SW
}
//hojun_kim ]
s5pc11x_pm_set_eint(11, 0x2);
s5pc11x_pm_set_eint(22, 0x2);
// s5pc11x_pm_set_eint(21, 0x4);
s5pc11x_pm_set_eint(7, 0x02); //PMIC
s5pc11x_pm_set_eint(6, 0x4); //det_3.5
s5pc11x_pm_set_eint(30, 0x4); //suik_Fix //short_sendend pin
s5pc11x_pm_set_eint(4, 0x4);
if(system_rev >= 0x08) //seonha
{
s5pc11x_pm_set_eint(2, 0x4); //suik_Fix //open_sendend pin
}
if(gp2a_get_proximity_enable())
{
if(system_rev >= 0x0A) //jihyon.82.kim for victory rev 10
{
s5pc11x_pm_set_eint(1, 0x4);
}
}
s5pc11x_pm_set_eint(3, 0x3);//WiFi SecFeature.Victory
s5pc11x_pm_set_eint(23, 0x2);//microusb.. 20100517_inchul
//gpio key
// if(HWREV >= 0xB)
// {
s5pc11x_pm_set_eint(24, 0x4);
s5pc11x_pm_set_eint(25, 0x4);
// }
if (!hw_version_check()) {
/*Set keypad as EINT for EVT0 wake up workaround*/
s5pc11x_pm_set_eint(24, 0x2);
s5pc11x_pm_set_eint(25, 0x2);
s5pc11x_pm_set_eint(26, 0x2);
s5pc11x_pm_set_eint(27, 0x2);
/*Column pull down enabled*/
tmp = readl(S5PC11X_GPH2PUD);
tmp &= ~(0xFF);
tmp |= 0x55;
writel(tmp, S5PC11X_GPH2PUD);
}
#if 1 //cky 20100416 WiMAX ext-interrupt
if (gpio_get_value(GPIO_WIMAX_EN))
{
DBG("WIMAX POWER ON!! Set WIMAX_INT as Ext-Int.\n");
s5pc11x_pm_set_eint(14, 0x0); // WIMAX_INT: GPH1(6); LOW LEVEL DETECT
}
#endif
s3c_config_sleep_gpio();
s3c_gpio_slp_cfgpin(S5PC11X_MP03(3), S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(S5PC11X_MP03(3), S3C_GPIO_SLP_OUT0);
#if 0
tmp = __raw_readl(S5P_OTHERS);
tmp &= ~(3 << 8);
tmp |= (3 << 8);
__raw_writel(tmp, S5P_OTHERS);
__raw_writel(0,S5P_MIE_CONTROL);
__raw_writel(0,S5P_HDMI_CONTROL);
__raw_writel(0,S5P_USB_PHY_CONTROL);
__raw_writel(0,S5P_DAC_CONTROL);
__raw_writel(0,S5P_MIPI_PHY_CONTROL);
__raw_writel(0,S5P_ADC_CONTROL);
__raw_writel(0,S5P_PSHOLD_CONTROL);
#endif
#if (!(defined CONFIG_ARIES_VER_B0) && !(defined CONFIG_ARIES_VER_B4) && !(defined CONFIG_ARIES_VER_B5))
// Enable PS_HOLD pin to avoid reset failure */
__raw_writel((0x5 << 12 | 0x1<<9 | 0x1<<8 | 0x1<<0),S5P_PSHOLD_CONTROL);
#endif
/* s5pc11x_cpu_save will also act as our return point from when
* we resume as it saves its own register state, so use the return
* code to differentiate return from save and return from sleep */
if (s5pc110_cpu_save(regs_save) == 0) {
flush_cache_all();
if (!hw_version_check()) {
/* This function for Chip bug on EVT0 */
tmp = __raw_readl(S5P_EINT_WAKEUP_MASK + 4); //PWR_MODE
tmp |= (1 << 2);
__raw_writel(tmp , S5P_EINT_WAKEUP_MASK + 4);
// end mod
}
pm_cpu_sleep();
}
/* restore the cpu state */
cpu_init();
#ifdef __DEBUG_PRINT_EINT_WAKEUP_STATUS
int eintcon[4],eintmask[4],eintpend[4];
int eint_wakeup_mask;
int i;
for(i=0; i<4; i++) {
eint_wakeup_mask = readl(S5P_EINT_WAKEUP_MASK);
eintcon[i] = __raw_readl(S5PC11X_EINTCON(i));
eintmask[i] = __raw_readl(S5PC11X_EINTMASK(i));
eintpend[i] = __raw_readl(S5PC11X_EINTPEND(i));
}
#endif
s5pc11x_pm_do_restore(gpio_save, ARRAY_SIZE(gpio_save));
#ifdef S5PC11X_ALIVEGPIO_STORE
s5pc11x_pm_do_restore_alive(gpio_save_alive, ARRAY_SIZE(gpio_save_alive));
#endif
s5pc11x_pm_do_restore(irq_save, ARRAY_SIZE(irq_save));
__raw_writel(0x0, S3C24XX_VA_UART2+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTP);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTM);
/* Temporary workaround to protect lockup by UART - 20100316 */
__raw_writel(0x0, S3C24XX_VA_UART3+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART3+S5P_UINTM);
__raw_writel(0xf, S3C24XX_VA_UART3+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART3+S5P_UINTP);
__raw_writel(0x0, S3C24XX_VA_UART2+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTM);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTP);
__raw_writel(0x0, S3C24XX_VA_UART1+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART1+S5P_UINTM);
__raw_writel(0xf, S3C24XX_VA_UART1+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART1+S5P_UINTP);
__raw_writel(0x0, S3C24XX_VA_UART0+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART0+S5P_UINTM);
__raw_writel(0xf, S3C24XX_VA_UART0+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART0+S5P_UINTP);
s5pc11x_pm_do_restore(uart_save, ARRAY_SIZE(uart_save));
s5pc11x_pm_do_restore(core_save, ARRAY_SIZE(core_save));
s5pc11x_pm_do_restore(sromc_save, ARRAY_SIZE(sromc_save));
/*enable gpio, uart, mmc*/
tmp = __raw_readl(S5P_OTHERS);
#if ((defined CONFIG_ARIES_VER_B0) || (defined CONFIG_ARIES_VER_B4) || (defined CONFIG_ARIES_VER_B5))
tmp |= (1<<31) | (1<<28) | (1<<29);
#else
tmp |= (1<<31) | (0x1<<30) | (1<<28) | (1<<29);
#endif
__raw_writel(tmp, S5P_OTHERS);
/* EINT22 Pending clear */
//s5pc11x_pm_clear_eint(22); //<= do action in s3c-keypad.c
// s5pc11x_pm_clear_eint(21);
if (!hw_version_check()) {
// for evt 0 keypad wakeup workaround
s5pc11x_pm_clear_eint(24);
s5pc11x_pm_clear_eint(25);
s5pc11x_pm_clear_eint(26);
s5pc11x_pm_clear_eint(27);
s5pc11x_pm_clear_eint(21);
s5pc11x_pm_clear_eint(20);
} else {
/* Clear WAKEUP_STAT register for next wakeup */
tmp = __raw_readl(S5P_WAKEUP_STAT);
__raw_writel(tmp, S5P_WAKEUP_STAT);
#if 0
/* This is for LCD wakeup if key is pressed */
tmp=(unsigned int)S5PC11X_EINTPEND(3);
tmp &= 0x07;
printk("wakeup source is 0x%x \n", tmp);
if (tmp)
key_wakeup_state=1;
else
key_wakeup_state=0;
writel(tmp, S5PC11X_EINTPEND(3));
#else
printk("wakeup source is 0x%x \n", tmp);
#endif
}
#ifdef __DEBUG_PRINT_EINT_WAKEUP_STATUS
// if woken up by external interrupt print eint registers
if(tmp&0x1) {
printk("EINT_WAKEUP_MASK(%08X)\n", eint_wakeup_mask);
for(i=0; i<4; i++) {
printk("EINT%dCON(%08X) EINT%dMASK(%08X) EINT%dPEND(%08X)\n"
,i,eintcon[i]
,i,eintmask[i]
,i,eintpend[i]);
}
}
#endif
#if 1 //cky 20100513 ext-int for wimax
if (gpio_get_value(GPIO_WIMAX_EN))
{
DBG("WIMAX POWER ON!! Set WIMAX_INT: INPUT.\n");
s5pc11x_pm_clear_eint(14);
s3c_gpio_cfgpin(GPIO_WIMAX_INT, S3C_GPIO_INPUT);
s3c_gpio_setpull(GPIO_WIMAX_INT, S3C_GPIO_PULL_NONE);
}
#endif
DBG("\npost sleep, preparing to return 2\n");
s5pc11x_pm_check_restore();
#ifdef CONFIG_HAS_WAKELOCK
//wake_lock_timeout(&pm_wake_lock, 5 * HZ);
#endif
/* ok, let's return from sleep */
DBG("S5PC110 PM Resume (post-restore)\n");
return 0;
}
static int bluetooth_set_power(void *data, enum rfkill_state state)
{
unsigned int ret = 0;
switch (state) {
case RFKILL_STATE_UNBLOCKED:
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] Device Powering ON \n");
#else
printk(KERN_DEBUG "[BT] Device Powering ON \n");
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
s3c_setup_uart_cfg_gpio(1);
if (gpio_is_valid(GPIO_BT_WLAN_REG_ON))
{
ret = gpio_request(GPIO_BT_WLAN_REG_ON, S3C_GPIO_LAVEL(GPIO_BT_WLAN_REG_ON));
if (ret < 0) {
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] Failed to request GPIO_BT_WLAN_REG_ON!\n");
#else
printk(KERN_ERR "[BT] Failed to request GPIO_BT_WLAN_REG_ON!\n");
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
return ret;
}
gpio_direction_output(GPIO_BT_WLAN_REG_ON, GPIO_LEVEL_HIGH);
}
if (gpio_is_valid(GPIO_BT_RST_N))
{
ret = gpio_request(GPIO_BT_RST_N, S3C_GPIO_LAVEL(GPIO_BT_RST_N));
if (ret < 0) {
gpio_free(GPIO_BT_WLAN_REG_ON);
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] Failed to request GPIO_BT_RST_N!\n");
#else
printk(KERN_ERR "[BT] Failed to request GPIO_BT_RST_N!\n");
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
return ret;
}
gpio_direction_output(GPIO_BT_RST_N, GPIO_LEVEL_LOW);
}
/* Set GPIO_BT_WLAN_REG_ON high */
s3c_gpio_setpull(GPIO_BT_WLAN_REG_ON, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_WLAN_REG_ON, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_BT_WLAN_REG_ON, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_BT_WLAN_REG_ON, S3C_GPIO_PULL_NONE);
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] GPIO_BT_WLAN_REG_ON = %d\n", gpio_get_value(GPIO_BT_WLAN_REG_ON));
mdelay(150); // 100msec, delay between reg_on & rst. (bcm4325 powerup sequence)
#else
printk(KERN_DEBUG "[BT] GPIO_BT_WLAN_REG_ON = %d\n", gpio_get_value(GPIO_BT_WLAN_REG_ON));
msleep(150); // 100msec, delay between reg_on & rst. (bcm4325 powerup sequence)
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
/* Set GPIO_BT_RST_N high */
s3c_gpio_setpull(GPIO_BT_RST_N, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_RST_N, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_BT_RST_N, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_BT_RST_N, S3C_GPIO_PULL_NONE);
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] GPIO_BT_RST_N = %d\n", gpio_get_value(GPIO_BT_RST_N));
#else
printk(KERN_DEBUG "[BT] GPIO_BT_RST_N = %d\n", gpio_get_value(GPIO_BT_RST_N));
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
gpio_free(GPIO_BT_RST_N);
gpio_free(GPIO_BT_WLAN_REG_ON);
break;
case RFKILL_STATE_SOFT_BLOCKED:
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] Device Powering OFF \n");
#else
printk(KERN_DEBUG "[BT] Device Powering OFF \n");
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
s3c_reset_uart_cfg_gpio(1);
s3c_gpio_setpull(GPIO_BT_RST_N, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_RST_N, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_BT_RST_N, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_BT_RST_N, S3C_GPIO_PULL_NONE);
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] GPIO_BT_RST_N = %d\n",gpio_get_value(GPIO_BT_RST_N));
#else
printk(KERN_DEBUG "[BT] GPIO_BT_RST_N = %d\n",gpio_get_value(GPIO_BT_RST_N));
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
if(gpio_get_value(GPIO_WLAN_RST_N) == 0)
{
s3c_gpio_setpull(GPIO_BT_WLAN_REG_ON, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_WLAN_REG_ON, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_BT_WLAN_REG_ON, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_BT_WLAN_REG_ON, S3C_GPIO_PULL_NONE);
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] GPIO_BT_WLAN_REG_ON = %d\n", gpio_get_value(GPIO_BT_WLAN_REG_ON));
#else
printk(KERN_DEBUG "[BT] GPIO_BT_WLAN_REG_ON = %d\n", gpio_get_value(GPIO_BT_WLAN_REG_ON));
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
}
gpio_free(GPIO_BT_RST_N);
gpio_free(GPIO_BT_WLAN_REG_ON);
break;
default:
printk(KERN_ERR "[BT] Bad bluetooth rfkill state %d\n", state);
}
return 0;
}
static int bluetooth_set_power(void *data, enum rfkill_user_states state)
{
int ret = 0;
int irq;
/* BT Host Wake IRQ */
irq = IRQ_WLAN_BT_HOST_WAKE;
switch (state) {
case RFKILL_USER_STATE_UNBLOCKED:
printk("[BT] Device Powering ON \n");//pr_debug
if (!loaded)
break;
/* Bluetooth over SDIO */
m8_bt_power(1, sdio);
msleep(100);
if (sdio && m8_checkse())
sdhci_s3c_force_presence_change(&s3c_device_hsmmc0);
msleep(100);
if (!sdio)
s3c_setup_uart_cfg_gpio(1);
#if 0 // uart not work now
if (gpio_is_valid(GPIO_WLAN_BT_EN)) {
printk("[BT] gpio_is_valid(GPIO_WLAN_BT_EN)\n");
gpio_direction_output(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH);
}
if (gpio_is_valid(GPIO_BT_nRST)) {
gpio_direction_output(GPIO_BT_nRST, GPIO_LEVEL_LOW);
printk("[BT] gpio_is_valid(GPIO_BT_nRST)\n");
}
printk("[BT] GPIO_BT_nRST = %d\n",
gpio_get_value(GPIO_BT_nRST));//pr_debug
/* Set GPIO_BT_WLAN_REG_ON high */
s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN,
S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_WLAN_BT_EN = %d\n",
gpio_get_value(GPIO_WLAN_BT_EN));
/*
* FIXME sleep should be enabled disabled since the device is
* not booting if its enabled
*/
/*
* 100msec, delay between reg_on & rst.
* (powerup sequence)
*/
msleep(500);//100);
/* Set GPIO_BT_nRST high */
s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_nRST = %d\n",
gpio_get_value(GPIO_BT_nRST));//pr_debug
/*
* 50msec, delay after bt rst
* (libertas powerup sequence)
*/
msleep(200);//50);
//ret = enable_irq_wake(irq);
//if (ret < 0)
// pr_err("[BT] set wakeup src failed\n");
#endif
enable_irq(irq);
break;
case RFKILL_USER_STATE_SOFT_BLOCKED:
printk("[BT] Device Powering OFF\n");
if (!loaded)
break;
/* Bluetooth over SDIO */
m8_bt_power(0, sdio);
msleep(100);
if (sdio && m8_checkse())
sdhci_s3c_force_presence_change(&s3c_device_hsmmc0);
//if (!sdio)
// s3c_reset_uart_cfg_gpio(1);
//ret = disable_irq_wake(irq);
//if (ret < 0)
// pr_err("[BT] unset wakeup src failed\n");
disable_irq(irq);
wake_unlock(&rfkill_wake_lock);
printk("[BT] wake_unlock rfkill_wake_lock\n");
#if 0 // UART
s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_nRST = %d\n",
gpio_get_value(GPIO_BT_nRST));//pr_debug
if (gpio_get_value(GPIO_BT_nRST) == 0) { //GPIO_WLAN_nRST
s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN,
S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_WLAN_BT_EN = %d\n",
gpio_get_value(GPIO_WLAN_BT_EN));
}
#endif
break;
default:
printk(KERN_ERR "[BT] Bad bluetooth rfkill state %d\n", state);//pr_err
}
return 0;
}
static int s5pc11x_pm_enter(suspend_state_t state)
{
unsigned long regs_save[16];
unsigned int tmp;
#ifdef CONFIG_HAS_WAKELOCK
//wake_unlock(&pm_wake_lock);
#endif
/* ensure the debug is initialised (if enabled) */
DBG("s5pc11x_pm_enter(%d)\n", state);
if (pm_cpu_prep == NULL || pm_cpu_sleep == NULL) {
printk(KERN_ERR PFX "error: no cpu sleep functions set\n");
return -EINVAL;
}
#ifdef CONFIG_CPU_FREQ
s5pc110_pm_target(BOOT_ARM_CLK);
#endif
/* store the physical address of the register recovery block */
s5pc110_sleep_save_phys = virt_to_phys(regs_save);
DBG("s5pc11x_sleep_save_phys=0x%08lx\n", s5pc110_sleep_save_phys);
s5pc11x_pm_do_save(gpio_save, ARRAY_SIZE(gpio_save));
#ifdef S5PC11X_ALIVEGPIO_STORE
s5pc11x_pm_do_save(gpio_save_alive, ARRAY_SIZE(gpio_save_alive));
#endif
s5pc11x_pm_do_save(irq_save, ARRAY_SIZE(irq_save));
s5pc11x_pm_do_save(core_save, ARRAY_SIZE(core_save));
s5pc11x_pm_do_save(sromc_save, ARRAY_SIZE(sromc_save));
s5pc11x_pm_do_save(uart_save, ARRAY_SIZE(uart_save));
/* ensure INF_REG0 has the resume address */
__raw_writel(virt_to_phys(s5pc110_cpu_resume), S5P_INFORM0);
/* call cpu specific preperation */
pm_cpu_prep();
/* flush cache back to ram */
flush_cache_all();
#if 0 // To preserve 24MHz clock.
/* USB & OSC Clock pad Enable */
tmp = __raw_readl(S5P_SLEEP_CFG);
//tmp |= (S5P_SLEEP_CFG_OSC_EN | S5P_SLEEP_CFG_USBOSC_EN);
tmp &= ~(S5P_SLEEP_CFG_OSC_EN | S5P_SLEEP_CFG_USBOSC_EN);
__raw_writel(tmp , S5P_SLEEP_CFG);
#endif
__raw_writel(0xffffffff , S5P_EINT_WAKEUP_MASK);
/* Power mode Config setting */
tmp = __raw_readl(S5P_PWR_CFG);
tmp &= S5P_CFG_WFI_CLEAN;
tmp |= S5P_CFG_WFI_SLEEP;
__raw_writel(tmp,S5P_PWR_CFG);
if (!hw_version_check()) {
/* Set wakeup mask regsiter */
__raw_writel(0xFFED, S5P_WAKEUP_MASK);
} else {
if((is_calling_or_playing & IS_VOICE_CALL_2G) || (is_calling_or_playing & IS_VOICE_CALL_3G) || (is_calling_or_playing & IS_DATA_CALL)){
__raw_writel(0xFFDD, S5P_WAKEUP_MASK); //0xFFDD:key, RTC_ALARM
}else{
__raw_writel(0xFFFD, S5P_WAKEUP_MASK); //0xFFDD:key, RTC_ALARM
}
}
__raw_writel(0xffffffff, S5PC110_VIC0REG(VIC_INT_ENABLE_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC1REG(VIC_INT_ENABLE_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC2REG(VIC_INT_ENABLE_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC3REG(VIC_INT_ENABLE_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC0REG(VIC_INT_SOFT_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC1REG(VIC_INT_SOFT_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC2REG(VIC_INT_SOFT_CLEAR));
__raw_writel(0xffffffff, S5PC110_VIC3REG(VIC_INT_SOFT_CLEAR));
/* SYSC INT Disable */
tmp = __raw_readl(S5P_OTHERS);
tmp |= (S5P_OTHER_SYSC_INTOFF);
__raw_writel(tmp,S5P_OTHERS);
/* Clear WAKEUP_STAT register for next wakeup */
tmp = __raw_readl(S5P_WAKEUP_STAT);
__raw_writel(tmp, S5P_WAKEUP_STAT);
/* Wake up source setting */
//s5pc11x_pm_configure_extint();
// key pad direction control for evt0
//s5pc11x_set_keypad_sleep_gpio();
/*Set EINT 22 as wake up source*/
s5pc11x_pm_set_eint(11, 0x2);
s5pc11x_pm_set_eint(22, 0x2);
s5pc11x_pm_set_eint(15, 0x4);
s5pc11x_pm_set_eint(21, 0x4);
s5pc11x_pm_set_eint(7, 0x02); //PMIC
s5pc11x_pm_set_eint(6, 0x4); //det_3.5
s5pc11x_pm_set_eint(28, 0x4); // T_FLASH_DETECT
//[hdlnc_bp_ytkwon : 20100326
#ifdef CONFIG_KEPLER_AUDIO_A1026
if(HWREV!=0x08)
{
if(get_headset_status() & SEC_HEADSET_4_POLE_DEVICE)
{
s5pc11x_pm_set_eint(30, 0x4); //sendend
s5pc11x_pm_set_eint(18, 0x4); //sendend 2.5
}
else
{
s5pc11x_pm_clear_eint(30);
s5pc11x_pm_clear_eint(18);
}
}
#else
if(HWREV==0x0a ||HWREV==0x0c)
{
if(get_headset_status() & SEC_HEADSET_4_POLE_DEVICE)
{
s5pc11x_pm_set_eint(30, 0x4); //sendend
}
else
{
s5pc11x_pm_clear_eint(30);
}
}
else
{
if(get_headset_status() & SEC_HEADSET_4_POLE_DEVICE)
{
s5pc11x_pm_set_eint(30, 0x4); //sendend
s5pc11x_pm_set_eint(18, 0x4); //sendend 2.5
}
else
{
s5pc11x_pm_clear_eint(30);
s5pc11x_pm_clear_eint(18);
}
}
#endif
//]hdlnc_bp_ytkwon : 20100326
if(gp2a_get_proximity_enable())
{
s5pc11x_pm_set_eint(2, 0x4);//proximity
}
s5pc11x_pm_set_eint(20, 0x3);//WiFi
s5pc11x_pm_set_eint(23, 0x2);//microusb
#if defined CONFIG_T959_VER_B0
s5pc11x_pm_set_eint(29, 0x4);
// [[junghyunseok edit for fuel_int interrupt control of fuel_gauge 20100504
#elif defined CONFIG_KEPLER_VER_B0
#elif defined(CONFIG_KEPLER_VER_B2) || defined(CONFIG_T959_VER_B5)
s5pc11x_pm_set_eint(27, 0x2);
// ]]junghyunseok edit for fuel_int interrupt control of fuel_gauge 20100504
#else
//gpio key
if(HWREV >= 0xB)
{
s5pc11x_pm_set_eint(27, 0x4);
s5pc11x_pm_set_eint(29, 0x4);
}
#endif
if (!hw_version_check()) {
/*Set keypad as EINT for EVT0 wake up workaround*/
s5pc11x_pm_set_eint(24, 0x2);
s5pc11x_pm_set_eint(25, 0x2);
s5pc11x_pm_set_eint(26, 0x2);
s5pc11x_pm_set_eint(27, 0x2);
/*Column pull down enabled*/
tmp = readl(S5PC11X_GPH2PUD);
tmp &= ~(0xFF);
tmp |= 0x55;
writel(tmp, S5PC11X_GPH2PUD);
}
s3c_config_sleep_gpio();
s3c_gpio_slp_cfgpin(S5PC11X_MP03(3), S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(S5PC11X_MP03(3), S3C_GPIO_SLP_OUT0);
#if 0
tmp = __raw_readl(S5P_OTHERS);
tmp &= ~(3 << 8);
tmp |= (3 << 8);
__raw_writel(tmp, S5P_OTHERS);
__raw_writel(0,S5P_MIE_CONTROL);
__raw_writel(0,S5P_HDMI_CONTROL);
__raw_writel(0,S5P_USB_PHY_CONTROL);
__raw_writel(0,S5P_DAC_CONTROL);
__raw_writel(0,S5P_MIPI_PHY_CONTROL);
__raw_writel(0,S5P_ADC_CONTROL);
__raw_writel(0,S5P_PSHOLD_CONTROL);
#endif
#if (!(defined CONFIG_ARIES_VER_B0) && !(defined CONFIG_ARIES_VER_B4) && !(defined CONFIG_ARIES_VER_B5))
// Enable PS_HOLD pin to avoid reset failure */
__raw_writel((0x5 << 12 | 0x1<<9 | 0x1<<8 | 0x1<<0),S5P_PSHOLD_CONTROL);
#endif
/* s5pc11x_cpu_save will also act as our return point from when
* we resume as it saves its own register state, so use the return
* code to differentiate return from save and return from sleep */
if (s5pc110_cpu_save(regs_save) == 0) {
flush_cache_all();
if (!hw_version_check()) {
/* This function for Chip bug on EVT0 */
tmp = __raw_readl(S5P_EINT_WAKEUP_MASK + 4); //PWR_MODE
tmp |= (1 << 2);
__raw_writel(tmp , S5P_EINT_WAKEUP_MASK + 4);
// end mod
}
pm_cpu_sleep();
}
/* restore the cpu state */
cpu_init();
s5pc11x_pm_do_restore(gpio_save, ARRAY_SIZE(gpio_save));
#ifdef S5PC11X_ALIVEGPIO_STORE
s5pc11x_pm_do_restore_alive(gpio_save_alive, ARRAY_SIZE(gpio_save_alive));
#endif
s5pc11x_pm_do_restore(irq_save, ARRAY_SIZE(irq_save));
__raw_writel(0x0, S3C24XX_VA_UART2+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTP);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTM);
/* Temporary workaround to protect lockup by UART - 20100316 */
__raw_writel(0x0, S3C24XX_VA_UART3+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART3+S5P_UINTM);
__raw_writel(0xf, S3C24XX_VA_UART3+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART3+S5P_UINTP);
__raw_writel(0x0, S3C24XX_VA_UART2+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTM);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART2+S5P_UINTP);
__raw_writel(0x0, S3C24XX_VA_UART1+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART1+S5P_UINTM);
__raw_writel(0xf, S3C24XX_VA_UART1+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART1+S5P_UINTP);
__raw_writel(0x0, S3C24XX_VA_UART0+S3C2410_UCON);
__raw_writel(0xf, S3C24XX_VA_UART0+S5P_UINTM);
__raw_writel(0xf, S3C24XX_VA_UART0+S5P_UINTSP);
__raw_writel(0xf, S3C24XX_VA_UART0+S5P_UINTP);
s5pc11x_pm_do_restore(uart_save, ARRAY_SIZE(uart_save));
s5pc11x_pm_do_restore(core_save, ARRAY_SIZE(core_save));
s5pc11x_pm_do_restore(sromc_save, ARRAY_SIZE(sromc_save));
/*enable gpio, uart, mmc*/
tmp = __raw_readl(S5P_OTHERS);
#if ((defined CONFIG_ARIES_VER_B0) || (defined CONFIG_ARIES_VER_B4) || (defined CONFIG_ARIES_VER_B5))
tmp |= (1<<31) | (1<<28) | (1<<29);
#else
tmp |= (1<<31) | (0x1<<30) | (1<<28) | (1<<29);
#endif
__raw_writel(tmp, S5P_OTHERS);
/* EINT22 Pending clear */
//s5pc11x_pm_clear_eint(22); //<= do action in s3c-keypad.c
// s5pc11x_pm_clear_eint(21);
if (!hw_version_check()) {
// for evt 0 keypad wakeup workaround
s5pc11x_pm_clear_eint(24);
s5pc11x_pm_clear_eint(25);
s5pc11x_pm_clear_eint(26);
s5pc11x_pm_clear_eint(27);
s5pc11x_pm_clear_eint(21);
} else {
/* Clear WAKEUP_STAT register for next wakeup */
tmp = __raw_readl(S5P_WAKEUP_STAT);
__raw_writel(tmp, S5P_WAKEUP_STAT);
printk("wakeup source is 0x%x \n", tmp);
printk(" EXT_INT_0_PEND %x \n", __raw_readl(S5PC11X_EINTPEND(0)));
printk(" EXT_INT_1_PEND %x \n", __raw_readl(S5PC11X_EINTPEND(1)));
printk(" EXT_INT_2_PEND %x \n", __raw_readl(S5PC11X_EINTPEND(2)));
printk(" EXT_INT_3_PEND %x \n", __raw_readl(S5PC11X_EINTPEND(3)));
}
DBG("\npost sleep, preparing to return 2\n");
s5pc11x_pm_check_restore();
#ifdef CONFIG_HAS_WAKELOCK
//wake_lock_timeout(&pm_wake_lock, 5 * HZ);
#endif
/* ok, let's return from sleep */
DBG("S5PC110 PM Resume (post-restore)\n");
return 0;
}
static int bluetooth_set_power(void *data, enum rfkill_user_states state)
{
int ret = 0;
int irq;
/* BT Host Wake IRQ */
irq = IRQ_BT_HOST_WAKE;
switch (state) {
case RFKILL_USER_STATE_UNBLOCKED:
pr_debug("[BT] Device Powering ON\n");
s3c_setup_uart_cfg_gpio(0);
if (gpio_is_valid(GPIO_WLAN_BT_EN))
gpio_direction_output(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH);
if (gpio_is_valid(GPIO_BT_nRST))
gpio_direction_output(GPIO_BT_nRST, GPIO_LEVEL_LOW);
pr_debug("[BT] GPIO_BT_nRST = %d\n",
gpio_get_value(GPIO_BT_nRST));
/* Set GPIO_BT_WLAN_REG_ON high */
s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN,
S3C_GPIO_PULL_NONE);
pr_debug("[BT] GPIO_WLAN_BT_EN = %d\n",
gpio_get_value(GPIO_WLAN_BT_EN));
/*
* FIXME sleep should be enabled disabled since the device is
* not booting if its enabled
*/
/*
* 100msec, delay between reg_on & rst.
* (bcm4329 powerup sequence)
*/
msleep(100);
/* Set GPIO_BT_nRST high */
s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
pr_debug("[BT] GPIO_BT_nRST = %d\n",
gpio_get_value(GPIO_BT_nRST));
/*
* 50msec, delay after bt rst
* (bcm4329 powerup sequence)
*/
msleep(50);
ret = enable_irq_wake(irq);
if (ret < 0)
pr_err("[BT] set wakeup src failed\n");
enable_irq(irq);
break;
case RFKILL_USER_STATE_SOFT_BLOCKED:
pr_debug("[BT] Device Powering OFF\n");
ret = disable_irq_wake(irq);
if (ret < 0)
pr_err("[BT] unset wakeup src failed\n");
disable_irq(irq);
wake_unlock(&rfkill_wake_lock);
s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
pr_debug("[BT] GPIO_BT_nRST = %d\n",
gpio_get_value(GPIO_BT_nRST));
if (gpio_get_value(GPIO_WLAN_nRST) == 0) {
s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN,
S3C_GPIO_PULL_NONE);
pr_debug("[BT] GPIO_WLAN_BT_EN = %d\n",
gpio_get_value(GPIO_WLAN_BT_EN));
}
break;
default:
pr_err("[BT] Bad bluetooth rfkill state %d\n", state);
}
return 0;
}
static int bluetooth_set_power(void *data, enum rfkill_user_states state)
{
unsigned int ret = 0;
switch (state) {
case RFKILL_USER_STATE_UNBLOCKED:
printk(KERN_DEBUG "[BT] Device Powering ON \n");
s3c_setup_uart_cfg_gpio(0);
if (gpio_is_valid(GPIO_WLAN_BT_EN))
{
ret = gpio_request(GPIO_WLAN_BT_EN, "GPB");
if (ret < 0) {
printk(KERN_ERR "[BT] Failed to request GPIO_WLAN_BT_EN!\n");
return ret;
}
gpio_direction_output(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH);
}
if (gpio_is_valid(GPIO_BT_nRST))
{
ret = gpio_request(GPIO_BT_nRST, "GPB");
if (ret < 0) {
gpio_free(GPIO_WLAN_BT_EN);
printk(KERN_ERR "[BT] Failed to request GPIO_BT_nRST\n");
return ret;
}
gpio_direction_output(GPIO_BT_nRST, GPIO_LEVEL_LOW);
}
printk(KERN_DEBUG "[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST));
/* Set GPIO_BT_WLAN_REG_ON high */
s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
printk( "[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN));
/*FIXME sleep should be enabled disabled since the device is not booting
* if its enabled*/
msleep(100); // 100msec, delay between reg_on & rst. (bcm4329 powerup sequence)
/* Set GPIO_BT_nRST high */
s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST));
gpio_free(GPIO_BT_nRST);
gpio_free(GPIO_WLAN_BT_EN);
break;
case RFKILL_USER_STATE_SOFT_BLOCKED:
printk(KERN_DEBUG "[BT] Device Powering OFF \n");
// s3c_reset_uart_cfg_gpio(0);
s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_nRST = %d\n",gpio_get_value(GPIO_BT_nRST));
if(gpio_get_value(GPIO_WLAN_nRST) == 0)
{
s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN));
}
gpio_free(GPIO_BT_nRST);
gpio_free(GPIO_WLAN_BT_EN);
break;
default:
printk(KERN_ERR "[BT] Bad bluetooth rfkill state %d\n", state);
}
return 0;
}
static int bluetooth_set_power(void *data, enum rfkill_user_states state)
{
unsigned int ret = 0;
switch (state) {
case RFKILL_USER_STATE_UNBLOCKED:
printk("[BT] Device Powering ON \n");
s3c_setup_uart_cfg_gpio(1);
//wake_unlock(&bt_wake_lock);
if (gpio_is_valid(GPIO_BT_WLAN_REG_ON))
{
ret = gpio_request(GPIO_BT_WLAN_REG_ON, S3C_GPIO_LAVEL(GPIO_BT_WLAN_REG_ON));
if (ret < 0) {
printk("[BT] Failed to request GPIO_BT_WLAN_REG_ON!\n");
return ret;
}
gpio_direction_output(GPIO_BT_WLAN_REG_ON, GPIO_LEVEL_HIGH);
}
if (gpio_is_valid(GPIO_BT_RST_N))
{
ret = gpio_request(GPIO_BT_RST_N, S3C_GPIO_LAVEL(GPIO_BT_RST_N));
if (ret < 0) {
gpio_free(GPIO_BT_WLAN_REG_ON);
printk("[BT] Failed to request GPIO_BT_RST_N!\n");
return ret;
}
gpio_direction_output(GPIO_BT_RST_N, GPIO_LEVEL_LOW);
}
/* Set GPIO_BT_WLAN_REG_ON high */
s3c_gpio_setpull(GPIO_BT_WLAN_REG_ON, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_WLAN_REG_ON, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_BT_WLAN_REG_ON, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_BT_WLAN_REG_ON, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_WLAN_REG_ON = %d\n", gpio_get_value(GPIO_BT_WLAN_REG_ON));
mdelay(150); // 100msec, delay between reg_on & rst. (bcm4325 powerup sequence)
/* Set GPIO_BT_RST_N high */
s3c_gpio_setpull(GPIO_BT_RST_N, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_RST_N, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_BT_RST_N, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_BT_RST_N, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_RST_N = %d\n", gpio_get_value(GPIO_BT_RST_N));
gpio_free(GPIO_BT_RST_N);
gpio_free(GPIO_BT_WLAN_REG_ON);
break;
case RFKILL_USER_STATE_SOFT_BLOCKED:
printk("[BT] Device Powering OFF \n");
//wake_unlock(&bt_wake_lock); //if not, it doesn't go to sleep after BT on->off. There's lock somewhere.
s3c_reset_uart_cfg_gpio(1);
s3c_gpio_setpull(GPIO_BT_RST_N, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_RST_N, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_BT_RST_N, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_BT_RST_N, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_RST_N = %d\n",gpio_get_value(GPIO_BT_RST_N));
if(gpio_get_value(GPIO_WLAN_RST_N) == 0)
{
s3c_gpio_setpull(GPIO_BT_WLAN_REG_ON, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_WLAN_REG_ON, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_BT_WLAN_REG_ON, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(GPIO_BT_WLAN_REG_ON, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_WLAN_REG_ON = %d\n", gpio_get_value(GPIO_BT_WLAN_REG_ON));
}
gpio_free(GPIO_BT_RST_N);
gpio_free(GPIO_BT_WLAN_REG_ON);
break;
default:
printk(KERN_ERR "[BT] Bad bluetooth rfkill state %d\n", state);
}
return 0;
}
void s5pv310_setup_sdhci3_cfg_gpio(struct platform_device *dev, int width)
{
unsigned int gpio;
#if defined(CONFIG_WIMAX_CMC) && defined(CONFIG_TARGET_LOCALE_NA)
if(gpio_get_value(GPIO_WIMAX_EN))
{
/* Set all the necessary GPK1[0:1] pins to special-function 2 */
for (gpio = S5PV310_GPK3(0); gpio < S5PV310_GPK3(2); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(2));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
}
/* Data pin GPK1[3:6] to special-function 2 */
for (gpio = S5PV310_GPK3(3); gpio <= S5PV310_GPK3(6); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(2));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
}
//__raw_writel(0x3FFF, GPK3DRV);
__raw_writel(0x2AAA, GPK3DRV); // for sdio noise
for (gpio = S5PV310_GPK3(0); gpio < S5PV310_GPK3(2); gpio++) {
s3c_gpio_slp_cfgpin(gpio,S3C_GPIO_SLP_INPUT );
s3c_gpio_slp_setpull_updown(gpio,S3C_GPIO_PULL_NONE );
}
for (gpio = S5PV310_GPK3(3); gpio < S5PV310_GPK3(6); gpio++) {
s3c_gpio_slp_cfgpin(gpio,S3C_GPIO_SLP_INPUT );
s3c_gpio_slp_setpull_updown(gpio,S3C_GPIO_PULL_NONE );
}
}
else
{
/* Set all the necessary GPK1[0:1] to Input pull down for power saving */
for (gpio = S5PV310_GPK3(0); gpio < S5PV310_GPK3(2); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(0));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_DOWN);
}
/* Data pin GPK1[3:6] to Input pull down for power saving */
for (gpio = S5PV310_GPK3(3); gpio <= S5PV310_GPK3(6); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(0));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_DOWN);
}
for (gpio = S5PV310_GPK3(0); gpio < S5PV310_GPK3(2); gpio++) {
s3c_gpio_slp_cfgpin(gpio,S3C_GPIO_SLP_INPUT );
s3c_gpio_slp_setpull_updown(gpio,S3C_GPIO_PULL_DOWN );
}
for (gpio = S5PV310_GPK3(3); gpio < S5PV310_GPK3(6); gpio++) {
s3c_gpio_slp_cfgpin(gpio,S3C_GPIO_SLP_INPUT );
s3c_gpio_slp_setpull_updown(gpio,S3C_GPIO_PULL_DOWN );
}
}
#else
/* Set all the necessary GPK1[0:1] pins to special-function 2 */
for (gpio = S5PV310_GPK3(0); gpio < S5PV310_GPK3(2); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(2));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
}
/* Data pin GPK1[3:6] to special-function 2 */
for (gpio = S5PV310_GPK3(3); gpio <= S5PV310_GPK3(6); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(2));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
}
//__raw_writel(0x3FFF, GPK3DRV);
__raw_writel(0x2AAA, GPK3DRV); // for sdio noise
#endif
}
static int bt_set_power(void *data, enum rfkill_user_states state)
{
int ret = 0;
int wl_ret =0;
int irq;
/* BT Host Wake IRQ */
irq = gpio_to_irq(BT_HOST_WAKE);
switch (state) {
case RFKILL_USER_STATE_UNBLOCKED:
pr_info("[BT] Device Powering ON\n");
/* config uart0 */
s3c_setup_uart_cfg_gpio(0);
/* set gpio direction */
if (gpio_is_valid(BT_POWER))
gpio_direction_output(BT_POWER, GPIO_LEVEL_HIGH);
//request gpio wl_power when use it
wl_ret = gpio_request(WL_POWER, "gpio_wl_power");
if (gpio_is_valid(WL_POWER))
gpio_direction_output(WL_POWER, GPIO_LEVEL_HIGH);
if (gpio_is_valid(BT_RESET))
gpio_direction_output(BT_RESET, GPIO_LEVEL_LOW);
/* Set BT_POWER high */
s3c_gpio_setpull(BT_POWER, S3C_GPIO_PULL_NONE);
gpio_set_value(BT_POWER, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(BT_POWER, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(BT_POWER, S3C_GPIO_PULL_NONE);
/* Set WL_POWER high */
s3c_gpio_setpull(WL_POWER, S3C_GPIO_PULL_NONE);
gpio_set_value(WL_POWER, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(WL_POWER, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(WL_POWER, S3C_GPIO_PULL_NONE);
if (wl_ret == 0) {
gpio_free(WL_POWER); //free wl_power
}
/*
* FIXME sleep should be enabled disabled since the device is
* not booting if its enabled ?
*/
/*
* at least 100 msec delay, between reg_on & rst.
* (bcm4329 powerup sequence)
*/
msleep(100); //default 50; lvcha
/* Set BT_RESET high */
s3c_gpio_setpull(BT_RESET, S3C_GPIO_PULL_NONE);
gpio_set_value(BT_RESET, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(BT_RESET, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(BT_RESET, S3C_GPIO_PULL_NONE);
/*
* at least 50 msec delay, after bt rst
* (bcm4329 powerup sequence)
*/
msleep(50);
gpio_set_value(BT_WAKE, GPIO_LEVEL_HIGH);
ret = enable_irq_wake(irq);
if (ret < 0)
pr_err("[BT] set wakeup src failed\n");
enable_irq(irq);
break;
case RFKILL_USER_STATE_SOFT_BLOCKED:
pr_info("[BT] Device Powering OFF\n");
/* Set irq */
ret = disable_irq_wake(irq);
if (ret < 0)
pr_err("[BT] unset wakeup src failed\n");
disable_irq(irq);
/* Unlock wake lock */
wake_unlock(&rfkill_wake_lock);
gpio_set_value(BT_WAKE, GPIO_LEVEL_LOW);
/* Set BT_RESET low */
s3c_gpio_setpull(BT_RESET, S3C_GPIO_PULL_NONE);
gpio_set_value(BT_RESET, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(BT_RESET, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(BT_RESET, S3C_GPIO_PULL_NONE);
/* Check WL_RESET */
if (gpio_get_value(WL_RESET) == 0) {
/* Set WL_POWER low */
s3c_gpio_setpull(WL_POWER, S3C_GPIO_PULL_NONE);
gpio_set_value(WL_POWER, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(WL_POWER, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(WL_POWER, S3C_GPIO_PULL_NONE);
/* Set BT_POWER low */
s3c_gpio_setpull(BT_POWER, S3C_GPIO_PULL_NONE);
gpio_set_value(BT_POWER, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(BT_POWER, S3C_GPIO_SLP_OUT0);
s3c_gpio_slp_setpull_updown(BT_POWER, S3C_GPIO_PULL_NONE);
}
break;
default:
pr_err("[BT] Bad bluetooth rfkill state %d\n", state);
}
return 0;
}
static int bluetooth_set_power(void *data, enum rfkill_user_states state)
{
unsigned int ret = 0;
static int on_off = 0;
switch (state) {
case RFKILL_USER_STATE_UNBLOCKED:
printk(KERN_DEBUG "[BT] Device Powering ON \n");
s3c_setup_uart_cfg_gpio(0);
if(on_off) return ret; //shiks_DF03 temp for AP sleep issue //just 1 time //FROYO MERGE
if (gpio_is_valid(GPIO_WLAN_BT_EN))
{
ret = gpio_request(GPIO_WLAN_BT_EN, "GPB");
if (ret < 0) {
printk(KERN_ERR "[BT] Failed to request GPIO_WLAN_BT_EN!\n");
return ret;
}
gpio_direction_output(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH);
}
//SecFeature shiks_DJ18 start
enable_irq(IRQ_BT_HOST_WAKE);//for sleep surrent when wifi goes to sleep mode
//SecFeature shiks_DJ18 end
if (gpio_is_valid(GPIO_BT_nRST))
{
ret = gpio_request(GPIO_BT_nRST, "GPB");
if (ret < 0) {
gpio_free(GPIO_WLAN_BT_EN);
printk(KERN_ERR "[BT] Failed to request GPIO_BT_nRST\n");
return ret;
}
gpio_direction_output(GPIO_BT_nRST, GPIO_LEVEL_LOW);
}
printk(KERN_DEBUG "[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST));
/* Set GPIO_BT_WLAN_REG_ON high */
s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_PREV);
s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
printk( "[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN));
/*FIXME sleep should be enabled disabled since the device is not booting
* if its enabled*/
msleep(200); // 100msec, delay between reg_on & rst. (bcm4329 powerup sequence)
/* Set GPIO_BT_nRST high */
s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_HIGH);
s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST));
on_off =1;
gpio_free(GPIO_BT_nRST);
gpio_free(GPIO_WLAN_BT_EN);
break;
case RFKILL_USER_STATE_SOFT_BLOCKED:
printk(KERN_DEBUG "[BT] Device Powering OFF \n");
// s3c_reset_uart_cfg_gpio(0);
s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_PREV);
s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_BT_nRST = %d\n",gpio_get_value(GPIO_BT_nRST));
//SecFeature shiks_DJ18 start
disable_irq(IRQ_BT_HOST_WAKE);//for sleep surrent when wifi goes to sleep mode
//SecFeature shiks_DJ18 end
if(gpio_get_value(GPIO_WLAN_nRST) == 0)
{
s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_LOW);
s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_PREV);
s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE);
printk("[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN));
}
on_off = 0;
gpio_free(GPIO_BT_nRST);
gpio_free(GPIO_WLAN_BT_EN);
break;
default:
printk(KERN_ERR "[BT] Bad bluetooth rfkill state %d\n", state);
}
return 0;
}
void exynos4_setup_sdhci3_cfg_gpio(struct platform_device *dev, int width)
{
struct s3c_sdhci_platdata *pdata = dev->dev.platform_data;
unsigned int gpio;
#if defined(CONFIG_WIMAX_CMC) /* && defined(CONFIG_TARGET_LOCALE_NA) */
if (gpio_get_value(GPIO_WIMAX_EN)) {
for (gpio = EXYNOS4_GPK3(0); gpio < EXYNOS4_GPK3(2); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(2));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV2);
}
for (gpio = EXYNOS4_GPK3(3); gpio <= EXYNOS4_GPK3(6); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(2));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV2);
}
for (gpio = EXYNOS4_GPK3(0); gpio < EXYNOS4_GPK3(2); gpio++) {
s3c_gpio_slp_cfgpin(gpio, S3C_GPIO_SLP_INPUT);
s3c_gpio_slp_setpull_updown(gpio, S3C_GPIO_PULL_NONE);
}
for (gpio = EXYNOS4_GPK3(3); gpio <= EXYNOS4_GPK3(6); gpio++) {
s3c_gpio_slp_cfgpin(gpio, S3C_GPIO_SLP_INPUT);
s3c_gpio_slp_setpull_updown(gpio, S3C_GPIO_PULL_NONE);
}
} else {
for (gpio = EXYNOS4_GPK3(0); gpio < EXYNOS4_GPK3(2); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(0));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_DOWN);
}
for (gpio = EXYNOS4_GPK3(3); gpio <= EXYNOS4_GPK3(6); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(0));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_DOWN);
}
for (gpio = EXYNOS4_GPK3(0); gpio < EXYNOS4_GPK3(2); gpio++) {
s3c_gpio_slp_cfgpin(gpio, S3C_GPIO_SLP_INPUT);
s3c_gpio_slp_setpull_updown(gpio, S3C_GPIO_PULL_DOWN);
}
for (gpio = EXYNOS4_GPK3(3); gpio <= EXYNOS4_GPK3(6); gpio++) {
s3c_gpio_slp_cfgpin(gpio, S3C_GPIO_SLP_INPUT);
s3c_gpio_slp_setpull_updown(gpio, S3C_GPIO_PULL_DOWN);
}
}
#else
/* Set all the necessary GPK3[0:1] pins to special-function 2 */
for (gpio = EXYNOS4_GPK3(0); gpio < EXYNOS4_GPK3(2); gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(2));
#ifdef CONFIG_MACH_U1
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV2);
#elif defined(CONFIG_MACH_MIDAS)
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV4);
#elif defined(CONFIG_MACH_PX)
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV4);
#else
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV4);
#endif
}
#if defined(CONFIG_MACH_PX)
s3c_gpio_setpull(EXYNOS4_GPK3(1), S3C_GPIO_PULL_UP);
#endif
for (gpio = EXYNOS4_GPK3(3); gpio <= EXYNOS4_GPK3(6); gpio++) {
/* Data pin GPK3[3:6] to special-function 2 */
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(2));
#ifdef CONFIG_MACH_U1
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV2);
#elif defined(CONFIG_MACH_MIDAS)
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV4);
#elif defined(CONFIG_MACH_PX)
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV4);
#else
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV4);
#endif
}
if (pdata->cd_type == S3C_SDHCI_CD_INTERNAL) {
s3c_gpio_cfgpin(EXYNOS4_GPK3(2), S3C_GPIO_SFN(2));
s3c_gpio_setpull(EXYNOS4_GPK3(2), S3C_GPIO_PULL_NONE);
s5p_gpio_set_drvstr(gpio, S5P_GPIO_DRVSTR_LV2);
}
#endif
}
