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

static void hci_smd_notify_event(void *data, unsigned int event){	struct hci_dev *hdev = hs.hdev;	struct hci_smd_data *hsmd = &hs;	struct work_struct *reset_worker;	struct work_struct *open_worker;	int len = 0;	if (!hdev) {		BT_ERR("Frame for unknown HCI device (hdev=NULL)");		return;	}	switch (event) {	case SMD_EVENT_DATA:		len = smd_read_avail(hsmd->event_channel);		if (len > 0)			tasklet_hi_schedule(&hs.rx_task);		else if (len < 0)			BT_ERR("Failed to read event from smd %d", len);		break;	case SMD_EVENT_OPEN:		BT_INFO("opening HCI-SMD channel :%s", EVENT_CHANNEL);		hci_smd_open(hdev);		open_worker = kzalloc(sizeof(*open_worker), GFP_ATOMIC);		if (!open_worker) {			BT_ERR("Out of memory");			break;		}		INIT_WORK(open_worker, hci_dev_smd_open);		schedule_work(open_worker);		break;	case SMD_EVENT_CLOSE:		BT_INFO("Closing HCI-SMD channel :%s", EVENT_CHANNEL);		hci_smd_close(hdev);		reset_worker = kzalloc(sizeof(*reset_worker), GFP_ATOMIC);		if (!reset_worker) {			BT_ERR("Out of memory");			break;		}		INIT_WORK(reset_worker, hci_dev_restart);		schedule_work(reset_worker);		break;	default:		break;	}}

static void usb_write_port_complete(struct urb *purb){	int i;	struct xmit_frame *pxmitframe = (struct xmit_frame *)purb->context;	struct xmit_buf *pxmitbuf = pxmitframe->pxmitbuf;	struct _adapter *padapter = pxmitframe->padapter;	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;	struct pkt_attrib *pattrib = &pxmitframe->attrib;	switch (pattrib->priority) {	case 1:	case 2:		pxmitpriv->bkq_cnt--;		break;	case 4:	case 5:		pxmitpriv->viq_cnt--;		break;	case 6:	case 7:		pxmitpriv->voq_cnt--;		break;	case 0:	case 3:	default:		pxmitpriv->beq_cnt--;		break;	}	pxmitpriv->txirp_cnt--;	for (i = 0; i < 8; i++) {		if (purb == pxmitframe->pxmit_urb[i]) {			pxmitframe->bpending[i] = false;			break;		}	}	if (padapter->bSurpriseRemoved)		return;	switch (purb->status) {	case 0:		break;	default:		printk(KERN_WARNING "r8712u: pipe error: (%d)/n", purb->status);		break;	}	/* not to consider tx fragment */	r8712_free_xmitframe_ex(pxmitpriv, pxmitframe);	r8712_free_xmitbuf(pxmitpriv, pxmitbuf);	tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);}

MAILBOX_LOCAL int mailbox_ipc_process(                struct mb_local_work  *local_work,                struct mb_local_proc  *local_proc,                unsigned int channel_id,                unsigned int proc_id){    unsigned int is_find = MAILBOX_TRUE;    while (local_work) {        /*从邮箱工作队列中找到对应的邮箱，设置标志位并释放信号量通知处理任务*/        if (channel_id  == local_work->channel_id) {            /*设置任务邮箱工作队列链表中此邮箱的数据标志位*/            local_work->data_flag = MAILBOX_TRUE;            #ifdef MAILBOX_OPEN_MNTN                          mailbox_record_sche_send(local_work->mb_priv);#endif                         wake_lock(&mb_lpwr_lock);            if ((proc_id > MAILBOX_RECV_TASK_START)                && (proc_id < MAILBOX_RECV_TASK_END)) {                             /*释放信号量，通知任务*/                local_proc->incoming = MAILBOX_TRUE;                wake_up(&local_proc->wait);            } else if(MAILBOX_RECV_TASKLET_HI == proc_id) {                 /*tasklet处理方式，在tasklet中处理邮箱数据*/                tasklet_hi_schedule(&local_proc->tasklet);                             } else if(MAILBOX_RECV_TASKLET == proc_id) {                 /*tasklet处理方式，在tasklet中处理邮箱数据*/                tasklet_schedule(&local_proc->tasklet);                             } else if(MAILBOX_RECV_INT_IRQ == proc_id) {                /*中断处理方式，在中断中直接处理邮箱数据*/                mailbox_receive_process((unsigned long)local_proc);                            } else {                is_find = MAILBOX_FALSE;            }		}		local_work = local_work->next;	}	return is_find;}

/* PS-Poll frame use BulkOutPipeId = 0 */void RTUSBBulkOutPsPollComplete(struct urb *pUrb, struct pt_regs * pt_regs){	struct rt_rtmp_adapter *pAd;	struct rt_tx_context *pPsPollContext;	int Status;	struct os_cookie *pObj;	pPsPollContext = (struct rt_tx_context *)pUrb->context;	pAd = pPsPollContext->pAd;	Status = pUrb->status;	pObj = (struct os_cookie *)pAd->OS_Cookie;	pObj->pspoll_frame_complete_task.data = (unsigned long)pUrb;	tasklet_hi_schedule(&pObj->pspoll_frame_complete_task);}

static irqreturn_t adf_isr(int irq, void *privdata){	struct adf_accel_dev *accel_dev = privdata;	struct adf_hw_device_data *hw_data = accel_dev->hw_device;	struct adf_bar *pmisc =			&GET_BARS(accel_dev)[hw_data->get_misc_bar_id(hw_data)];	void __iomem *pmisc_bar_addr = pmisc->virt_addr;	u32 v_int;	/* Read VF INT source CSR to determine the source of VF interrupt */	v_int = ADF_CSR_RD(pmisc_bar_addr, ADF_VINTSOU_OFFSET);	/* Check for PF2VF interrupt */	if (v_int & ADF_VINTSOU_PF2VF) {		/* Disable PF to VF interrupt */		adf_disable_pf2vf_interrupts(accel_dev);		/* Schedule tasklet to handle interrupt BH */		tasklet_hi_schedule(&accel_dev->vf.pf2vf_bh_tasklet);		return IRQ_HANDLED;	}	/* Check bundle interrupt */	if (v_int & ADF_VINTSOU_BUN) {		struct adf_etr_data *etr_data = accel_dev->transport;		struct adf_etr_bank_data *bank = &etr_data->banks[0];		/* Disable Flag and Coalesce Ring Interrupts */		WRITE_CSR_INT_FLAG_AND_COL(bank->csr_addr, bank->bank_number,					   0);		tasklet_hi_schedule(&bank->resp_handler);		return IRQ_HANDLED;	}	return IRQ_NONE;}

	void request_done_tasklet(unsigned long data)	{		ifxpcd_ep_t *_ifxep = (ifxpcd_ep_t *)data;		ifxpcd_request_t   *req;		unsigned long flags=0;		int k=10;		_ifxep->cmpt_tasklet_in_process=1;		while (k)		{			SPIN_LOCK_IRQSAVE(&_ifxep->cmp_lock,flags);			if(_ifxep->queue_cmpt.next != &_ifxep->queue_cmpt)			{				req = list_entry(_ifxep->queue_cmpt.next, ifxpcd_request_t,trq);				list_del_init(&req->trq);				SPIN_UNLOCK_IRQRESTORE(&_ifxep->cmp_lock,flags);				if(req->sysreq.complete)					req->sysreq.complete(&_ifxep->sysep, &req->sysreq);				else				{					#ifdef __req_num_dbg__						IFX_ERROR("%s() no complete EP%d Req%d/n",__func__,_ifxep->num, req->reqid);					#else						IFX_ERROR("%s() no complete EP%d Req %p/n",__func__,_ifxep->num, req);					#endif				}			}			else			{				SPIN_UNLOCK_IRQRESTORE(&_ifxep->cmp_lock,flags);				break;			}			k--;		}		if(!list_empty(&_ifxep->queue_cmpt))		{			#ifdef __GADGET_TASKLET_HIGH__				tasklet_hi_schedule(&_ifxep->cmpt_tasklet);			#else				tasklet_schedule(&_ifxep->cmpt_tasklet);			#endif		}		else			_ifxep->cmpt_tasklet_in_process=0;	}

// PS-Poll frame use BulkOutPipeId = 0VOID RTUSBBulkOutPsPollComplete(purbb_t pUrb,struct pt_regs *pt_regs){	PRTMP_ADAPTER		pAd;	PTX_CONTEXT			pPsPollContext;	NTSTATUS			Status;	POS_COOKIE			pObj;	pPsPollContext= (PTX_CONTEXT)pUrb->context;	pAd = pPsPollContext->pAd;	Status = pUrb->status;	pObj = (POS_COOKIE) pAd->OS_Cookie;	pObj->pspoll_frame_complete_task.data = (unsigned long)pUrb;	tasklet_hi_schedule(&pObj->pspoll_frame_complete_task);}

void r8712_xmit_bh(void *priv){	int ret = false;	struct _adapter *padapter = (struct _adapter *)priv;	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;	if ((padapter->bDriverStopped == true) ||	    (padapter->bSurpriseRemoved == true)) {		netdev_err(padapter->pnetdev, "xmit_bh => bDriverStopped or bSurpriseRemoved/n");		return;	}	ret = r8712_xmitframe_complete(padapter, pxmitpriv, NULL);	if (ret == false)		return;	tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);}

void rtw_os_xmit_schedule(struct adapter *padapter){	struct xmit_priv *pxmitpriv;	if (!padapter)		return;	pxmitpriv = &padapter->xmitpriv;	spin_lock_bh(&pxmitpriv->lock);	if (rtw_txframes_pending(padapter))		tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);	spin_unlock_bh(&pxmitpriv->lock);}

static irqreturn_t hsi_mpu_handler(int irq, void *p){	struct hsi_port *pport = (struct hsi_port *) p;	/* Check no other interrupt handler has already scheduled the tasklet */	if (test_and_set_bit(HSI_FLAGS_TASKLET_LOCK, &pport->flags))		return IRQ_HANDLED;		tasklet_hi_schedule(&pport->hsi_tasklet);	/* Disable interrupt until Bottom Half has cleared the IRQ status */	/* register */		disable_irq_nosync(pport->irq);	return IRQ_HANDLED;}

void rtl8723b_silentreset_for_specific_platform(_adapter *padapter){	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);	struct sreset_priv *psrtpriv = &pHalData->srestpriv;	struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);	struct mlme_priv	*pmlmepriv = &(padapter->mlmepriv);	struct xmit_priv	*pxmitpriv = &padapter->xmitpriv;	_irqL irqL;#ifdef DBG_CONFIG_ERROR_RESET	DBG_871X("%s/n", __FUNCTION__);	psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS;	if (!rtw_netif_queue_stopped(padapter->pnetdev))		rtw_netif_stop_queue(padapter->pnetdev);	rtw_cancel_all_timer(padapter);	tasklet_kill(&pxmitpriv->xmit_tasklet);	_enter_critical_mutex(&psrtpriv->silentreset_mutex, &irqL);	psrtpriv->silent_reset_inprogress = _TRUE;	pwrpriv->change_rfpwrstate = rf_off;#ifdef CONFIG_IPS	ips_enter(padapter);	ips_leave(padapter);#endif	if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)	{		_restore_network_status(padapter);		_restore_security_setting(padapter);	}	_clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING);	psrtpriv->silent_reset_inprogress = _FALSE;	_exit_critical_mutex(&psrtpriv->silentreset_mutex, &irqL);	tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);	_set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);	if (netif_queue_stopped(padapter->pnetdev))		netif_wake_queue(padapter->pnetdev);#endif}

/***********************************************************************************  onuEponIrqRoutine**  ____________________________________________________________________________****  DESCRIPTION: EPON Interrupt routinr**               **  PARAMETERS:  none** **  OUTPUTS:     none**                               **  RETURNS:     IRQ_HANDLED*********************************************************************************/irqreturn_t onuEponIrqRoutine(int irq, void *arg){#ifdef MV_EPON_HW_INTERRUPT  onuEponIsrRoutine(0, 0);#else /* SW_INTERRUPT - TASKLET */  MV_U32 interruptEvent;  MV_U32 interruptStatus;  S_onuPonIrq *irqId = (S_onuPonIrq*)arg;  onuEponIsrLowRoutine(&interruptEvent, &interruptStatus);  eponCurrentInterruptEvent  = interruptEvent;  eponCurrentInterruptStatus = interruptStatus;  tasklet_hi_schedule(&(irqId->onuPonTasklet));#endif   return(IRQ_HANDLED);}

/*	========================================================================	Routine Description:		This routine process Rx Irp and call rx complete function.	Arguments:		DeviceObject	Pointer to the device object for next lower						device. DeviceObject passed in here belongs to						the next lower driver in the stack because we						were invoked via IoCallDriver in USB_RxPacket						AND it is not OUR device object	  Irp				Ptr to completed IRP	  Context			Ptr to our Adapter object (context specified						in IoSetCompletionRoutine	Return Value:		Always returns STATUS_MORE_PROCESSING_REQUIRED	Note:		Always returns STATUS_MORE_PROCESSING_REQUIRED	========================================================================*/void RTUSBBulkRxComplete(struct urb *pUrb, struct pt_regs *pt_regs){	/* use a receive tasklet to handle received packets; */	/* or sometimes hardware IRQ will be disabled here, so we can not */	/* use spin_lock_bh()/spin_unlock_bh() after IRQ is disabled. :< */	struct rt_rx_context *pRxContext;	struct rt_rtmp_adapter *pAd;	struct os_cookie *pObj;	pRxContext = (struct rt_rx_context *)pUrb->context;	pAd = pRxContext->pAd;	pObj = (struct os_cookie *)pAd->OS_Cookie;	pObj->rx_done_task.data = (unsigned long)pUrb;	tasklet_hi_schedule(&pObj->rx_done_task);}

void rtw_os_xmit_schedule(struct adapter *padapter){	unsigned long  irql;	struct xmit_priv *pxmitpriv;	if (!padapter)		return;	pxmitpriv = &padapter->xmitpriv;	_enter_critical_bh(&pxmitpriv->lock, &irql);	if (rtw_txframes_pending(padapter))		tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);	_exit_critical_bh(&pxmitpriv->lock, &irql);}

void rtl8192c_silentreset_for_specific_platform(_adapter *padapter){	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);		struct sreset_priv *psrtpriv = &pHalData->srestpriv;		struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;			struct mlme_priv	*pmlmepriv = &(padapter->mlmepriv);	struct xmit_priv	*pxmitpriv = &padapter->xmitpriv;		_irqL irqL;	psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS;	if (!netif_queue_stopped(padapter->pnetdev))		netif_stop_queue(padapter->pnetdev);			rtw_cancel_all_timer(padapter);		tasklet_kill(&pxmitpriv->xmit_tasklet);		_enter_critical_mutex(&psrtpriv->silentreset_mutex, &irqL);	psrtpriv->silent_reset_inprogress = _TRUE;	pwrpriv->change_rfpwrstate = rf_off;			ips_enter(padapter);									ips_leave(padapter);	if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)	{		_restore_network_status(padapter);		_restore_security_setting(padapter);		}		if(pmlmepriv->fw_state & _FW_UNDER_SURVEY)					pmlmepriv->fw_state ^= _FW_UNDER_SURVEY;		if(pmlmepriv->fw_state & _FW_UNDER_LINKING) 				pmlmepriv->fw_state ^= _FW_UNDER_LINKING;			psrtpriv->silent_reset_inprogress = _FALSE;	_exit_critical_mutex(&psrtpriv->silentreset_mutex, &irqL);			tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);	_set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);						if (netif_queue_stopped(padapter->pnetdev))		netif_wake_queue(padapter->pnetdev);	}

/*	========================================================================	Routine Description:		This routine process Rx Irp and call rx complete function.	Arguments:		DeviceObject	Pointer to the device object for next lower						device. DeviceObject passed in here belongs to						the next lower driver in the stack because we						were invoked via IoCallDriver in USB_RxPacket						AND it is not OUR device object	  Irp				Ptr to completed IRP	  Context			Ptr to our Adapter object (context specified						in IoSetCompletionRoutine	Return Value:		Always returns STATUS_MORE_PROCESSING_REQUIRED	Note:		Always returns STATUS_MORE_PROCESSING_REQUIRED	========================================================================*/VOID RTUSBBulkRxComplete(purbb_t pUrb, struct pt_regs *pt_regs){	// use a receive tasklet to handle received packets;	// or sometimes hardware IRQ will be disabled here, so we can not	// use spin_lock_bh()/spin_unlock_bh() after IRQ is disabled. :<	PRX_CONTEXT		pRxContext;	PRTMP_ADAPTER	pAd;	POS_COOKIE 		pObj;	pRxContext	= (PRX_CONTEXT)pUrb->context;	pAd 		= pRxContext->pAd;	pObj 		= (POS_COOKIE) pAd->OS_Cookie;	pObj->rx_done_task.data = (unsigned long)pUrb;	tasklet_hi_schedule(&pObj->rx_done_task);}

VOID RTUSBBulkOutMLMEPacketComplete(purbb_t pUrb, struct pt_regs *pt_regs){	PTX_CONTEXT			pMLMEContext;	PRTMP_ADAPTER		pAd;	NTSTATUS			Status;	POS_COOKIE 			pObj;	int					index;	//DBGPRINT_RAW(RT_DEBUG_INFO, ("--->RTUSBBulkOutMLMEPacketComplete/n"));	pMLMEContext	= (PTX_CONTEXT)pUrb->context;	pAd 			= pMLMEContext->pAd;	pObj 			= (POS_COOKIE)pAd->OS_Cookie;	Status			= pUrb->status;	index 			= pMLMEContext->SelfIdx;	pObj->mgmt_dma_done_task.data = (unsigned long)pUrb;	tasklet_hi_schedule(&pObj->mgmt_dma_done_task);}

void RTUSBBulkOutMLMEPacketComplete(struct urb *pUrb, struct pt_regs * pt_regs){	struct rt_tx_context *pMLMEContext;	struct rt_rtmp_adapter *pAd;	int Status;	struct os_cookie *pObj;	int index;	/*DBGPRINT_RAW(RT_DEBUG_INFO, ("--->RTUSBBulkOutMLMEPacketComplete/n")); */	pMLMEContext = (struct rt_tx_context *)pUrb->context;	pAd = pMLMEContext->pAd;	pObj = (struct os_cookie *)pAd->OS_Cookie;	Status = pUrb->status;	index = pMLMEContext->SelfIdx;	pObj->mgmt_dma_done_task.data = (unsigned long)pUrb;	tasklet_hi_schedule(&pObj->mgmt_dma_done_task);}

VOID AndesBhSchedule(RTMP_ADAPTER *ad){	struct MCU_CTRL *ctl = &ad->MCUCtrl;	if (!OS_TEST_BIT(MCU_INIT, &ctl->flags))		return;	if (((AndesQueueLen(ctl, &ctl->rx_doneq) > 0)							|| (AndesQueueLen(ctl, &ctl->tx_doneq) > 0))							&& OS_TEST_BIT(MCU_INIT, &ctl->flags)) {#ifndef WORKQUEUE_BH		RTMP_NET_TASK_DATA_ASSIGN(&ctl->cmd_msg_task, (unsigned long)(ad));		RTMP_OS_TASKLET_SCHE(&ctl->cmd_msg_task);#else		tasklet_hi_schedule(&ctl->cmd_msg_task);#endif	}}

void jit_tasklet_fn(unsigned long arg){	struct jit_data *data = (struct jit_data *)arg;	unsigned long j = jiffies;	seq_printf(data->s, "%9li  %3li     %i    %6i   %i   %s/n",		     j, j - data->prevjiffies, in_interrupt() ? 1 : 0,		     current->pid, smp_processor_id(), current->comm);	if (--data->loops) {		data->prevjiffies = j;		if (data->hi)			tasklet_hi_schedule(&data->tlet);		else			tasklet_schedule(&data->tlet);	} else {		wake_up_interruptible(&data->wait);	}}

static irqreturn_t qtnf_pcie_pearl_interrupt(int irq, void *data){	struct qtnf_bus *bus = (struct qtnf_bus *)data;	struct qtnf_pcie_pearl_state *ps = get_bus_priv(bus);	struct qtnf_pcie_bus_priv *priv = &ps->base;	u32 status;	priv->pcie_irq_count++;	status = readl(PCIE_HDP_INT_STATUS(ps->pcie_reg_base));	qtnf_shm_ipc_irq_handler(&priv->shm_ipc_ep_in);	qtnf_shm_ipc_irq_handler(&priv->shm_ipc_ep_out);	if (!(status & ps->pcie_irq_mask))		goto irq_done;	if (status & PCIE_HDP_INT_RX_BITS)		ps->pcie_irq_rx_count++;	if (status & PCIE_HDP_INT_TX_BITS)		ps->pcie_irq_tx_count++;	if (status & PCIE_HDP_INT_HHBM_UF)		ps->pcie_irq_uf_count++;	if (status & PCIE_HDP_INT_RX_BITS) {		qtnf_dis_rxdone_irq(ps);		napi_schedule(&bus->mux_napi);	}	if (status & PCIE_HDP_INT_TX_BITS) {		qtnf_dis_txdone_irq(ps);		tasklet_hi_schedule(&priv->reclaim_tq);	}irq_done:	/* H/W workaround: clean all bits, not only enabled */	qtnf_non_posted_write(~0U, PCIE_HDP_INT_STATUS(ps->pcie_reg_base));	if (!priv->msi_enabled)		qtnf_deassert_intx(ps);	return IRQ_HANDLED;}

/*	========================================================================	Routine Description:	Arguments:		Adapter 	Pointer to our adapter. Dequeue all power safe delayed braodcast frames after beacon.	IRQL = DISPATCH_LEVEL		========================================================================*/VOID	RTMPHandleTBTTInterrupt(	IN PRTMP_ADAPTER pAd){#ifdef CONFIG_AP_SUPPORT	POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;	if (pAd->OpMode == OPMODE_AP)	{		ReSyncBeaconTime(pAd);#ifdef WORKQUEUE_BH			schedule_work(&pObj->tbtt_work);#else		tasklet_hi_schedule(&pObj->tbtt_task);#endif // WORKQUEUE_BH //		if ((pAd->CommonCfg.Channel > 14)			&& (pAd->CommonCfg.bIEEE80211H == 1)			&& (pAd->CommonCfg.RadarDetect.RDMode == RD_SWITCHING_MODE))		{			DBGPRINT(RT_DEBUG_TRACE, ("RTMPHandlePreTBTTInterrupt::Channel Switching...(%d/%d)/n", pAd->CommonCfg.RadarDetect.CSCount, pAd->CommonCfg.RadarDetect.CSPeriod));						pAd->CommonCfg.RadarDetect.CSCount++;			if (pAd->CommonCfg.RadarDetect.CSCount >= pAd->CommonCfg.RadarDetect.CSPeriod)			{#ifdef DFS_HARDWARE_SUPPORT				pAd->CommonCfg.DFSAPRestart=1;				schedule_dfs_task(pAd);#else				APStop(pAd);				APStartUp(pAd);#endif // DFS_HARDWARE_SUPPORT //			}		}	}	else#endif // CONFIG_AP_SUPPORT //	{		if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE))		{		}	}}

static void smd_net_notify(void *_dev, unsigned event){	struct rmnet_private *p = netdev_priv((struct net_device *)_dev);	if (event != SMD_EVENT_DATA)		return;	spin_lock(&p->lock);	if (p->skb && (smd_write_avail(p->ch) >= p->skb->len))		tasklet_hi_schedule(&p->tsklt);	spin_unlock(&p->lock);	if (smd_read_avail(p->ch) &&	    (smd_read_avail(p->ch) >= smd_cur_packet_size(p->ch))) {		smd_net_data_tasklet.data = (unsigned long) _dev;		tasklet_schedule(&smd_net_data_tasklet);	}}

/* the /proc function: allocate everything to allow concurrency */int jit_tasklet(char *buf, char **start, off_t offset,	      int len, int *eof, void *arg){	struct jit_data *data;	char *buf2 = buf;	unsigned long j = jiffies;	long hi = (long)arg;	data = kmalloc(sizeof(*data), GFP_KERNEL);	if (!data)		return -ENOMEM;	init_waitqueue_head (&data->wait);	/* write the first lines in the buffer */	buf2 += sprintf(buf2, "   time   delta  inirq    pid   cpu command/n");	buf2 += sprintf(buf2, "%9li  %3li     %i    %6i   %i   %s/n",			j, 0L, in_interrupt() ? 1 : 0,			current->pid, smp_processor_id(), current->comm);	/* fill the data for our tasklet function */	data->prevjiffies = j;	data->buf = buf2;	data->loops = JIT_ASYNC_LOOPS;		/* register the tasklet */	tasklet_init(&data->tlet, jit_tasklet_fn, (unsigned long)data);	data->hi = hi;	if (hi)		tasklet_hi_schedule(&data->tlet);	else		tasklet_schedule(&data->tlet);	/* wait for the buffer to fill */	wait_event_interruptible(data->wait, !data->loops);	if (signal_pending(current))		return -ERESTARTSYS;	buf2 = data->buf;	kfree(data);	*eof = 1;	return buf2 - buf;}

static irqreturn_t rt2400pci_interrupt(int irq, void *dev_instance){	struct rt2x00_dev *rt2x00dev = dev_instance;	u32 reg, mask;	rt2x00pci_register_read(rt2x00dev, CSR7, &reg);	rt2x00pci_register_write(rt2x00dev, CSR7, reg);	if (!reg)		return IRQ_NONE;	if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))		return IRQ_HANDLED;	mask = reg;	if (rt2x00_get_field32(reg, CSR7_TBCN_EXPIRE))		tasklet_hi_schedule(&rt2x00dev->tbtt_tasklet);	if (rt2x00_get_field32(reg, CSR7_RXDONE))		tasklet_schedule(&rt2x00dev->rxdone_tasklet);	if (rt2x00_get_field32(reg, CSR7_TXDONE_ATIMRING) ||	    rt2x00_get_field32(reg, CSR7_TXDONE_PRIORING) ||	    rt2x00_get_field32(reg, CSR7_TXDONE_TXRING)) {		tasklet_schedule(&rt2x00dev->txstatus_tasklet);		rt2x00_set_field32(&mask, CSR8_TXDONE_TXRING, 1);		rt2x00_set_field32(&mask, CSR8_TXDONE_ATIMRING, 1);		rt2x00_set_field32(&mask, CSR8_TXDONE_PRIORING, 1);	}	spin_lock(&rt2x00dev->irqmask_lock);	rt2x00pci_register_read(rt2x00dev, CSR8, &reg);	reg |= mask;	rt2x00pci_register_write(rt2x00dev, CSR8, reg);	spin_unlock(&rt2x00dev->irqmask_lock);	return IRQ_HANDLED;}

s32	 rtl8812au_hal_xmitframe_enqueue(_adapter *padapter, struct xmit_frame *pxmitframe){	struct xmit_priv 	*pxmitpriv = &padapter->xmitpriv;	s32 err;		if ((err=rtw_xmitframe_enqueue(padapter, pxmitframe)) != _SUCCESS) 	{		rtw_free_xmitframe(pxmitpriv, pxmitframe);		pxmitpriv->tx_drop++;						}	else	{		tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);	}		return err;	}

/* Ethernet Tx DMA interrupt */static irqreturn_trc32434_tx_dma_interrupt(int irq, void *dev_id){	struct net_device *dev = (struct net_device *)dev_id;	struct rc32434_local *lp;	volatile u32 dmas,dmasm;	irqreturn_t retval;		ASSERT(dev != NULL);		lp = (struct rc32434_local *)dev->priv;		spin_lock(&lp->lock);		dmas = __raw_readl(&lp->tx_dma_regs->dmas);		if (dmas & (DMAS_f_m | DMAS_e_m)) {		dmasm = __raw_readl(&lp->tx_dma_regs->dmasm);		/* Mask F E bit in Tx DMA */		__raw_writel(dmasm | (DMASM_f_m | DMASM_e_m), &lp->tx_dma_regs->dmasm);				tasklet_hi_schedule(lp->tx_tasklet);				if(lp->tx_chain_status == filled && (__raw_readl(&(lp->tx_dma_regs->dmandptr)) == 0)) {			__raw_writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]), &(lp->tx_dma_regs->dmandptr));						lp->tx_chain_status = empty;			lp->tx_chain_head = lp->tx_chain_tail;			dev->trans_start = jiffies;		}				if (dmas & DMAS_e_m)			ERR(": DMA error/n");				retval = IRQ_HANDLED;	}	else		retval = IRQ_NONE;		spin_unlock(&lp->lock);		return retval;}

void omap_mmc_notify_cover_event(struct device *dev, int num, int is_closed){	int cover_open;	struct mmc_omap_host *host = dev_get_drvdata(dev);	struct mmc_omap_slot *slot = host->slots[num];	BUG_ON(num >= host->nr_slots);	/* Other subsystems can call in here before we're initialised. */	if (host->nr_slots == 0 || !host->slots[num])		return;	cover_open = mmc_omap_cover_is_open(slot);	if (cover_open != slot->cover_open) {		slot->cover_open = cover_open;		sysfs_notify(&slot->mmc->class_dev.kobj, NULL, "cover_switch");	}	tasklet_hi_schedule(&slot->cover_tasklet);}