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

static uint32_t send_cmd_to_user(uint32_t command_id){    uint32_t ret = TUI_DCI_ERR_NO_RESPONSE;    /* Init shared variables */    g_cmd_id = command_id;    g_user_rsp.id = TLC_TUI_CMD_NONE;    g_user_rsp.return_code = TLC_TUI_ERR_UNKNOWN_CMD;    /* S.LSI : Clean up previous response. */    complete_all(&io_comp);    INIT_COMPLETION(io_comp);    /* Give way to ioctl thread */    complete(&dci_comp);    pr_debug("send_cmd_to_user: give way to ioctl thread/n");    /* Wait for ioctl thread to complete */    wait_for_completion_interruptible(&io_comp);    pr_debug("send_cmd_to_user: Got an answer from ioctl thread./n");    INIT_COMPLETION(io_comp);    /* Check id of the cmd processed by ioctl thread (paranoia) */    if (g_user_rsp.id != command_id) {        pr_debug("ERROR %s: Wrong response id 0x%08x iso 0x%08x/n",                 __func__, dci->nwd_rsp.id, RSP_ID(command_id));        ret = TUI_DCI_ERR_INTERNAL_ERROR;    } else {        /* retrieve return code */        switch (g_user_rsp.return_code) {        case TLC_TUI_OK:            ret = TUI_DCI_OK;            break;        case TLC_TUI_ERROR:            ret = TUI_DCI_ERR_INTERNAL_ERROR;            break;        case TLC_TUI_ERR_UNKNOWN_CMD:            ret = TUI_DCI_ERR_UNKNOWN_CMD;            break;        }    }    return ret;}

/** * Read charge-current via ADC. * * The ISL CCMON (charge-current-monitor) pin is connected to * the PMIC MPP#X pin. * This not required when notify_by_pmic is used where the PMIC * uses BMS to notify the ISL on charging-done / charge-resume. */static int isl_read_adc(int channel, int *mv_reading){	int ret;	void *h;	struct adc_chan_result adc_chan_result;	struct completion  conv_complete_evt;	pr_debug("called for %d/n", channel);	ret = adc_channel_open(channel, &h);	if (ret) {		pr_err("couldnt open channel %d ret=%d/n", channel, ret);		goto out;	}	init_completion(&conv_complete_evt);	ret = adc_channel_request_conv(h, &conv_complete_evt);	if (ret) {		pr_err("couldnt request conv channel %d ret=%d/n",						channel, ret);		goto out;	}	ret = wait_for_completion_interruptible(&conv_complete_evt);	if (ret) {		pr_err("wait interrupted channel %d ret=%d/n", channel, ret);		goto out;	}	ret = adc_channel_read_result(h, &adc_chan_result);	if (ret) {		pr_err("couldnt read result channel %d ret=%d/n",						channel, ret);		goto out;	}	ret = adc_channel_close(h);	if (ret)		pr_err("couldnt close channel %d ret=%d/n", channel, ret);	if (mv_reading)		*mv_reading = (int)adc_chan_result.measurement;	pr_debug("done for %d/n", channel);	return adc_chan_result.physical;out:	*mv_reading = 0;	pr_debug("done with error for %d/n", channel);	return -EINVAL;}

static int exec_test_job(struct device *ksdev, u32 *jobdesc){	struct exec_test_result testres;	struct caam_drv_private_sm *kspriv;	int rtn = 0;	kspriv = dev_get_drvdata(ksdev);	init_completion(&testres.completion);	rtn = caam_jr_enqueue(kspriv->smringdev, jobdesc, exec_test_done,			      &testres);	if (!rtn) {		wait_for_completion_interruptible(&testres.completion);		rtn = testres.error;	}	return rtn;}

static long cptest_ioctl(struct file *filp,unsigned int cmd,unsigned long arg){	printk("%s,Enter/n",__func__);	switch(cmd){	case WAIT_FOR_CP:		printk("%s, wait_for_completion./n",__func__);		wait_for_completion_interruptible(&cp_dev->cp_completion);		break;	case COMPLETE_CP:		printk("%s, wake_up_completion./n",__func__);		complete(&cp_dev->cp_completion);		break;	default:		pr_err("%s, illegal cmd./n",__func__);		return -ENOIOCTLCMD;	}	return 0;}

int wlan_logging_sock_deactivate_svc(void){	nl_srv_unregister(ANI_NL_MSG_LOG, wlan_logging_proc_sock_rx_msg);	clear_default_logtoapp_log_level();	gapp_pid = INVALID_PID;	gwlan_logging.exit = true;	INIT_COMPLETION(gwlan_logging.shutdown_comp);	wake_up_interruptible(&gwlan_logging.wait_queue);	wait_for_completion_interruptible(&gwlan_logging.shutdown_comp);	vfree(gplog_msg);	pr_info("%s: Deactivate wlan_logging svc/n", __func__);	return 0;}

static void switch_work_f(struct work_struct *work){#if 0	int rc, i;	u32 res = 0;	struct adc_chan_result adc_result;	struct pm8058_othc *dd =		container_of(work, struct pm8058_othc, switch_work);	DECLARE_COMPLETION_ONSTACK(adc_wait);	u8 num_adc_samples = dd->switch_config->num_adc_samples;	/* sleep for settling time */	msleep(dd->switch_config->voltage_settling_time_ms);	for (i = 0; i < num_adc_samples; i++) {		rc = adc_channel_request_conv(dd->adc_handle, &adc_wait);		if (rc) {			pr_err("adc_channel_request_conv failed/n");			goto bail_out;		}		rc = wait_for_completion_interruptible(&adc_wait);		if (rc) {			pr_err("wait_for_completion_interruptible failed/n");			goto bail_out;		}		rc = adc_channel_read_result(dd->adc_handle, &adc_result);		if (rc) {			pr_err("adc_channel_read_result failed/n");			goto bail_out;		}		res += adc_result.physical;	}bail_out:	if (i == num_adc_samples && num_adc_samples != 0) {		res /= num_adc_samples;		othc_report_switch(dd, res);	} else		pr_err("Insufficient ADC samples/n");	enable_irq(dd->othc_irq_sw);#endif      }

static int pwm_ir_tx_transmit_with_timer(struct pwm_ir_packet *pkt){    int rc = 0;    init_completion(&pkt->done);    hrtimer_init(&pkt->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);    pkt->timer.function = pwm_ir_tx_timer;    hrtimer_start(&pkt->timer, ns_to_ktime(0), HRTIMER_MODE_REL);    rc = wait_for_completion_interruptible(&pkt->done);    if (rc != 0) { /* signal exit immediately */        pkt->abort = true;        wait_for_completion(&pkt->done);    }    return pkt->next ? : -ERESTARTSYS;}

static intgpio_pwm_stop_sync(struct pwm_channel *p){    struct gpio_pwm *gp = to_gpio_pwm(p);    int ret;    int was_on = hrtimer_active(&gp->timer);    if (was_on) {        do {            init_completion(&p->complete);            set_bit(FLAG_STOP, &p->flags);            ret = wait_for_completion_interruptible(&p->complete);            if (ret)                return ret;        } while (p->flags & BIT(FLAG_STOP));    }    return was_on;}

static int target_xcopy_issue_pt_cmd(struct xcopy_pt_cmd *xpt_cmd){	struct se_cmd *se_cmd = &xpt_cmd->se_cmd;	sense_reason_t sense_rc;	sense_rc = transport_generic_new_cmd(se_cmd);	if (sense_rc)		return -EINVAL;	if (se_cmd->data_direction == DMA_TO_DEVICE)		target_execute_cmd(se_cmd);	wait_for_completion_interruptible(&xpt_cmd->xpt_passthrough_sem);	pr_debug("target_xcopy_issue_pt_cmd(): SCSI status: 0x%02x/n",			se_cmd->scsi_status);	return (se_cmd->scsi_status) ? -EINVAL : 0;}

int tlc_wait_cmd(uint32_t *cmd_id){    /* Create the TlcTui Main thread and start secure driver (only       1st time) */    if (dr_session_handle.session_id == 0) {        thread_id = kthread_run(main_thread, NULL, "dci_thread");        if (!thread_id) {            pr_debug(KERN_ERR "Unable to start Trusted UI main thread/n");            return -EFAULT;        }    }    /* Wait for signal from DCI handler */    /* In case of an interrupted sys call, return with -EINTR */    wait_for_completion_interruptible(&dci_comp);    INIT_COMPLETION(dci_comp);    *cmd_id = g_cmd_id;    return 0;}

static int erase_write (struct mtd_info *mtd, unsigned long pos,			int len, const char *buf){	struct erase_info erase = {};	DECLARE_COMPLETION(erase_completion);	size_t retlen;	int ret;	/*	 * First, let's erase the flash block.	 */	erase.mtd = mtd;	erase.priv = (u_long)&erase_completion;	erase.callback = erase_callback;	erase.addr = pos;	erase.len = len;	ret = mtd->erase(mtd, &erase);	if (ret) {		printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] "				     "on /"%s/" failed/n",			pos, len, mtd->name);		return ret;	}	wait_for_completion_interruptible(&erase_completion);	/*	 * Next, writhe data to flash.	 */	ret = mtd->write(mtd, pos, len, &retlen, buf);	if (ret)		return ret;	if (retlen != len)		return -EIO;	return 0;}

static uint32_t sendCmdToUser(uint32_t commandId){	dciReturnCode_t ret = TUI_DCI_ERR_NO_RESPONSE;	/* Init shared variables */	gCmdId = commandId;	gUserRsp.id = TLC_TUI_CMD_NONE;	gUserRsp.returnCode = TLC_TUI_ERR_UNKNOWN_CMD;		/* Give way to ioctl thread */	complete(&dciComp);	pr_debug("sendCmdToUser: give way to ioctl thread/n");	/* Wait for ioctl thread to complete */	wait_for_completion_interruptible(&ioComp);	pr_debug("sendCmdToUser: Got an answer from ioctl thread./n");	INIT_COMPLETION(ioComp);	/* Check id of the cmd processed by ioctl thread (parano
C++ wait_for_completion_interruptible_timeout函数代码示例
C++ wait_for_completion函数代码示例