C++ set_irq_wake函数代码示例

int sapphire_init_gpio(void)
{
	int i;
	if (!machine_is_sapphire())
		return 0;

	DBG("%d,%d\r\n",SAPPHIRE_INT_START, SAPPHIRE_INT_END);
	DBG("NR_MSM_IRQS=%d, NR_GPIO_IRQS=%d\r\n", NR_MSM_IRQS, NR_GPIO_IRQS);
	for(i = SAPPHIRE_INT_START; i <= SAPPHIRE_INT_END; i++) {
		set_irq_chip(i, &sapphire_gpio_irq_chip);
		set_irq_handler(i, handle_edge_irq);
		set_irq_flags(i, IRQF_VALID);
	}

	register_gpio_chip(&sapphire_gpio_chip);
	register_gpio_chip(&sapphire_h2w_gpio_chip);

	/*setup CPLD INT connecting to SOC's gpio 17 */
	set_irq_type(MSM_GPIO_TO_INT(17), IRQF_TRIGGER_HIGH);
	set_irq_chained_handler(MSM_GPIO_TO_INT(17), sapphire_gpio_irq_handler);
	set_irq_wake(MSM_GPIO_TO_INT(17), 1);

	if(sysdev_class_register(&sapphire_sysdev_class) == 0)
		sysdev_register(&sapphire_irq_device);

	return 0;
}

int bcmsdh_register_oob_intr(void *dhdp)
{
	int error = 0;

	SDLX_MSG(("%s Enter\n", __func__));

	sdhcinfo->oob_flags =
	    IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL |
	    IORESOURCE_IRQ_SHAREABLE;
	dev_set_drvdata(sdhcinfo->dev, dhdp);

	if (!sdhcinfo->oob_irq_registered) {
		SDLX_MSG(("%s IRQ=%d Type=%X\n", __func__,
			  (int)sdhcinfo->oob_irq, (int)sdhcinfo->oob_flags));
		/* Refer to customer Host IRQ docs about
			 proper irqflags definition */
		error =
		    request_irq(sdhcinfo->oob_irq, wlan_oob_irq,
				sdhcinfo->oob_flags, "bcmsdh_sdmmc", NULL);
		if (error)
			return -ENODEV;

		set_irq_wake(sdhcinfo->oob_irq, 1);
		sdhcinfo->oob_irq_registered = true;
	}

	return 0;
}

int __init desirec_init_mmc(unsigned int sys_rev)
{
	wifi_status_cb = NULL;
	sdslot_vreg_enabled = 0;

	vreg_wifi_osc = vreg_get(0, "gp4");
	if (IS_ERR(vreg_wifi_osc))
		return PTR_ERR(vreg_wifi_osc);
	vreg_set_level(vreg_wifi_osc, 1800);

	msm_add_sdcc(1, &desirec_wifi_data, 0, 0); /* r porting 29: change func*/

	if (opt_disable_sdcard) {
		printk(KERN_INFO "desirec: SD-Card interface disabled\n");
		goto done;
	}

	vreg_sdslot = vreg_get(0, "gp6");
	if (IS_ERR(vreg_sdslot))
		return PTR_ERR(vreg_sdslot);

	set_irq_wake(MSM_GPIO_TO_INT(DESIREC_GPIO_SDMC_CD_N), 1);

	msm_add_sdcc(2, &desirec_sdslot_data, MSM_GPIO_TO_INT(DESIREC_GPIO_SDMC_CD_N),
		IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE); /* r porting 29 */

done:
	return 0;
}

int bluetooth_enable_irq(int enable, struct platform_device *pdev)
{
    int ret;
    if (enable) {
        set_irq_type(host_wake_irq , IRQ_TYPE_EDGE_RISING);
        ret = request_irq(host_wake_irq , bt_host_wake_isr, 0, pdev->name, NULL);
        if (ret < 0)
            return ret;
        set_irq_wake(host_wake_irq, 1);
    }
    else {
        set_irq_wake(host_wake_irq, 0);
        free_irq(host_wake_irq, NULL);
    }
    return ret;
}

static int __init msm_mpm_init(void)
{
	unsigned int irq = MSM_MPM_IPC_IRQ;
	int rc;

	bitmap_set(msm_mpm_gic_irqs_mask, 0, NR_MSM_IRQS - 1);
	bitmap_set(msm_mpm_gpio_irqs_mask, NR_MSM_IRQS,
			MSM_MPM_NR_APPS_IRQS - 1);

	rc = request_irq(irq, msm_mpm_irq,
			IRQF_TRIGGER_RISING, "mpm_drv", msm_mpm_irq);

	if (rc) {
		pr_err("%s: failed to request irq %u: %d\n",
			__func__, irq, rc);
		goto init_bail;
	}

	rc = set_irq_wake(irq, 1);
	if (rc) {
		pr_err("%s: failed to set wakeup irq %u: %d\n",
			__func__, irq, rc);
		goto init_free_bail;
	}

	return 0;

init_free_bail:
	free_irq(irq, msm_mpm_irq);

init_bail:
	return rc;
}

static int bcm_bt_lpm_probe(struct platform_device *pdev)
{
	int irq;
	int ret;
	struct bcm_bt_lpm_platform_data *pdata = pdev->dev.platform_data;

	if (bt_lpm.request_clock_off_locked != NULL) {
		printk(KERN_ERR "Cannot register two bcm_bt_lpm drivers\n");
		return -EINVAL;
	}

	bt_lpm.gpio_wake = pdata->gpio_wake;
	bt_lpm.gpio_host_wake = pdata->gpio_host_wake;
	bt_lpm.request_clock_off_locked = pdata->request_clock_off_locked;
	bt_lpm.request_clock_on_locked = pdata->request_clock_on_locked;

	hrtimer_init(&bt_lpm.enter_lpm_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	bt_lpm.enter_lpm_delay = ktime_set(1, 0);  /* 1 sec */
	bt_lpm.enter_lpm_timer.function = enter_lpm;

	gpio_set_value(bt_lpm.gpio_wake, 0);
	bt_lpm.host_wake = 0;

	irq = gpio_to_irq(bt_lpm.gpio_host_wake);
	ret = request_irq(irq, host_wake_isr,
			IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
			"bt host_wake", NULL);
	if (ret)
		return ret;
	ret = set_irq_wake(irq, 1);
	if (ret)
		return ret;

	return 0;
}

static uint32_t msm_sdcc_setup_power(struct device *dv, unsigned int vdd)
{
	int rc = 0;
	struct platform_device *pdev;
	static int first_setup = 1;

	pdev = container_of(dv, struct platform_device, dev);

	rc = msm_sdcc_setup_gpio(pdev->id, !!vdd);
	if (rc)
		goto out;

	rc = msm_sdcc_setup_vreg(pdev->id, !!vdd);

	/* if first called related to sdcc1,
	 *  irq should be registered as wakeup source
	 * [email protected], 2010-02-19
	 */
	if (vdd && first_setup) {
		struct mmc_platform_data *pdata = pdev->dev.platform_data;
		if (pdev->id == 1) {
			first_setup = 0;
			set_irq_wake(pdata->status_irq, 1);
		}
	}
out:
	return rc;
}

/**********************************************************
**  Function: Jack detection-in gpio configuration function
**  Parameter: none
**  Return value: if sucess, then returns 0
**
************************************************************/
static int jack_config_gpio()
{
	int ret;
	
	printk("HEADSET: Config Jack-in detection gpio\n");

	tegra_gpio_enable(JACK_GPIO);
	ret = gpio_request(JACK_GPIO, "h2w_detect");
	ret = gpio_direction_input(JACK_GPIO);

	hs_data->irq = gpio_to_irq(JACK_GPIO);
	ret = request_irq(hs_data->irq, detect_irq_handler,
			  IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "h2w_detect", NULL);

	ret = set_irq_wake(hs_data->irq, 1);

	if (gpio_get_value(JACK_GPIO) == 0){
		jack_alive = true;
		insert_headset();
	}else {
		jack_alive = false;
		remove_headset();
	}

	return 0;
}

/**
 * Stops the Sleep-Mode Protocol on the Host.
 */
static void
dhd_disable_hwakeup(void)
{

	if (set_irq_wake(dhd_wifi_sleep->host_wake_irq, 0))
		DHD_ERROR(("Couldn't disable hostwake IRQ wakeup mode\n"));
}

void hPlatform_freeInterrupt(void *tnet_drv)
{
	TWlanDrvIfObj *drv = tnet_drv;

	set_irq_wake(drv->irq, 0);
	free_irq(drv->irq, drv);
	gpio_free(WLAN_EN);
}

static int adp5587_remove(struct i2c_client *client)
{
	struct adp5587_data *client_data = i2c_get_clientdata(client);
    set_irq_wake(client->irq, 0);
	free_irq(client->irq, client_data);
	input_unregister_device(client_data->input_dev);
	kfree(client_data);
	return 0;
}

void bcmsdh_unregister_oob_intr(void)
{
	SDLX_MSG(("%s: Enter\n", __func__));

	set_irq_wake(sdhcinfo->oob_irq, 0);
	disable_irq(sdhcinfo->oob_irq);	/* just in case.. */
	free_irq(sdhcinfo->oob_irq, NULL);
	sdhcinfo->oob_irq_registered = false;
}

int __init x3proto_gpio_setup(void)
{
	int ilsel;
	int ret, i;

	ilsel = ilsel_enable(ILSEL_KEY);
	if (unlikely(ilsel < 0))
		return ilsel;

	ret = gpiochip_add(&x3proto_gpio_chip);
	if (unlikely(ret))
		goto err_gpio;

	for (i = 0; i < NR_BASEBOARD_GPIOS; i++) {
		unsigned long flags;
		int irq = create_irq();

		if (unlikely(irq < 0)) {
			ret = -EINVAL;
			goto err_irq;
		}

		spin_lock_irqsave(&x3proto_gpio_lock, flags);
		x3proto_gpio_irq_map[i] = irq;
		set_irq_chip_and_handler_name(irq, &dummy_irq_chip,
					handle_simple_irq, "gpio");
		spin_unlock_irqrestore(&x3proto_gpio_lock, flags);
	}

	pr_info("registering '%s' support, handling GPIOs %u -> %u, "
		"bound to IRQ %u\n",
		x3proto_gpio_chip.label, x3proto_gpio_chip.base,
		x3proto_gpio_chip.base + x3proto_gpio_chip.ngpio,
		ilsel);

	set_irq_chained_handler(ilsel, x3proto_gpio_irq_handler);
	set_irq_wake(ilsel, 1);

	return 0;

err_irq:
	for (; i >= 0; --i)
		if (x3proto_gpio_irq_map[i])
			destroy_irq(x3proto_gpio_irq_map[i]);

	ret = gpiochip_remove(&x3proto_gpio_chip);
	if (unlikely(ret))
		pr_err("Failed deregistering GPIO\n");

err_gpio:
	synchronize_irq(ilsel);

	ilsel_disable(ILSEL_KEY);

	return ret;
}

void hPlatform_freeInterrupt( void *tnet_drv )
{
	TWlanDrvIfObj *drv = tnet_drv;

	if (drv->irq == 0)
		return;

	set_irq_wake(drv->irq, 0);
	free_irq(drv->irq, drv);
}

static void insert_headset(void)
{
	unsigned long irq_flags;
	int jpole;
	H2W_DBG("");
#ifdef CONFIG_LGE_AUDIO_HEADSET_PROTECT
	gpio_set_value(hi->gpio_mic_bias_en, 1);
	msleep(100);
#endif 	
	jpole = gpio_get_value(hi->gpio_jpole);

    	if(jpole) // 3pole 
   	{	
   		hi->ignore_btn = 1;
		H2W_DBG("insert_headset_no-mic-headset \n");
		switch_set_state(&hi->sdev, LGE_NO_MIC_HEADSET);
//kiwone, 2009.12.24 , to fix bug
//no mic headset insert->no mic headset eject->4pole headset insert->button key do not work.		
		/* Enable button irq */
		local_irq_save(irq_flags);
		enable_irq(hi->irq_btn);
        	set_irq_wake(hi->irq_btn, 1);
		local_irq_restore(irq_flags);
		hi->debounce_time = ktime_set(0, 20000000);  /* 20 ms */
		hi->unplug_debounce_time = ktime_set(0, 100000000);  // add eklee 
		gpio_set_value(hi->gpio_mic_bias_en, 0);
   	}
	else
	{      //  4pole
		hi->ignore_btn =0;
		H2W_DBG("insert_headset_headset \n");
		switch_set_state(&hi->sdev, LGE_HEADSET);
		
		/* Enable button irq */
		local_irq_save(irq_flags);
		enable_irq(hi->irq_btn);
        	set_irq_wake(hi->irq_btn, 1);
		local_irq_restore(irq_flags);
		
		hi->debounce_time = ktime_set(0, 20000000);  /* 20 ms */
		hi->unplug_debounce_time = ktime_set(0, 100000000);  // add eklee 
	}
}