int audio_init(void)
{
/* AUDIO_EN */
if (gpio_is_valid(GPIO_AUDIO_EN)) {
if (gpio_request(GPIO_AUDIO_EN, S3C_GPIO_LAVEL(GPIO_AUDIO_EN)))
printk(KERN_ERR "Failed to request GPIO_AUDIO_EN! \n");
gpio_direction_output(GPIO_AUDIO_EN, 0);
}
s3c_gpio_setpull(GPIO_AUDIO_EN, S3C_GPIO_PULL_NONE);
/* MICBIAS_EN */
if (gpio_is_valid(GPIO_MICBIAS_EN)) {
if (gpio_request(GPIO_MICBIAS_EN, S3C_GPIO_LAVEL(GPIO_MICBIAS_EN)))
printk(KERN_ERR "Failed to request GPIO_MICBIAS_EN! \n");
gpio_direction_output(GPIO_MICBIAS_EN, 0);
}
s3c_gpio_setpull(GPIO_MICBIAS_EN, S3C_GPIO_PULL_NONE);
//HYH_20100526 if (system_rev >= 0x40)
{
if (gpio_is_valid(GPIO_MIC_SEL_EN_REV04)) {
if (gpio_request(GPIO_MIC_SEL_EN_REV04, S3C_GPIO_LAVEL(GPIO_MIC_SEL_EN_REV04)))
printk(KERN_ERR "Failed to request GPIO_MIC_SEL_EN_REV04! \n");
gpio_direction_output(GPIO_MIC_SEL_EN_REV04, 0);
}
s3c_gpio_setpull(GPIO_MIC_SEL_EN_REV04, S3C_GPIO_PULL_NONE);
}
#if 0 //HYH_20100526
else {
if (gpio_is_valid(GPIO_MIC_SEL_EN)) {
int audio_init(void)
{
/* AUDIO_EN */
if (gpio_is_valid(GPIO_AUDIO_EN)) {
if (gpio_request(GPIO_AUDIO_EN, S3C_GPIO_LAVEL(GPIO_AUDIO_EN)))
printk(KERN_ERR "Failed to request GPIO_AUDIO_EN! \n");
gpio_direction_output(GPIO_AUDIO_EN, 0);
}
s3c_gpio_setpull(GPIO_AUDIO_EN, S3C_GPIO_PULL_NONE);
/* MICBIAS_EN */
if (gpio_is_valid(GPIO_MICBIAS_EN)) {
if (gpio_request(GPIO_MICBIAS_EN, S3C_GPIO_LAVEL(GPIO_MICBIAS_EN)))
printk(KERN_ERR "Failed to request GPIO_MICBIAS_EN! \n");
gpio_direction_output(GPIO_MICBIAS_EN, 0);
}
s3c_gpio_setpull(GPIO_MICBIAS_EN, S3C_GPIO_PULL_NONE);
/* MIC_SEL */
if (gpio_is_valid(GPIO_MIC_SEL)) {
if (gpio_request(GPIO_MIC_SEL, S3C_GPIO_LAVEL(GPIO_MIC_SEL)))
printk(KERN_ERR "Failed to request GPIO_MIC_SEL! \n");
gpio_direction_output(GPIO_MIC_SEL, 0);
}
s3c_gpio_setpull(GPIO_MIC_SEL, S3C_GPIO_PULL_NONE);
return 0;
}
int aat1271a_flash_init(void)
{
int ret;
/* hrtimer settings */
hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
timer.function = aat1271_flash_timer_func;
if (gpio_is_valid(GPIO_CAM_FLASH_SET)) {
if (gpio_request(GPIO_CAM_FLASH_SET, S3C_GPIO_LAVEL(GPIO_CAM_FLASH_SET)))
printk(KERN_ERR "Failed to request GPIO_CAM_FLASH_SET!\n");
gpio_direction_output(GPIO_CAM_FLASH_SET, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_CAM_FLASH_SET, S3C_GPIO_PULL_NONE);
if (gpio_is_valid(GPIO_CAM_FLASH_EN)) {
if (gpio_request(GPIO_CAM_FLASH_EN, S3C_GPIO_LAVEL(GPIO_CAM_FLASH_EN)))
printk(KERN_ERR "Failed to request GPIO_CAM_FLASH_EN!\n");
gpio_direction_output(GPIO_CAM_FLASH_EN, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_CAM_FLASH_EN, S3C_GPIO_PULL_NONE);
/* timed_output_device settings */
ret = timed_output_dev_register(&timed_output_flash);
if(ret)
printk(KERN_ERR "[VIBETONZ] timed_output_dev_register is fail \n");
}
static int bluetooth_set_sleep(void *data, enum rfkill_user_states state)
{
unsigned int ret =0;
switch (state) {
case RFKILL_USER_STATE_UNBLOCKED:
if (gpio_is_valid(GPIO_BT_WAKE))
{
ret = gpio_request(GPIO_BT_WAKE, S3C_GPIO_LAVEL(GPIO_BT_WAKE));
if(ret < 0) {
printk(KERN_ERR "[BT] Failed to request GPIO_BT_WAKE!\n");
return ret;
}
gpio_direction_output(GPIO_BT_WAKE, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_BT_WAKE, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_WAKE, GPIO_LEVEL_LOW);
mdelay(50); // 50msec, why?
printk("[BT] GPIO_BT_WAKE = %d\n", gpio_get_value(GPIO_BT_WAKE) );
gpio_free(GPIO_BT_WAKE);
//billy's changes
printk("[BT] wake_unlock(bt_wake_lock)\n");
wake_unlock(&bt_wake_lock);
break;
case RFKILL_USER_STATE_SOFT_BLOCKED:
if (gpio_is_valid(GPIO_BT_WAKE))
{
ret = gpio_request(GPIO_BT_WAKE, S3C_GPIO_LAVEL(GPIO_BT_WAKE));
if(ret < 0) {
printk("[BT] Failed to request GPIO_BT_WAKE!\n");
return ret;
}
gpio_direction_output(GPIO_BT_WAKE, GPIO_LEVEL_HIGH);
}
s3c_gpio_setpull(GPIO_BT_WAKE, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_WAKE, GPIO_LEVEL_HIGH);
mdelay(50);
printk("[BT] GPIO_BT_WAKE = %d\n", gpio_get_value(GPIO_BT_WAKE) );
gpio_free(GPIO_BT_WAKE);
//billy's changes
printk("[BT] wake_lock(bt_wake_lock)\n");
wake_lock(&bt_wake_lock);
break;
default:
printk(KERN_ERR "[BT] Bad bluetooth rfkill state %d\n", state);
}
return 0;
}
int aat1271a_flash_init(void)
{
struct timed_gpio_data * gpio_data;
int ret;
gpio_data = kzalloc(sizeof(struct timed_gpio_data), GFP_KERNEL);
if (!gpio_data)
return -ENOMEM;
aat1271_flash_data = gpio_data;
hrtimer_init(&gpio_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
gpio_data->timer.function = aat1271_flash_timer_func;
spin_lock_init(&gpio_data->lock);
if (gpio_is_valid(GPIO_CAM_FLASH_SET)) {
if (gpio_request(GPIO_CAM_FLASH_SET, S3C_GPIO_LAVEL(GPIO_CAM_FLASH_SET)))
printk(KERN_ERR "Failed to request GPIO_CAM_FLASH_SET!\n");
gpio_direction_output(GPIO_CAM_FLASH_SET, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_CAM_FLASH_SET, S3C_GPIO_PULL_NONE);
if (gpio_is_valid(GPIO_CAM_FLASH_EN)) {
if (gpio_request(GPIO_CAM_FLASH_EN, S3C_GPIO_LAVEL(GPIO_CAM_FLASH_EN)))
printk(KERN_ERR "Failed to request GPIO_CAM_FLASH_EN!\n");
gpio_direction_output(GPIO_CAM_FLASH_EN, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_CAM_FLASH_EN, S3C_GPIO_PULL_NONE);
gpio_data->dev = device_create(timed_gpio_class, NULL, 0, "%s", "flash");
if (!gpio_data->dev)
goto dev_create;
dev_set_drvdata(gpio_data->dev, gpio_data);
ret = device_create_file(gpio_data->dev, &dev_attr_enable);
if (ret)
goto dev_create_file;
return 0;
dev_create_file:
device_unregister(gpio_data->dev);
dev_create:
kfree(gpio_data);
return -ENODEV;
}
static void vibetonz_start(void)
{
int ret = 0;
//printk("[VIBETONZ] %s : \n",__func__);
spin_lock_init(&vib_lock);
/* hrtimer settings */
hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
timer.function = vibetonz_timer_func;
if (gpio_is_valid(GPIO_VIB_EN)) {
if (gpio_request(GPIO_VIB_EN, S3C_GPIO_LAVEL(GPIO_VIB_EN)))
printk(KERN_ERR "Failed to request GPIO_VIB_EN!\n");
gpio_direction_output(GPIO_VIB_EN,0);
mdelay(10);
gpio_set_value(GPIO_VIB_EN, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_VIB_EN, S3C_GPIO_PULL_NONE);
/* pwm timer settings */
s3c6410_timer_setup(1,10,VIBRATOR_ON_STRONG_PERIOD, VIBRATOR_OFF_STRONG_PERIOD);
/* timed_output_device settings */
ret = timed_output_dev_register(&timed_output_vt);
if(ret)
printk(KERN_ERR "[VIBETONZ] timed_output_dev_register is fail \n");
}
int __init Si4709_driver_init(void)
{
int ret = 0;
debug("Si4709_driver_init called");
/*Initilize the Si4709 dev mutex*/
Si4709_dev_mutex_init();
/*misc device registration*/
if( (ret = misc_register(&Si4709_misc_device)) < 0 )
{
error("Si4709_driver_init misc_register failed");
return ret;
}
s3c_gpio_cfgpin(GPIO_FM_INT, S3C_GPIO_SFN(GPIO_FM_INT_AF));
s3c_gpio_setpull(GPIO_FM_INT, S3C_GPIO_PULL_NONE);
set_irq_type(Si4709_IRQ, IRQ_TYPE_EDGE_BOTH);
if( (ret = request_irq(Si4709_IRQ, Si4709_isr, IRQF_DISABLED, "Si4709", (void *)NULL)) < 0 )
{
error("Si4709_driver_init request_irq failed %d", Si4709_IRQ);
goto MISC_DREG;
}
if (gpio_is_valid(GPIO_FM_nRST)) {
if (gpio_request(GPIO_FM_nRST, S3C_GPIO_LAVEL(GPIO_FM_nRST)))
printk(KERN_ERR "Failed to request GPIO_FM_nRST!\n");
gpio_direction_output(GPIO_FM_nRST, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_FM_INT, S3C_GPIO_PULL_DOWN);
/****Resetting the device****/
gpio_set_value(GPIO_FM_nRST, GPIO_LEVEL_LOW);
gpio_set_value(GPIO_FM_nRST, GPIO_LEVEL_HIGH);
/*Add the i2c driver*/
if ( (ret = Si4709_i2c_drv_init() < 0) )
{
goto MISC_IRQ_DREG;
}
init_waitqueue_head(&Si4709_waitq);
debug("Si4709_driver_init successful");
return ret;
MISC_IRQ_DREG:
free_irq(Si4709_IRQ, (void *)NULL);
MISC_DREG:
misc_deregister(&Si4709_misc_device);
return ret;
}
int device_poweron ()
{
if (gpio_is_valid(GPIO_BT_WAKE)) {
if (gpio_request(GPIO_BT_WAKE, S3C_GPIO_LAVEL(GPIO_BT_WAKE)))
{
printk(KERN_ERR "Failed to request GPIO_BT_WAKE!\n");
goto ERROR_VAL;
}
gpio_direction_output(GPIO_BT_WAKE, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_BT_WAKE, S3C_GPIO_PULL_NONE);
if (gpio_is_valid(GPIO_BT_RST_N)) {
if (gpio_request(GPIO_BT_RST_N, S3C_GPIO_LAVEL(GPIO_BT_RST_N)))
{
printk(KERN_ERR "Failed to request GPIO_BT_RST_N!\n");
goto ERROR_VAL;
}
gpio_direction_output(GPIO_BT_RST_N, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_BT_RST_N, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_BT_HOST_WAKE, S3C_GPIO_SFN(GPIO_BT_HOST_WAKE_AF));
s3c_gpio_setpull(GPIO_BT_HOST_WAKE, S3C_GPIO_PULL_DOWN);
//s3c_gpio_cfgpin(GPIO_WLAN_HOST_WAKE, S3C_GPIO_SFN(GPIO_WLAN_HOST_WAKE_AF));
//s3c_gpio_setpull(GPIO_WLAN_HOST_WAKE, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_BT_RST_N, GPIO_LEVEL_LOW);
msleep (100);
gpio_set_value(GPIO_BT_RST_N, GPIO_LEVEL_HIGH);
printk (KERN_INFO "BT GPIO Power On Success\n");
return 0;
ERROR_VAL:
printk (KERN_ERR "BT GPIO Power On Failure!\n");
return -1;
}
static void gp2a_chip_init(void)
{
gprintk("\n");
/* Power On */
if (gpio_is_valid(GPIO_LUM_PWM))
{
if (gpio_request(GPIO_LUM_PWM, S3C_GPIO_LAVEL(GPIO_LUM_PWM)))
printk(KERN_ERR "Filed to request GPIO_LUM_PWM!\n");
gpio_direction_output(GPIO_LUM_PWM, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_LUM_PWM, S3C_GPIO_PULL_NONE);
mdelay(5);
/* set INT */
s3c_gpio_cfgpin(GPIO_PS_VOUT, S3C_GPIO_SFN(GPIO_PS_VOUT_AF));
s3c_gpio_setpull(GPIO_PS_VOUT, S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_GP2A_INT, IRQ_TYPE_EDGE_FALLING);
/* check HW revision */
if(system_rev == 0x30)
{
printk("[OPT_sensor]This HW is rev03 or later \n");
light_state[0].adc_bottom_limit = ADC_CUT_HIGH_M900_R3 - ADC_CUT_GAP_M900_R3/2;
light_state[1].adc_bottom_limit = ADC_CUT_LOW_M900_R3 - ADC_CUT_GAP_M900_R3/2;
light_state[1].adc_top_limit = ADC_CUT_HIGH_M900_R3 + ADC_CUT_GAP_M900_R3/2;
light_state[2].adc_top_limit = ADC_CUT_LOW_M900_R3 + ADC_CUT_GAP_M900_R3/2;
}
if(system_rev > 0x30)
{
printk("[OPT_sensor]This HW is rev04 or later \n");
light_state[0].adc_bottom_limit = ADC_CUT_HIGH_M900_R4 - ADC_CUT_GAP_M900_R4/2;
light_state[1].adc_bottom_limit = ADC_CUT_LOW_M900_R4 - ADC_CUT_GAP_M900_R4/2;
light_state[1].adc_top_limit = ADC_CUT_HIGH_M900_R4 + ADC_CUT_GAP_M900_R4/2;
light_state[2].adc_top_limit = ADC_CUT_LOW_M900_R4 + ADC_CUT_GAP_M900_R4/2;
}
}
static void vibetonz_start(void)
{
int ret = 0;
printk("[VIBETONZ] %s : \n",__func__);
spin_lock_init(&vib_spin_lock);
/* hrtimer settings */
hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
timer.function = vibetonz_timer_func;
if (gpio_is_valid(GPIO_VIB_EN)) {
if (gpio_request(GPIO_VIB_EN, S3C_GPIO_LAVEL(GPIO_VIB_EN)))
printk(KERN_ERR "Failed to request GPIO_VIB_EN!\n");
gpio_direction_output(GPIO_VIB_EN,0);
mdelay(10);
gpio_set_value(GPIO_VIB_EN, GPIO_LEVEL_LOW);
}
s3c_gpio_setpull(GPIO_VIB_EN, S3C_GPIO_PULL_NONE);
/*Initialising work-queue*/
vib_wq = create_singlethread_workqueue("vib_wq");
if(!vib_wq){
printk(KERN_ERR "Not enough memory for vibrator workqueue\n");
}
INIT_WORK(&work_vib,vib_work_func);
/* pwm timer settings */
#ifdef CONFIG_MACH_VINSQ
s3c6410_timer_setup(1,10,290,3);
#else
s3c6410_timer_setup(1,10,300,3);
#endif
/* timed_output_device settings */
ret = timed_output_dev_register(&timed_output_vt);
if(ret)
printk(KERN_ERR "[VIBETONZ] timed_output_dev_register is fail \n");
}
int device_readhostline (int *hostval)
{
if (gpio_is_valid(GPIO_BT_HOST_WAKE)) {
if (gpio_request(GPIO_BT_HOST_WAKE, S3C_GPIO_LAVEL(GPIO_BT_HOST_WAKE)))
{
printk(KERN_ERR "Failed to request GPIO_BT_HOST_WAKE!\n");
goto ERROR_VAL;
}
gpio_direction_input(GPIO_BT_HOST_WAKE);
}
*hostval = gpio_get_value (GPIO_BT_HOST_WAKE);
printk (KERN_DEBUG "The READ_HOST_WAKE value is = %d\n", *hostval);
gpio_free(GPIO_BT_HOST_WAKE);
return 0;
ERROR_VAL:
return -1;
}
static void omnia_II_switch_init(void)
{
sec_class = class_create(THIS_MODULE, "sec");
if (IS_ERR(sec_class))
pr_err("Failed to create class(sec)!\n");
switch_dev = device_create(sec_class, NULL, 0, NULL, "switch");
if (IS_ERR(switch_dev))
pr_err("Failed to create device(switch)!\n");
if (gpio_is_valid(GPIO_UART_SEL)) {
if (gpio_request(GPIO_UART_SEL, S3C_GPIO_LAVEL(GPIO_UART_SEL)))
printk(KERN_ERR "Failed to request GPIO_UART_SEL!\n");
gpio_direction_output(GPIO_UART_SEL, gpio_get_value(GPIO_UART_SEL));
}
s3c_gpio_setpull(GPIO_UART_SEL, S3C_GPIO_PULL_NONE);
if (device_create_file(switch_dev, &dev_attr_uart_sel) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_uart_sel.attr.name);
};
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)
{
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;
}
static void saturn_pm_power_off(void)
{
int mode = REBOOT_MODE_NONE;
char reset_mode = 'r';
int cnt = 0;
int i;
if (!gpio_get_value(GPIO_TA_CONNECTED_N))
{ /* Reboot Charging */
mode = REBOOT_MODE_CHARGING;
if (sec_set_param_value)
sec_set_param_value(__REBOOT_MODE, &mode);
/* Watchdog Reset */
arch_reset(reset_mode);
}
else
{ /* Power Off or Reboot */
if (sec_set_param_value)
sec_set_param_value(__REBOOT_MODE, &mode);
if (get_usb_cable_state() & (JIG_UART_ON | JIG_UART_OFF | JIG_USB_OFF | JIG_USB_ON)) {
/* Watchdog Reset */
arch_reset(reset_mode);
}
else
{
/* POWER_N -> Input */
gpio_direction_input(GPIO_POWER_N);
gpio_direction_input(GPIO_PHONE_ACTIVE);
if (!gpio_get_value(GPIO_POWER_N) || gpio_get_value(GPIO_PHONE_ACTIVE))
{
/* Wait Power Button Release */
while (gpio_get_value(GPIO_PHONE_ACTIVE))
{
if (cnt++ < 5)
{
printk(KERN_EMERG "%s: GPIO_PHONE_ACTIVE is high(%d)\n", __func__, cnt);
mdelay(1000);
}
else
{
printk(KERN_EMERG "%s: GPIO_PHONE_ACTIVE TIMED OUT!!!\n", __func__);
// Display Yellow LED
if (gpio_request(GPIO_7_LED_LDO_EN, S3C_GPIO_LAVEL(GPIO_7_LED_LDO_EN)))
printk(KERN_ERR "Failed to request GPIO_7_LED_LDO_EN!\n");
else
{
gpio_direction_output(GPIO_7_LED_LDO_EN, GPIO_LEVEL_HIGH);
gpio_free(GPIO_7_LED_LDO_EN);
udelay(50);
}
for (i=0; i<61; i++)
{
gpio_direction_output(GPIO_7_LED_EN, GPIO_LEVEL_LOW);
udelay(1);
gpio_direction_output(GPIO_7_LED_EN, GPIO_LEVEL_HIGH);
udelay(1);
}
// (PHONE_RST: Output Low) -> (nPHONE_RST: Low) -> (MSM_PSHOLD: Low) -> CP PMIC Off
gpio_direction_output(GPIO_PHONE_RST_N, GPIO_LEVEL_HIGH);
s3c_gpio_setpull(GPIO_PHONE_RST_N, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_PHONE_RST_N, GPIO_LEVEL_LOW);
break;
}
}
while (!gpio_get_value(GPIO_POWER_N));
}
if (!gpio_get_value(GPIO_TA_CONNECTED_N) || !gpio_get_value(GPIO_CHG_ING_N) )
{
mode = REBOOT_MODE_CHARGING;
if (sec_set_param_value)
sec_set_param_value(__REBOOT_MODE, &mode);
/* Watchdog Reset */
arch_reset(reset_mode);
}
else
{
if (sec_set_param_value)
sec_set_param_value(__REBOOT_MODE, &mode);
/* PS_HOLD -> Output Low */
gpio_direction_output(GPIO_PDA_PS_HOLD, GPIO_LEVEL_HIGH);
s3c_gpio_setpull(GPIO_PDA_PS_HOLD, S3C_GPIO_PULL_NONE);
gpio_set_value(GPIO_PDA_PS_HOLD, GPIO_LEVEL_LOW);
}
}
}
while (1);
}
