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)) {
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
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");

}
Ejemplo n.º 4
0
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;
}
Ejemplo n.º 5
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;
}
Ejemplo n.º 6
0
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");	
}
Ejemplo n.º 7
0
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; 
}
Ejemplo n.º 8
0
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;
	
}
Ejemplo n.º 9
0
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;

	}
	
}
Ejemplo n.º 10
0
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");

	
}
Ejemplo n.º 11
0
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;

}
Ejemplo n.º 12
0
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);

};
Ejemplo n.º 13
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;
}
Ejemplo n.º 14
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;
}
Ejemplo n.º 15
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);
}