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

/** * dsp_gpt_wait_overflow - set gpt overflow and wait for fixed timeout * @clk_id:      GP Timer clock id. * @load:        Overflow value. * * Sets an overflow interrupt for the desired GPT waiting for a timeout * of 5 msecs for the interrupt to occur. */void dsp_gpt_wait_overflow(short int clk_id, unsigned int load){	struct omap_dm_timer *gpt = timer[clk_id - 1];	unsigned long timeout;	if (!gpt)		return;	/* Enable overflow interrupt */	omap_dm_timer_set_int_enable(gpt, OMAP_TIMER_INT_OVERFLOW);	/*	 * Set counter value to overflow counter after	 * one tick and start timer.	 */	omap_dm_timer_set_load_start(gpt, 0, load);	/* Wait 80us for timer to overflow */	udelay(80);	timeout = msecs_to_jiffies(5);	/* Check interrupt status and wait for interrupt */	while (!(omap_dm_timer_read_status(gpt) & OMAP_TIMER_INT_OVERFLOW)) {		if (time_is_after_jiffies(timeout)) {			pr_err("%s: GPTimer interrupt failed/n", __func__);			break;		}	}}

/* * Handle link status changes. For RNDIS_STATUS_NETWORK_CHANGE emulate link * down/up sequence. In case of RNDIS_STATUS_MEDIA_CONNECT when carrier is * present send GARP packet to network peers with netif_notify_peers(). */static void netvsc_link_change(struct work_struct *w){	struct net_device_context *ndev_ctx;	struct net_device *net;	struct netvsc_device *net_device;	struct rndis_device *rdev;	struct netvsc_reconfig *event = NULL;	bool notify = false, reschedule = false;	unsigned long flags, next_reconfig, delay;	ndev_ctx = container_of(w, struct net_device_context, dwork.work);	net_device = hv_get_drvdata(ndev_ctx->device_ctx);	rdev = net_device->extension;	net = net_device->ndev;	next_reconfig = ndev_ctx->last_reconfig + LINKCHANGE_INT;	if (time_is_after_jiffies(next_reconfig)) {		/* link_watch only sends one notification with current state		 * per second, avoid doing reconfig more frequently. Handle		 * wrap around.		 */		delay = next_reconfig - jiffies;		delay = delay < LINKCHANGE_INT ? delay : LINKCHANGE_INT;		schedule_delayed_work(&ndev_ctx->dwork, delay);		return;	}	ndev_ctx->last_reconfig = jiffies;	spin_lock_irqsave(&ndev_ctx->lock, flags);	if (!list_empty(&ndev_ctx->reconfig_events)) {		event = list_first_entry(&ndev_ctx->reconfig_events,					 struct netvsc_reconfig, list);		list_del(&event->list);		reschedule = !list_empty(&ndev_ctx->reconfig_events);	}

/* * After accepting the AddBA Response we activated a timer, * resetting it after each frame that we send. */static void sta_tx_agg_session_timer_expired(unsigned long data){	/* not an elegant detour, but there is no choice as the timer passes	 * only one argument, and various sta_info are needed here, so init	 * flow in sta_info_create gives the TID as data, while the timer_to_id	 * array gives the sta through container_of */	u8 *ptid = (u8 *)data;	u8 *timer_to_id = ptid - *ptid;	struct sta_info *sta = container_of(timer_to_id, struct sta_info,					 timer_to_tid[0]);	struct tid_ampdu_tx *tid_tx;	unsigned long timeout;	rcu_read_lock();	tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[*ptid]);	if (!tid_tx || test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {		rcu_read_unlock();		return;	}	timeout = tid_tx->last_tx + TU_TO_JIFFIES(tid_tx->timeout);	if (time_is_after_jiffies(timeout)) {		mod_timer(&tid_tx->session_timer, timeout);		rcu_read_unlock();		return;	}	rcu_read_unlock();	ht_dbg(sta->sdata, "tx session timer expired on %pM tid %d/n",	       sta->sta.addr, (u16)*ptid);	ieee80211_stop_tx_ba_session(&sta->sta, *ptid);}

int msmsdcc_suspend(struct platform_device *dev, pm_message_t state){	struct mmc_host *mmc = mmc_get_drvdata(dev);	int rc = 0;	if (mmc) {		struct msmsdcc_host *host = mmc_priv(mmc);		void __iomem *base = host->base;		uint32_t status;		unsigned long timeleft = jiffies + msecs_to_jiffies(100);		if (host->stat_irq)			disable_irq(host->stat_irq);		do {			status = readl(base + MMCISTATUS);			if (!(status & (MCI_TXFIFOEMPTY | MCI_RXFIFOEMPTY)))				break;			cpu_relax();		} while (time_is_after_jiffies(timeleft));		if (mmc->card && mmc->card->type != MMC_TYPE_SDIO)			rc = mmc_suspend_host(mmc, state);		if (!rc) {			writel(0, host->base + MMCIMASK0);			if (host->clks_on) {				clk_disable(host->clk);				clk_disable(host->pclk);				host->clks_on = 0;			}		}	}	return rc;}

static int gpu_i2c_check_status(struct gpu_i2c_dev *i2cd){	unsigned long target = jiffies + msecs_to_jiffies(1000);	u32 val;	do {		val = readl(i2cd->regs + I2C_MST_CNTL);		if (!(val & I2C_MST_CNTL_CYCLE_TRIGGER))			break;		if ((val & I2C_MST_CNTL_STATUS) !=				I2C_MST_CNTL_STATUS_BUS_BUSY)			break;		usleep_range(500, 600);	} while (time_is_after_jiffies(target));	if (time_is_before_jiffies(target)) {		dev_err(i2cd->dev, "i2c timeout error %x/n", val);		return -ETIMEDOUT;	}	val = readl(i2cd->regs + I2C_MST_CNTL);	switch (val & I2C_MST_CNTL_STATUS) {	case I2C_MST_CNTL_STATUS_OKAY:		return 0;	case I2C_MST_CNTL_STATUS_NO_ACK:		return -ENXIO;	case I2C_MST_CNTL_STATUS_TIMEOUT:		return -ETIMEDOUT;	default:		return 0;	}}

/* * After accepting the AddBA Response we activated a timer, * resetting it after each frame that we send. */static void sta_tx_agg_session_timer_expired(unsigned long data){    /* not an elegant detour, but there is no choice as the timer passes     * only one argument, and various sta_info are needed here, so init     * flow in sta_info_create gives the TID as data, while the timer_to_id     * array gives the sta through container_of */    u8 *ptid = (u8 *)data;    u8 *timer_to_id = ptid - *ptid;    struct sta_info *sta = container_of(timer_to_id, struct sta_info,                                        timer_to_tid[0]);    struct tid_ampdu_tx *tid_tx;    unsigned long timeout;    tid_tx = rcu_dereference_protected_tid_tx(sta, *ptid);    if (!tid_tx)        return;    timeout = tid_tx->last_tx + TU_TO_JIFFIES(tid_tx->timeout);    if (time_is_after_jiffies(timeout)) {        mod_timer(&tid_tx->session_timer, timeout);        return;    }#ifdef CONFIG_MAC80211_HT_DEBUG    printk(KERN_DEBUG "tx session timer expired on tid %d/n", (u16)*ptid);#endif    ieee80211_stop_tx_ba_session(&sta->sta, *ptid);}

/* * si4713_send_command - sends a command to si4713 and waits its response * @sdev: si4713_device structure for the device we are communicating * @command: command id * @args: command arguments we are sending (up to 7) * @argn: actual size of @args * @response: buffer to place the expected response from the device (up to 15) * @respn: actual size of @response * @usecs: amount of time to wait before reading the response (in usecs) */static int si4713_send_command(struct si4713_device *sdev, const u8 command,				const u8 args[], const int argn,				u8 response[], const int respn, const int usecs){	struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);	unsigned long until_jiffies;	u8 data1[MAX_ARGS + 1];	int err;	if (!client->adapter)		return -ENODEV;	/* First send the command and its arguments */	data1[0] = command;	memcpy(data1 + 1, args, argn);	DBG_BUFFER(&sdev->sd, "Parameters", data1, argn + 1);	err = i2c_master_send(client, data1, argn + 1);	if (err != argn + 1) {		v4l2_err(&sdev->sd, "Error while sending command 0x%02x/n",			command);		return err < 0 ? err : -EIO;	}	until_jiffies = jiffies + usecs_to_jiffies(usecs) + 1;	/* Wait response from interrupt */	if (client->irq) {		if (!wait_for_completion_timeout(&sdev->work,				usecs_to_jiffies(usecs) + 1))			v4l2_warn(&sdev->sd,				"(%s) Device took too much time to answer./n",				__func__);	}	do {		err = i2c_master_recv(client, response, respn);		if (err != respn) {			v4l2_err(&sdev->sd,				"Error %d while reading response for command 0x%02x/n",				err, command);			return err < 0 ? err : -EIO;		}		DBG_BUFFER(&sdev->sd, "Response", response, respn);		if (!check_command_failed(response[0]))			return 0;		if (client->irq)			return -EBUSY;		if (usecs <= 1000)			usleep_range(usecs, 1000);		else			usleep_range(1000, 2000);	} while (time_is_after_jiffies(until_jiffies));	return -EBUSY;}

static void tsc200x_esd_work(struct work_struct *work){    struct tsc200x *ts = container_of(work, struct tsc200x, esd_work.work);    int error;    unsigned int r;    if (!mutex_trylock(&ts->mutex)) {        /*         * If the mutex is taken, it means that disable or enable is in         * progress. In that case just reschedule the work. If the work         * is not needed, it will be canceled by disable.         */        goto reschedule;    }    if (time_is_after_jiffies(ts->last_valid_interrupt +                              msecs_to_jiffies(ts->esd_timeout)))        goto out;    /* We should be able to read register without disabling interrupts. */    error = regmap_read(ts->regmap, TSC200X_REG_CFR0, &r);    if (!error &&            !((r ^ TSC200X_CFR0_INITVALUE) & TSC200X_CFR0_RW_MASK)) {        goto out;    }    /*     * If we could not read our known value from configuration register 0     * then we should reset the controller as if from power-up and start     * scanning again.     */    dev_info(ts->dev, "TSC200X not responding - resetting/n");    disable_irq(ts->irq);    del_timer_sync(&ts->penup_timer);    tsc200x_update_pen_state(ts, 0, 0, 0);    tsc200x_set_reset(ts, false);    usleep_range(100, 500); /* only 10us required */    tsc200x_set_reset(ts, true);    enable_irq(ts->irq);    tsc200x_start_scan(ts);out:    mutex_unlock(&ts->mutex);reschedule:    /* re-arm the watchdog */    schedule_delayed_work(&ts->esd_work,                          round_jiffies_relative(                              msecs_to_jiffies(ts->esd_timeout)));}

static struct sk_buff *mt76_mcu_get_response(struct mt76_dev *dev, unsigned long expires){	unsigned long timeout;	if (!time_is_after_jiffies(expires))		return NULL;	timeout = expires - jiffies;	wait_event_timeout(dev->mcu.wait, !skb_queue_empty(&dev->mcu.res_q),			   timeout);	return skb_dequeue(&dev->mcu.res_q);}

static int fm10k_mbx_test(struct fm10k_intfc *interface, u64 *data){	struct fm10k_hw *hw = &interface->hw;	struct fm10k_mbx_info *mbx = &hw->mbx;	u32 attr_flag, test_msg[6];	unsigned long timeout;	int err;	/* For now this is a VF only feature */	if (hw->mac.type != fm10k_mac_vf)		return 0;	/* loop through both nested and unnested attribute types */	for (attr_flag = (1 << FM10K_TEST_MSG_UNSET);	     attr_flag < (1 << (2 * FM10K_TEST_MSG_NESTED));	     attr_flag += attr_flag) {		/* generate message to be tested */		fm10k_tlv_msg_test_create(test_msg, attr_flag);		fm10k_mbx_lock(interface);		mbx->test_result = FM10K_NOT_IMPLEMENTED;		err = mbx->ops.enqueue_tx(hw, mbx, test_msg);		fm10k_mbx_unlock(interface);		/* wait up to 1 second for response */		timeout = jiffies + HZ;		do {			if (err < 0)				goto err_out;			usleep_range(500, 1000);			fm10k_mbx_lock(interface);			mbx->ops.process(hw, mbx);			fm10k_mbx_unlock(interface);			err = mbx->test_result;			if (!err)				break;		} while (time_is_after_jiffies(timeout));		/* reporting errors */		if (err)			goto err_out;	}err_out:	*data = err < 0 ? (attr_flag) : (err > 0);	return err;}

static bool hvc_dcc_check(void){	unsigned long time = jiffies + (HZ / 10);	/* Write a test character to check if it is handled */	__dcc_putchar('/n');	while (time_is_after_jiffies(time)) {		if (!(__dcc_getstatus() & DCC_STATUS_TX))			return true;	}	return false;}

static void wil_fw_error_worker(struct work_struct *work){	struct wil6210_priv *wil = container_of(work,			struct wil6210_priv, fw_error_worker);	struct wireless_dev *wdev = wil->wdev;	wil_dbg_misc(wil, "fw error worker/n");	if (no_fw_recovery)		return;	/* increment @recovery_count if less then WIL6210_FW_RECOVERY_TO	 * passed since last recovery attempt	 */	if (time_is_after_jiffies(wil->last_fw_recovery +				  WIL6210_FW_RECOVERY_TO))		wil->recovery_count++;	else		wil->recovery_count = 1; /* fw was alive for a long time */	if (wil->recovery_count > WIL6210_FW_RECOVERY_RETRIES) {		wil_err(wil, "too many recovery attempts (%d), giving up/n",			wil->recovery_count);		return;	}	wil->last_fw_recovery = jiffies;	mutex_lock(&wil->mutex);	switch (wdev->iftype) {	case NL80211_IFTYPE_STATION:	case NL80211_IFTYPE_P2P_CLIENT:	case NL80211_IFTYPE_MONITOR:		wil_info(wil, "fw error recovery started (try %d).../n",			 wil->recovery_count);		wil_reset(wil);		/* need to re-allocate Rx ring after reset */		wil_rx_init(wil);		break;	case NL80211_IFTYPE_AP:	case NL80211_IFTYPE_P2P_GO:		/* recovery in these modes is done by upper layers */		break;	default:		break;	}	mutex_unlock(&wil->mutex);}

static int ucsi_reset_ppm(struct ucsi *ucsi){	struct ucsi_control ctrl;	unsigned long tmo;	int ret;	ctrl.raw_cmd = 0;	ctrl.cmd.cmd = UCSI_PPM_RESET;	trace_ucsi_command(&ctrl);	ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl);	if (ret)		goto err;	tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS);	do {		/* Here sync is critical. */		ret = ucsi_sync(ucsi);		if (ret)			goto err;		if (ucsi->ppm->data->cci.reset_complete)			break;		/* If the PPM is still doing something else, reset it again. */		if (ucsi->ppm->data->raw_cci) {			dev_warn_ratelimited(ucsi->dev,				"Failed to reset PPM! Trying again../n");			trace_ucsi_command(&ctrl);			ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl);			if (ret)				goto err;		}		/* Letting the PPM settle down. */		msleep(20);		ret = -ETIMEDOUT;	} while (time_is_after_jiffies(tmo));err:	trace_ucsi_reset_ppm(&ctrl, ret);	return ret;}

/** * m5mols_busy_wait - Busy waiting with I2C register polling * @reg: the I2C_REG() address of an 8-bit status register to check * @value: expected status register value * @mask: bit mask for the read status register value * @timeout: timeout in miliseconds, or -1 for default timeout * * The @reg register value is ORed with @mask before comparing with @value. * * Return: 0 if the requested condition became true within less than *         @timeout ms, or else negative errno. */int m5mols_busy_wait(struct v4l2_subdev *sd, u32 reg, u32 value, u32 mask,		     int timeout){	int ms = timeout < 0 ? M5MOLS_BUSY_WAIT_DEF_TIMEOUT : timeout;	unsigned long end = jiffies + msecs_to_jiffies(ms);	u8 status;	do {		int ret = m5mols_read_u8(sd, reg, &status);		if (ret < 0 && !(mask & M5MOLS_I2C_RDY_WAIT_FL))			return ret;		if (!ret && (status & mask & 0xff) == (value & 0xff))			return 0;		usleep_range(100, 250);	} while (ms > 0 && time_is_after_jiffies(end));	return -EBUSY;}

void flite_hw_reset(struct fimc_lite *dev){	unsigned long end = jiffies + msecs_to_jiffies(FLITE_RESET_TIMEOUT);	u32 cfg;	cfg = readl(dev->regs + FLITE_REG_CIGCTRL);	cfg |= FLITE_REG_CIGCTRL_SWRST_REQ;	writel(cfg, dev->regs + FLITE_REG_CIGCTRL);	while (time_is_after_jiffies(end)) {		cfg = readl(dev->regs + FLITE_REG_CIGCTRL);		if (cfg & FLITE_REG_CIGCTRL_SWRST_RDY)			break;		usleep_range(1000, 5000);	}	cfg |= FLITE_REG_CIGCTRL_SWRST;	writel(cfg, dev->regs + FLITE_REG_CIGCTRL);}

/* * See if the other side has responded to a partition deactivate request * from us. Though we requested the remote partition to deactivate with regard * to us, we really only need to wait for the other side to disengage from us. */intxpc_partition_disengaged(struct xpc_partition *part){	short partid = XPC_PARTID(part);	int disengaged;	disengaged = !xpc_partition_engaged(partid);	if (part->disengage_timeout) {		if (!disengaged) {			if (time_is_after_jiffies(part->disengage_timeout)) {				/* timelimit hasn't been reached yet */				return 0;			}			/*			 * Other side hasn't responded to our deactivate			 * request in a timely fashion, so assume it's dead.			 */			dev_info(xpc_part, "deactivate request to remote "				 "partition %d timed out/n", partid);			xpc_disengage_timedout = 1;			xpc_assume_partition_disengaged(partid);			disengaged = 1;		}		part->disengage_timeout = 0;		/* cancel the timer function, provided it's not us */		if (!in_interrupt())			del_singleshot_timer_sync(&part->disengage_timer);		DBUG_ON(part->act_state != XPC_P_AS_DEACTIVATING &&			part->act_state != XPC_P_AS_INACTIVE);		if (part->act_state != XPC_P_AS_INACTIVE)			xpc_wakeup_channel_mgr(part);		xpc_cancel_partition_deactivation_request(part);	}	return disengaged;}

static unsigned long round_jiffies_common(unsigned long j, int cpu,		bool force_up){	int rem;	unsigned long original = j;	/*	 * We don't want all cpus firing their timers at once hitting the	 * same lock or cachelines, so we skew each extra cpu with an extra	 * 3 jiffies. This 3 jiffies came originally from the mm/ code which	 * already did this.	 * The skew is done by adding 3*cpunr, then round, then subtract this	 * extra offset again.	 */	j += cpu * 3;	rem = j % HZ;	/*	 * If the target jiffie is just after a whole second (which can happen	 * due to delays of the timer irq, long irq off times etc etc) then	 * we should round down to the whole second, not up. Use 1/4th second	 * as cutoff for this rounding as an extreme upper bound for this.	 * But never round down if @force_up is set.	 */	if (rem < HZ/4 && !force_up) /* round down */		j = j - rem;	else /* round up */		j = j - rem + HZ;	/* now that we have rounded, subtract the extra skew again */	j -= cpu * 3;	/*	 * Make sure j is still in the future. Otherwise return the	 * unmodified value.	 */	return time_is_after_jiffies(j) ? j : original;}

static int stk1160_i2c_busy_wait(struct stk1160 *dev, u8 wait_bit_mask){	unsigned long end;	u8 flag;	/* Wait until read/write finish bit is set */	end = jiffies + msecs_to_jiffies(STK1160_I2C_TIMEOUT);	while (time_is_after_jiffies(end)) {		stk1160_read_reg(dev, STK1160_SICTL+1, &flag);		/* read/write done? */		if (flag & wait_bit_mask)			goto done;		usleep_range(10 * USEC_PER_MSEC, 20 * USEC_PER_MSEC);	}	return -ETIMEDOUT;done:	return 0;}

/* * this is the low level routine to * reset the device on the One Wire interface * on the hardware */static u8 mxc_w1_ds2_reset_bus(void *data){	struct mxc_w1_device *dev = data;	unsigned long timeout;	writeb(MXC_W1_CONTROL_RPP, dev->regs + MXC_W1_CONTROL);	/* Wait for reset sequence 511+512us, use 1500us for sure */	timeout = jiffies + usecs_to_jiffies(1500);	udelay(511 + 512);	do {		u8 ctrl = readb(dev->regs + MXC_W1_CONTROL);		/* PST bit is valid after the RPP bit is self-cleared */		if (!(ctrl & MXC_W1_CONTROL_RPP))			return !(ctrl & MXC_W1_CONTROL_PST);	} while (time_is_after_jiffies(timeout));	return 1;}

/* * this is the low level routine to read/write a bit on the One Wire * interface on the hardware. It does write 0 if parameter bit is set * to 0, otherwise a write 1/read. */static u8 mxc_w1_ds2_touch_bit(void *data, u8 bit){	struct mxc_w1_device *dev = data;	unsigned long timeout;	writeb(MXC_W1_CONTROL_WR(bit), dev->regs + MXC_W1_CONTROL);	/* Wait for read/write bit (60us, Max 120us), use 200us for sure */	timeout = jiffies + usecs_to_jiffies(200);	udelay(60);	do {		u8 ctrl = readb(dev->regs + MXC_W1_CONTROL);		/* RDST bit is valid after the WR1/RD bit is self-cleared */		if (!(ctrl & MXC_W1_CONTROL_WR(bit)))			return !!(ctrl & MXC_W1_CONTROL_RDST);	} while (time_is_after_jiffies(timeout));	return 0;}

static int __watchdog_ping(struct watchdog_device *wdd){	struct watchdog_core_data *wd_data = wdd->wd_data;	unsigned long earliest_keepalive = wd_data->last_hw_keepalive +				msecs_to_jiffies(wdd->min_hw_heartbeat_ms);	int err;	if (time_is_after_jiffies(earliest_keepalive)) {		mod_delayed_work(watchdog_wq, &wd_data->work,				 earliest_keepalive - jiffies);		return 0;	}	wd_data->last_hw_keepalive = jiffies;	if (wdd->ops->ping)		err = wdd->ops->ping(wdd);  /* ping the watchdog */	else		err = wdd->ops->start(wdd); /* restart watchdog */	watchdog_update_worker(wdd);	return err;}

void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid){	struct tid_ampdu_tx *tid_tx;	struct ieee80211_local *local = sta->local;	struct ieee80211_sub_if_data *sdata = sta->sdata;	struct ieee80211_ampdu_params params = {		.sta = &sta->sta,		.action = IEEE80211_AMPDU_TX_START,		.tid = tid,		.buf_size = 0,		.amsdu = false,		.timeout = 0,	};	int ret;	tid_tx = rcu_dereference_protected_tid_tx(sta, tid);	/*	 * Start queuing up packets for this aggregation session.	 * We're going to release them once the driver is OK with	 * that.	 */	clear_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);	ieee80211_agg_stop_txq(sta, tid);	/*	 * Make sure no packets are being processed. This ensures that	 * we have a valid starting sequence number and that in-flight	 * packets have been flushed out and no packets for this TID	 * will go into the driver during the ampdu_action call.	 */	synchronize_net();	params.ssn = sta->tid_seq[tid] >> 4;	ret = drv_ampdu_action(local, sdata, &params);	if (ret) {		ht_dbg(sdata,		       "BA request denied - HW unavailable for %pM tid %d/n",		       sta->sta.addr, tid);		spin_lock_bh(&sta->lock);		ieee80211_agg_splice_packets(sdata, tid_tx, tid);		ieee80211_assign_tid_tx(sta, tid, NULL);		ieee80211_agg_splice_finish(sdata, tid);		spin_unlock_bh(&sta->lock);		ieee80211_agg_start_txq(sta, tid, false);		kfree_rcu(tid_tx, rcu_head);		return;	}	/* activate the timer for the recipient's addBA response */	mod_timer(&tid_tx->addba_resp_timer, jiffies + ADDBA_RESP_INTERVAL);	ht_dbg(sdata, "activated addBA response timer on %pM tid %d/n",	       sta->sta.addr, tid);	spin_lock_bh(&sta->lock);	sta->ampdu_mlme.last_addba_req_time[tid] = jiffies;	sta->ampdu_mlme.addba_req_num[tid]++;	spin_unlock_bh(&sta->lock);	/* send AddBA request */	ieee80211_send_addba_request(sdata, sta->sta.addr, tid,				     tid_tx->dialog_token, params.ssn,				     IEEE80211_MAX_AMPDU_BUF,				     tid_tx->timeout);}/* * After accepting the AddBA Response we activated a timer, * resetting it after each frame that we send. */static void sta_tx_agg_session_timer_expired(unsigned long data){	/* not an elegant detour, but there is no choice as the timer passes	 * only one argument, and various sta_info are needed here, so init	 * flow in sta_info_create gives the TID as data, while the timer_to_id	 * array gives the sta through container_of */	u8 *ptid = (u8 *)data;	u8 *timer_to_id = ptid - *ptid;	struct sta_info *sta = container_of(timer_to_id, struct sta_info,					 timer_to_tid[0]);	struct tid_ampdu_tx *tid_tx;	unsigned long timeout;	rcu_read_lock();	tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[*ptid]);	if (!tid_tx || test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {		rcu_read_unlock();		return;	}	timeout = tid_tx->last_tx + TU_TO_JIFFIES(tid_tx->timeout);	if (time_is_after_jiffies(timeout)) {		mod_timer(&tid_tx->session_timer, timeout);		rcu_read_unlock();		return;	}//.........这里部分代码省略.........

static int etnaviv_hw_reset(struct etnaviv_gpu *gpu){	u32 control, idle;	unsigned long timeout;	bool failed = true;	/* TODO	 *	 * - clock gating	 * - puls eater	 * - what about VG?	 */	/* We hope that the GPU resets in under one second */	timeout = jiffies + msecs_to_jiffies(1000);	while (time_is_after_jiffies(timeout)) {		control = VIVS_HI_CLOCK_CONTROL_DISABLE_DEBUG_REGISTERS |			  VIVS_HI_CLOCK_CONTROL_FSCALE_VAL(0x40);		/* enable clock */		etnaviv_gpu_load_clock(gpu, control);		/* Wait for stable clock.  Vivante's code waited for 1ms */		usleep_range(1000, 10000);		/* isolate the GPU. */		control |= VIVS_HI_CLOCK_CONTROL_ISOLATE_GPU;		gpu_write(gpu, VIVS_HI_CLOCK_CONTROL, control);		/* set soft reset. */		control |= VIVS_HI_CLOCK_CONTROL_SOFT_RESET;		gpu_write(gpu, VIVS_HI_CLOCK_CONTROL, control);		/* wait for reset. */		msleep(1);		/* reset soft reset bit. */		control &= ~VIVS_HI_CLOCK_CONTROL_SOFT_RESET;		gpu_write(gpu, VIVS_HI_CLOCK_CONTROL, control);		/* reset GPU isolation. */		control &= ~VIVS_HI_CLOCK_CONTROL_ISOLATE_GPU;		gpu_write(gpu, VIVS_HI_CLOCK_CONTROL, control);		/* read idle register. */		idle = gpu_read(gpu, VIVS_HI_IDLE_STATE);		/* try reseting again if FE it not idle */		if ((idle & VIVS_HI_IDLE_STATE_FE) == 0) {			dev_dbg(gpu->dev, "FE is not idle/n");			continue;		}		/* read reset register. */		control = gpu_read(gpu, VIVS_HI_CLOCK_CONTROL);		/* is the GPU idle? */		if (((control & VIVS_HI_CLOCK_CONTROL_IDLE_3D) == 0) ||		    ((control & VIVS_HI_CLOCK_CONTROL_IDLE_2D) == 0)) {			dev_dbg(gpu->dev, "GPU is not idle/n");			continue;		}		failed = false;		break;	}	if (failed) {		idle = gpu_read(gpu, VIVS_HI_IDLE_STATE);		control = gpu_read(gpu, VIVS_HI_CLOCK_CONTROL);		dev_err(gpu->dev, "GPU failed to reset: FE %sidle, 3D %sidle, 2D %sidle/n",			idle & VIVS_HI_IDLE_STATE_FE ? "" : "not ",			control & VIVS_HI_CLOCK_CONTROL_IDLE_3D ? "" : "not ",			control & VIVS_HI_CLOCK_CONTROL_IDLE_2D ? "" : "not ");		return -EBUSY;	}	/* We rely on the GPU running, so program the clock */	control = VIVS_HI_CLOCK_CONTROL_DISABLE_DEBUG_REGISTERS |		  VIVS_HI_CLOCK_CONTROL_FSCALE_VAL(0x40);	/* enable clock */	etnaviv_gpu_load_clock(gpu, control);	return 0;}

//.........这里部分代码省略.........	spin_lock_bh(&sta->lock);	sta->ampdu_mlme.last_addba_req_time[tid] = jiffies;	sta->ampdu_mlme.addba_req_num[tid]++;	spin_unlock_bh(&sta->lock);	/* send AddBA request */	ieee80211_send_addba_request(sdata, sta->sta.addr, tid,				     tid_tx->dialog_token, params.ssn,				     IEEE80211_MAX_AMPDU_BUF,				     tid_tx->timeout);}/* * After accepting the AddBA Response we activated a timer, * resetting it after each frame that we send. */static void sta_tx_agg_session_timer_expired(struct timer_list *t){	struct tid_ampdu_tx *tid_tx_timer =		from_timer(tid_tx_timer, t, session_timer);	struct sta_info *sta = tid_tx_timer->sta;	u8 tid = tid_tx_timer->tid;	struct tid_ampdu_tx *tid_tx;	unsigned long timeout;	rcu_read_lock();	tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);	if (!tid_tx || test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {		rcu_read_unlock();		return;	}	timeout = tid_tx->last_tx + TU_TO_JIFFIES(tid_tx->timeout);	if (time_is_after_jiffies(timeout)) {		mod_timer(&tid_tx->session_timer, timeout);		rcu_read_unlock();		return;	}	rcu_read_unlock();	ht_dbg(sta->sdata, "tx session timer expired on %pM tid %d/n",	       sta->sta.addr, tid);	ieee80211_stop_tx_ba_session(&sta->sta, tid);}int ieee80211_start_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid,				  u16 timeout){	struct sta_info *sta = container_of(pubsta, struct sta_info, sta);	struct ieee80211_sub_if_data *sdata = sta->sdata;	struct ieee80211_local *local = sdata->local;	struct tid_ampdu_tx *tid_tx;	int ret = 0;	trace_api_start_tx_ba_session(pubsta, tid);	if (WARN(sta->reserved_tid == tid,		 "Requested to start BA session on reserved tid=%d", tid))		return -EINVAL;	if (!pubsta->ht_cap.ht_supported)		return -EINVAL;	if (WARN_ON_ONCE(!local->ops->ampdu_action))

static void iso_resource_work(struct work_struct *work){	struct iso_resource_event *e;	struct iso_resource *r =			container_of(work, struct iso_resource, work.work);	struct client *client = r->client;	int generation, channel, bandwidth, todo;	bool skip, free, success;	spin_lock_irq(&client->lock);	generation = client->device->generation;	todo = r->todo;	/* Allow 1000ms grace period for other reallocations. */	if (todo == ISO_RES_ALLOC &&	    time_is_after_jiffies(client->device->card->reset_jiffies + HZ)) {		if (schedule_delayed_work(&r->work, DIV_ROUND_UP(HZ, 3)))			client_get(client);		skip = true;	} else {		/* We could be called twice within the same generation. */		skip = todo == ISO_RES_REALLOC &&		       r->generation == generation;	}	free = todo == ISO_RES_DEALLOC ||	       todo == ISO_RES_ALLOC_ONCE ||	       todo == ISO_RES_DEALLOC_ONCE;	r->generation = generation;	spin_unlock_irq(&client->lock);	if (skip)		goto out;	bandwidth = r->bandwidth;	fw_iso_resource_manage(client->device->card, generation,			r->channels, &channel, &bandwidth,			todo == ISO_RES_ALLOC ||			todo == ISO_RES_REALLOC ||			todo == ISO_RES_ALLOC_ONCE,			r->transaction_data);	/*	 * Is this generation outdated already?  As long as this resource sticks	 * in the idr, it will be scheduled again for a newer generation or at	 * shutdown.	 */	if (channel == -EAGAIN &&	    (todo == ISO_RES_ALLOC || todo == ISO_RES_REALLOC))		goto out;	success = channel >= 0 || bandwidth > 0;	spin_lock_irq(&client->lock);	/*	 * Transit from allocation to reallocation, except if the client	 * requested deallocation in the meantime.	 */	if (r->todo == ISO_RES_ALLOC)		r->todo = ISO_RES_REALLOC;	/*	 * Allocation or reallocation failure?  Pull this resource out of the	 * idr and prepare for deletion, unless the client is shutting down.	 */	if (r->todo == ISO_RES_REALLOC && !success &&	    !client->in_shutdown &&	    idr_find(&client->resource_idr, r->resource.handle)) {		idr_remove(&client->resource_idr, r->resource.handle);		client_put(client);		free = true;	}	spin_unlock_irq(&client->lock);	if (todo == ISO_RES_ALLOC && channel >= 0)		r->channels = 1ULL << channel;	if (todo == ISO_RES_REALLOC && success)		goto out;	if (todo == ISO_RES_ALLOC || todo == ISO_RES_ALLOC_ONCE) {		e = r->e_alloc;		r->e_alloc = NULL;	} else {		e = r->e_dealloc;		r->e_dealloc = NULL;	}	e->resource.handle	= r->resource.handle;	e->resource.channel	= channel;	e->resource.bandwidth	= bandwidth;	queue_event(client, &e->event,		    &e->resource, sizeof(e->resource), NULL, 0);	if (free) {		cancel_delayed_work(&r->work);		kfree(r->e_alloc);		kfree(r->e_dealloc);		kfree(r);	} out:	client_put(client);}