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

static int s5p_idpram_prepare_suspend(struct dpram_link_device *dpld){	struct link_device *ld = &dpld->ld;	struct idpram_pm_data *pm_data = &dpld->pm_data;	struct modem_ctl *mc = dpld->ld.mc;	struct completion *cmpl;	unsigned long timeout;	unsigned long rest;	int cnt = 0;	u16 cmd = INT_CMD(INT_CMD_IDPRAM_SUSPEND_REQ);	mif_info("+++/n");	pm_data->pm_state = IDPRAM_PM_SUSPEND_PREPARE;	pm_data->last_msg = 0;	s5p_idpram_set_pm_lock(dpld, 1);	/*	* Because, if dpram was powered down, cp dpram random intr was	* ocurred. so, fixed by muxing cp dpram intr pin to GPIO output	* high,..	*/	gpio_set_value(dpld->gpio_int2cp, 1);	s3c_gpio_cfgpin(dpld->gpio_int2cp, S3C_GPIO_OUTPUT);	/* prevent PDA_ACTIVE status is low */	gpio_set_value(mc->gpio_pda_active, 1);	cmpl = &pm_data->down_cmpl;	timeout = IDPRAM_SUSPEND_REQ_TIMEOUT;	cnt = 0;	do {		init_completion(cmpl);		mif_info("send IDPRAM_SUSPEND_REQ (0x%X)/n", cmd);		dpld->send_intr(dpld, cmd);		rest = wait_for_completion_timeout(cmpl, timeout);		if (rest == 0) {			cnt++;			mif_err("timeout!!! (count = %d)/n", cnt);			if (cnt >= 3) {				mif_err("ERR! no response from CP/n");				break;			}		}	} while (rest == 0);	switch (pm_data->last_msg) {	case INT_CMD(INT_CMD_IDPRAM_SUSPEND_ACK):		mif_info("recv IDPRAM_SUSPEND_ACK (0x%X)/n", pm_data->last_msg);		pm_data->pm_state = IDPRAM_PM_DPRAM_POWER_DOWN;		break;	default:		mif_err("ERR! %s down or not ready!!! (intr 0x%04X)/n",			ld->name, dpld->recv_intr(dpld));		timeout = msecs_to_jiffies(500);		wake_lock_timeout(&pm_data->hold_wlock, timeout);		s5p_idpram_set_pm_lock(dpld, 0);		break;	}	mif_info("---/n");	return 0;}

int ccci_df_to_ccci_callback(unsigned int rxq_no){    int ret, hc_ret;    bool is_xcmd = false;    struct sk_buff * skb = NULL;    CCCI_BUFF_T *ccci_h  = NULL;    XBOOT_CMD *p_xcmd = NULL;    KAL_UINT32   port_id = CCCI_PORT_CTRL;    static KAL_UINT32 rx_err_cnt[CCCI_PORT_NUM_MAX] = {0};#ifdef __EEMCS_EXPT_SUPPORT__    EEMCS_EXCEPTION_STATE mode = EEMCS_EX_INVALID;#endif#if defined (DBG_FEATURE_ADD_CCCI_SEQNO)    KAL_INT16 channel, seq_num, assert_bit;#endif    DEBUG_LOG_FUNCTION_ENTRY;    /* Step 1. read skb from swq */    skb = hif_dl_read_swq(rxq_no);    if(skb == NULL) {    	DBGLOG(CCCI, DBG, "ccci_df_to_ccci_callback read NULL skb on %d", rxq_no);    	if(is_exception_mode(&mode))    		return KAL_FAIL;    	else    		KAL_ASSERT(NULL != skb);    }    /* Step 2. call handle complete */    hc_ret = hif_dl_pkt_handle_complete(rxq_no);    KAL_ASSERT(0 == hc_ret);    wake_lock_timeout(&eemcs_wake_lock, HZ/2); // Using 0.5s wake lock	/* Step 3. buffer type */    if (rxq_no == RXQ_Q0) {        //is_xcmd = is_xboot_command(skb);        p_xcmd = (XBOOT_CMD *)skb->data;	    if (p_xcmd->magic == (KAL_UINT32)MAGIC_MD_CMD) {			if (check_device_state() >= EEMCS_MOLY_HS_P1) {        		DBGLOG(CCCI, ERR, "can't recv xBoot cmd when EEMCS state=%d", check_device_state());    		} else {    			is_xcmd = true;	    	}	    }    }    if (is_xcmd) {        /* Step 4. callback to xBoot */    	CDEV_LOG(port_id, CCCI, INF, "XBOOT_CMD: 0x%08X, 0x%08X, 0x%08X, 0x%08X",/        	p_xcmd->magic, p_xcmd->msg_id, p_xcmd->status, p_xcmd->reserved[0]);    	ret = ccci_port_info[port_id].ch.rx_cb(skb, 0);    } else {    	ccci_h = (CCCI_BUFF_T *)skb->data;    	port_id = ccci_ch_to_port(ccci_h->channel);		    	CDEV_LOG(port_id, CCCI, INF, "CCCI_H: 0x%08X, 0x%08X, 0x%08X, 0x%08X",/        	ccci_h->data[0],ccci_h->data[1],ccci_h->channel, ccci_h->reserved);    	/*check rx sequence number for expect*/    	#if defined (DBG_FEATURE_ADD_CCCI_SEQNO)    	channel = ccci_h->channel;    	seq_num = ccci_h->seq_num;    	assert_bit = ccci_h->assert_bit;	    	DBGLOG(CCCI, DBG, "Port%d CCCI_H: data[0]=0x%08X, data[1]=0x%08X, ch=0x%02X, seqno=0x%02X, assert=%d, resv=0x%08X(0x%08X, 0x%08X, 0x%08X)",/        	port_id, ccci_h->data[0],ccci_h->data[1],ccci_h->channel, ccci_h->seq_num, /        	ccci_h->assert_bit, ccci_h->reserved, channel, seq_num, assert_bit);		    	if(((seq_num - ccci_seqno_tbl[channel].seqno[RX]) & 0x7FFF) != 1 && assert_bit) {            DBGLOG(CCCI, ERR, "Port%d seqno out-of-order(0x%02X->0x%02X): data[0]=0x%08X, data[1]=0x%08X, ch=0x%02X, seqno=0x%02X, assert=%d, resv=0x%08X", /											port_id, seq_num, ccci_seqno_tbl[channel].seqno[RX], ccci_h->data[0], ccci_h->data[1], /				ccci_h->channel, ccci_h->seq_num, ccci_h->assert_bit, ccci_h->reserved);						            hif_force_md_assert_swint();    	}					    	ccci_seqno_tbl[channel].seqno[RX] = seq_num;    	#endif		        /* Step 4. callback to CCCI device */               if(NULL != ccci_port_info[port_id].ch.rx_cb){            #ifdef __EEMCS_EXPT_SUPPORT__            if(is_exception_mode(&mode))            {                if(!is_valid_exception_port(port_id, true))                {                    ret = KAL_FAIL;                    dev_kfree_skb(skb);                    eemcs_ccci_release_rx_skb(port_id, 1, skb);                    eemcs_expt_ccci_rx_drop(port_id);                    DBGLOG(CCCI, ERR, "PKT DROP when PORT%d(rxq=%d) at md exception", /						port_id, rxq_no);                    goto _end;                } else {                    ret = ccci_port_info[port_id].ch.rx_cb(skb, 0);                }            }            else            #endif                  {                ret = ccci_port_info[port_id].ch.rx_cb(skb, 0);            }            rx_err_cnt[port_id] = 0;        } else { //.........这里部分代码省略.........

static int ccmni_rx_callback(int md_id, int rx_ch, struct sk_buff *skb, void *priv_data){	ccmni_ctl_block_t *ctlb = ccmni_ctl_blk[md_id];//	struct ccci_header *ccci_h = (struct ccci_header*)skb->data;	ccmni_instance_t *ccmni = NULL;	struct net_device *dev = NULL;	int pkt_type, skb_len, ccmni_idx;	if (unlikely(ctlb == NULL || ctlb->ccci_ops == NULL)) {		CCMNI_ERR_MSG(md_id, "invalid CCMNI ctrl/ops struct for RX_CH(%d)/n", rx_ch);		dev_kfree_skb(skb);		return -1;	}	ccmni_idx = get_ccmni_idx_from_ch(md_id, rx_ch);	if (unlikely(ccmni_idx < 0)) {		CCMNI_ERR_MSG(md_id, "CCMNI rx(%d) skb ch error/n", rx_ch);		dev_kfree_skb(skb);		return -1;	}	ccmni = ctlb->ccmni_inst[ccmni_idx];	dev = ccmni->dev;	//	skb_pull(skb, sizeof(struct ccci_header));	pkt_type = skb->data[0] & 0xF0;	ccmni_make_etherframe(skb->data-ETH_HLEN, dev->dev_addr, pkt_type);    skb_set_mac_header(skb, -ETH_HLEN);	skb->dev = dev;	if(pkt_type == 0x60) {            		skb->protocol  = htons(ETH_P_IPV6);	} else {		skb->protocol  = htons(ETH_P_IP);	}	skb->ip_summed = CHECKSUM_NONE;	skb_len = skb->len;		if (unlikely(ccmni_debug_level&CCMNI_DBG_LEVEL_RX)) {		CCMNI_INF_MSG(md_id, "[RX]CCMNI%d(rx_ch=%d) recv data_len=%d/n", ccmni_idx, rx_ch, skb->len);	}	if (unlikely(ccmni_debug_level&CCMNI_DBG_LEVEL_RX_SKB)) {		ccmni_dbg_skb_header(ccmni->md_id, false, skb);	}		if(likely(ctlb->ccci_ops->md_ability & MODEM_CAP_NAPI)) {		netif_receive_skb(skb);	} else {#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0))		if(!in_interrupt()) {			netif_rx_ni(skb);		} else {			netif_rx(skb);		}#else		netif_rx(skb);#endif	}	dev->stats.rx_packets++;	dev->stats.rx_bytes += skb_len;	wake_lock_timeout(&ctlb->ccmni_wakelock, HZ);		return 0;}

void android_ar6k_check_wow_status(AR_SOFTC_T *ar, struct sk_buff *skb, A_BOOL isEvent){    AR_SOFTC_DEV_T *arPriv;    A_UINT8  i;     A_BOOL needWake = FALSE;    for(i = 0; i < num_device; i++)     {        arPriv = ar->arDev[i];        if (#ifdef CONFIG_HAS_EARLYSUSPEND            screen_is_off && #endif                skb && arPriv->arConnected) {            if (isEvent) {                if (A_NETBUF_LEN(skb) >= sizeof(A_UINT16)) {                    A_UINT16 cmd = *(const A_UINT16 *)A_NETBUF_DATA(skb);                    switch (cmd) {                    case WMI_CONNECT_EVENTID:                    case WMI_DISCONNECT_EVENTID:                         needWake = TRUE;                         break;                    default:                        /* dont wake lock the system for other event */                         break;                    }                }            } else if (A_NETBUF_LEN(skb) >= sizeof(ATH_MAC_HDR)) {                ATH_MAC_HDR *datap = (ATH_MAC_HDR *)A_NETBUF_DATA(skb);                if (!IEEE80211_IS_MULTICAST(datap->dstMac)) {                    switch (A_BE2CPU16(datap->typeOrLen)) {                    case 0x0800: /* IP */                    case 0x888e: /* EAPOL */                    case 0x88c7: /* RSN_PREAUTH */                    case 0x88b4: /* WAPI */                         needWake = TRUE;                         break;                    case 0x0806: /* ARP is not important to hold wake lock */                        needWake = (arPriv->arNetworkType==AP_NETWORK);                        break;                    default:                         break;                    }                } else if ( !IEEE80211_IS_BROADCAST(datap->dstMac) ) {                    if (A_NETBUF_LEN(skb)>=14+20 ) {					    /* check if it is mDNS packets */                        A_UINT8 *dstIpAddr = (A_UINT8*)(A_NETBUF_DATA(skb)+14+20-4);                                            struct net_device *ndev = arPriv->arNetDev;                        needWake = ((dstIpAddr[3] & 0xf8) == 0xf8) &&                                (arPriv->arNetworkType==AP_NETWORK ||                                 (ndev->flags & IFF_ALLMULTI || ndev->flags & IFF_MULTICAST));                    }                }else if (arPriv->arNetworkType==AP_NETWORK) {                    switch (A_BE2CPU16(datap->typeOrLen)) {                    case 0x0800: /* IP */                        if (A_NETBUF_LEN(skb)>=14+20+2) {                            A_UINT16 dstPort = *(A_UINT16*)(A_NETBUF_DATA(skb)+14+20);                            dstPort = A_BE2CPU16(dstPort);                            needWake = (dstPort == 0x43); /* dhcp request */                        }                        break;                    case 0x0806:                         needWake = TRUE;                    default:                        break;                    }                }             }         }    }    if (needWake) {#ifdef CONFIG_HAS_WAKELOCK        /* keep host wake up if there is any event and packate comming in*/        wake_lock_timeout(&ar6k_wow_wake_lock, 3*HZ);#endif        if (wowledon) {            char buf[32];            int len = sprintf(buf, "on");            android_readwrite_file("/sys/power/state", NULL, buf, len);            len = sprintf(buf, "%d", 127);            android_readwrite_file("/sys/class/leds/lcd-backlight/brightness",                                   NULL, buf,len);        }    }}

extern void pm8058_drvx_led_brightness_set(struct led_classdev *led_cdev,					   enum led_brightness brightness){	struct pm8058_led_data *ldata;	int *pduties;	int id, mode;	int lut_flag;	int milliamps;	int enable = 0;	ldata = container_of(led_cdev, struct pm8058_led_data, ldev);	pwm_disable(ldata->pwm_led);	cancel_delayed_work_sync(&ldata->led_delayed_work);	id = bank_to_id(ldata->bank);	mode = (id == PM_PWM_LED_KPD) ? PM_PWM_CONF_PWM1 :					PM_PWM_CONF_PWM1 + (ldata->bank - 4);	brightness = (brightness > LED_FULL) ? LED_FULL : brightness;	brightness = (brightness < LED_OFF) ? LED_OFF : brightness;	LED_INFO_LOG("%s: bank %d brightness %d +/n", __func__,	       ldata->bank, brightness);	enable = (brightness) ? 1 : 0;	if (strcmp(ldata->ldev.name, "charming-led") == 0)		charming_led_enable(enable);	lut_flag = ldata->lut_flag & ~(PM_PWM_LUT_LOOP | PM_PWM_LUT_REVERSE);	virtual_key_state = enable;	if (flag_hold_virtual_key == 1) {		LED_INFO_LOG("%s, Return control by button_backlight flash /n", __func__);		return;	}	if (brightness) {		milliamps = (ldata->flags & PM8058_LED_DYNAMIC_BRIGHTNESS_EN) ?			    ldata->out_current * brightness / LED_FULL :			    ldata->out_current;		pm8058_pwm_config_led(ldata->pwm_led, id, mode, milliamps);		if (ldata->flags & PM8058_LED_LTU_EN) {			pduties = &duty_array[ldata->start_index];			pm8058_pwm_lut_config(ldata->pwm_led,					      ldata->period_us,					      pduties,					      ldata->duty_time_ms,					      ldata->start_index,					      ldata->duites_size,					      0, 0,					      lut_flag);			pm8058_pwm_lut_enable(ldata->pwm_led, 0);			pm8058_pwm_lut_enable(ldata->pwm_led, 1);		} else {			pwm_config(ldata->pwm_led, 64000, 64000);			pwm_enable(ldata->pwm_led);		}	} else {		if (ldata->flags & PM8058_LED_LTU_EN) {			wake_lock_timeout(&pmic_led_wake_lock,HZ*2);			pduties = &duty_array[ldata->start_index +					  ldata->duites_size];			pm8058_pwm_lut_config(ldata->pwm_led,					      ldata->period_us,					      pduties,					      ldata->duty_time_ms,					      ldata->start_index +					      ldata->duites_size,					      ldata->duites_size,					      0, 0,					      lut_flag);			pm8058_pwm_lut_enable(ldata->pwm_led, 1);			queue_delayed_work(g_led_work_queue,					   &ldata->led_delayed_work,					   msecs_to_jiffies(ldata->duty_time_ms * ldata->duites_size));			LED_INFO_LOG("%s: bank %d fade out brightness %d -/n", __func__,			ldata->bank, brightness);			return;		} else			pwm_disable(ldata->pwm_led);		pm8058_pwm_config_led(ldata->pwm_led, id, mode, 0);	}	LED_INFO_LOG("%s: bank %d brightness %d -/n", __func__, ldata->bank, brightness);}

static irqreturn_t usb_detect_irq_handler(int irq, void *dev_id){	wake_lock_timeout(&usb_wakelock, 10 * HZ);	schedule_delayed_work(&wakeup_work, HZ / 10);	return IRQ_HANDLED;}

/* this function holds xmm_lock */void baseband_xmm_set_power_status(unsigned int status){	struct baseband_power_platform_data *data = xmm_power_drv_data.pdata;	int value = 0;	unsigned long flags;	if (baseband_xmm_get_power_status() == status)		return;	/* avoid prints inside spinlock */	if (status <= BBXMM_PS_L2)		pr_info("%s/n", status == BBXMM_PS_L0 ? "L0" : "L2");	spin_lock_irqsave(&xmm_lock, flags);	switch (status) {	case BBXMM_PS_L0:		baseband_xmm_powerstate = status;		if (!wake_lock_active(&wakelock))			wake_lock_timeout(&wakelock, HZ*2);		/* pull hsic_active high for enumeration */		value = gpio_get_value(data->modem.xmm.ipc_hsic_active);		if (!value) {			pr_debug("L0 gpio set ipc_hsic_active=1 ->/n");			gpio_set_value(data->modem.xmm.ipc_hsic_active, 1);		}		if (modem_power_on) {			modem_power_on = false;			baseband_modem_power_on(data);		}		/* cp acknowledgment for ap L2->L0 wake */		if (!modem_acked_resume)			pr_err("%s: CP didn't ack usb-resume/n", __func__);		value = gpio_get_value(data->modem.xmm.ipc_bb_wake);		if (value) {			/* clear the slave wakeup request */			gpio_set_value(data->modem.xmm.ipc_bb_wake, 0);			pr_debug("gpio bb_wake done low/n");		}		break;	case BBXMM_PS_L2:		modem_acked_resume = false;		if (wakeup_pending) {			spin_unlock_irqrestore(&xmm_lock, flags);			pr_debug("%s: wakeup pending/n", __func__);			xmm_power_l2_resume();			spin_lock_irqsave(&xmm_lock, flags);			break;		 } else {			if (wake_lock_active(&wakelock))				wake_unlock(&wakelock);			modem_sleep_flag = true;		}		baseband_xmm_powerstate = status;		break;	case BBXMM_PS_L2TOL0:		pr_debug("L2TOL0/n");		system_suspending = false;		wakeup_pending = false;		/* do this only from L2 state */		if (baseband_xmm_powerstate == BBXMM_PS_L2) {			baseband_xmm_powerstate = status;			spin_unlock_irqrestore(&xmm_lock, flags);			xmm_power_l2_resume();			spin_lock_irqsave(&xmm_lock, flags);		}		baseband_xmm_powerstate = status;		break;	default:		baseband_xmm_powerstate = status;		break;	}	spin_unlock_irqrestore(&xmm_lock, flags);	pr_debug("BB XMM POWER STATE = %d/n", status);}

static void msm_hsusb_request_host(void *handle, int request){    struct msmusb_hcd *mhcd = handle;    struct usb_hcd *hcd = mhcd_to_hcd(mhcd);    struct msm_usb_host_platform_data *pdata = mhcd->pdata;    struct msm_otg *otg = container_of(mhcd->xceiv, struct msm_otg, phy);#ifdef CONFIG_USB_OTG    struct usb_device *udev = hcd->self.root_hub;#endif    struct device *dev = hcd->self.controller;    switch (request) {#ifdef CONFIG_USB_OTG    case REQUEST_HNP_SUSPEND:        /* disable Root hub auto suspend. As hardware is configured         * for peripheral mode, mark hardware is not available.         */        if (PHY_TYPE(pdata->phy_info) == USB_PHY_INTEGRATED) {            pm_runtime_disable(&udev->dev);            /* Mark root hub as disconnected. This would             * protect suspend/resume via sysfs.             */            udev->state = USB_STATE_NOTATTACHED;            clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);            hcd->state = HC_STATE_HALT;            pm_runtime_put_noidle(dev);            pm_runtime_suspend(dev);        }        break;    case REQUEST_HNP_RESUME:        if (PHY_TYPE(pdata->phy_info) == USB_PHY_INTEGRATED) {            pm_runtime_get_noresume(dev);            pm_runtime_resume(dev);            disable_irq(hcd->irq);            ehci_msm_reset(hcd);            ehci_msm_run(hcd);            set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);            pm_runtime_enable(&udev->dev);            udev->state = USB_STATE_CONFIGURED;            enable_irq(hcd->irq);        }        break;#endif    case REQUEST_RESUME:        usb_hcd_resume_root_hub(hcd);        break;    case REQUEST_START:        if (mhcd->running)            break;        pm_runtime_get_noresume(dev);        pm_runtime_resume(dev);        wake_lock(&mhcd->wlock);        msm_xusb_pm_qos_update(mhcd, 1);        msm_xusb_enable_clks(mhcd);        if (PHY_TYPE(pdata->phy_info) == USB_PHY_INTEGRATED)            if (otg->set_clk)                otg->set_clk(mhcd->xceiv, 1);        if (pdata->vbus_power)            pdata->vbus_power(pdata->phy_info, 1);        if (pdata->config_gpio)            pdata->config_gpio(1);        usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);        mhcd->running = 1;        if (PHY_TYPE(pdata->phy_info) == USB_PHY_INTEGRATED)            if (otg->set_clk)                otg->set_clk(mhcd->xceiv, 0);        break;    case REQUEST_STOP:        if (!mhcd->running)            break;        mhcd->running = 0;        /* come out of lpm before deregistration */        if (PHY_TYPE(pdata->phy_info) == USB_PHY_SERIAL_PMIC) {            usb_lpm_exit(hcd);            if (cancel_work_sync(&(mhcd->lpm_exit_work)))                usb_lpm_exit_w(&mhcd->lpm_exit_work);        }        usb_remove_hcd(hcd);        if (pdata->config_gpio)            pdata->config_gpio(0);        if (pdata->vbus_power)            pdata->vbus_power(pdata->phy_info, 0);        msm_xusb_disable_clks(mhcd);        wake_lock_timeout(&mhcd->wlock, HZ/2);        msm_xusb_pm_qos_update(mhcd, 0);        pm_runtime_put_noidle(dev);        pm_runtime_suspend(dev);        break;    }}

/* Do the work for AP/CP initiated L2->L0 */static void xmm_power_l2_resume(void){	struct baseband_power_platform_data *pdata = xmm_power_drv_data.pdata;	struct xmm_power_data *drv = &xmm_power_drv_data;	int value;	int delay = 1000; /* maxmum delay in msec */	unsigned long flags;	int ret, rcount = 0;	pr_debug("%s/n", __func__);	if (!pdata)		return;	/* erroneous remote-wakeup might call this from irq */	if (in_interrupt() || in_atomic()) {		pr_err("%s: not allowed in interrupt/n", __func__);		return;	}	/* claim the wakelock here to avoid any system suspend */	if (!wake_lock_active(&wakelock))		wake_lock_timeout(&wakelock, HZ*2);	spin_lock_irqsave(&xmm_lock, flags);	modem_sleep_flag = false;	wakeup_pending = false;	value = gpio_get_value(pdata->modem.xmm.ipc_ap_wake);	if (value) {		/* set the slave wakeup request - bb_wake high */		drv->hostwake = 0;		gpio_set_value(pdata->modem.xmm.ipc_bb_wake, 1);		spin_unlock_irqrestore(&xmm_lock, flags);		pr_info("AP L2->L0/n");retry:		/* wait for cp */		pr_debug("waiting for host wakeup from CP.../n");		ret = wait_event_interruptible_timeout(drv->bb_wait,				drv->hostwake == 1, msecs_to_jiffies(delay));		if (ret == 0) {			pr_info("!!AP L2->L0 Failed/n");			return;		}		if (ret == -ERESTARTSYS) {			if (rcount >= 5) {				pr_info("!!AP L2->L0 Failed/n");				return;			}			pr_debug("%s: caught signal/n", __func__);			rcount++;			goto retry;		}		pr_debug("Get gpio host wakeup low <-/n");	} else {		cp_initiated_l2tol0 = false;		queue_work(workqueue, &l2_resume_work);		spin_unlock_irqrestore(&xmm_lock, flags);		pr_info("CP L2->L0/n");	}}

//.........这里部分代码省略.........	mmc_bus_get(host);	/* if there still is a card present, stop here */	if (host->bus_ops != NULL) {		mmc_bus_put(host);		goto out;	}	/* detect a newly inserted card */	/*	 * Only we can add a new handler, so it's safe to	 * release the lock here.	 */	mmc_bus_put(host);	if (host->ops->get_cd && host->ops->get_cd(host) == 0)		goto out;	mmc_claim_host(host);	mmc_power_up(host);	mmc_go_idle(host);	mmc_send_if_cond(host, host->ocr_avail);	/*	 * First we search for SDIO...	 */	err = mmc_send_io_op_cond(host, 0, &ocr);	if (!err) {		if (mmc_attach_sdio(host, ocr))			mmc_power_off(host);		extend_wakelock = 1;		goto out;	}	/*	 * ...then normal SD...	 */	err = mmc_send_app_op_cond(host, 0, &ocr);	if (!err) {		if (mmc_attach_sd(host, ocr))			mmc_power_off(host);		extend_wakelock = 1;		goto out;	}	/*	 * ...and finally MMC.	 */	err = mmc_send_op_cond(host, 0, &ocr);	if (!err) {		if (mmc_attach_mmc(host, ocr))			mmc_power_off(host);		extend_wakelock = 1;		goto out;	}	mmc_release_host(host);	mmc_power_off(host);out:    // FIH_FOX, BillHJChang	{ 20090904,  Modify for UMS currect handle	if(host->index == 0) 	{		if(host->bus_ops == NULL)			storage_state = false;		else			storage_state = true;		printk(KERN_INFO"%s: (storage_state : %d)/n",__func__,storage_state);	}	// FIH_F0X, BillHJChang	}    /* FIH, BillHJChang, 2009/11/20 { */	/* [FXX_CR], issue of card detect fail in suspend mode */	#ifdef CONFIG_FIH_FXX		if(host->index == 0) 		{		wake_lock_timeout(&mmc_delayed_work_wake_lock, HZ * 2);				wake_lock_timeout(&sdcard_idle_wake_lock, HZ * 2);			}		else		{		wake_unlock(&mmc_delayed_work_wake_lock);		wake_unlock(&sdcard_idle_wake_lock);		}	#else	    if (extend_wakelock)		    wake_lock_timeout(&mmc_delayed_work_wake_lock, HZ / 2);	    else		    wake_unlock(&mmc_delayed_work_wake_lock);    #endif    /* } FIH, BillHJChang, 2009/11/20 */	if (host->caps & MMC_CAP_NEEDS_POLL)		mmc_schedule_delayed_work(&host->detect, HZ);}

static int wl1271_rx_handle_data(struct wl1271 *wl, u8 *data, u32 length,				 enum wl_rx_buf_align rx_align, u8 *hlid){	struct wl1271_rx_descriptor *desc;	struct sk_buff *skb;	struct ieee80211_hdr *hdr;	u8 *buf;	u8 beacon = 0;	u8 is_data = 0;	u8 reserved = 0, offset_to_data = 0;	u16 seq_num;	u32 pkt_data_len;	/*	 * In PLT mode we seem to get frames and mac80211 warns about them,	 * workaround this by not retrieving them at all.	 */	if (unlikely(wl->plt))		return -EINVAL;	pkt_data_len = wlcore_hw_get_rx_packet_len(wl, data, length);	if (!pkt_data_len) {		wl1271_error("Invalid packet arrived from HW. length %d",			     length);		return -EINVAL;	}	if (rx_align == WLCORE_RX_BUF_UNALIGNED)		reserved = RX_BUF_ALIGN;	else if (rx_align == WLCORE_RX_BUF_PADDED)		offset_to_data = RX_BUF_ALIGN;	/* the data read starts with the descriptor */	desc = (struct wl1271_rx_descriptor *) data;	if (desc->packet_class == WL12XX_RX_CLASS_LOGGER) {		size_t len = length - sizeof(*desc);		wl12xx_copy_fwlog(wl, data + sizeof(*desc), len);		wake_up_interruptible(&wl->fwlog_waitq);		return 0;	}	/* discard corrupted packets */	if (desc->status & WL1271_RX_DESC_DECRYPT_FAIL) {		hdr = (void *)(data + sizeof(*desc) + offset_to_data);		wl1271_warning("corrupted packet in RX: status: 0x%x len: %d",			       desc->status & WL1271_RX_DESC_STATUS_MASK,			       pkt_data_len);		wl1271_dump((DEBUG_RX|DEBUG_CMD), "PKT: ", data + sizeof(*desc),			    min(pkt_data_len,				ieee80211_hdrlen(hdr->frame_control)));		return -EINVAL;	}	/* skb length not including rx descriptor */	skb = __dev_alloc_skb(pkt_data_len + reserved, GFP_KERNEL);	if (!skb) {		wl1271_error("Couldn't allocate RX frame");		return -ENOMEM;	}	/* reserve the unaligned payload(if any) */	skb_reserve(skb, reserved);	buf = skb_put(skb, pkt_data_len);	/*	 * Copy packets from aggregation buffer to the skbs without rx	 * descriptor and with packet payload aligned care. In case of unaligned	 * packets copy the packets in offset of 2 bytes guarantee IP header	 * payload aligned to 4 bytes.	 */	memcpy(buf, data + sizeof(*desc), pkt_data_len);	if (rx_align == WLCORE_RX_BUF_PADDED)		skb_pull(skb, RX_BUF_ALIGN);	*hlid = desc->hlid;	hdr = (struct ieee80211_hdr *)skb->data;	if (ieee80211_is_beacon(hdr->frame_control))		beacon = 1;	if (ieee80211_is_data_present(hdr->frame_control))		is_data = 1;	wl1271_rx_status(wl, desc, IEEE80211_SKB_RXCB(skb), beacon);	wlcore_hw_set_rx_csum(wl, desc, skb);	seq_num = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4;	wl1271_debug(DEBUG_RX, "rx skb 0x%p: %d B %s seq %d hlid %d", skb,		     skb->len - desc->pad_len,		     beacon ? "beacon" : "",		     seq_num, *hlid);	skb_queue_tail(&wl->deferred_rx_queue, skb);	queue_work(wl->freezable_wq, &wl->netstack_work);#ifdef CONFIG_HAS_WAKELOCK	/* let the frame some time to propagate to user-space */	wake_lock_timeout(&wl->rx_wake, HZ);#endif//.........这里部分代码省略.........

void mmc_rescan(struct work_struct *work){	struct mmc_host *host =		container_of(work, struct mmc_host, detect.work);	u32 ocr;	int err;	mmc_bus_get(host);	if (host->bus_ops == NULL) {		/*		 * Only we can add a new handler, so it's safe to		 * release the lock here.		 */		mmc_bus_put(host);		if (host->ops->get_cd && host->ops->get_cd(host) == 0)			goto out;		mmc_claim_host(host);		mmc_power_up(host);		mmc_go_idle(host);		mmc_send_if_cond(host, host->ocr_avail);		/*		 * First we search for SDIO...		 */		err = mmc_send_io_op_cond(host, 0, &ocr);		if (!err) {			if (mmc_attach_sdio(host, ocr))				mmc_power_off(host);			goto out;		}		/*		 * ...then normal SD...		 */		err = mmc_send_app_op_cond(host, 0, &ocr);		if (!err) {			if (mmc_attach_sd(host, ocr))				mmc_power_off(host);			goto out;		}		/*		 * ...and finally MMC.		 */		err = mmc_send_op_cond(host, 0, &ocr);		if (!err) {			if (mmc_attach_mmc(host, ocr))				mmc_power_off(host);			goto out;		}		mmc_release_host(host);		mmc_power_off(host);	} else {		if (host->bus_ops->detect && !host->bus_dead)			host->bus_ops->detect(host);		mmc_bus_put(host);	}out:	/* give userspace some time to react */	wake_lock_timeout(&mmc_delayed_work_wake_lock, HZ / 2);	if (host->caps & MMC_CAP_NEEDS_POLL)		mmc_schedule_delayed_work(&host->detect, HZ);}

static void tab3_mic_id(void *data, u16 status){	struct wm1811_machine_priv *wm1811 = data;	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(wm1811->codec);	int report;	int reg;	bool present;	wake_lock_timeout(&wm1811->jackdet_wake_lock, 5 * HZ);	/* Either nothing present or just starting detection */	if (!(status & WM8958_MICD_STS)) {		if (!wm8994->jackdet) {			/* If nothing present then clear our statuses */			dev_dbg(wm1811->codec->dev, "Detected open circuit/n");			wm8994->jack_mic = false;			wm8994->mic_detecting = true;			tab3_micd_set_rate(wm1811->codec);			snd_soc_jack_report(wm8994->micdet[0].jack, 0,					    wm8994->btn_mask |					     SND_JACK_HEADSET);		}		/*ToDo*/		/*return;*/	}	/* If the measurement is showing a high impedence we've got a	 * microphone.	 */	if (wm8994->mic_detecting && (status & 0x400)) {		dev_info(wm1811->codec->dev, "Detected microphone/n");		wm8994->mic_detecting = false;		wm8994->jack_mic = true;		tab3_micd_set_rate(wm1811->codec);		snd_soc_jack_report(wm8994->micdet[0].jack, SND_JACK_HEADSET,				    SND_JACK_HEADSET);	}	if (wm8994->mic_detecting && status & 0x4) {		dev_info(wm1811->codec->dev, "Detected headphone/n");		wm8994->mic_detecting = false;		tab3_micd_set_rate(wm1811->codec);		snd_soc_jack_report(wm8994->micdet[0].jack, SND_JACK_HEADPHONE,				    SND_JACK_HEADSET);		/* If we have jackdet that will detect removal */		if (wm8994->jackdet) {			mutex_lock(&wm8994->accdet_lock);			snd_soc_update_bits(wm1811->codec, WM8958_MIC_DETECT_1,					    WM8958_MICD_ENA, 0);			if (wm8994->active_refcount) {				snd_soc_update_bits(wm1811->codec,					WM8994_ANTIPOP_2,					WM1811_JACKDET_MODE_MASK,					WM1811_JACKDET_MODE_AUDIO);			}			mutex_unlock(&wm8994->accdet_lock);			if (wm8994->pdata->jd_ext_cap) {				mutex_lock(&wm1811->codec->mutex);				snd_soc_dapm_disable_pin(&wm1811->codec->dapm,							 "MICBIAS2");				snd_soc_dapm_sync(&wm1811->codec->dapm);				mutex_unlock(&wm1811->codec->mutex);			}		}	}}

int smdhsic_pm_resume_AP(void){	int r;	int expire = 500;	int pending_spin = 20;	int suspended_spin = 20;	struct completion done;	struct device *dev;	if (!g_usbdev.usbdev) {		smdctl_request_connection_recover(true);		return -ENODEV;	}	dev = &g_usbdev.usbdev->dev;retry:	/* Hold Wake lock, when TX...*/	wake_lock_timeout(&g_usbdev.tx_wlock, msecs_to_jiffies(500));	/* dpm_suspending can be set during RPM STATUS changing */	if (g_usbdev.hsic && g_usbdev.hsic->dpm_suspending)		return -EAGAIN;	switch (dev->power.runtime_status) {	case RPM_SUSPENDED:		pr_debug("%s: HSIC suspended/n", __func__);		init_completion(&done);		r = smdctl_request_slave_wakeup(&done);		if (r <= 0 &&			!wait_for_completion_timeout(&done,						msecs_to_jiffies(expire))) {			pr_err("%s: HSIC Resume timeout %d/n",			       __func__, expire);			r = smdctl_request_slave_wakeup(NULL);			if (r <= 0) {				if (g_usbdev.hsic &&					g_usbdev.hsic->resume_failcnt++ > 5) {					g_usbdev.hsic->resume_failcnt = 0;					smdctl_request_connection_recover(true);				}				return -ETIMEDOUT;			}		}		if (suspended_spin-- <= 0) {			if (g_usbdev.hsic &&				g_usbdev.hsic->resume_failcnt++ > 5) {				g_usbdev.hsic->resume_failcnt = 0;				smdctl_request_connection_recover(true);			}			return -ETIMEDOUT;		}		msleep(100);		goto retry;	case RPM_SUSPENDING:	case RPM_RESUMING:		pr_debug("%s: HSIC status : %d spin: %d/n", __func__,			dev->power.runtime_status,			pending_spin);		if (pending_spin == 0) {			pr_err("%s: Modem runtime pm timeout/n",			       __func__);			if (g_usbdev.hsic &&				g_usbdev.hsic->resume_failcnt++ > 5) {				g_usbdev.hsic->resume_failcnt = 0;				smdctl_request_connection_recover(true);			}			smdctl_reenumeration_control();			return -ETIMEDOUT;		}		pending_spin--;		usleep_range(5000, 10000);		goto retry;	case RPM_ACTIVE:		if (g_usbdev.hsic)			g_usbdev.hsic->resume_failcnt = 0;		/* For under autosuspend timer */		wake_lock_timeout(&g_usbdev.tx_wlock, msecs_to_jiffies(100));		break;	default:		return -EIO;	}	return 0;}

static void ccmni_md_state_callback(int md_id, int rx_ch, MD_STATE state){	ccmni_ctl_block_t *ctlb = ccmni_ctl_blk[md_id];	ccmni_instance_t  *ccmni = NULL;	int ccmni_idx = 0;		if (unlikely(ctlb == NULL)) {		CCMNI_ERR_MSG(md_id, "invalid ccmni ctrl struct when rx_ch=%d md_sta=%d/n", rx_ch, state);		return;	}		ccmni_idx = get_ccmni_idx_from_ch(md_id, rx_ch); 	if (unlikely(ccmni_idx < 0)) {		CCMNI_ERR_MSG(md_id, "get error ccmni index when md_sta=%d/n", state);		return; 	}			ccmni = ctlb->ccmni_inst[ccmni_idx];	if ((state != TX_IRQ) && (state != TX_FULL) && (atomic_read(&ccmni->usage) > 0)) {		CCMNI_INF_MSG(md_id, "md_state_cb: CCMNI%d, md_sta=%d, usage=%d/n", /			ccmni_idx, state, atomic_read(&ccmni->usage));	}			switch(state) {		case READY:			netif_carrier_on(ccmni->dev);			ccmni->tx_seq_num[0] = 0;			ccmni->tx_seq_num[1] = 0;			ccmni->rx_seq_num = 0;			break;					case EXCEPTION:		case RESET:			netif_carrier_off(ccmni->dev);			break;		case RX_IRQ:			mod_timer(&ccmni->timer, jiffies+HZ);			napi_schedule(&ccmni->napi);			wake_lock_timeout(&ctlb->ccmni_wakelock, HZ);			break;					case TX_IRQ:			if(netif_running(ccmni->dev) && netif_queue_stopped(ccmni->dev) && atomic_read(&ccmni->usage)>0) {				netif_wake_queue(ccmni->dev);				//ccmni->flags &= ~PORT_F_RX_FULLED;				CCMNI_INF_MSG(md_id, "md_state_cb: CCMNI%d, md_sta=TX_IRQ, usage=%d/n", /					ccmni_idx, atomic_read(&ccmni->usage));			}			break;					case TX_FULL:			netif_stop_queue(ccmni->dev);			CCMNI_INF_MSG(md_id, "md_state_cb: CCMNI%d, md_sta=TX_FULL, usage=%d/n", /				ccmni_idx, atomic_read(&ccmni->usage));			//ccmni->flags |= PORT_F_RX_FULLED; // for convenient in traffic log			break;		default:			break;	}}

//.........这里部分代码省略.........						state_machine_retry = true;					}#endif	// #ifdef SDCHG_SELF_TEST#else					need_set_alarm = info->state_machine_run = false;#endif	// #ifdef SDCHG_STATE_MACHINE_RETRY_AT_END_COND				}			} else {	// discharging -> discharging				//need_set_alarm = info->state_machine_run = true;				//set_alarm_time = SDCHG_DISCHARGING_DELAY;				need_set_alarm = false; // in discharing, according to original monitor work time				info->state_machine_run = true;			}		}	}	/****************************************/	else {//KEEP_GOING:		need_set_state = false;		if (info->need_state == SDCHG_STATE_NONE) {	// prev : none			if (sdchg_ta_attach(battery) || battcond >= SDCHG_BATTCOND_START) {				need_set_alarm = info->state_machine_run = true;				if (temperature < SDCHG_TEMP_FOR_BATT_CHECK_DELAY)					set_alarm_time = SDCHG_BATT_CHECK_DELAY_NORMAL; 				else					set_alarm_time = SDCHG_BATT_CHECK_DELAY_IMMINENT;#ifdef SDCHG_STATE_MACHINE_RETRY_AT_END_COND				state_machine_retry = false;#endif			} else {#ifdef SDCHG_STATE_MACHINE_RETRY_AT_END_COND#ifdef SDCHG_SELF_TEST				need_set_alarm = info->state_machine_run = true;				if (temperature < SDCHG_TEMP_FOR_BATT_CHECK_DELAY)					set_alarm_time = SDCHG_BATT_CHECK_DELAY_NORMAL; 				else					set_alarm_time = SDCHG_BATT_CHECK_DELAY_IMMINENT;#else				if (state_machine_retry) {					if (runned_by_sdchg_poll) {						need_set_alarm = info->state_machine_run = false;						state_machine_retry = false;												} else {						need_set_alarm = info->state_machine_run = true;						if (temperature < SDCHG_TEMP_FOR_BATT_CHECK_DELAY)							set_alarm_time = SDCHG_BATT_CHECK_DELAY_NORMAL; 						else							set_alarm_time = SDCHG_BATT_CHECK_DELAY_IMMINENT;					}				} else {					need_set_alarm = info->state_machine_run = true;					if (temperature < SDCHG_TEMP_FOR_BATT_CHECK_DELAY)						set_alarm_time = SDCHG_BATT_CHECK_DELAY_NORMAL; 					else						set_alarm_time = SDCHG_BATT_CHECK_DELAY_IMMINENT;					state_machine_retry = true;				}#endif	// #ifdef SDCHG_SELF_TEST#else				need_set_alarm = info->state_machine_run = false;#endif	// #ifdef SDCHG_STATE_MACHINE_RETRY_AT_END_COND			}		} else {		// prev : discharging			//need_set_alarm = info->state_machine_run = true;			//set_alarm_time = SDCHG_DISCHARGING_DELAY;			need_set_alarm = false;	// in discharing, according to original monitor work time			info->state_machine_run = true;		}	}	/****************************************/	if (need_set_state) {		current_source_set(info);	}	if (need_set_alarm)		sdchg_set_polling_time(set_alarm_time);	else		sdchg_set_polling_time(0);#ifdef SDCHG_CHECK_TYPE_SOC		pr_info("[SDCHG][%s] soc : %d , temp : %d, state : %s/n", 			__func__, battcond, temperature, sdchg_state_str[info->set_state]);#else		pr_info("[SDCHG][%s] volt : %d , temp : %d, state : %s/n", 			__func__, battcond, temperature, sdchg_state_str[info->set_state]);#endif	if (info->set_state == SDCHG_STATE_NONE)	{		if (info->wake_lock_set) {			wake_lock_timeout(&info->wake_lock, HZ * 10);			wake_unlock(&info->wake_lock);			info->wake_lock_set = false;		}	}	return;}

static int hym8563_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm){		struct i2c_client *client = to_i2c_client(dev);	struct hym8563 *hym8563 = i2c_get_clientdata(client);	struct rtc_time now, *tm = &alarm->time;	u8 regs[4] = { 0, };	u8 mon_day;	pr_debug("%4d-%02d-%02d(%d) %02d:%02d:%02d enabled %d/n",		1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_wday,		tm->tm_hour, tm->tm_min, tm->tm_sec, alarm->enabled);	hym8563_read_datetime(client, &now);	if (alarm->enabled && now.tm_year == tm->tm_year &&	    now.tm_mon == tm->tm_mon && now.tm_mday == tm->tm_mday &&	    now.tm_hour == tm->tm_hour && now.tm_min == tm->tm_min &&	    tm->tm_sec > now.tm_sec) {		long timeout = tm->tm_sec - now.tm_sec + 1;		pr_info("stay awake %lds/n", timeout);		wake_lock_timeout(&hym8563->wake_lock, timeout * HZ);	}	mutex_lock(&hym8563->mutex);	hym8563->alarm = *alarm;	regs[0] = 0x0;	hym8563_i2c_set_regs(client, RTC_CTL2, regs, 1);	mon_day = rtc_month_days(tm->tm_mon, tm->tm_year + 1900);	hym8563_i2c_read_regs(client, RTC_A_MIN, regs, 4);		if (tm->tm_min >= 60 || tm->tm_min < 0)		//set  min		regs[0x00] = bin2bcd(0x00) & 0x7f;	else		regs[0x00] = bin2bcd(tm->tm_min) & 0x7f;	if (tm->tm_hour >= 24 || tm->tm_hour < 0)	//set  hour		regs[0x01] = bin2bcd(0x00) & 0x7f;	else		regs[0x01] = bin2bcd(tm->tm_hour) & 0x7f;	regs[0x03] = bin2bcd (tm->tm_wday) & 0x7f;	/* if the input month day is bigger than the biggest day of this month, set the biggest day */	if (tm->tm_mday > mon_day)		regs[0x02] = bin2bcd(mon_day) & 0x7f;	else if (tm->tm_mday > 0)		regs[0x02] = bin2bcd(tm->tm_mday) & 0x7f;	else if (tm->tm_mday <= 0)		regs[0x02] = bin2bcd(0x01) & 0x7f;	hym8563_i2c_set_regs(client, RTC_A_MIN, regs, 4);		hym8563_i2c_read_regs(client, RTC_A_MIN, regs, 4);		hym8563_i2c_read_regs(client, RTC_CTL2, regs, 1);	if (alarm->enabled == 1)		regs[0] |= AIE;	else		regs[0] &= 0x0;	hym8563_i2c_set_regs(client, RTC_CTL2, regs, 1);	hym8563_i2c_read_regs(client, RTC_CTL2, regs, 1);	mutex_unlock(&hym8563->mutex);	return 0;}

static void pm8xxx_led_current_set_flagged(struct led_classdev *led_cdev, enum led_brightness brightness, int blink){	struct pm8xxx_led_data *led = container_of(led_cdev,  struct pm8xxx_led_data, cdev);	int rc, offset;	u8 level;	int *pduties;	LED_INFO("%s, bank:%d, brightness:%d/n", __func__, led->bank, brightness);	cancel_delayed_work_sync(&led->fade_delayed_work);	virtual_key_state = brightness;	if (flag_hold_virtual_key == 1) {		LED_INFO("%s, key control /n", __func__);		return;	}	if(brightness) {		level = (led->out_current << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;		offset = PM8XXX_LED_OFFSET(led->id);		led->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;		led->reg |= level;		rc = pm8xxx_writeb(led->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), led->reg);		if (rc)			LED_ERR("%s can't set (%d) led value rc=%d/n", __func__, led->id, rc);		if (led->function_flags & LED_BRETH_FUNCTION) {			if (blink == 0)			{				buttons_led_is_on = 1;				// no blink needed				pduties = led->duties;				pm8xxx_pwm_lut_config(led->pwm_led,							led->period_us,							pduties,							led->duty_time_ms,							led->start_index,							led->duites_size,							0, 0,							led->lut_flag);			} else			{				pduties = led->duties;				// LUT_LOOP for blinking				pm8xxx_pwm_lut_config(led->pwm_led,							led->period_us,							pduties,							led->duty_time_ms, // slower, 2x							led->start_index,							led->duites_size * 8, // 16 duty entries -> original size * 2, + 6 * 8 zeroes for pause							0, 0,							PM_PWM_LUT_LOOP | PM_PWM_LUT_PAUSE_HI_EN);			}			pm8xxx_pwm_lut_enable(led->pwm_led, 0);			pm8xxx_pwm_lut_enable(led->pwm_led, 1);		} else {			pwm_config(led->pwm_led, 64000, 64000);			pwm_enable(led->pwm_led);		}	} else {		if (led->function_flags & LED_BRETH_FUNCTION) {			buttons_led_is_on = 0;			wake_lock_timeout(&pmic_led_wake_lock, HZ*2);			pduties = led->duties + led->duites_size;			pm8xxx_pwm_lut_config(led->pwm_led,						led->period_us,						pduties,						led->duty_time_ms,						led->start_index,						led->duites_size,						0, 0,						led->lut_flag);			pm8xxx_pwm_lut_enable(led->pwm_led, 0);			pm8xxx_pwm_lut_enable(led->pwm_led, 1);			queue_delayed_work(g_led_work_queue,						&led->fade_delayed_work,						msecs_to_jiffies(led->duty_time_ms*led->duites_size));		} else {			pwm_disable(led->pwm_led);			level = (0 << PM8XXX_DRV_LED_CTRL_SHIFT) & PM8XXX_DRV_LED_CTRL_MASK;			offset = PM8XXX_LED_OFFSET(led->id);			led->reg &= ~PM8XXX_DRV_LED_CTRL_MASK;			led->reg |= level;			rc = pm8xxx_writeb(led->dev->parent, SSBI_REG_ADDR_LED_CTRL(offset), led->reg);			if (rc)				LED_ERR("%s can't set (%d) led value rc=%d/n", __func__, led->id, rc);		}	}}

static irqreturn_t mdm6600_host_wake_irq_handler(int irq, void *ptr){	/* Keep us awake for a bit until RIL gets going */	wake_lock_timeout(&mdm6600_host_wakelock, (HZ * 1));	return IRQ_HANDLED;}

/*give the packet to TCP/IP*/static void xmd_trans_packet(	struct net_device *dev,	int type,	void *buf,	int sz){	struct rmnet_private *p = netdev_priv(dev);	struct sk_buff *skb;	void *ptr = NULL;	sz += RMNET_ETH_HDR_SIZE;#if defined (RMNET_CRITICAL_DEBUG)      dynadbg_module(DYNADBG_CRIT|DYNADBG_TX,"/nRMNET: %d</n",sz);//	printk("/nRMNET: %d</n",sz);#endif	if (sz > (RMNET_MTU_SIZE + RMNET_ETH_HDR_SIZE)) {#if defined (RMNET_ERR)             dynadbg_module(DYNADBG_WARN|DYNADBG_TX,"xmd_trans_packet() discarding %d pkt len/n", sz);//		printk("xmd_trans_packet() discarding %d pkt len/n", sz);#endif		ptr = 0;		return;	}	else {		skb = dev_alloc_skb(sz + NET_IP_ALIGN);		if (skb == NULL) {#if defined (RMNET_ERR)                   dynadbg_module(DYNADBG_WARN|DYNADBG_TX,"xmd_trans_packet() cannot allocate skb/n");//			printk("xmd_trans_packet() cannot allocate skb/n");#endif			return;		}		else {			skb->dev = dev;			skb_reserve(skb, NET_IP_ALIGN);			ptr = skb_put(skb, sz);			wake_lock_timeout(&p->wake_lock, HZ / 2);			/* adding ethernet header */			{				/* struct ethhdr eth_hdr = {0xB6,0x91,0x24,0xa8,0x14,0x72,0xb6,										0x91,0x24,0xa8,0x14,0x72,0x08,0x0};*/				char temp[] = {0xB6,0x91,0x24,0xa8,0x14,0x72,0xb6,0x91,0x24,							   0xa8,0x14,0x72,0x08,0x0};				struct ethhdr *eth_hdr = (struct ethhdr *) temp;				if (type == RMNET_IPV6_VER) {					eth_hdr->h_proto = 0x08DD;					eth_hdr->h_proto = htons(eth_hdr->h_proto);				}				memcpy((void *)eth_hdr->h_dest,					   (void*)dev->dev_addr,					   sizeof(eth_hdr->h_dest));				memcpy((void *)ptr,					   (void *)eth_hdr,					   sizeof(struct ethhdr));			}			memcpy(ptr + RMNET_ETH_HDR_SIZE, buf, sz - RMNET_ETH_HDR_SIZE);			skb->protocol = eth_type_trans(skb, dev);			if (count_this_packet(ptr, skb->len)) {#ifdef CONFIG_MSM_RMNET_DEBUG				p->wakeups_rcv += rmnet_cause_wakeup(p);#endif				p->stats.rx_packets++;				p->stats.rx_bytes += skb->len;			}			netif_rx(skb);			wake_unlock(&p->wake_lock);		}	}}

static void ts27010_uart_retran_worker(struct work_struct *work){	int ret;	int j;	u8 para[SLIDE_WINDOWS_SIZE_AP];	struct ts27010_retran_info_t *retran_info;	FUNC_ENTER();	memset(para, 0, sizeof(u8) * SLIDE_WINDOWS_SIZE_AP);	/* get timeout indexs and clean counter */	ts27010_get_timer_para(s_timer_para, para);	ts27010_slidewindow_lock(s_slide_window);	for (j = 0; j < SLIDE_WINDOWS_SIZE_AP; j++) {		if (para[j] && ts27010_slidewindow_is_idx_in(			s_slide_window, j)) {			/* need retransfer j */			retran_info = ts27010_slidewindow_peek(				s_slide_window, j);			mux_print(MSG_INFO,				"retransfering... index=%d, "				"sn = %x, length=%d/n",				j, ts27010_get_retran_sn(retran_info),				ts27010_get_retran_len(retran_info));			ret = ts27010_uart_driver_send(				ts27010_get_retran_data(retran_info),				ts27010_get_retran_len(retran_info),				&s_mux_resend_lock);			ts27010_mod_retran_timer(retran_info);			if (!ret) {				/* this frame retransfered */				mux_print(MSG_INFO,					"frame %x retransfered successful, "					"length=%d/n",					ts27010_get_retran_sn(retran_info),					ts27010_get_retran_len(retran_info));#ifdef CONFIG_WAKELOCK				/*				 * Re-transfer happened,				 * so block system 1s for next re-send.				 */				wake_lock_timeout(&s_mux_resend_lock, HZ);#endif				if (ts27010_inc_retran_count(retran_info)					== MAX_RETRAN_TIMES) {					/* retran 10 times, trigger panic */					mux_print(MSG_ERROR,						"retrans frame %x(index %d) "						"failed more than 10 times!/n",						ts27010_get_retran_sn(							retran_info), j);					mux_uart_hexdump(MSG_ERROR,						"dump frame",						__func__, __LINE__,						ts27010_get_retran_data(							retran_info),						ts27010_get_retran_len(							retran_info));					/* TODO: trigger panic or reset BP? */				}			} else {				mux_print(MSG_ERROR,					"retran interrupted because of "					"ipc driver error/n");				goto EXIT;			}		} else if (para[j]) {			/*			 * since j is not in slide window,			 * should stop this timer			 */			mux_print(MSG_INFO,				"timer index %d is out of slide window "				"head: %d, tail %d/n",				j, ts27010_slidewindow_head(s_slide_window),				ts27010_slidewindow_tail(s_slide_window));			ts27010_stop_retran_timer(				ts27010_slidewindow_peek(s_slide_window, j));			ts27010_clear_timer_para(s_timer_para, j);		}	}EXIT:	ts27010_slidewindow_unlock(s_slide_window);	FUNC_EXIT();}

//.........这里部分代码省略.........		}#endif		/* copy modem data */		if (driver->in_busy_1 == 1) {			/*Copy the actual data being passed*/			COPY_USER_SPACE_OR_EXIT(buf+ret,					*(driver->buf_in_1),					 driver->write_ptr_1->length);			driver->in_busy_1 = 0;		}		if (driver->in_busy_2 == 1) {			/*Copy the actual data being passed*/			COPY_USER_SPACE_OR_EXIT(buf+ret,					 *(driver->buf_in_2),					 driver->write_ptr_2->length);			driver->in_busy_2 = 0;		}		/* copy q6 data */		if (driver->in_busy_qdsp_1 == 1) {			/*Copy the actual data being passed*/			COPY_USER_SPACE_OR_EXIT(buf+ret, *(driver->							buf_in_qdsp_1),					 driver->write_ptr_qdsp_1->length);			driver->in_busy_qdsp_1 = 0;		}		if (driver->in_busy_qdsp_2 == 1) {			/*Copy the actual data being passed*/			COPY_USER_SPACE_OR_EXIT(buf+ret, *(driver->				buf_in_qdsp_2), driver->					write_ptr_qdsp_2->length);			driver->in_busy_qdsp_2 = 0;		}		if (driver->ch)			queue_work(driver->diag_wq,					 &(driver->diag_read_smd_work));		if (driver->chqdsp)			queue_work(driver->diag_wq,					 &(driver->diag_read_smd_qdsp_work));		if (diag7k_debug_mask)			pr_info("%s() return %d byte/n", __func__, ret);		goto exit;	}	if (driver->data_ready[index] & DEINIT_TYPE) {		/*Copy the type of data being passed*/		data_type = driver->data_ready[index] & DEINIT_TYPE;		COPY_USER_SPACE_OR_EXIT(buf, data_type, 4);		driver->data_ready[index] ^= DEINIT_TYPE;		goto exit;	}	if (driver->data_ready[index] & MSG_MASKS_TYPE) {		/*Copy the type of data being passed*/		data_type = driver->data_ready[index] & MSG_MASKS_TYPE;		COPY_USER_SPACE_OR_EXIT(buf, data_type, 4);		COPY_USER_SPACE_OR_EXIT(buf+4, *(driver->msg_masks),							 MSG_MASK_SIZE);		driver->data_ready[index] ^= MSG_MASKS_TYPE;		goto exit;	}	if (driver->data_ready[index] & EVENT_MASKS_TYPE) {		/*Copy the type of data being passed*/		data_type = driver->data_ready[index] & EVENT_MASKS_TYPE;		COPY_USER_SPACE_OR_EXIT(buf, data_type, 4);		COPY_USER_SPACE_OR_EXIT(buf+4, *(driver->event_masks),							 EVENT_MASK_SIZE);		driver->data_ready[index] ^= EVENT_MASKS_TYPE;		goto exit;	}	if (driver->data_ready[index] & LOG_MASKS_TYPE) {		/*Copy the type of data being passed*/		data_type = driver->data_ready[index] & LOG_MASKS_TYPE;		COPY_USER_SPACE_OR_EXIT(buf, data_type, 4);		COPY_USER_SPACE_OR_EXIT(buf+4, *(driver->log_masks),							 LOG_MASK_SIZE);		driver->data_ready[index] ^= LOG_MASKS_TYPE;		goto exit;	}	if (driver->data_ready[index] & PKT_TYPE) {		/*Copy the type of data being passed*/		data_type = driver->data_ready[index] & PKT_TYPE;		COPY_USER_SPACE_OR_EXIT(buf, data_type, 4);		COPY_USER_SPACE_OR_EXIT(buf+4, *(driver->pkt_buf),							 driver->pkt_length);		driver->data_ready[index] ^= PKT_TYPE;		goto exit;	}exit:	if (ret)		wake_lock_timeout(&driver->wake_lock, HZ / 2);	mutex_unlock(&driver->diagchar_mutex);	return ret;}

static irqreturn_t s5p_ap_wakeup_irq_handler(int irq, void *data){	struct idpram_pm_data *pm_data = data;	wake_lock_timeout(&pm_data->ap_wlock, HZ*5);	return IRQ_HANDLED;}