自学教程：C++ wake_lock_active函数代码示例

static int ss300_dump_reset(struct modem_ctl *mc){	struct io_device *iod = mc->iod;	struct link_device *ld = get_current_link(iod);	unsigned int gpio_cp_reset = mc->gpio_cp_reset;	unsigned long flags;	mif_disable_irq(&mc->irq_cp_active);	mif_info("%s: %s: +++/n", mc->name, FUNC);	print_mc_state(mc);	spin_lock_irqsave(&mc->lock, flags);	iod->modem_state_changed(iod, STATE_CRASH_EXIT);	if (mc->wake_lock && !wake_lock_active(mc->wake_lock)) {		wake_lock(mc->wake_lock);		mif_err("%s->wake_lock locked/n", mc->name);	}	if (ld->ready)		ld->ready(ld);	spin_unlock_irqrestore(&mc->lock, flags);	gpio_set_value(gpio_cp_reset, 0);	print_mc_state(mc);	udelay(200);	if (ld->reset)		ld->reset(ld);	gpio_set_value(gpio_cp_reset, 1);	print_mc_state(mc);	msleep(300);	gpio_set_value(mc->gpio_ap_status, 1);	mif_info("%s: %s: ---/n", mc->name, FUNC);	return 0;}

void mt_usb_disconnect(void){	printk("[MUSB] USB is ready for disconnect/n");	if (!mtk_musb || !mtk_musb->is_ready || mtk_musb->is_host || !mtk_musb->power)		return;	musb_stop(mtk_musb);	if (wake_lock_active(&mtk_musb->usb_lock))		wake_unlock(&mtk_musb->usb_lock);	if (cable_mode != CABLE_MODE_NORMAL) {		musb_sync_with_bat(mtk_musb,USB_SUSPEND);		mtk_musb->power = false;		return;	}	printk("[MUSB] USB disconnect/n");}

static bool bln_start_blinking_ex(bool start, unsigned int timeout_ms){	DEBUG_LOG("start: %d, bln_enabled: %d, bln_on: %d", start, bln_enabled, bln_on);	if (start) {		ktime_t delay;		if (!bln_enabled || !bln_on) return false;		bln_blink_on = true;		delay = ktime_add(alarm_get_elapsed_realtime(), ktime_set(timeout_ms/1000, 0));		alarm_start_range(&bln_blink_alarm, delay, delay);		return true;	} else {		bln_blink_on = false;		alarm_try_to_cancel(&bln_blink_alarm);		cancel_delayed_work(&bln_blink_work);		if (wake_lock_active(&bln_blink_wakelock)) wake_unlock(&bln_blink_wakelock);		return false;	}}

static int cmc221_dump_reset(struct modem_ctl *mc){	mif_err("%s/n", mc->name);	if (!wake_lock_active(&mc->mc_wake_lock))		wake_lock(&mc->mc_wake_lock);	set_sromc_access(true);	gpio_set_value(mc->gpio_host_active, 0);	gpio_set_value(mc->gpio_cp_reset, 0);	udelay(200);	gpio_set_value(mc->gpio_cp_reset, 1);	msleep(300);	return 0;}

static void hw_timer_expire(void* data){        unsigned int host_wake;	unsigned long flags;	struct bcmbt_lpm_entry_struct *priv =			(struct bcmbt_lpm_entry_struct *)data;	spin_lock_irqsave(&priv->plpm->bcmbt_lpm_lock, flags);	host_wake = gpio_get_value(priv->pdata->host_wake_gpio);	if(host_wake==BCMBT_LPM_HOST_WAKE_DEASSERT) {		pi_mgr_qos_request_update(&priv->plpm->host_wake_qos_node,					PI_MGR_QOS_DEFAULT_VALUE);		if (wake_lock_active(&priv->plpm->host_wake_lock))		  wake_unlock(&priv->plpm->host_wake_lock);	}	/* else do nothing if host_wake == BCMBT_LPM_HOST_WAKE_ASSERT */	priv->plpm->hw_timer_st = IDLE;	spin_unlock_irqrestore(&priv->plpm->bcmbt_lpm_lock, flags);}

static int bq24192_step_down_detect_disable(struct bq24192_chip *chip){	int ret;	chip->adc_param.state_request = ADC_TM_HIGH_LOW_THR_DISABLE;	chip->adc_param.threshold_notification = bq24192_vbat_notification;	chip->adc_param.channel = VBAT_SNS;	ret = qpnp_adc_tm_channel_measure(&chip->adc_param);	if (ret)		pr_err("request ADC error %d/n", ret);	cancel_delayed_work_sync(&chip->vbat_work);	if (wake_lock_active(&chip->chg_wake_lock)) {		pr_debug("releasing wakelock/n");		wake_unlock(&chip->chg_wake_lock);	}	return ret;}

static int ss222_dump_reset(struct modem_ctl *mc){	unsigned int gpio_cp_reset = mc->gpio_cp_reset;	mif_err("+++/n");	if (!wake_lock_active(&mc->mc_wake_lock))		wake_lock(&mc->mc_wake_lock);	gpio_set_value(gpio_cp_reset, 0);	udelay(200);	gpio_set_value(gpio_cp_reset, 1);#if 0	c2c_reload();#endif	msleep(300);	mif_err("---/n");	return 0;}

static int ss222_on(struct modem_ctl *mc){	struct link_device *ld = get_current_link(mc->iod);	int cp_on = gpio_get_value(mc->gpio_cp_on);	int cp_off = gpio_get_value(mc->gpio_cp_off);	int cp_reset  = gpio_get_value(mc->gpio_cp_reset);	int cp_active = gpio_get_value(mc->gpio_phone_active);	int cp_status = gpio_get_value(mc->gpio_cp_status);	mif_err("+++/n");	mif_err("cp_on:%d cp_reset:%d ps_hold:%d cp_active:%d cp_status:%d/n",		cp_on, cp_reset, cp_off, cp_active, cp_status);	gpio_set_value(mc->gpio_pda_active, 1);	if (!wake_lock_active(&mc->mc_wake_lock))		wake_lock(&mc->mc_wake_lock);	mc->phone_state = STATE_OFFLINE;	ld->mode = LINK_MODE_OFFLINE;	/* Make PS_HOLD_OFF floating (Hi-Z) for CP ON */	make_gpio_floating(mc->gpio_cp_off, true);	gpio_set_value(mc->gpio_cp_on, 0);	msleep(100);	gpio_set_value(mc->gpio_cp_reset, 0);	msleep(500);	gpio_set_value(mc->gpio_cp_on, 1);	msleep(100);	gpio_set_value(mc->gpio_cp_reset, 1);#if 0	c2c_reload();#endif	msleep(300);	mif_err("---/n");	return 0;}

int twl4030_cable_type_detection(void){	int dtct = 0;	enum usb_xceiv_events stat = USB_EVENT_NONE;	int status;	if(g_twl_usb == NULL)		return stat;	/*	 * Why sleep here instead of waiting for ACCISR1 interrupt?	 *	 * Upon cable plugging the VBUS and GND signals are the first to	 * contact the connector pins, leaving D+/D- floating for a while so	 * that the charger D+/D- short cannot be detected. This leaves us	 * with the only option to wait a while after VBUS RISE IRQ, praying	 * that cable will be fully inserted by then.	 */	status = twl4030_readb(g_twl_usb, TWL4030_MODULE_PM_MASTER,			STS_HW_CONDITIONS);	if (status < 0)		dev_err(g_twl_usb->dev, "USB link status err %d/n", status);	else if (status & (BIT(7) | BIT(2))) {		if (status & BIT(2))			stat = USB_EVENT_ID;		else {			/* Read charger detection status */			dtct = twl4030_readb(g_twl_usb, TWL4030_MODULE_MAIN_CHARGE,							TPS65921_USB_DTCT_CTRL);			if ((dtct & TPS65921_USB_DET_STS_MASK) != TPS65921_USB_DET_STS_500MA)				stat = USB_EVENT_VBUS;			else				stat = USB_EVENT_CHARGER;			printk("[twl4030-usb]USB_DTCT_CTRL=0x%02x, status=0x%02x/n", dtct, status);		}	} else		stat = USB_EVENT_NONE;	if(!wake_lock_active(&usb_lock))		wake_lock(&usb_lock);	return stat;}

static int coffee_open (struct inode *inode, struct file *file){	struct coffee_platform_data *pdata;	int ret=0;#if 0	struct miscdevice *misc;	misc = file->private_data;	if (misc)		pdata = dev_get_drvdata(misc->this_device);#endif	pdata = container_of(file->private_data,						struct coffee_platform_data, miscdev);	if (!pdata) {		pr_err("%s cannot get pdata./n", __func__);		return -ENXIO;	}	pr_info("%s speed=%lu/n", __func__, pdata->speed);#ifdef FEATURE_ESE_WAKELOCK	if (wake_lock_active(&pdata->ese_lock)) {		pr_err("%s Already opened/n", __func__);	}	else		wake_lock(&pdata->ese_lock);#endif	ret = coffee_regulator_onoff(pdata, POWER_ON);	if (ret < 0)		pr_info("%s good to turn on regulator/n", __func__);#ifdef CONFIG_ESE_SECURE	ret = coffee_clk_prepare(pdata);	if (ret < 0)		pr_info("%s good to prepare clk./n", __func__);#endif	pr_info("%s... [%d]/n", __func__, ret);	return ret;}

static int p61_disable_clk(struct p61_dev *p61_device){    int ret_val = 0;    struct spi_device *spidev = NULL;    struct s3c64xx_spi_driver_data *sdd = NULL;    if (!p61_device->enabled_clk) {        pr_err("%s - clock was not enabled!/n", __func__);        return ret_val;    }    spin_lock_irq(&p61_device->ese_spi_lock);    spidev = spi_dev_get(p61_device->spi);    spin_unlock_irq(&p61_device->ese_spi_lock);    if (spidev == NULL) {        pr_err("%s - Failed to get spi dev!/n", __func__);        return -1;    }    sdd = spi_master_get_devdata(spidev->master);    if (!sdd) {        pr_err("%s - Failed to get spi dev./n", __func__);        return -1;    }    p61_device->enabled_clk = false;    pm_runtime_put(&sdd->pdev->dev); /* Disable clock */    spi_dev_put(spidev);    //CS disable    gpio_set_value(p61_device->cspin, 1);    if (wake_lock_active(&p61_device->ese_lock)) {        pr_info("%s: [NFC-ESE] wake unlock./n", __func__);        wake_unlock(&p61_device->ese_lock);    }    return ret_val;}

static void wacom_power_on(struct wacom_i2c *wac_i2c){	bool en = true;	printk(KERN_DEBUG"epen: %s/n", __func__);#ifdef BATTERY_SAVING_MODE	if (wac_i2c->battery_saving_mode		&& wac_i2c->pen_insert)		en = false;#endif	if (wake_lock_active(&wac_i2c->wakelock)) {		en = false;		printk(KERN_DEBUG"epen:wake_lock active/n");	}	if (en) {		wac_i2c->wac_pdata->resume_platform_hw();		cancel_delayed_work_sync(&wac_i2c->resume_work);		schedule_delayed_work(&wac_i2c->resume_work, HZ / 5);	}}

int bcmbt_lpm_deassert_bt_wake(void){	if (priv_g == NULL)		pr_err("%s BLUETOOTH: structure corrupted" /			" or not init - cannot assert bt_wake/n", __func__);	if (unlikely((priv_g->pdata->bt_wake_gpio == -1)))		return -EFAULT;	gpio_set_value(priv_g->pdata->bt_wake_gpio, BCMBT_LPM_BT_WAKE_DEASSERT);	pr_debug("BLUETOOTH:DEASSERT BT_WAKE/n");	pi_mgr_qos_request_update(&priv_g->plpm->bt_wake_qos_node,				PI_MGR_QOS_DEFAULT_VALUE);#ifdef CONFIG_HAS_WAKELOCK	if (priv_g != NULL) {		if (wake_lock_active(&priv_g->plpm->bt_wake_lock))				wake_unlock(&priv_g->plpm->bt_wake_lock);	}#endif	pr_debug("%s BLUETOOTH:Exiting/n", __func__);	return 0;}

/* Rx timer callback function */static void schedule_timer(unsigned long arg){	struct hci_dev *hdev = (struct hci_dev *) arg;	struct hci_smd_data *hsmd = &hs;	BT_DBG("%s Schedule Rx timer", hdev->name);	if (is_rx_q_empty(arg) && wake_lock_active(&hs.wake_lock_rx)) {		BT_DBG("%s RX queue empty", hdev->name);		/*		 * Since the queue is empty, its ideal		 * to release the wake lock on Rx		 */		wake_unlock(&hs.wake_lock_rx);	} else{		BT_DBG("%s RX queue not empty", hdev->name);		/*		 * Restart the timer to monitor whether the Rx queue is		 * empty for releasing the Rx wake lock		 */		mod_timer(&hsmd->rx_q_timer,			jiffies + msecs_to_jiffies(RX_Q_MONITOR));	}}

int bcmbt_lpm_assert_bt_wake(void){	int rc;	if (priv_g == NULL)		pr_err("%s BLUETOOTH: structure corrupted or not init" /				" - cannot assert bt_wake/n", __func__);	if (unlikely((priv_g->pdata->bt_wake_gpio == -1)))		return -EFAULT;#ifdef CONFIG_HAS_WAKELOCK	if (priv_g != NULL) {		if (!wake_lock_active(&priv_g->plpm->bt_wake_lock))			wake_lock(&priv_g->plpm->bt_wake_lock);	}#endif	rc = pi_mgr_qos_request_update(&priv_g->plpm->bt_wake_qos_node, 0);	gpio_set_value(priv_g->pdata->bt_wake_gpio, BCMBT_LPM_BT_WAKE_ASSERT);	pr_debug("%s BLUETOOTH:ASSERT BT_WAKE/n", __func__);	return 0;}

static int p61_set_clk(struct p61_dev *p61_device){    int ret_val = 0;    struct spi_device *spidev = NULL;    struct s3c64xx_spi_driver_data *sdd = NULL;    spin_lock_irq(&p61_device->ese_spi_lock);    spidev = spi_dev_get(p61_device->spi);    spin_unlock_irq(&p61_device->ese_spi_lock);    if (spidev == NULL) {        pr_err("%s - Failed to get spi dev/n", __func__);        return -1;    }    spidev->max_speed_hz = P61_SPI_CLOCK;    sdd = spi_master_get_devdata(spidev->master);    if (!sdd) {        pr_err("%s - Failed to get spi dev./n", __func__);        return -1;    }    pm_runtime_get_sync(&sdd->pdev->dev); /* Enable clk */    /* set spi clock rate */    clk_set_rate(sdd->src_clk, spidev->max_speed_hz * 2);    p61_device->enabled_clk = true;    spi_dev_put(spidev);    //CS enable    gpio_set_value(p61_device->cspin, 0);    usleep_range(50, 70);    if (!wake_lock_active(&p61_device->ese_lock)) {        pr_info("%s: [NFC-ESE] wake lock./n", __func__);        wake_lock(&p61_device->ese_lock);    }    return ret_val;}

void mem_handle_cp_crash(struct mem_link_device *mld, enum modem_state state){	struct link_device *ld = &mld->link_dev;	struct modem_ctl *mc = ld->mc;	int i;	/* Disable normal IPC */	set_magic(mld, MEM_CRASH_MAGIC);	set_access(mld, 0);	if (!wake_lock_active(&mld->dump_wlock))		wake_lock(&mld->dump_wlock);	stop_net_ifaces(ld);	/* Purge the skb_txq in every IPC device (IPC_FMT, IPC_RAW, etc.) */	for (i = 0; i < MAX_SIPC5_DEV; i++)		skb_queue_purge(mld->dev[i]->skb_txq);	if (cp_online(mc))		set_modem_state(mld, state);	mld->forced_cp_crash = false;}

static int ss300_dump_reset(struct modem_ctl *mc){	struct link_device *ld = get_current_link(mc->iod);	unsigned int gpio_cp_reset = mc->gpio_cp_reset;	unsigned long flags;	spin_lock_irqsave(&ld->lock, flags);	mif_err("+++/n");	if (mc->wake_lock && !wake_lock_active(mc->wake_lock)) {		wake_lock(mc->wake_lock);		mif_err("%s->wake_lock locked/n", mc->name);	}	if (ld->ready)		ld->ready(ld);	spin_unlock_irqrestore(&ld->lock, flags);	mif_disable_irq(&mc->irq_cp_active);	gpio_set_value(gpio_cp_reset, 0);	udelay(200);	if (ld->reset)		ld->reset(ld);	gpio_set_value(gpio_cp_reset, 1);	msleep(300);	gpio_set_value(mc->gpio_ap_status, 1);	mif_err("---/n");	return 0;}

static int p3_disable_clk(struct p3_dev *p3_device){	int ret_val = 0;	//unsigned short clock = 0;	struct spi_device *spidev = NULL;	struct s3c64xx_spi_driver_data *sdd = NULL;	if (!p3_device->enabled_clk) {		P3_ERR_MSG("%s - clock was not enabled!/n", __func__);		return ret_val;	}	spin_lock_irq(&p3_device->ese_spi_lock);	spidev = spi_dev_get(p3_device->spi);	spin_unlock_irq(&p3_device->ese_spi_lock);	if (spidev == NULL) {		P3_ERR_MSG("%s - Failed to get spi dev!/n", __func__);		return -1;	}	sdd = spi_master_get_devdata(spidev->master);	if (!sdd){		P3_ERR_MSG("%s - Failed to get spi dev./n", __func__);		return -EFAULT;	}	p3_device->enabled_clk = false;	pm_runtime_put_sync(&sdd->pdev->dev); /* Disable clock */	spi_dev_put(spidev);#ifdef FEATURE_ESE_WAKELOCK	if (wake_lock_active(&p3_device->ese_lock))		wake_unlock(&p3_device->ese_lock);#endif	return ret_val;}

static irqreturn_t bcmbt_lpm_host_wake_isr(int irq, void *dev){	unsigned int host_wake;	unsigned long flags;	struct bcmbt_lpm_entry_struct *priv =				(struct bcmbt_lpm_entry_struct *)dev;	if (priv == NULL) {		pr_err("%s BLUETOOTH: Error data pointer is null/n", __func__);		return IRQ_HANDLED;	}	spin_lock_irqsave(&priv->plpm->bcmbt_lpm_lock, flags);	host_wake = gpio_get_value(priv->pdata->host_wake_gpio);	if (BCMBT_LPM_HOST_WAKE_ASSERT == host_wake) {		if (priv->plpm->hw_timer_st == IDLE) {		/* wake up peripheral clock */		if (!wake_lock_active(&priv->plpm->host_wake_lock))		   wake_lock(&priv->plpm->host_wake_lock);			pi_mgr_qos_request_update(			      &priv->plpm->host_wake_qos_node, 0);		}		/* else do nothing if state == ACTIVE */		spin_unlock_irqrestore(&priv->plpm->bcmbt_lpm_lock, flags);	} else {		if (priv->plpm->hw_timer_st == IDLE) {			mod_timer(&priv->plpm->hw_timer,				jiffies + msecs_to_jiffies(TIMER_PERIOD));			priv->plpm->hw_timer_st = ACTIVE;		}		/* else do nothing if state == ACTIVE */		spin_unlock_irqrestore(&priv->plpm->bcmbt_lpm_lock, flags);	}	pr_debug("%s BLUETOOTH:Exiting./n", __func__);	return IRQ_HANDLED;}

//.........这里部分代码省略.........        frame_desc = &(msdu.frame_desc);        /* Before forwarding the packet across to the HOST interface security    */        /* checks needs to performed on the states of the transmitting station   */        if(sta_check_sec_tx_sta_state(se, frame_desc,                                      (CIPHER_T)(wlan_rx->ct)) != BTRUE)        {			TROUT_FUNC_EXIT;            return;        }        /* Check for SNAP header at the beginning of the data and set the    */        /* data pointer and length accordingly.                              */        if(BTRUE == is_snap_header_present(frame_desc))        {            /* If the message is a unicast packet, search for the STA entry */            if(is_group(msdu.da) == BFALSE)            {                /* If the received packet is a security handshake packet     */                /* process it in the security layer                          */                if(is_sec_handshake_pkt_sta(se, frame_desc->buffer_addr,                                            frame_desc->data_offset,                                            frame_desc->data_len,                                            (CIPHER_T)(wlan_rx->ct)) == BTRUE)                {                    continue;                }#ifdef WIFI_SLEEP_POLICY                  if(check_11i_frame(frame_desc->buffer_addr + frame_desc->data_offset) ||                     check_wapi_frame(frame_desc->buffer_addr + frame_desc->data_offset))                  {  #if 0                    if(wake_lock_active(&handshake_frame_lock))                      {                           pr_info("%s-%d: release wake_lock %s/n", __func__, __LINE__, handshake_frame_lock.name);                           wake_unlock(&handshake_frame_lock);                      }                                       wake_lock_timeout(&handshake_frame_lock,msecs_to_jiffies(2000)); /*Keep 2s awake when HK, by caisf 20131004*/                      pr_info("%s-%d: acquire wake_lock %s/n", __func__, __LINE__, handshake_frame_lock.name);  #else                    if(wake_lock_active(&handshake_frame_lock))                    {					    stop_hs_wake_timer();		                /*Keep 2s awake when HK, by caisf 20131004*/						start_hs_wake_timer();						pr_info("%s-%d: refresh timer wake_lock %s/n", __func__,					                            __LINE__, handshake_frame_lock.name);                    }                    else                    {						wake_lock(&handshake_frame_lock);                        /*Keep 2s awake when HK, by caisf 20131004*/                        start_hs_wake_timer();						pr_info("%s-%d: acquire wake_lock %s/n", __func__,                            __LINE__, handshake_frame_lock.name);                    }#endif                } #endif              }            /* Adjust the frame to account for the SNAP header */            adjust_for_snap_header(frame_desc);        }

static void bq24192_irq_worker(struct work_struct *work){	struct bq24192_chip *chip =		container_of(work, struct bq24192_chip, irq_work);	union power_supply_propval ret = {0,};	bool ext_pwr;	bool wlc_pwr = 0;	bool chg_done = false;	u8 temp;	int rc;	unsigned long flags;	wake_lock(&chip->irq_wake_lock);	msleep(100 * chip->irq_scheduled_time_status);	rc = bq24192_read_reg(chip->client, SYSTEM_STATUS_REG, &temp);	/* Open up for next possible interrupt handler beyond read reg	 * asap, lest we miss an interrupt	 */	spin_lock_irqsave(&chip->irq_work_lock, flags);	chip->irq_scheduled_time_status = 0;	spin_unlock_irqrestore(&chip->irq_work_lock, flags);	if (rc) {		pr_err("failed to read SYSTEM_STATUS_REG rc=%d/n", rc);		goto irq_worker_exit;	}	ext_pwr = !!(temp & PG_STAT_MASK);	chg_done = (temp & CHARGING_MASK) == 0x30 ? true : false;	if (chg_done) {		if (chip->batt_health != POWER_SUPPLY_HEALTH_OVERHEAT &&				bq24192_get_soc_from_batt_psy(chip) < 100) {			wake_lock(&chip->extra_chg_lock);			bq24192_enable_chg_term(chip, false);			bq24192_trigger_recharge(chip);			schedule_delayed_work(&chip->extra_chg_work,					msecs_to_jiffies(EXTRA_CHG_TIME_MS));		} else {			if (chip->batt_health != POWER_SUPPLY_HEALTH_OVERHEAT)				bq24192_set_rechg_voltage(chip, VRECHG_300MV);			power_supply_changed(&chip->ac_psy);			pr_info("charge done!!/n");		}	}	if (chip->wlc_psy) {		chip->wlc_psy->get_property(chip->wlc_psy,				POWER_SUPPLY_PROP_PRESENT, &ret);		wlc_pwr = ret.intval;	}	if ((chip->ext_pwr ^ ext_pwr) || (chip->wlc_pwr ^ wlc_pwr)) {		pr_info("power source changed! ext_pwr = %d wlc_pwr = %d/n",				ext_pwr, wlc_pwr);		if (wake_lock_active(&chip->icl_wake_lock))			wake_unlock(&chip->icl_wake_lock);		if (wake_lock_active(&chip->extra_chg_lock))			wake_unlock(&chip->extra_chg_lock);		cancel_delayed_work_sync(&chip->input_limit_work);		cancel_delayed_work_sync(&chip->therm_work);		cancel_delayed_work_sync(&chip->extra_chg_work);		bq24192_enable_chg_term(chip, true);		bq24192_step_down_detect_disable(chip);		chip->saved_ibat_ma = 0;		chip->set_chg_current_ma = chip->chg_current_ma;		chip->max_input_i_ma = INPUT_CURRENT_LIMIT_MAX_MA;		if (chip->wlc_psy) {			if (wlc_pwr && ext_pwr) {				chip->wlc_pwr = true;				power_supply_set_online(chip->wlc_psy, true);			} else if (chip->wlc_pwr && !(ext_pwr && wlc_pwr)) {				chip->wlc_pwr = false;				power_supply_set_online(chip->wlc_psy, false);			}		}		if (!wlc_pwr) {			pr_info("notify vbus to usb otg ext_pwr = %d/n", ext_pwr);			power_supply_set_present(chip->usb_psy, ext_pwr);		}		chip->ext_pwr = ext_pwr;	}irq_worker_exit:	wake_lock_timeout(&chip->irq_wake_lock, 2*HZ);}