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

/* This is the common part of the URB message submission code * * All URBs from the usb-storage driver involved in handling a queued scsi * command _must_ pass through this function (or something like it) for the * abort mechanisms to work properly. */static int usb_stor_msg_common(struct us_data *us, int timeout){	struct completion urb_done;	long timeleft;	int status;	/* don't submit URBs during abort processing */	if (test_bit(US_FLIDX_ABORTING, &us->dflags))		return -EIO;	/* set up data structures for the wakeup system */	init_completion(&urb_done);	/* fill the common fields in the URB */	us->current_urb->context = &urb_done;	us->current_urb->transfer_flags = 0;	/* we assume that if transfer_buffer isn't us->iobuf then it	 * hasn't been mapped for DMA.  Yes, this is clunky, but it's	 * easier than always having the caller tell us whether the	 * transfer buffer has already been mapped. */	if (us->current_urb->transfer_buffer == us->iobuf)		us->current_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	us->current_urb->transfer_dma = us->iobuf_dma;	/* submit the URB */	status = usb_submit_urb(us->current_urb, GFP_NOIO);	if (status) {		/* something went wrong */		return status;	}	/* since the URB has been submitted successfully, it's now okay	 * to cancel it */	set_bit(US_FLIDX_URB_ACTIVE, &us->dflags);	/* did an abort occur during the submission? */	if (test_bit(US_FLIDX_ABORTING, &us->dflags)) {		/* cancel the URB, if it hasn't been cancelled already */		if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->dflags)) {			US_DEBUGP("-- cancelling URB/n");			usb_unlink_urb(us->current_urb);		}	} 	/* wait for the completion of the URB */	timeleft = wait_for_completion_interruptible_timeout(			&urb_done, timeout ? : MAX_SCHEDULE_TIMEOUT); 	clear_bit(US_FLIDX_URB_ACTIVE, &us->dflags);	if (timeleft <= 0) {		US_DEBUGP("%s -- cancelling URB/n",			  timeleft == 0 ? "Timeout" : "Signal");		usb_kill_urb(us->current_urb);	}	/* return the URB status */	return us->current_urb->status;}

static int qlcnic_set_led(struct net_device *dev,			  enum ethtool_phys_id_state state){	struct qlcnic_adapter *adapter = netdev_priv(dev);	int max_sds_rings = adapter->max_sds_rings;	int err = -EIO, active = 1;	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {		netdev_warn(dev, "LED test not supported for non "				"privilege function/n");		return -EOPNOTSUPP;	}	switch (state) {	case ETHTOOL_ID_ACTIVE:		if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state))			return -EBUSY;		if (test_bit(__QLCNIC_RESETTING, &adapter->state))			break;		if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {			if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))				break;			set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);		}		if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0) {			err = 0;			break;		}		dev_err(&adapter->pdev->dev,			"Failed to set LED blink state./n");		break;	case ETHTOOL_ID_INACTIVE:		active = 0;		if (test_bit(__QLCNIC_RESETTING, &adapter->state))			break;		if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {			if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))				break;			set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);		}		if (adapter->nic_ops->config_led(adapter, 0, 0xf))			dev_err(&adapter->pdev->dev,				"Failed to reset LED blink state./n");		break;	default:		return -EINVAL;	}	if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))		qlcnic_diag_free_res(dev, max_sds_rings);	if (!active || err)		clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);	return err;}

/* * see if we have space for a number of pages and/or a number of files in the * cache */int cachefiles_has_space(struct cachefiles_cache *cache,			 unsigned fnr, unsigned bnr){	struct kstatfs stats;	struct path path = {		.mnt	= cache->mnt,		.dentry	= cache->mnt->mnt_root,	};	int ret;	//_enter("{%llu,%llu,%llu,%llu,%llu,%llu},%u,%u",	//       (unsigned long long) cache->frun,	//       (unsigned long long) cache->fcull,	//       (unsigned long long) cache->fstop,	//       (unsigned long long) cache->brun,	//       (unsigned long long) cache->bcull,	//       (unsigned long long) cache->bstop,	//       fnr, bnr);	/* find out how many pages of blockdev are available */	memset(&stats, 0, sizeof(stats));	ret = vfs_statfs(&path, &stats);	if (ret < 0) {		if (ret == -EIO)			cachefiles_io_error(cache, "statfs failed");		_leave(" = %d", ret);		return ret;	}	stats.f_bavail >>= cache->bshift;	//_debug("avail %llu,%llu",	//       (unsigned long long) stats.f_ffree,	//       (unsigned long long) stats.f_bavail);	/* see if there is sufficient space */	if (stats.f_ffree > fnr)		stats.f_ffree -= fnr;	else		stats.f_ffree = 0;	if (stats.f_bavail > bnr)		stats.f_bavail -= bnr;	else		stats.f_bavail = 0;	ret = -ENOBUFS;	if (stats.f_ffree < cache->fstop ||	    stats.f_bavail < cache->bstop)		goto begin_cull;	ret = 0;	if (stats.f_ffree < cache->fcull ||	    stats.f_bavail < cache->bcull)		goto begin_cull;	if (test_bit(CACHEFILES_CULLING, &cache->flags) &&	    stats.f_ffree >= cache->frun &&	    stats.f_bavail >= cache->brun &&	    test_and_clear_bit(CACHEFILES_CULLING, &cache->flags)	    ) {		_debug("cease culling");		cachefiles_state_changed(cache);	}	//_leave(" = 0");	return 0;begin_cull:	if (!test_and_set_bit(CACHEFILES_CULLING, &cache->flags)) {		_debug("### CULL CACHE ###");		cachefiles_state_changed(cache);	}	_leave(" = %d", ret);	return ret;}

/* * Garbage collector for unused keys. * * This is done in process context so that we don't have to disable interrupts * all over the place.  key_put() schedules this rather than trying to do the * cleanup itself, which means key_put() doesn't have to sleep. */static void key_garbage_collector(struct work_struct *work){	static LIST_HEAD(graveyard);	static u8 gc_state;		/* Internal persistent state */#define KEY_GC_REAP_AGAIN	0x01	/* - Need another cycle */#define KEY_GC_REAPING_LINKS	0x02	/* - We need to reap links */#define KEY_GC_SET_TIMER	0x04	/* - We need to restart the timer */#define KEY_GC_REAPING_DEAD_1	0x10	/* - We need to mark dead keys */#define KEY_GC_REAPING_DEAD_2	0x20	/* - We need to reap dead key links */#define KEY_GC_REAPING_DEAD_3	0x40	/* - We need to reap dead keys */#define KEY_GC_FOUND_DEAD_KEY	0x80	/* - We found at least one dead key */	struct rb_node *cursor;	struct key *key;	time64_t new_timer, limit;	kenter("[%lx,%x]", key_gc_flags, gc_state);	limit = ktime_get_real_seconds();	if (limit > key_gc_delay)		limit -= key_gc_delay;	else		limit = key_gc_delay;	/* Work out what we're going to be doing in this pass */	gc_state &= KEY_GC_REAPING_DEAD_1 | KEY_GC_REAPING_DEAD_2;	gc_state <<= 1;	if (test_and_clear_bit(KEY_GC_KEY_EXPIRED, &key_gc_flags))		gc_state |= KEY_GC_REAPING_LINKS | KEY_GC_SET_TIMER;	if (test_and_clear_bit(KEY_GC_REAP_KEYTYPE, &key_gc_flags))		gc_state |= KEY_GC_REAPING_DEAD_1;	kdebug("new pass %x", gc_state);	new_timer = TIME64_MAX;	/* As only this function is permitted to remove things from the key	 * serial tree, if cursor is non-NULL then it will always point to a	 * valid node in the tree - even if lock got dropped.	 */	spin_lock(&key_serial_lock);	cursor = rb_first(&key_serial_tree);continue_scanning:	while (cursor) {		key = rb_entry(cursor, struct key, serial_node);		cursor = rb_next(cursor);		if (refcount_read(&key->usage) == 0)			goto found_unreferenced_key;		if (unlikely(gc_state & KEY_GC_REAPING_DEAD_1)) {			if (key->type == key_gc_dead_keytype) {				gc_state |= KEY_GC_FOUND_DEAD_KEY;				set_bit(KEY_FLAG_DEAD, &key->flags);				key->perm = 0;				goto skip_dead_key;			} else if (key->type == &key_type_keyring &&				   key->restrict_link) {				goto found_restricted_keyring;			}		}		if (gc_state & KEY_GC_SET_TIMER) {			if (key->expiry > limit && key->expiry < new_timer) {				kdebug("will expire %x in %lld",				       key_serial(key), key->expiry - limit);				new_timer = key->expiry;			}		}		if (unlikely(gc_state & KEY_GC_REAPING_DEAD_2))			if (key->type == key_gc_dead_keytype)				gc_state |= KEY_GC_FOUND_DEAD_KEY;		if ((gc_state & KEY_GC_REAPING_LINKS) ||		    unlikely(gc_state & KEY_GC_REAPING_DEAD_2)) {			if (key->type == &key_type_keyring)				goto found_keyring;		}		if (unlikely(gc_state & KEY_GC_REAPING_DEAD_3))			if (key->type == key_gc_dead_keytype)				goto destroy_dead_key;	skip_dead_key:		if (spin_is_contended(&key_serial_lock) || need_resched())			goto contended;	}contended:	spin_unlock(&key_serial_lock);//.........这里部分代码省略.........

//.........这里部分代码省略.........			cs->BC_Write_Reg(cs, bchan, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RRST | W_B_CMDR_RACT);		} else {			count = cs->BC_Read_Reg(cs, bchan, W_B_RBCL) & (W_B_FIFO_THRESH - 1);			if (count == 0)				count = W_B_FIFO_THRESH;			W6692B_empty_fifo(bcs, count);			if ((count = bcs->hw.w6692.rcvidx) > 0) {				if (cs->debug & L1_DEB_HSCX_FIFO)					debugl1(cs, "W6692 Bchan Frame %d", count);				if (!(skb = dev_alloc_skb(count)))					printk(KERN_WARNING "W6692: Bchan receive out of memory/n");				else {					memcpy(skb_put(skb, count), bcs->hw.w6692.rcvbuf, count);					skb_queue_tail(&bcs->rqueue, skb);				}			}		}		bcs->hw.w6692.rcvidx = 0;		schedule_event(bcs, B_RCVBUFREADY);	}	if (val & W_B_EXI_RMR) {	/* RMR */		W6692B_empty_fifo(bcs, W_B_FIFO_THRESH);		r = cs->BC_Read_Reg(cs, bchan, W_B_STAR);		if (r & W_B_STAR_RDOV) {			if (cs->debug & L1_DEB_WARN)				debugl1(cs, "W6692 B RDOV(RMR) mode=%d",bcs->mode);			cs->BC_Write_Reg(cs, bchan, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RRST | W_B_CMDR_RACT);			if (bcs->mode != L1_MODE_TRANS)				bcs->hw.w6692.rcvidx = 0;		}		if (bcs->mode == L1_MODE_TRANS) {			/* receive audio data */			if (!(skb = dev_alloc_skb(W_B_FIFO_THRESH)))				printk(KERN_WARNING "HiSax: receive out of memory/n");			else {				memcpy(skb_put(skb, W_B_FIFO_THRESH), bcs->hw.w6692.rcvbuf, W_B_FIFO_THRESH);				skb_queue_tail(&bcs->rqueue, skb);			}			bcs->hw.w6692.rcvidx = 0;			schedule_event(bcs, B_RCVBUFREADY);		}	}	if (val & W_B_EXI_XDUN) {	/* XDUN */		cs->BC_Write_Reg(cs, bchan, W_B_CMDR, W_B_CMDR_XRST | W_B_CMDR_RACT);		if (cs->debug & L1_DEB_WARN)			debugl1(cs, "W6692 B EXIR %x Lost TX", val);		if (bcs->mode == 1)			W6692B_fill_fifo(bcs);		else {			/* Here we lost an TX interrupt, so			   * restart transmitting the whole frame.			 */			if (bcs->tx_skb) {				skb_push(bcs->tx_skb, bcs->hw.w6692.count);				bcs->tx_cnt += bcs->hw.w6692.count;				bcs->hw.w6692.count = 0;			}		}		return;	}	if (val & W_B_EXI_XFR) {	/* XFR */		r = cs->BC_Read_Reg(cs, bchan, W_B_STAR);		if (r & W_B_STAR_XDOW) {			if (cs->debug & L1_DEB_WARN)				debugl1(cs, "W6692 B STAR %x XDOW", r);			cs->BC_Write_Reg(cs, bchan, W_B_CMDR, W_B_CMDR_XRST | W_B_CMDR_RACT);			if (bcs->tx_skb && (bcs->mode != 1)) {				skb_push(bcs->tx_skb, bcs->hw.w6692.count);				bcs->tx_cnt += bcs->hw.w6692.count;				bcs->hw.w6692.count = 0;			}		}		if (bcs->tx_skb) {			if (bcs->tx_skb->len) {				W6692B_fill_fifo(bcs);				return;			} else {				if (test_bit(FLG_LLI_L1WAKEUP,&bcs->st->lli.flag) &&					(PACKET_NOACK != bcs->tx_skb->pkt_type)) {					u_long	flags;					spin_lock_irqsave(&bcs->aclock, flags);					bcs->ackcnt += bcs->hw.w6692.count;					spin_unlock_irqrestore(&bcs->aclock, flags);					schedule_event(bcs, B_ACKPENDING);				}				dev_kfree_skb_irq(bcs->tx_skb);				bcs->hw.w6692.count = 0;				bcs->tx_skb = NULL;			}		}		if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {			bcs->hw.w6692.count = 0;			test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);			W6692B_fill_fifo(bcs);		} else {			test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);			schedule_event(bcs, B_XMTBUFREADY);		}	}}

static voidW6692_l1hw(struct PStack *st, int pr, void *arg){	struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;	struct sk_buff *skb = arg;	u_long flags;	int val;	switch (pr) {		case (PH_DATA | REQUEST):			if (cs->debug & DEB_DLOG_HEX)				LogFrame(cs, skb->data, skb->len);			if (cs->debug & DEB_DLOG_VERBOSE)				dlogframe(cs, skb, 0);			spin_lock_irqsave(&cs->lock, flags);			if (cs->tx_skb) {				skb_queue_tail(&cs->sq, skb);#ifdef L2FRAME_DEBUG		/* psa */				if (cs->debug & L1_DEB_LAPD)					Logl2Frame(cs, skb, "PH_DATA Queued", 0);#endif			} else {				cs->tx_skb = skb;				cs->tx_cnt = 0;#ifdef L2FRAME_DEBUG		/* psa */				if (cs->debug & L1_DEB_LAPD)					Logl2Frame(cs, skb, "PH_DATA", 0);#endif				W6692_fill_fifo(cs);			}			spin_unlock_irqrestore(&cs->lock, flags);			break;		case (PH_PULL | INDICATION):			spin_lock_irqsave(&cs->lock, flags);			if (cs->tx_skb) {				if (cs->debug & L1_DEB_WARN)					debugl1(cs, " l2l1 tx_skb exist this shouldn't happen");				skb_queue_tail(&cs->sq, skb);				spin_unlock_irqrestore(&cs->lock, flags);				break;			}			if (cs->debug & DEB_DLOG_HEX)				LogFrame(cs, skb->data, skb->len);			if (cs->debug & DEB_DLOG_VERBOSE)				dlogframe(cs, skb, 0);			cs->tx_skb = skb;			cs->tx_cnt = 0;#ifdef L2FRAME_DEBUG		/* psa */			if (cs->debug & L1_DEB_LAPD)				Logl2Frame(cs, skb, "PH_DATA_PULLED", 0);#endif			W6692_fill_fifo(cs);			spin_unlock_irqrestore(&cs->lock, flags);			break;		case (PH_PULL | REQUEST):#ifdef L2FRAME_DEBUG		/* psa */			if (cs->debug & L1_DEB_LAPD)				debugl1(cs, "-> PH_REQUEST_PULL");#endif			if (!cs->tx_skb) {				test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);				st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);			} else				test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);			break;		case (HW_RESET | REQUEST):			spin_lock_irqsave(&cs->lock, flags);			if ((cs->dc.w6692.ph_state == W_L1IND_DRD)) {				ph_command(cs, W_L1CMD_ECK);				spin_unlock_irqrestore(&cs->lock, flags);			} else {				ph_command(cs, W_L1CMD_RST);				cs->dc.w6692.ph_state = W_L1CMD_RST;				spin_unlock_irqrestore(&cs->lock, flags);				W6692_new_ph(cs);			}			break;		case (HW_ENABLE | REQUEST):			spin_lock_irqsave(&cs->lock, flags);			ph_command(cs, W_L1CMD_ECK);			spin_unlock_irqrestore(&cs->lock, flags);			break;		case (HW_INFO3 | REQUEST):			spin_lock_irqsave(&cs->lock, flags);			ph_command(cs, W_L1CMD_AR8);			spin_unlock_irqrestore(&cs->lock, flags);			break;		case (HW_TESTLOOP | REQUEST):			val = 0;			if (1 & (long) arg)				val |= 0x0c;			if (2 & (long) arg)				val |= 0x3;			/* !!! not implemented yet */			break;		case (HW_DEACTIVATE | RESPONSE):			skb_queue_purge(&cs->rq);			skb_queue_purge(&cs->sq);			if (cs->tx_skb) {				dev_kfree_skb_any(cs->tx_skb);//.........这里部分代码省略.........

int ivtv_start_capture(struct ivtv_open_id *id){	struct ivtv *itv = id->itv;	struct ivtv_stream *s = &itv->streams[id->type];	struct ivtv_stream *s_vbi;	if (s->type == IVTV_ENC_STREAM_TYPE_RAD ||	    s->type == IVTV_DEC_STREAM_TYPE_MPG ||	    s->type == IVTV_DEC_STREAM_TYPE_YUV ||	    s->type == IVTV_DEC_STREAM_TYPE_VOUT) {		/* you cannot read from these stream types. */		return -EINVAL;	}	/* Try to claim this stream. */	if (ivtv_claim_stream(id, s->type))		return -EBUSY;	/* This stream does not need to start capturing */	if (s->type == IVTV_DEC_STREAM_TYPE_VBI) {		set_bit(IVTV_F_S_APPL_IO, &s->s_flags);		return 0;	}	/* If capture is already in progress, then we also have to	   do nothing extra. */	if (test_bit(IVTV_F_S_STREAMOFF, &s->s_flags) || test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags)) {		set_bit(IVTV_F_S_APPL_IO, &s->s_flags);		return 0;	}	/* Start VBI capture if required */	s_vbi = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];	if (s->type == IVTV_ENC_STREAM_TYPE_MPG &&	    test_bit(IVTV_F_S_INTERNAL_USE, &s_vbi->s_flags) &&	    !test_and_set_bit(IVTV_F_S_STREAMING, &s_vbi->s_flags)) {		/* Note: the IVTV_ENC_STREAM_TYPE_VBI is claimed		   automatically when the MPG stream is claimed.		   We only need to start the VBI capturing. */		if (ivtv_start_v4l2_encode_stream(s_vbi)) {			IVTV_DEBUG_WARN("VBI capture start failed/n");			/* Failure, clean up and return an error */			clear_bit(IVTV_F_S_STREAMING, &s_vbi->s_flags);			clear_bit(IVTV_F_S_STREAMING, &s->s_flags);			/* also releases the associated VBI stream */			ivtv_release_stream(s);			return -EIO;		}		IVTV_DEBUG_INFO("VBI insertion started/n");	}	/* Tell the card to start capturing */	if (!ivtv_start_v4l2_encode_stream(s)) {		/* We're done */		set_bit(IVTV_F_S_APPL_IO, &s->s_flags);		/* Resume a possibly paused encoder */		if (test_and_clear_bit(IVTV_F_I_ENC_PAUSED, &itv->i_flags))			ivtv_vapi(itv, CX2341X_ENC_PAUSE_ENCODER, 1, 1);		return 0;	}	/* failure, clean up */	IVTV_DEBUG_WARN("Failed to start capturing for stream %s/n", s->name);	/* Note: the IVTV_ENC_STREAM_TYPE_VBI is released	   automatically when the MPG stream is released.	   We only need to stop the VBI capturing. */	if (s->type == IVTV_ENC_STREAM_TYPE_MPG &&	    test_bit(IVTV_F_S_STREAMING, &s_vbi->s_flags)) {		ivtv_stop_v4l2_encode_stream(s_vbi, 0);		clear_bit(IVTV_F_S_STREAMING, &s_vbi->s_flags);	}	clear_bit(IVTV_F_S_STREAMING, &s->s_flags);	ivtv_release_stream(s);	return -EIO;}

/* * hfs_mdb_commit() * * Description: *   This updates the MDB on disk (look also at hfs_write_super()). *   It does not check, if the superblock has been modified, or *   if the filesystem has been mounted read-only. It is mainly *   called by hfs_write_super() and hfs_btree_extend(). * Input Variable(s): *   struct hfs_mdb *mdb: Pointer to the hfs MDB *   int backup; * Output Variable(s): *   NONE * Returns: *   void * Preconditions: *   'mdb' points to a "valid" (struct hfs_mdb). * Postconditions: *   The HFS MDB and on disk will be updated, by copying the possibly *   modified fields from the in memory MDB (in native byte order) to *   the disk block buffer. *   If 'backup' is non-zero then the alternate MDB is also written *   and the function doesn't return until it is actually on disk. */void hfs_mdb_commit(struct super_block *sb){	struct hfs_mdb *mdb = HFS_SB(sb)->mdb;	if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) {		/* These parameters may have been modified, so write them back */		mdb->drLsMod = hfs_mtime();		mdb->drFreeBks = cpu_to_be16(HFS_SB(sb)->free_ablocks);		mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id);		mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files);		mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs);		mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count);		mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count);		/* write MDB to disk */		mark_buffer_dirty(HFS_SB(sb)->mdb_bh);	}	/* write the backup MDB, not returning until it is written.	 * we only do this when either the catalog or extents overflow	 * files grow. */	if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags) &&	    HFS_SB(sb)->alt_mdb) {		hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec,				     &mdb->drXTFlSize, NULL);		hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,				     &mdb->drCTFlSize, NULL);		memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);		HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);		HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);		mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);		hfs_buffer_sync(HFS_SB(sb)->alt_mdb_bh);	}	if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags)) {		struct buffer_head *bh;		sector_t block;		char *ptr;		int off, size, len;		block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start;		off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1);		block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS;		size = (HFS_SB(sb)->fs_ablocks + 7) / 8;		ptr = (u8 *)HFS_SB(sb)->bitmap;		while (size) {			bh = sb_bread(sb, block);			if (!bh) {				printk(KERN_ERR "hfs: unable to read volume bitmap/n");				break;			}			len = min((int)sb->s_blocksize - off, size);			memcpy(bh->b_data + off, ptr, len);			mark_buffer_dirty(bh);			brelse(bh);			block++;			off = 0;			ptr += len;			size -= len;		}	}}

static irqreturn_t flite_irq_handler(int irq, void *priv){	struct fimc_lite *fimc = priv;	struct flite_buffer *vbuf;	unsigned long flags;	struct timeval *tv;	struct timespec ts;	u32 intsrc;	spin_lock_irqsave(&fimc->slock, flags);	intsrc = flite_hw_get_interrupt_source(fimc);	flite_hw_clear_pending_irq(fimc);	if (test_and_clear_bit(ST_FLITE_OFF, &fimc->state)) {		wake_up(&fimc->irq_queue);		goto done;	}	if (intsrc & FLITE_REG_CISTATUS_IRQ_SRC_OVERFLOW) {		clear_bit(ST_FLITE_RUN, &fimc->state);		fimc->events.data_overflow++;	}	if (intsrc & FLITE_REG_CISTATUS_IRQ_SRC_LASTCAPEND) {		flite_hw_clear_last_capture_end(fimc);		clear_bit(ST_FLITE_STREAM, &fimc->state);		wake_up(&fimc->irq_queue);	}	if (fimc->out_path != FIMC_IO_DMA)		goto done;	if ((intsrc & FLITE_REG_CISTATUS_IRQ_SRC_FRMSTART) &&	    test_bit(ST_FLITE_RUN, &fimc->state) &&	    !list_empty(&fimc->active_buf_q) &&	    !list_empty(&fimc->pending_buf_q)) {		vbuf = fimc_lite_active_queue_pop(fimc);		ktime_get_ts(&ts);		tv = &vbuf->vb.v4l2_buf.timestamp;		tv->tv_sec = ts.tv_sec;		tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC;		vbuf->vb.v4l2_buf.sequence = fimc->frame_count++;		vb2_buffer_done(&vbuf->vb, VB2_BUF_STATE_DONE);		vbuf = fimc_lite_pending_queue_pop(fimc);		flite_hw_set_output_addr(fimc, vbuf->paddr);		fimc_lite_active_queue_add(fimc, vbuf);	}	if (test_bit(ST_FLITE_CONFIG, &fimc->state))		fimc_lite_config_update(fimc);	if (list_empty(&fimc->pending_buf_q)) {		flite_hw_capture_stop(fimc);		clear_bit(ST_FLITE_STREAM, &fimc->state);	}done:	set_bit(ST_FLITE_RUN, &fimc->state);	spin_unlock_irqrestore(&fimc->slock, flags);	return IRQ_HANDLED;}

static inline intbitmap_ipmac_do_del(const struct bitmap_ipmac_adt_elem *e,		    struct bitmap_ipmac *map){	return !test_and_clear_bit(e->id, map->members);}

static void msg_cleanup(void){	if (test_and_clear_bit(0, &msg_registered))		usb_composite_unregister(&msg_driver);}

static int perf_ibs_handle_irq(struct perf_ibs *perf_ibs, struct pt_regs *iregs){	struct cpu_perf_ibs *pcpu = this_cpu_ptr(perf_ibs->pcpu);	struct perf_event *event = pcpu->event;	struct hw_perf_event *hwc = &event->hw;	struct perf_sample_data data;	struct perf_raw_record raw;	struct pt_regs regs;	struct perf_ibs_data ibs_data;	int offset, size, check_rip, offset_max, throttle = 0;	unsigned int msr;	u64 *buf, *config, period;	if (!test_bit(IBS_STARTED, pcpu->state)) {		/*		 * Catch spurious interrupts after stopping IBS: After		 * disabling IBS there could be still incoming NMIs		 * with samples that even have the valid bit cleared.		 * Mark all this NMIs as handled.		 */		return test_and_clear_bit(IBS_STOPPING, pcpu->state) ? 1 : 0;	}	msr = hwc->config_base;	buf = ibs_data.regs;	rdmsrl(msr, *buf);	if (!(*buf++ & perf_ibs->valid_mask))		return 0;	config = &ibs_data.regs[0];	perf_ibs_event_update(perf_ibs, event, config);	perf_sample_data_init(&data, 0, hwc->last_period);	if (!perf_ibs_set_period(perf_ibs, hwc, &period))		goto out;	/* no sw counter overflow */	ibs_data.caps = ibs_caps;	size = 1;	offset = 1;	check_rip = (perf_ibs == &perf_ibs_op && (ibs_caps & IBS_CAPS_RIPINVALIDCHK));	if (event->attr.sample_type & PERF_SAMPLE_RAW)		offset_max = perf_ibs->offset_max;	else if (check_rip)		offset_max = 2;	else		offset_max = 1;	do {		rdmsrl(msr + offset, *buf++);		size++;		offset = find_next_bit(perf_ibs->offset_mask,				       perf_ibs->offset_max,				       offset + 1);	} while (offset < offset_max);	ibs_data.size = sizeof(u64) * size;	regs = *iregs;	if (check_rip && (ibs_data.regs[2] & IBS_RIP_INVALID)) {		regs.flags &= ~PERF_EFLAGS_EXACT;	} else {		set_linear_ip(&regs, ibs_data.regs[1]);		regs.flags |= PERF_EFLAGS_EXACT;	}	if (event->attr.sample_type & PERF_SAMPLE_RAW) {		raw.size = sizeof(u32) + ibs_data.size;		raw.data = ibs_data.data;		data.raw = &raw;	}	throttle = perf_event_overflow(event, &data, &regs);out:	if (throttle)		perf_ibs_disable_event(perf_ibs, hwc, *config);	else		perf_ibs_enable_event(perf_ibs, hwc, period >> 4);	perf_event_update_userpage(event);	return 1;}

static void abort_usb_playback(struct ua101 *ua){	if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states))		wake_up(&ua->alsa_playback_wait);}

/* * Check whether the dentry is still valid * * If the entry validity timeout has expired and the dentry is * positive, try to redo the lookup.  If the lookup results in a * different inode, then let the VFS invalidate the dentry and redo * the lookup once more.  If the lookup results in the same inode, * then refresh the attributes, timeouts and mark the dentry valid. */static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags){	struct inode *inode;	struct dentry *parent;	struct fuse_conn *fc;	struct fuse_inode *fi;	int ret;	inode = ACCESS_ONCE(entry->d_inode);	if (inode && is_bad_inode(inode))		goto invalid;	else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||		 (flags & LOOKUP_REVAL)) {		struct fuse_entry_out outarg;		FUSE_ARGS(args);		struct fuse_forget_link *forget;		u64 attr_version;		/* For negative dentries, always do a fresh lookup */		if (!inode)			goto invalid;		ret = -ECHILD;		if (flags & LOOKUP_RCU)			goto out;		fc = get_fuse_conn(inode);		forget = fuse_alloc_forget();		ret = -ENOMEM;		if (!forget)			goto out;		attr_version = fuse_get_attr_version(fc);		parent = dget_parent(entry);		fuse_lookup_init(fc, &args, get_node_id(parent->d_inode),				 &entry->d_name, &outarg);		ret = fuse_simple_request(fc, &args);		dput(parent);		/* Zero nodeid is same as -ENOENT */		if (!ret && !outarg.nodeid)			ret = -ENOENT;		if (!ret) {			fi = get_fuse_inode(inode);			if (outarg.nodeid != get_node_id(inode)) {				fuse_queue_forget(fc, forget, outarg.nodeid, 1);				goto invalid;			}			spin_lock(&fc->lock);			fi->nlookup++;			spin_unlock(&fc->lock);		}		kfree(forget);		if (ret == -ENOMEM)			goto out;		if (ret || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)			goto invalid;		fuse_change_attributes(inode, &outarg.attr,				       entry_attr_timeout(&outarg),				       attr_version);		fuse_change_entry_timeout(entry, &outarg);	} else if (inode) {		fi = get_fuse_inode(inode);		if (flags & LOOKUP_RCU) {			if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))				return -ECHILD;		} else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {			parent = dget_parent(entry);			fuse_advise_use_readdirplus(parent->d_inode);			dput(parent);		}	}	ret = 1;out:	return ret;invalid:	ret = 0;	goto out;}

static irqreturn_tW6692_interrupt(int intno, void *dev_id, struct pt_regs *regs){	struct IsdnCardState	*cs = dev_id;	u_char			val, exval, v1;	struct sk_buff		*skb;	u_int			count;	u_long			flags;	int			icnt = 5;	spin_lock_irqsave(&cs->lock, flags);	val = cs->readW6692(cs, W_ISTA);	if (!val) {		spin_unlock_irqrestore(&cs->lock, flags);		return IRQ_NONE;	}      StartW6692:	if (cs->debug & L1_DEB_ISAC)		debugl1(cs, "W6692 ISTA %x", val);	if (val & W_INT_D_RME) {	/* RME */		exval = cs->readW6692(cs, W_D_RSTA);		if (exval & (W_D_RSTA_RDOV | W_D_RSTA_CRCE | W_D_RSTA_RMB)) {			if (exval & W_D_RSTA_RDOV)				if (cs->debug & L1_DEB_WARN)					debugl1(cs, "W6692 RDOV");			if (exval & W_D_RSTA_CRCE)				if (cs->debug & L1_DEB_WARN)					debugl1(cs, "W6692 D-channel CRC error");			if (exval & W_D_RSTA_RMB)				if (cs->debug & L1_DEB_WARN)					debugl1(cs, "W6692 D-channel ABORT");			cs->writeW6692(cs, W_D_CMDR, W_D_CMDR_RACK | W_D_CMDR_RRST);		} else {			count = cs->readW6692(cs, W_D_RBCL) & (W_D_FIFO_THRESH - 1);			if (count == 0)				count = W_D_FIFO_THRESH;			W6692_empty_fifo(cs, count);			if ((count = cs->rcvidx) > 0) {				cs->rcvidx = 0;				if (!(skb = alloc_skb(count, GFP_ATOMIC)))					printk(KERN_WARNING "HiSax: D receive out of memory/n");				else {					memcpy(skb_put(skb, count), cs->rcvbuf, count);					skb_queue_tail(&cs->rq, skb);				}			}		}		cs->rcvidx = 0;		schedule_event(cs, D_RCVBUFREADY);	}	if (val & W_INT_D_RMR) {	/* RMR */		W6692_empty_fifo(cs, W_D_FIFO_THRESH);	}	if (val & W_INT_D_XFR) {	/* XFR */		if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))			del_timer(&cs->dbusytimer);		if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))			schedule_event(cs, D_CLEARBUSY);		if (cs->tx_skb) {			if (cs->tx_skb->len) {				W6692_fill_fifo(cs);				goto afterXFR;			} else {				dev_kfree_skb_irq(cs->tx_skb);				cs->tx_cnt = 0;				cs->tx_skb = NULL;			}		}		if ((cs->tx_skb = skb_dequeue(&cs->sq))) {			cs->tx_cnt = 0;			W6692_fill_fifo(cs);		} else			schedule_event(cs, D_XMTBUFREADY);	}      afterXFR:	if (val & (W_INT_XINT0 | W_INT_XINT1)) {	/* XINT0/1 - never */		if (cs->debug & L1_DEB_ISAC)			debugl1(cs, "W6692 spurious XINT!");	}	if (val & W_INT_D_EXI) {	/* EXI */		exval = cs->readW6692(cs, W_D_EXIR);		if (cs->debug & L1_DEB_WARN)			debugl1(cs, "W6692 D_EXIR %02x", exval);		if (exval & (W_D_EXI_XDUN | W_D_EXI_XCOL)) {	/* Transmit underrun/collision */			debugl1(cs, "W6692 D-chan underrun/collision");			printk(KERN_WARNING "HiSax: W6692 XDUN/XCOL/n");			if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))				del_timer(&cs->dbusytimer);			if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))				schedule_event(cs, D_CLEARBUSY);			if (cs->tx_skb) {	/* Restart frame */				skb_push(cs->tx_skb, cs->tx_cnt);				cs->tx_cnt = 0;				W6692_fill_fifo(cs);			} else {				printk(KERN_WARNING "HiSax: W6692 XDUN/XCOL no skb/n");				debugl1(cs, "W6692 XDUN/XCOL no skb");				cs->writeW6692(cs, W_D_CMDR, W_D_CMDR_XRST);			}//.........这里部分代码省略.........

int __initsetup_netjet_u(struct IsdnCard *card){    int bytecnt;    struct IsdnCardState *cs = card->cs;    char tmp[64];    long flags;#if CONFIG_PCI#endif#ifdef __BIG_ENDIAN#error "not running on big endian machines now"#endif    strcpy(tmp, NETjet_U_revision);    printk(KERN_INFO "HiSax: Traverse Tech. NETspider-U driver Rev. %s/n", HiSax_getrev(tmp));    if (cs->typ != ISDN_CTYPE_NETJET_U)        return(0);    test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);#if CONFIG_PCI    for ( ;; )    {        if (!pci_present()) {            printk(KERN_ERR "Netjet: no PCI bus present/n");            return(0);        }        if ((dev_netjet = pci_find_device(PCI_VENDOR_ID_TIGERJET,                                          PCI_DEVICE_ID_TIGERJET_300,  dev_netjet))) {            if (pci_enable_device(dev_netjet))                return(0);            pci_set_master(dev_netjet);            cs->irq = dev_netjet->irq;            if (!cs->irq) {                printk(KERN_WARNING "NETspider-U: No IRQ for PCI card found/n");                return(0);            }            cs->hw.njet.base = pci_resource_start(dev_netjet, 0);            if (!cs->hw.njet.base) {                printk(KERN_WARNING "NETspider-U: No IO-Adr for PCI card found/n");                return(0);            }        } else {            printk(KERN_WARNING "NETspider-U: No PCI card found/n");            return(0);        }        cs->hw.njet.auxa = cs->hw.njet.base + NETJET_AUXDATA;        cs->hw.njet.isac = cs->hw.njet.base | NETJET_ISAC_OFF;        save_flags(flags);        sti();        cs->hw.njet.ctrl_reg = 0xff;  /* Reset On */        byteout(cs->hw.njet.base + NETJET_CTRL, cs->hw.njet.ctrl_reg);        set_current_state(TASK_UNINTERRUPTIBLE);        schedule_timeout((10*HZ)/1000);	/* Timeout 10ms */        cs->hw.njet.ctrl_reg = 0x00;  /* Reset Off and status read clear */        byteout(cs->hw.njet.base + NETJET_CTRL, cs->hw.njet.ctrl_reg);        set_current_state(TASK_UNINTERRUPTIBLE);        schedule_timeout((10*HZ)/1000);	/* Timeout 10ms */        restore_flags(flags);        cs->hw.njet.auxd = 0xC0;        cs->hw.njet.dmactrl = 0;        byteout(cs->hw.njet.auxa, 0);        byteout(cs->hw.njet.base + NETJET_AUXCTRL, ~NETJET_ISACIRQ);        byteout(cs->hw.njet.base + NETJET_IRQMASK1, NETJET_ISACIRQ);        byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);        switch ( ( ( NETjet_ReadIC( cs, ICC_RBCH ) >> 5 ) & 3 ) )        {        case 3 :            break;        case 0 :            printk( KERN_WARNING "NETspider-U: NETjet-S PCI card found/n" );            continue;        default :            printk( KERN_WARNING "NETspider-U: No PCI card found/n" );            return 0;        }        break;    }#else    printk(KERN_WARNING "NETspider-U: NO_PCI_BIOS/n");    printk(KERN_WARNING "NETspider-U: unable to config NETspider-U PCI/n");    return (0);#endif /* CONFIG_PCI */    bytecnt = 256;    printk(KERN_INFO//.........这里部分代码省略.........

voidicc_interrupt(struct IsdnCardState *cs, u_char val){	u_char exval, v1;	struct sk_buff *skb;	unsigned int count;	if (cs->debug & L1_DEB_ISAC)		debugl1(cs, "ICC interrupt %x", val);	if (val & 0x80) {	/* RME */		exval = cs->readisac(cs, ICC_RSTA);		if ((exval & 0x70) != 0x20) {			if (exval & 0x40) {				if (cs->debug & L1_DEB_WARN)					debugl1(cs, "ICC RDO");#ifdef ERROR_STATISTIC				cs->err_rx++;#endif			}			if (!(exval & 0x20)) {				if (cs->debug & L1_DEB_WARN)					debugl1(cs, "ICC CRC error");#ifdef ERROR_STATISTIC				cs->err_crc++;#endif			}			cs->writeisac(cs, ICC_CMDR, 0x80);		} else {			count = cs->readisac(cs, ICC_RBCL) & 0x1f;			if (count == 0)				count = 32;			icc_empty_fifo(cs, count);			if ((count = cs->rcvidx) > 0) {				cs->rcvidx = 0;				if (!(skb = alloc_skb(count, GFP_ATOMIC)))					printk(KERN_WARNING "HiSax: D receive out of memory/n");				else {					memcpy(skb_put(skb, count), cs->rcvbuf, count);					skb_queue_tail(&cs->rq, skb);				}			}		}		cs->rcvidx = 0;		schedule_event(cs, D_RCVBUFREADY);	}	if (val & 0x40) {	/* RPF */		icc_empty_fifo(cs, 32);	}	if (val & 0x20) {	/* RSC */		/* never */		if (cs->debug & L1_DEB_WARN)			debugl1(cs, "ICC RSC interrupt");	}	if (val & 0x10) {	/* XPR */		if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))			del_timer(&cs->dbusytimer);		if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))			schedule_event(cs, D_CLEARBUSY);		if (cs->tx_skb) {			if (cs->tx_skb->len) {				icc_fill_fifo(cs);				goto afterXPR;			} else {				dev_kfree_skb_irq(cs->tx_skb);				cs->tx_cnt = 0;				cs->tx_skb = NULL;			}		}		if ((cs->tx_skb = skb_dequeue(&cs->sq))) {			cs->tx_cnt = 0;			icc_fill_fifo(cs);		} else			schedule_event(cs, D_XMTBUFREADY);	}      afterXPR:	if (val & 0x04) {	/* CISQ */		exval = cs->readisac(cs, ICC_CIR0);		if (cs->debug & L1_DEB_ISAC)			debugl1(cs, "ICC CIR0 %02X", exval );		if (exval & 2) {			cs->dc.icc.ph_state = (exval >> 2) & 0xf;			if (cs->debug & L1_DEB_ISAC)				debugl1(cs, "ph_state change %x", cs->dc.icc.ph_state);			schedule_event(cs, D_L1STATECHANGE);		}

static voidnetjet_u_interrupt(int intno, void *dev_id, struct pt_regs *regs){    struct IsdnCardState *cs = dev_id;    u_char val, sval;    long flags;    if (!cs) {        printk(KERN_WARNING "NETspider-U: Spurious interrupt!/n");        return;    }    if (!((sval = bytein(cs->hw.njet.base + NETJET_IRQSTAT1)) &            NETJET_ISACIRQ)) {        val = NETjet_ReadIC(cs, ICC_ISTA);        if (cs->debug & L1_DEB_ISAC)            debugl1(cs, "tiger: i1 %x %x", sval, val);        if (val) {            icc_interrupt(cs, val);            NETjet_WriteIC(cs, ICC_MASK, 0xFF);            NETjet_WriteIC(cs, ICC_MASK, 0x0);        }    }    save_flags(flags);    cli();    /* start new code 13/07/00 GE */    /* set bits in sval to indicate which page is free */    if (inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR) <            inl(cs->hw.njet.base + NETJET_DMA_WRITE_IRQ))        /* the 2nd write page is free */        sval = 0x08;    else	/* the 1st write page is free */        sval = 0x04;    if (inl(cs->hw.njet.base + NETJET_DMA_READ_ADR) <            inl(cs->hw.njet.base + NETJET_DMA_READ_IRQ))        /* the 2nd read page is free */        sval = sval | 0x02;    else	/* the 1st read page is free */        sval = sval | 0x01;    if (sval != cs->hw.njet.last_is0) /* we have a DMA interrupt */    {        if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {            restore_flags(flags);            return;        }        cs->hw.njet.irqstat0 = sval;        restore_flags(flags);        if ((cs->hw.njet.irqstat0 & NETJET_IRQM0_READ) !=                (cs->hw.njet.last_is0 & NETJET_IRQM0_READ))            /* we have a read dma int */            read_tiger(cs);        if ((cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE) !=                (cs->hw.njet.last_is0 & NETJET_IRQM0_WRITE))            /* we have a write dma int */            write_tiger(cs);        /* end new code 13/07/00 GE */        test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);    } else        restore_flags(flags);    /*	if (!testcnt--) {    		cs->hw.njet.dmactrl = 0;    		byteout(cs->hw.njet.base + NETJET_DMACTRL,    			cs->hw.njet.dmactrl);    		byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);    	}    */}

/* * Callback for completed capture URB. */static void audio_in_callback(struct urb *urb){	int i, index, length = 0, shutdown = 0;	unsigned long flags;	struct snd_line6_pcm *line6pcm = (struct snd_line6_pcm *)urb->context;	line6pcm->last_frame_in = urb->start_frame;	/* find index of URB */	for (index = 0; index < LINE6_ISO_BUFFERS; ++index)		if (urb == line6pcm->urb_audio_in[index])			break;#ifdef CONFIG_LINE6_USB_DUMP_PCM	for (i = 0; i < LINE6_ISO_PACKETS; ++i) {		struct usb_iso_packet_descriptor *fout =		    &urb->iso_frame_desc[i];		line6_write_hexdump(line6pcm->line6, 'C',				    urb->transfer_buffer + fout->offset,				    fout->length);	}#endif	spin_lock_irqsave(&line6pcm->lock_audio_in, flags);	for (i = 0; i < LINE6_ISO_PACKETS; ++i) {		char *fbuf;		int fsize;		struct usb_iso_packet_descriptor *fin = &urb->iso_frame_desc[i];		if (fin->status == -EXDEV) {			shutdown = 1;			break;		}		fbuf = urb->transfer_buffer + fin->offset;		fsize = fin->actual_length;		if (fsize > line6pcm->max_packet_size) {			dev_err(line6pcm->line6->ifcdev,				"driver and/or device bug: packet too large (%d > %d)/n",				fsize, line6pcm->max_packet_size);		}		length += fsize;		/* the following assumes LINE6_ISO_PACKETS == 1: */		line6pcm->prev_fbuf = fbuf;		line6pcm->prev_fsize = fsize;#ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE		if (!(line6pcm->flags & MASK_PCM_IMPULSE))#endif			if (test_bit(BIT_PCM_ALSA_CAPTURE, &line6pcm->flags)			    && (fsize > 0))				line6_capture_copy(line6pcm, fbuf, fsize);	}	clear_bit(index, &line6pcm->active_urb_in);	if (test_and_clear_bit(index, &line6pcm->unlink_urb_in))		shutdown = 1;	spin_unlock_irqrestore(&line6pcm->lock_audio_in, flags);	if (!shutdown) {		submit_audio_in_urb(line6pcm);#ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE		if (!(line6pcm->flags & MASK_PCM_IMPULSE))#endif			if (test_bit(BIT_PCM_ALSA_CAPTURE, &line6pcm->flags))				line6_capture_check_period(line6pcm, length);	}}

voidclear_arcofi(struct IsdnCardState *cs) {	if (test_and_clear_bit(FLG_ARCOFI_TIMER, &cs->HW_Flags)) {		del_timer(&cs->dc.isac.arcofitimer);	}}

//.........这里部分代码省略.........				break;			if (!timeout)				break;			if (file->f_flags & O_NONBLOCK) {				retval = -EAGAIN;				break;			}			if (signal_pending(current)) {				retval = -ERESTARTSYS;				break;			}			clear_bit(TTY_DONT_FLIP, &tty->flags);			timeout = schedule_timeout(timeout);			set_bit(TTY_DONT_FLIP, &tty->flags);			continue;		}		__set_current_state(TASK_RUNNING);		/* Deal with packet mode. */		if (tty->packet && b == buf) {			if (put_user(TIOCPKT_DATA, b++)) {				retval = -EFAULT;				b--;				break;			}			nr--;		}		if (tty->icanon) {			/* N.B. avoid overrun if nr == 0 */			while (nr && tty->read_cnt) { 				int eol;				eol = test_and_clear_bit(tty->read_tail,						tty->read_flags);				c = tty->read_buf[tty->read_tail];				spin_lock_irqsave(&tty->read_lock, flags);				tty->read_tail = ((tty->read_tail+1) &						  (N_TTY_BUF_SIZE-1));				tty->read_cnt--;				if (eol) {					/* this test should be redundant:					 * we shouldn't be reading data if					 * canon_data is 0					 */					if (--tty->canon_data < 0)						tty->canon_data = 0;				}				spin_unlock_irqrestore(&tty->read_lock, flags);				if (!eol || (c != __DISABLED_CHAR)) {					if (put_user(c, b++)) {						retval = -EFAULT;						b--;						break;					}					nr--;				}				if (eol)					break;			}			if (retval)				break;		} else {			int uncopied;			uncopied = copy_from_read_buf(tty, &b, &nr);

intarcofi_fsm(struct IsdnCardState *cs, int event, void *data) {	if (cs->debug & L1_DEB_MONITOR) {		debugl1(cs, "arcofi state %d event %d", cs->dc.isac.arcofi_state, event);	}	if (event == ARCOFI_TIMEOUT) {		cs->dc.isac.arcofi_state = ARCOFI_NOP;		test_and_set_bit(FLG_ARCOFI_ERROR, &cs->HW_Flags);		wake_up(&cs->dc.isac.arcofi_wait); 		return(1);	}	switch (cs->dc.isac.arcofi_state) {		case ARCOFI_NOP:			if (event == ARCOFI_START) {				cs->dc.isac.arcofi_list = data;				cs->dc.isac.arcofi_state = ARCOFI_TRANSMIT;				send_arcofi(cs);			}			break;		case ARCOFI_TRANSMIT:			if (event == ARCOFI_TX_END) {				if (cs->dc.isac.arcofi_list->receive) {					add_arcofi_timer(cs);					cs->dc.isac.arcofi_state = ARCOFI_RECEIVE;				} else {					if (cs->dc.isac.arcofi_list->next) {						cs->dc.isac.arcofi_list =							cs->dc.isac.arcofi_list->next;						send_arcofi(cs);					} else {						if (test_and_clear_bit(FLG_ARCOFI_TIMER, &cs->HW_Flags)) {							del_timer(&cs->dc.isac.arcofitimer);						}						cs->dc.isac.arcofi_state = ARCOFI_NOP;						wake_up(&cs->dc.isac.arcofi_wait);					}				}			}			break;		case ARCOFI_RECEIVE:			if (event == ARCOFI_RX_END) {				if (cs->dc.isac.arcofi_list->next) {					cs->dc.isac.arcofi_list =						cs->dc.isac.arcofi_list->next;					cs->dc.isac.arcofi_state = ARCOFI_TRANSMIT;					send_arcofi(cs);				} else {					if (test_and_clear_bit(FLG_ARCOFI_TIMER, &cs->HW_Flags)) {						del_timer(&cs->dc.isac.arcofitimer);					}					cs->dc.isac.arcofi_state = ARCOFI_NOP;					wake_up(&cs->dc.isac.arcofi_wait);				}			}			break;		default:			debugl1(cs, "Arcofi unknown state %x", cs->dc.isac.arcofi_state);			return(2);	}	return(0);}

static int iwl_send_scan_abort(struct iwl_priv *priv){	int ret;	struct iwl_rx_packet *pkt;	struct iwl_host_cmd cmd = {		.id = REPLY_SCAN_ABORT_CMD,		.flags = CMD_SYNC | CMD_WANT_SKB,	};	/* Exit instantly with error when device is not ready	 * to receive scan abort command or it does not perform	 * hardware scan currently */	if (!test_bit(STATUS_READY, &priv->shrd->status) ||	    !test_bit(STATUS_GEO_CONFIGURED, &priv->shrd->status) ||	    !test_bit(STATUS_SCAN_HW, &priv->shrd->status) ||	    test_bit(STATUS_FW_ERROR, &priv->shrd->status) ||	    test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))		return -EIO;	ret = iwl_trans_send_cmd(trans(priv), &cmd);	if (ret)		return ret;	pkt = (struct iwl_rx_packet *)cmd.reply_page;	if (pkt->u.status != CAN_ABORT_STATUS) {		/* The scan abort will return 1 for success or		 * 2 for "failure".  A failure condition can be		 * due to simply not being in an active scan which		 * can occur if we send the scan abort before we		 * the microcode has notified us that a scan is		 * completed. */		IWL_DEBUG_SCAN(priv, "SCAN_ABORT ret %d./n", pkt->u.status);		ret = -EIO;	}	iwl_free_pages(priv->shrd, cmd.reply_page);	return ret;}static void iwl_complete_scan(struct iwl_priv *priv, bool aborted){	/* check if scan was requested from mac80211 */	if (priv->scan_request) {		IWL_DEBUG_SCAN(priv, "Complete scan in mac80211/n");		ieee80211_scan_completed(priv->hw, aborted);	}	if (priv->scan_type == IWL_SCAN_ROC) {		ieee80211_remain_on_channel_expired(priv->hw);		priv->hw_roc_channel = NULL;		schedule_delayed_work(&priv->hw_roc_disable_work, 10 * HZ);	}	priv->scan_type = IWL_SCAN_NORMAL;	priv->scan_vif = NULL;	priv->scan_request = NULL;}static void iwl_process_scan_complete(struct iwl_priv *priv){	bool aborted;	lockdep_assert_held(&priv->shrd->mutex);	if (!test_and_clear_bit(STATUS_SCAN_COMPLETE, &priv->shrd->status))		return;	IWL_DEBUG_SCAN(priv, "Completed scan./n");	cancel_delayed_work(&priv->scan_check);	aborted = test_and_clear_bit(STATUS_SCAN_ABORTING, &priv->shrd->status);	if (aborted)		IWL_DEBUG_SCAN(priv, "Aborted scan completed./n");	if (!test_and_clear_bit(STATUS_SCANNING, &priv->shrd->status)) {		IWL_DEBUG_SCAN(priv, "Scan already completed./n");		goto out_settings;	}	if (priv->scan_type == IWL_SCAN_ROC) {		ieee80211_remain_on_channel_expired(priv->hw);		priv->hw_roc_channel = NULL;		schedule_delayed_work(&priv->hw_roc_disable_work, 10 * HZ);	}	if (priv->scan_type != IWL_SCAN_NORMAL && !aborted) {		int err;		/* Check if mac80211 requested scan during our internal scan */		if (priv->scan_request == NULL)			goto out_complete;		/* If so request a new scan */		err = iwl_scan_initiate(priv, priv->scan_vif, IWL_SCAN_NORMAL,					priv->scan_request->channels[0]->band);		if (err) {			IWL_DEBUG_SCAN(priv,				"failed to initiate pending scan: %d/n", err);			aborted = true;//.........这里部分代码省略.........

/* called by config.c */int __initsetup_enternow_pci(struct IsdnCard *card){	int bytecnt;	struct IsdnCardState *cs = card->cs;	char tmp[64];#if CONFIG_PCI#ifdef __BIG_ENDIAN#error "not running on big endian machines now"#endif        strcpy(tmp, enternow_pci_rev);	printk(KERN_INFO "HiSax: Formula-n Europe AG enter:now ISDN PCI driver Rev. %s/n", HiSax_getrev(tmp));	if (cs->typ != ISDN_CTYPE_ENTERNOW)		return(0);	test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);	for ( ;; )	{		if ((dev_netjet = pci_find_device(PCI_VENDOR_ID_TIGERJET,			PCI_DEVICE_ID_TIGERJET_300,  dev_netjet))) {			if (pci_enable_device(dev_netjet))				return(0);			cs->irq = dev_netjet->irq;			if (!cs->irq) {				printk(KERN_WARNING "enter:now PCI: No IRQ for PCI card found/n");				return(0);			}			cs->hw.njet.base = pci_resource_start(dev_netjet, 0);			if (!cs->hw.njet.base) {				printk(KERN_WARNING "enter:now PCI: No IO-Adr for PCI card found/n");				return(0);			}                        /* checks Sub-Vendor ID because system crashes with Traverse-Card */			if ((dev_netjet->subsystem_vendor != 0x55) ||				(dev_netjet->subsystem_device != 0x02)) {				printk(KERN_WARNING "enter:now: You tried to load this driver with an incompatible TigerJet-card/n");                                printk(KERN_WARNING "Use type=20 for Traverse NetJet PCI Card./n");                                return(0);                        }		} else {                        printk(KERN_WARNING "enter:now PCI: No PCI card found/n");			return(0);		}		cs->hw.njet.auxa = cs->hw.njet.base + NETJET_AUXDATA;		cs->hw.njet.isac = cs->hw.njet.base + 0xC0; // Fenster zum AMD		/* Reset an */		cs->hw.njet.ctrl_reg = 0x07;  // ge
C++ test_and_set_bit函数代码示例
C++ test_add函数代码示例