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

static int32_t vqec_reader_start (test_vqec_reader_params_t *p){    struct completion wait_reader_spawned;    struct in_addr src, dst;    uint16_t port;    int tunerid;    uint32_t use_iobufs;    uint32_t use_iobuf_size;    int32_t use_timeout;    struct socket *sk;    start_params_t params;    if (!p) {        return (0);    }    if (p->use_module_params) {        /* use the values from the module params */        src.s_addr = in_aton(src_ipaddr);        dst.s_addr = in_aton(dest_ipaddr);        if (!src.s_addr || !dst.s_addr) {            printk("test_reader: failed to parse src/dest addresses/n");            return (0);        }        port = dest_port;        tunerid = cp_tuner_id;        use_iobufs = iobufs;        use_iobuf_size = iobuf_size;        use_timeout = timeout;    } else {        /* use the values from argument params */        src.s_addr = p->srcaddr;        dst.s_addr = p->dstaddr;        port = p->dstport;        tunerid = p->tid;        use_iobufs = p->iobufs;        use_iobuf_size = p->iobuf_size;        use_timeout = p->timeout;        if (!port) {            /* use default port if none specified */            port = dest_port;        }    }    if (!src.s_addr || !dst.s_addr) {        sk = NULL;    } else {        sk = udp_tx_sock_create(src, htons(port), dst, 0);        if (!sk) {            printk("test_reader: failed to create socket/n");            return (0);        }    }    if (s_reader_task_running) {        return (-1);    }    s_reader_task_running = TRUE;    params.sk = sk;    params.cp_tuner_id = tunerid;    params.completion = &wait_reader_spawned;    params.iobufs = use_iobufs;    params.iobuf_size = use_iobuf_size;    params.timeout = use_timeout;    init_completion(&wait_reader_spawned);    s_reader_task = kernel_thread(vqec_reader_loop,                                   &params,                                   0);    if (s_reader_task >= 0) {        wait_for_completion(&wait_reader_spawned);    }    return (0);}

static void tsc210x_wait_data(struct tsc210x_dev *dev){	wait_for_completion(&dev->data_avail);	tsc210x_data_report(dev);}

static int pm8001_update_flash(struct pm8001_hba_info *pm8001_ha){	struct pm8001_ioctl_payload	*payload;	DECLARE_COMPLETION_ONSTACK(completion);	u8		*ioctlbuffer = NULL;	u32		length = 0;	struct fw_control_info	*fwControl;	u32		loopNumber, loopcount = 0;	u32		sizeRead = 0;	u32		partitionSize, partitionSizeTmp;	u32		ret = 0;	u32		partitionNumber = 0;	struct pm8001_fw_image_header *image_hdr;	length = 1024 * 16 + sizeof(*payload) - 1;	ioctlbuffer = kzalloc(length, GFP_KERNEL);	image_hdr = (struct pm8001_fw_image_header *)pm8001_ha->fw_image->data;	if (!ioctlbuffer)		return -ENOMEM;	if (pm8001_ha->fw_image->size < 28) {		ret = FAIL_FILE_SIZE;		goto out;	}	while (sizeRead < pm8001_ha->fw_image->size) {		partitionSizeTmp =			*(u32 *)((u8 *)&image_hdr->image_length + sizeRead);		partitionSize = be32_to_cpu(partitionSizeTmp);		loopcount = (partitionSize + HEADER_LEN)/IOCTL_BUF_SIZE;		if (loopcount % IOCTL_BUF_SIZE)			loopcount++;		if (loopcount == 0)			loopcount++;		for (loopNumber = 0; loopNumber < loopcount; loopNumber++) {			payload = (struct pm8001_ioctl_payload *)ioctlbuffer;			payload->length = 1024*16;			payload->id = 0;			fwControl =			      (struct fw_control_info *)payload->func_specific;			fwControl->len = IOCTL_BUF_SIZE;   /* IN */			fwControl->size = partitionSize + HEADER_LEN;/* IN */			fwControl->retcode = 0;/* OUT */			fwControl->offset = loopNumber * IOCTL_BUF_SIZE;/*OUT */		/* for the last chunk of data in case file size is not even with		4k, load only the rest*/		if (((loopcount-loopNumber) == 1) &&			((partitionSize + HEADER_LEN) % IOCTL_BUF_SIZE)) {			fwControl->len =				(partitionSize + HEADER_LEN) % IOCTL_BUF_SIZE;			memcpy((u8 *)fwControl->buffer,				(u8 *)pm8001_ha->fw_image->data + sizeRead,				(partitionSize + HEADER_LEN) % IOCTL_BUF_SIZE);			sizeRead +=				(partitionSize + HEADER_LEN) % IOCTL_BUF_SIZE;		} else {			memcpy((u8 *)fwControl->buffer,				(u8 *)pm8001_ha->fw_image->data + sizeRead,				IOCTL_BUF_SIZE);			sizeRead += IOCTL_BUF_SIZE;		}		pm8001_ha->nvmd_completion = &completion;		ret = PM8001_CHIP_DISP->fw_flash_update_req(pm8001_ha, payload);		wait_for_completion(&completion);		if (ret || (fwControl->retcode > FLASH_UPDATE_IN_PROGRESS)) {			ret = fwControl->retcode;			kfree(ioctlbuffer);			ioctlbuffer = NULL;			break;		}	}	if (ret)		break;	partitionNumber++;}out:	kfree(ioctlbuffer);	return ret;}

static int usb_send(struct link_device *ld, struct io_device *iod,			struct sk_buff *skb){	struct sk_buff_head *txq;	size_t tx_size;	struct usb_link_device *usb_ld = to_usb_link_device(ld);	struct link_pm_data *pm_data = usb_ld->link_pm_data;	switch (iod->format) {	case IPC_RAW:		txq = &ld->sk_raw_tx_q;		if (unlikely(ld->raw_tx_suspended)) {			/* Unlike misc_write, vnet_xmit is in interrupt.			 * Despite call netif_stop_queue on CMD_SUSPEND,			 * packets can be reached here.			 */			if (in_irq()) {				mif_err("raw tx is suspended, "						"drop packet. size=%d",						skb->len);				return -EBUSY;			}			mif_err("wait RESUME CMD.../n");			INIT_COMPLETION(ld->raw_tx_resumed_by_cp);			wait_for_completion(&ld->raw_tx_resumed_by_cp);			mif_err("resumed done./n");		}		break;	case IPC_BOOT:	case IPC_FMT:	case IPC_RFS:	default:		txq = &ld->sk_fmt_tx_q;		break;	}	/* store the tx size before run the tx_delayed_work*/	tx_size = skb->len;	/* drop packet, when link is not online */	if (ld->com_state == COM_BOOT && iod->format != IPC_BOOT) {		mif_err("%s: drop packet, size=%d, com_state=%d/n",				iod->name, skb->len, ld->com_state);		dev_kfree_skb_any(skb);		return 0;	}	/* en queue skb data */	skb_queue_tail(txq, skb);	/* Hold wake_lock for getting schedule the tx_work */#ifdef CONFIG_HAS_WAKELOCK	wake_lock(&pm_data->tx_async_wake);#else	pm_stay_awake(pm_data->miscdev.this_device);#endif	if (!work_pending(&ld->tx_delayed_work.work))		queue_delayed_work(ld->tx_wq, &ld->tx_delayed_work, 0);	return tx_size;}

static int xilinx_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t){	struct xilinx_spi *xspi = spi_master_get_devdata(spi->master);	u32 ipif_ier;	/* We get here with transmitter inhibited */	xspi->tx_ptr = t->tx_buf;	xspi->rx_ptr = t->rx_buf;	xspi->remaining_bytes = t->len;	INIT_COMPLETION(xspi->done);	/* Enable the transmit empty interrupt, which we use to determine	 * progress on the transmission.	 */	ipif_ier = xspi->read_fn(xspi->regs + XIPIF_V123B_IIER_OFFSET);	xspi->write_fn(ipif_ier | XSPI_INTR_TX_EMPTY,		xspi->regs + XIPIF_V123B_IIER_OFFSET);	for (;;) {		u16 cr;		u8 sr;		xilinx_spi_fill_tx_fifo(xspi);		/* Start the transfer by not inhibiting the transmitter any		 * longer		 */		cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET) &							~XSPI_CR_TRANS_INHIBIT;		xspi->write_fn(cr, xspi->regs + XSPI_CR_OFFSET);		wait_for_completion(&xspi->done);		/* A transmit has just completed. Process received data and		 * check for more data to transmit. Always inhibit the		 * transmitter while the Isr refills the transmit register/FIFO,		 * or make sure it is stopped if we're done.		 */		cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET);		xspi->write_fn(cr | XSPI_CR_TRANS_INHIBIT,			       xspi->regs + XSPI_CR_OFFSET);		/* Read out all the data from the Rx FIFO */		sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);		while ((sr & XSPI_SR_RX_EMPTY_MASK) == 0) {			xspi->rx_fn(xspi);			sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);		}		/* See if there is more data to send */		if (xspi->remaining_bytes <= 0)			break;	}	/* Disable the transmit empty interrupt */	xspi->write_fn(ipif_ier, xspi->regs + XIPIF_V123B_IIER_OFFSET);	return t->len - xspi->remaining_bytes;}

/** * ext4_fname_encrypt() - * * This function encrypts the input filename, and returns the length of the * ciphertext. Errors are returned as negative numbers.  We trust the caller to * allocate sufficient memory to oname string. */static int ext4_fname_encrypt(struct inode *inode,			      const struct qstr *iname,			      struct ext4_str *oname){	u32 ciphertext_len;	struct skcipher_request *req = NULL;	DECLARE_EXT4_COMPLETION_RESULT(ecr);	struct ext4_crypt_info *ci = EXT4_I(inode)->i_crypt_info;	struct crypto_skcipher *tfm = ci->ci_ctfm;	int res = 0;	char iv[EXT4_CRYPTO_BLOCK_SIZE];	struct scatterlist src_sg, dst_sg;	int padding = 4 << (ci->ci_flags & EXT4_POLICY_FLAGS_PAD_MASK);	char *workbuf, buf[32], *alloc_buf = NULL;	unsigned lim = max_name_len(inode);	if (iname->len <= 0 || iname->len > lim)		return -EIO;	ciphertext_len = (iname->len < EXT4_CRYPTO_BLOCK_SIZE) ?		EXT4_CRYPTO_BLOCK_SIZE : iname->len;	ciphertext_len = ext4_fname_crypto_round_up(ciphertext_len, padding);	ciphertext_len = (ciphertext_len > lim)			? lim : ciphertext_len;	if (ciphertext_len <= sizeof(buf)) {		workbuf = buf;	} else {		alloc_buf = kmalloc(ciphertext_len, GFP_NOFS);		if (!alloc_buf)			return -ENOMEM;		workbuf = alloc_buf;	}	/* Allocate request */	req = skcipher_request_alloc(tfm, GFP_NOFS);	if (!req) {		printk_ratelimited(		    KERN_ERR "%s: crypto_request_alloc() failed/n", __func__);		kfree(alloc_buf);		return -ENOMEM;	}	skcipher_request_set_callback(req,		CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,		ext4_dir_crypt_complete, &ecr);	/* Copy the input */	memcpy(workbuf, iname->name, iname->len);	if (iname->len < ciphertext_len)		memset(workbuf + iname->len, 0, ciphertext_len - iname->len);	/* Initialize IV */	memset(iv, 0, EXT4_CRYPTO_BLOCK_SIZE);	/* Create encryption request */	sg_init_one(&src_sg, workbuf, ciphertext_len);	sg_init_one(&dst_sg, oname->name, ciphertext_len);	skcipher_request_set_crypt(req, &src_sg, &dst_sg, ciphertext_len, iv);	res = crypto_skcipher_encrypt(req);	if (res == -EINPROGRESS || res == -EBUSY) {		wait_for_completion(&ecr.completion);		res = ecr.res;	}	kfree(alloc_buf);	skcipher_request_free(req);	if (res < 0) {		printk_ratelimited(		    KERN_ERR "%s: Error (error code %d)/n", __func__, res);	}	oname->len = ciphertext_len;	return res;}

static int join(struct mddev *mddev, int nodes){	struct md_cluster_info *cinfo;	int ret, ops_rv;	char str[64];	cinfo = kzalloc(sizeof(struct md_cluster_info), GFP_KERNEL);	if (!cinfo)		return -ENOMEM;	INIT_LIST_HEAD(&cinfo->suspend_list);	spin_lock_init(&cinfo->suspend_lock);	init_completion(&cinfo->completion);	set_bit(MD_CLUSTER_BEGIN_JOIN_CLUSTER, &cinfo->state);	init_waitqueue_head(&cinfo->wait);	mutex_init(&cinfo->recv_mutex);	mddev->cluster_info = cinfo;	memset(str, 0, 64);	sprintf(str, "%pU", mddev->uuid);	ret = dlm_new_lockspace(str, mddev->bitmap_info.cluster_name,				DLM_LSFL_FS, LVB_SIZE,				&md_ls_ops, mddev, &ops_rv, &cinfo->lockspace);	if (ret)		goto err;	wait_for_completion(&cinfo->completion);	if (nodes < cinfo->slot_number) {		pr_err("md-cluster: Slot allotted(%d) is greater than available slots(%d).",			cinfo->slot_number, nodes);		ret = -ERANGE;		goto err;	}	/* Initiate the communication resources */	ret = -ENOMEM;	cinfo->recv_thread = md_register_thread(recv_daemon, mddev, "cluster_recv");	if (!cinfo->recv_thread) {		pr_err("md-cluster: cannot allocate memory for recv_thread!/n");		goto err;	}	cinfo->message_lockres = lockres_init(mddev, "message", NULL, 1);	if (!cinfo->message_lockres)		goto err;	cinfo->token_lockres = lockres_init(mddev, "token", NULL, 0);	if (!cinfo->token_lockres)		goto err;	cinfo->no_new_dev_lockres = lockres_init(mddev, "no-new-dev", NULL, 0);	if (!cinfo->no_new_dev_lockres)		goto err;	ret = dlm_lock_sync(cinfo->token_lockres, DLM_LOCK_EX);	if (ret) {		ret = -EAGAIN;		pr_err("md-cluster: can't join cluster to avoid lock issue/n");		goto err;	}	cinfo->ack_lockres = lockres_init(mddev, "ack", ack_bast, 0);	if (!cinfo->ack_lockres) {		ret = -ENOMEM;		goto err;	}	/* get sync CR lock on ACK. */	if (dlm_lock_sync(cinfo->ack_lockres, DLM_LOCK_CR))		pr_err("md-cluster: failed to get a sync CR lock on ACK!(%d)/n",				ret);	dlm_unlock_sync(cinfo->token_lockres);	/* get sync CR lock on no-new-dev. */	if (dlm_lock_sync(cinfo->no_new_dev_lockres, DLM_LOCK_CR))		pr_err("md-cluster: failed to get a sync CR lock on no-new-dev!(%d)/n", ret);	pr_info("md-cluster: Joined cluster %s slot %d/n", str, cinfo->slot_number);	snprintf(str, 64, "bitmap%04d", cinfo->slot_number - 1);	cinfo->bitmap_lockres = lockres_init(mddev, str, NULL, 1);	if (!cinfo->bitmap_lockres) {		ret = -ENOMEM;		goto err;	}	if (dlm_lock_sync(cinfo->bitmap_lockres, DLM_LOCK_PW)) {		pr_err("Failed to get bitmap lock/n");		ret = -EINVAL;		goto err;	}	cinfo->resync_lockres = lockres_init(mddev, "resync", NULL, 0);	if (!cinfo->resync_lockres) {		ret = -ENOMEM;		goto err;	}	return 0;err:	md_unregister_thread(&cinfo->recovery_thread);	md_unregister_thread(&cinfo->recv_thread);	lockres_free(cinfo->message_lockres);	lockres_free(cinfo->token_lockres);	lockres_free(cinfo->ack_lockres);	lockres_free(cinfo->no_new_dev_lockres);	lockres_free(cinfo->resync_lockres);	lockres_free(cinfo->bitmap_lockres);//.........这里部分代码省略.........

static int pm8xxx_tz_get_temp_pm8058_adc(struct thermal_zone_device *thermal,			      unsigned long *temp){	struct pm8xxx_tm_chip *chip = thermal->devdata;	DECLARE_COMPLETION_ONSTACK(wait);	struct adc_chan_result adc_result = {		.physical = 0lu,	};	int rc;	if (!chip || !temp)		return -EINVAL;	*temp = chip->temp;	rc = adc_channel_request_conv(chip->adc_handle, &wait);	if (rc < 0) {		pr_err("%s: adc_channel_request_conv() failed, rc = %d/n",			__func__, rc);		return rc;	}	wait_for_completion(&wait);	rc = adc_channel_read_result(chip->adc_handle, &adc_result);	if (rc < 0) {		pr_err("%s: adc_channel_read_result() failed, rc = %d/n",			__func__, rc);		return rc;	}	*temp = adc_result.physical;	chip->temp = adc_result.physical;	return 0;}static int pm8xxx_tz_get_temp_pm8xxx_adc(struct thermal_zone_device *thermal,				      unsigned long *temp){	struct pm8xxx_tm_chip *chip = thermal->devdata;	struct pm8xxx_adc_chan_result result = {		.physical = 0lu,	};	int rc;	if (!chip || !temp)		return -EINVAL;	*temp = chip->temp;	rc = pm8xxx_adc_read(chip->cdata.adc_channel, &result);	if (rc < 0) {		pr_err("%s: adc_channel_read_result() failed, rc = %d/n",			chip->cdata.tm_name, rc);		return rc;	}	*temp = result.physical;	chip->temp = result.physical;	return 0;}static int pm8xxx_tz_get_mode(struct thermal_zone_device *thermal,			      enum thermal_device_mode *mode){	struct pm8xxx_tm_chip *chip = thermal->devdata;	if (!chip || !mode)		return -EINVAL;	*mode = chip->mode;	return 0;}static int pm8xxx_tz_set_mode(struct thermal_zone_device *thermal,			      enum thermal_device_mode mode){	struct pm8xxx_tm_chip *chip = thermal->devdata;	if (!chip)		return -EINVAL;	/* Mask software override requests if they are not allowed. */	if (!chip->cdata.allow_software_override)		mode = THERMAL_DEVICE_DISABLED;	if (mode != chip->mode) {		if (mode == THERMAL_DEVICE_ENABLED)			pm8xxx_tm_shutdown_override(chip,						    SOFTWARE_OVERRIDE_ENABLED);		else			pm8xxx_tm_shutdown_override(chip,						    SOFTWARE_OVERRIDE_DISABLED);	}	chip->mode = mode;	return 0;//.........这里部分代码省略.........

//.........这里部分代码省略.........				*st_ssc->rx_ptr++ = tmp.bytes[0];			st_ssc->rx_bytes_pending--;		}	} else {		dgb_print("should only be one word in RX_FIFO"			  "(rx_fifo_status = %d)/n", rx_fifo_status);	}	return 0;}static int spi_stmssc_txrx_bufs(struct spi_device *spi, struct spi_transfer *t){	struct spi_stm_ssc *st_ssc;	dgb_print("/n");	st_ssc = spi_master_get_devdata(spi->master);	st_ssc->tx_ptr = t->tx_buf;	st_ssc->rx_ptr = t->rx_buf;	st_ssc->tx_bytes_pending = t->len;	st_ssc->rx_bytes_pending = t->len;	INIT_COMPLETION(st_ssc->done);	/* fill TX_FIFO */	spi_stmssc_fill_tx_fifo(st_ssc);	/* enable TX_FIFO_EMPTY interrupts */	ssc_store32(st_ssc, SSC_IEN, SSC_IEN_TIEN);	/* wait for all bytes to be transmitted*/	wait_for_completion(&st_ssc->done);	/* check 'last' byte has been received */	/* NOTE: need to read rxbuf, even if ignoring the result! */	if (st_ssc->rx_bytes_pending)		spi_stmssc_rx_mopup(st_ssc);	/* disable ints */	ssc_store32(st_ssc, SSC_IEN, 0x0);	return t->len - st_ssc->tx_bytes_pending;}static irqreturn_t spi_stmssc_irq(int irq, void *dev_id){	struct spi_stm_ssc *st_ssc = (struct spi_stm_ssc *)dev_id;	unsigned int rx_fifo_status;	u32 ssc_status;	union {		u8 bytes[4];		u32 dword;	} tmp = {.dword = 0,};	ssc_status = ssc_load32(st_ssc, SSC_STA);	/* FIFO_TX_EMPTY */	if (ssc_status & SSC_STA_TIR) {		/* Find number of words available in RX_FIFO: 8 if RX_FIFO_FULL,		   else SSC_RX_FSTAT (0-7)		*/

static ssize_t adg739_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos){	char buf_term[NUM_MULTIPLEXER];	//буфер, куда копируются сообщения из пользовательского пространства, и где они проходят предварительное форматирование	int status = 0;	int i =0;	struct spi_transfer t = {		//формируется передача			.tx_buf = adg739_status->buffer,			.len = NUM_MULTIPLEXER * 2,	};	struct spi_message	m;	// сообщение	DECLARE_COMPLETION_ONSTACK(done);	//объявляется и инициализуется условная переменная	//проверка на достоверность переданного буфера	if (count > NUM_MULTIPLEXER)		return (-EMSGSIZE);	if (copy_from_user(buf_term, buf, count))		return (-EFAULT);	for (i=0; i<count; i++)	{		switch(buf_term[i])		{		case 's':			buf_term[i] = 0x11;			break;		case 'v':			buf_term[i] = 0x82;			break;		case 'g':			buf_term[i] = 0x88;			break;		default:			return (-EINVAL);		}	}	//передача сообщения драйверу контроллера	mutex_lock(&device_lockk);	for (i=0; i<count; i++) {		adg739_status->buffer[i]= buf_term[i];		adg739_status->buffer[i+4]= buf_term[i];	}	spi_message_init(&m);	//инициализация сообщения	spi_message_add_tail(&t, &m);	//постановка передачи в очередь сообщения	m.complete = adg739_complete;	m.context = &done;	if (adg739_status->spi == NULL)		status = -ESHUTDOWN;	else	{		status = spi_async(adg739_status->spi, &m);	//передача сообщения		printk(KERN_INFO "Status function spi_async = %d/n", status);		}	if (status == 0) {		wait_for_completion(&done);	//ожидание обработки сообщения контроллером spi		status = m.status;		printk(KERN_INFO "Status message = %d/n", status);		if (status == 0)			status = m.actual_length/2;	}	mutex_unlock(&device_lockk);	return (status);}//ФУНКЦИИ СТРУКТУРЫ SPI_DRIVERstatic int	__devinit adg739_probe(struct spi_device *spi){	int status, dev;	//регистрация устройства	dev =device_create(devclass, &spi->dev, dev_adg739, NULL, MULTIPLEXER_NAME);	//создание устройства	status = IS_ERR(dev) ? PTR_ERR(dev) : 0;	if(status != 0)	{		printk(KERN_ERR "The device_create function failed/n");		return (status);	}	//инициализация членов структуры состояния драйвера	mutex_lock(&device_lockk);	adg739_status->users = 0;	adg739_status->spi = spi;	spi->bits_per_word = 16;	spi->max_speed_hz = 700000;	spin_lock_init(&adg739_status->spi_lock);	memset(adg739_status->buffer, 0, sizeof(adg739_status->buffer));	spi_set_drvdata(spi, adg739_status);	//присваевает указателю spi->dev->driver_data значение adg739_status	mutex_unlock(&device_lockk);	return (0);}

/* *  Ok, this is the main fork-routine. * * It copies the process, and if successful kick-starts * it and waits for it to finish using the VM if required. */long do_fork(unsigned long clone_flags,	      unsigned long stack_start,	      struct pt_regs *regs,	      unsigned long stack_size,	      int __user *parent_tidptr,	      int __user *child_tidptr){	struct task_struct *p;	int trace = 0;	struct pid *pid = alloc_pid();	long nr;	if (!pid)		return -EAGAIN;	nr = pid->nr;	if (unlikely(current->ptrace)) {		trace = fork_traceflag (clone_flags);		if (trace)			clone_flags |= CLONE_PTRACE;	}	p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, nr);	/*	 * Do this prior waking up the new thread - the thread pointer	 * might get invalid after that point, if the thread exits quickly.	 */	if (!IS_ERR(p)) {		struct completion vfork;		if (clone_flags & CLONE_VFORK) {			p->vfork_done = &vfork;			init_completion(&vfork);		}		if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {			/*			 * We'll start up with an immediate SIGSTOP.			 */			sigaddset(&p->pending.signal, SIGSTOP);			set_tsk_thread_flag(p, TIF_SIGPENDING);		}		if (!(clone_flags & CLONE_STOPPED))			wake_up_new_task(p, clone_flags);		else			p->state = TASK_STOPPED;		if (unlikely (trace)) {			current->ptrace_message = nr;			ptrace_notify ((trace << 8) | SIGTRAP);		}		if (clone_flags & CLONE_VFORK) {			wait_for_completion(&vfork);			if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {				current->ptrace_message = nr;				ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);			}		}	} else {		free_pid(pid);		nr = PTR_ERR(p);	}	return nr;}

/* *  Ok, this is the main fork-routine. * * It copies the process, and if successful kick-starts * it and waits for it to finish using the VM if required. */long do_fork(unsigned long clone_flags,	      unsigned long stack_start,	      struct pt_regs *regs,	      unsigned long stack_size,	      int __user *parent_tidptr,	      int __user *child_tidptr){	struct task_struct *p;	int trace = 0;	long nr;	/*	 * Do some preliminary argument and permissions checking before we	 * actually start allocating stuff	 */	if (clone_flags & CLONE_NEWUSER) {		if (clone_flags & CLONE_THREAD)			return -EINVAL;		/* hopefully this check will go away when userns support is		 * complete		 */		if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SETUID) ||				!capable(CAP_SETGID))			return -EPERM;	}	/*	 * Determine whether and which event to report to ptracer.  When	 * called from kernel_thread or CLONE_UNTRACED is explicitly	 * requested, no event is reported; otherwise, report if the event	 * for the type of forking is enabled.	 */	if (likely(user_mode(regs)) && !(clone_flags & CLONE_UNTRACED)) {		if (clone_flags & CLONE_VFORK)			trace = PTRACE_EVENT_VFORK;		else if ((clone_flags & CSIGNAL) != SIGCHLD)			trace = PTRACE_EVENT_CLONE;		else			trace = PTRACE_EVENT_FORK;		if (likely(!ptrace_event_enabled(current, trace)))			trace = 0;	}	p = copy_process(clone_flags, stack_start, regs, stack_size,			 child_tidptr, NULL, trace);	/*	 * Do this prior waking up the new thread - the thread pointer	 * might get invalid after that point, if the thread exits quickly.	 */	if (!IS_ERR(p)) {		struct completion vfork;		trace_sched_process_fork(current, p);		atomic_notifier_call_chain(&task_fork_notifier, 0, p);		nr = task_pid_vnr(p);		if (clone_flags & CLONE_PARENT_SETTID)			put_user(nr, parent_tidptr);		if (clone_flags & CLONE_VFORK) {			p->vfork_done = &vfork;			init_completion(&vfork);		}		audit_finish_fork(p);		/*		 * We set PF_STARTING at creation in case tracing wants to		 * use this to distinguish a fully live task from one that		 * hasn't finished SIGSTOP raising yet.  Now we clear it		 * and set the child going.		 */		p->flags &= ~PF_STARTING;		wake_up_new_task(p);		/* forking complete and child started to run, tell ptracer */		if (unlikely(trace))			ptrace_event(trace, nr);		if (clone_flags & CLONE_VFORK) {			freezer_do_not_count();			wait_for_completion(&vfork);			freezer_count();			ptrace_event(PTRACE_EVENT_VFORK_DONE, nr);		}	} else {		nr = PTR_ERR(p);	}	return nr;}

/** * i2c_pnx_xfer - generic transfer entry point * @adap:		pointer to I2C adapter structure * @msgs:		array of messages * @num:		number of messages * * Initiates the transfer */static inti2c_pnx_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num){	struct i2c_msg *pmsg;	int rc = 0, completed = 0, i;	struct i2c_pnx_algo_data *alg_data = adap->algo_data;	u32 stat = ioread32(I2C_REG_STS(alg_data));	dev_dbg(&alg_data->adapter.dev,		"%s(): entering: %d messages, stat = %04x./n",		__func__, num, ioread32(I2C_REG_STS(alg_data)));	bus_reset_if_active(alg_data);	/* Process transactions in a loop. */	for (i = 0; rc >= 0 && i < num; i++) {		u8 addr;		pmsg = &msgs[i];		addr = pmsg->addr;		if (pmsg->flags & I2C_M_TEN) {			dev_err(&alg_data->adapter.dev,				"%s: 10 bits addr not supported!/n",				alg_data->adapter.name);			rc = -EINVAL;			break;		}		alg_data->mif.buf = pmsg->buf;		alg_data->mif.len = pmsg->len;		alg_data->mif.mode = (pmsg->flags & I2C_M_RD) ?			I2C_SMBUS_READ : I2C_SMBUS_WRITE;		alg_data->mif.ret = 0;		alg_data->last = (i == num - 1);		dev_dbg(&alg_data->adapter.dev, "%s(): mode %d, %d bytes/n",			__func__, alg_data->mif.mode, alg_data->mif.len);		i2c_pnx_arm_timer(alg_data);		/* initialize the completion var */		init_completion(&alg_data->mif.complete);		/* Enable master interrupt */		iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_afie |				mcntrl_naie | mcntrl_drmie,			  I2C_REG_CTL(alg_data));		/* Put start-code and slave-address on the bus. */		rc = i2c_pnx_start(addr, alg_data);		if (rc < 0)			break;		/* Wait for completion */		wait_for_completion(&alg_data->mif.complete);		if (!(rc = alg_data->mif.ret))			completed++;		dev_dbg(&alg_data->adapter.dev,			"%s(): Complete, return code = %d./n",			__func__, rc);		/* Clear TDI and AFI bits in case they are set. */		if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_tdi) {			dev_dbg(&alg_data->adapter.dev,				"%s: TDI still set... clearing now./n",				alg_data->adapter.name);			iowrite32(stat, I2C_REG_STS(alg_data));		}		if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_afi) {			dev_dbg(&alg_data->adapter.dev,				"%s: AFI still set... clearing now./n",				alg_data->adapter.name);			iowrite32(stat, I2C_REG_STS(alg_data));		}	}	bus_reset_if_active(alg_data);	/* Cleanup to be sure... */	alg_data->mif.buf = NULL;	alg_data->mif.len = 0;	dev_dbg(&alg_data->adapter.dev, "%s(): exiting, stat = %x/n",		__func__, ioread32(I2C_REG_STS(alg_data)));	if (completed != num)		return ((rc < 0) ? rc : -EREMOTEIO);	return num;}

/**ltl功能:提交scatterlist urb请求，并等待执行结果参数:说明:此接口给usb_storage驱动使用<usb_stor_bulk_transfer_sglist>*/void usb_sg_wait (struct usb_sg_request *io){	int		i, entries = io->entries;	/* queue the urbs.  */	spin_lock_irq (&io->lock);	for (i = 0; i < entries && !io->status; i++) {		int	retval;		io->urbs [i]->dev = io->dev;		retval = usb_submit_urb (io->urbs [i], SLAB_ATOMIC);		/* after we submit, let completions or cancelations fire;		 * we handshake using io->status.		 */		spin_unlock_irq (&io->lock);		switch (retval) {			/* maybe we retrying will recover */		case -ENXIO:	// hc didn't queue this one		case -EAGAIN:		case -ENOMEM:			io->urbs[i]->dev = NULL;			retval = 0;			i--;			yield ();			break;			/* no error? continue immediately.			 *			 * NOTE: to work better with UHCI (4K I/O buffer may			 * need 3K of TDs) it may be good to limit how many			 * URBs are queued at once; N milliseconds?			 */		case 0:			cpu_relax ();			break;			/* fail any uncompleted urbs */		default:			io->urbs [i]->dev = NULL;			io->urbs [i]->status = retval;			dev_dbg (&io->dev->dev, "%s, submit --> %d/n",				__FUNCTION__, retval);			usb_sg_cancel (io);		}		spin_lock_irq (&io->lock);		if (retval && (io->status == 0 || io->status == -ECONNRESET))			io->status = retval;	}	io->count -= entries - i;	if (io->count == 0)		complete (&io->complete);	spin_unlock_irq (&io->lock);	/* OK, yes, this could be packaged as non-blocking.	 * So could the submit loop above ... but it's easier to	 * solve neither problem than to solve both!	 */	wait_for_completion (&io->complete);	sg_clean (io);}

//.........这里部分代码省略.........	default:		return -ENOTTY;	}	return 0;}static ssize_t mtx1_wdt_write(struct file *file, const char *buf,						size_t count, loff_t *ppos){	if (!count)		return -EIO;	mtx1_wdt_reset();	return count;}static const struct file_operations mtx1_wdt_fops = {	.owner		= THIS_MODULE,	.llseek		= no_llseek,	.unlocked_ioctl	= mtx1_wdt_ioctl,	.open		= mtx1_wdt_open,	.write		= mtx1_wdt_write,	.release	= mtx1_wdt_release,};static struct miscdevice mtx1_wdt_misc = {	.minor	= WATCHDOG_MINOR,	.name	= "watchdog",	.fops	= &mtx1_wdt_fops,};static int __devinit mtx1_wdt_probe(struct platform_device *pdev){	int ret;	mtx1_wdt_device.gpio = pdev->resource[0].start;	ret = gpio_request_one(mtx1_wdt_device.gpio,				GPIOF_OUT_INIT_HIGH, "mtx1-wdt");	if (ret < 0) {		dev_err(&pdev->dev, "failed to request gpio");		return ret;	}	spin_lock_init(&mtx1_wdt_device.lock);	init_completion(&mtx1_wdt_device.stop);	mtx1_wdt_device.queue = 0;	clear_bit(0, &mtx1_wdt_device.inuse);	setup_timer(&mtx1_wdt_device.timer, mtx1_wdt_trigger, 0L);	mtx1_wdt_device.default_ticks = ticks;	ret = misc_register(&mtx1_wdt_misc);	if (ret < 0) {		dev_err(&pdev->dev, "failed to register/n");		return ret;	}	mtx1_wdt_start();	dev_info(&pdev->dev, "MTX-1 Watchdog driver/n");	return 0;}static int __devexit mtx1_wdt_remove(struct platform_device *pdev){	/* FIXME: do we need to lock this test ? */	if (mtx1_wdt_device.queue) {		mtx1_wdt_device.queue = 0;		wait_for_completion(&mtx1_wdt_device.stop);	}	gpio_free(mtx1_wdt_device.gpio);	misc_deregister(&mtx1_wdt_misc);	return 0;}static struct platform_driver mtx1_wdt_driver = {	.probe = mtx1_wdt_probe,	.remove = __devexit_p(mtx1_wdt_remove),	.driver.name = "mtx1-wdt",	.driver.owner = THIS_MODULE,};static int __init mtx1_wdt_init(void){	return platform_driver_register(&mtx1_wdt_driver);}static void __exit mtx1_wdt_exit(void){	platform_driver_unregister(&mtx1_wdt_driver);}module_init(mtx1_wdt_init);module_exit(mtx1_wdt_exit);MODULE_AUTHOR("Michael Stickel, Florian Fainelli");MODULE_DESCRIPTION("Driver for the MTX-1 watchdog");MODULE_LICENSE("GPL");MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);MODULE_ALIAS("platform:mtx1-wdt");

//.........这里部分代码省略.........          if (i==0) { dataStartIndex=0; }          else      { dataStartIndex=hdr->entry_point_offset[i-1]; }          int dataEnd;          if (i==nRows-1) dataEnd = reader.bytes_remaining;          else            dataEnd = hdr->entry_point_offset[i];          init_thread_context(&hdr->thread_context[i]);          init_CABAC_decoder(&hdr->thread_context[i].cabac_decoder,                             &reader.data[dataStartIndex],                             dataEnd-dataStartIndex);          hdr->thread_context[i].shdr = hdr;          hdr->thread_context[i].decctx = ctx;        }        // TODO: hard-coded thread context        assert(ctx->img->tasks_pending == 0);        //printf("-------- decode --------/n");        add_CTB_decode_task_syntax(&hdr->thread_context[0], 0,0  ,0,0, NULL);        /*          for (int x=0;x<ctx->current_sps->PicWidthInCtbsY;x++)          for (int y=0;y<ctx->current_sps->PicHeightInCtbsY;y++)          {          add_CTB_decode_task_syntax(&hdr->thread_context[y], x,y);          }        */        wait_for_completion(ctx->img);        //flush_thread_pool(&ctx->thread_pool);        //printf("slice decoding finished/n");      }    }  }  else switch (nal_hdr.nal_unit_type) {    case NAL_UNIT_VPS_NUT:      {        logdebug(LogHeaders,"---> read VPS/n");        video_parameter_set vps;        read_vps(&reader,&vps);        if (ctx->param_vps_headers_fd>=0) {          dump_vps(&vps, ctx->param_vps_headers_fd);        }        process_vps(ctx, &vps);      }      break;    case NAL_UNIT_SPS_NUT:      {        logdebug(LogHeaders,"----> read SPS/n");        seq_parameter_set sps;        if ((err=read_sps(ctx, &reader,&sps, &ctx->ref_pic_sets)) != DE265_OK) {          break;        }        if (ctx->param_sps_headers_fd>=0) {

int rtas_ibm_suspend_me(u64 handle, int *vasi_return){	long state;	long rc;	unsigned long retbuf[PLPAR_HCALL_BUFSIZE];	struct rtas_suspend_me_data data;	DECLARE_COMPLETION_ONSTACK(done);	cpumask_var_t offline_mask;	int cpuret;	if (!rtas_service_present("ibm,suspend-me"))		return -ENOSYS;	/* Make sure the state is valid */	rc = plpar_hcall(H_VASI_STATE, retbuf, handle);	state = retbuf[0];	if (rc) {		printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld/n",rc);		return rc;	} else if (state == H_VASI_ENABLED) {		*vasi_return = RTAS_NOT_SUSPENDABLE;		return 0;	} else if (state != H_VASI_SUSPENDING) {		printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned state %ld/n",		       state);		*vasi_return = -1;		return 0;	}	if (!alloc_cpumask_var(&offline_mask, GFP_TEMPORARY))		return -ENOMEM;	atomic_set(&data.working, 0);	atomic_set(&data.done, 0);	atomic_set(&data.error, 0);	data.token = rtas_token("ibm,suspend-me");	data.complete = &done;	/* All present CPUs must be online */	cpumask_andnot(offline_mask, cpu_present_mask, cpu_online_mask);	cpuret = rtas_online_cpus_mask(offline_mask);	if (cpuret) {		pr_err("%s: Could not bring present CPUs online./n", __func__);		atomic_set(&data.error, cpuret);		goto out;	}	stop_topology_update();	/* Call function on all CPUs.  One of us will make the	 * rtas call	 */	if (on_each_cpu(rtas_percpu_suspend_me, &data, 0))		atomic_set(&data.error, -EINVAL);	wait_for_completion(&done);	if (atomic_read(&data.error) != 0)		printk(KERN_ERR "Error doing global join/n");	start_topology_update();	/* Take down CPUs not online prior to suspend */	cpuret = rtas_offline_cpus_mask(offline_mask);	if (cpuret)		pr_warn("%s: Could not restore CPUs to offline state./n",				__func__);out:	free_cpumask_var(offline_mask);	return atomic_read(&data.error);}

void tux3_iowait_wait(struct iowait *iowait){	/* All I/O was submitted, release initial 1, then wait I/O */	iowait_inflight_dec(iowait);	wait_for_completion(&iowait->done);}

static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt){	struct Scsi_Host *scsi_host = scpnt->device->host;	struct zfcp_adapter *adapter =		(struct zfcp_adapter *) scsi_host->hostdata[0];	struct zfcp_fsf_req *old_req, *abrt_req;	unsigned long flags;	unsigned long old_reqid = (unsigned long) scpnt->host_scribble;	int retval = SUCCESS, ret;	int retry = 3;	char *dbf_tag;		write_lock_irqsave(&adapter->abort_lock, flags);	old_req = zfcp_reqlist_find(adapter->req_list, old_reqid);	if (!old_req) {		write_unlock_irqrestore(&adapter->abort_lock, flags);		zfcp_dbf_scsi_abort("abrt_or", scpnt, NULL);		return FAILED; 	}	old_req->data = NULL;		write_unlock_irqrestore(&adapter->abort_lock, flags);	while (retry--) {		abrt_req = zfcp_fsf_abort_fcp_cmnd(scpnt);		if (abrt_req)			break;		zfcp_erp_wait(adapter);		ret = fc_block_scsi_eh(scpnt);		if (ret) {			zfcp_dbf_scsi_abort("abrt_bl", scpnt, NULL);			return ret;		}		if (!(atomic_read(&adapter->status) &		      ZFCP_STATUS_COMMON_RUNNING)) {			zfcp_dbf_scsi_abort("abrt_ru", scpnt, NULL);			return SUCCESS;		}	}	if (!abrt_req) {		zfcp_dbf_scsi_abort("abrt_ar", scpnt, NULL);		return FAILED;	}	wait_for_completion(&abrt_req->completion);	if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED)		dbf_tag = "abrt_ok";	else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED)		dbf_tag = "abrt_nn";	else {		dbf_tag = "abrt_fa";		retval = FAILED;	}	zfcp_dbf_scsi_abort(dbf_tag, scpnt, abrt_req);	zfcp_fsf_req_free(abrt_req);	return retval;}

static int __init kernel_init(void * unused){	/*	 * Wait until kthreadd is all set-up.	 */	wait_for_completion(&kthreadd_done);	lock_kernel();	/*	 * init can run on any cpu.	 */	set_cpus_allowed(current, CPU_MASK_ALL);	/*	 * Tell the world that we're going to be the grim	 * reaper of innocent orphaned children.	 *	 * We don't want people to have to make incorrect	 * assumptions about where in the task array this	 * can be found.	 */	init_pid_ns.child_reaper = current;	__set_special_pids(1, 1);	cad_pid = task_pid(current);	smp_prepare_cpus(max_cpus);	do_pre_smp_initcalls();	smp_init();	sched_init_smp();	cpuset_init_smp();	do_basic_setup();	/* Open the /dev/console on the rootfs, this should never fail */	if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)		printk(KERN_WARNING "Warning: unable to open an initial console./n");	(void) sys_dup(0);	(void) sys_dup(0);	/*	 * check if there is an early userspace init.  If yes, let it do all	 * the work	 */	if (!ramdisk_execute_command)		ramdisk_execute_command = "/init";	if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {		ramdisk_execute_command = NULL;		prepare_namespace();	}	/*	 * Ok, we have completed the initial bootup, and	 * we're essentially up and running. Get rid of the	 * initmem segments and start the user-mode stuff..	 */	init_post();	return 0;}

static int wakeup_event_thread(void *param){	struct wakeup_ctrl *ctrl = (struct wakeup_ctrl *)param;	struct sched_param sch_param = {.sched_priority = 1};	sched_setscheduler(current, SCHED_RR, &sch_param);	while (1) {		wait_for_completion(&ctrl->event);		if (kthread_should_stop())			break;		wakeup_event_handler(ctrl);		enable_irq(ctrl->wakeup_irq);		if ((ctrl->usb_irq > 0) && (ctrl->wakeup_irq != ctrl->usb_irq))			enable_irq(ctrl->usb_irq);	}	return 0;}static int wakeup_dev_probe(struct platform_device *pdev){	struct fsl_usb2_wakeup_platform_data *pdata;	struct wakeup_ctrl *ctrl = NULL;	int status;	unsigned long interrupt_flag;	printk(KERN_INFO "IMX usb wakeup probe/n");	if (!pdev || !pdev->dev.platform_data)		return -ENODEV;	ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);	if (!ctrl)		return -ENOMEM;	pdata = pdev->dev.platform_data;	ctrl->pdata = pdata;	init_waitqueue_head(&pdata->wq);	pdata->usb_wakeup_is_pending = false;	init_completion(&ctrl->event);	ctrl->wakeup_irq = platform_get_irq(pdev, 0);	ctrl->usb_irq = platform_get_irq(pdev, 1);	if (ctrl->wakeup_irq != ctrl->wakeup_irq)		interrupt_flag = IRQF_DISABLED;	else		interrupt_flag = IRQF_SHARED;	status = request_irq(ctrl->wakeup_irq, usb_wakeup_handler, interrupt_flag, "usb_wakeup", (void *)ctrl);	if (status)		goto error1;	ctrl->thread = kthread_run(wakeup_event_thread, (void *)ctrl, "usb_wakeup thread");	status = IS_ERR(ctrl->thread) ? -1 : 0;	if (status)		goto error2;	g_ctrl = ctrl;	printk(KERN_DEBUG "the wakeup pdata is 0x%p/n", pdata);	return 0;error2:	free_irq(ctrl->wakeup_irq, (void *)ctrl);error1:	kfree(ctrl);	return status;}static int  wakeup_dev_exit(struct platform_device *pdev){	if (g_ctrl->thread) {		complete(&g_ctrl->event);		kthread_stop(g_ctrl->thread);	}	free_irq(g_ctrl->wakeup_irq, (void *)g_ctrl);	kfree(g_ctrl);	return 0;}static struct platform_driver wakeup_d = {	.probe   = wakeup_dev_probe,	.remove  = wakeup_dev_exit,	.driver = {		.name = "usb_wakeup",	},};static int __init wakeup_dev_init(void){	return platform_driver_register(&wakeup_d);}static void __exit wakeup_dev_uninit(void){	platform_driver_unregister(&wakeup_d);}