Attachment #303904 for bug #217119

Lines 552-559 static void rt2x00queue_kick_tx_queue(struct data_queue *queue, Link Here

(-)a/drivers/net/wireless/ralink/rt2x00/rt2x00queue.c (-1 / +2 lines)
552	* 2) Rule 1 can be broken when the available entries	552	* 2) Rule 1 can be broken when the available entries
553	* in the queue are less then a certain threshold.	553	* in the queue are less then a certain threshold.
554	*/	554	*/
555	if (rt2x00queue_threshold(queue) \|\|	555	/* if (rt2x00queue_threshold(queue) \|\|
556	!test_bit(ENTRY_TXD_BURST, &txdesc->flags))	556	!test_bit(ENTRY_TXD_BURST, &txdesc->flags))
		557	*/
557	queue->rt2x00dev->ops->lib->kick_queue(queue);	558	queue->rt2x00dev->ops->lib->kick_queue(queue);
558	}	559	}
559		560

Lines 32-37 static inline void drv_tx(struct ieee80211_local *local, Link Here

(-)a/net/mac80211/driver-ops.h (+5 lines)
32	struct ieee80211_tx_control *control,	32	struct ieee80211_tx_control *control,
33	struct sk_buff *skb)	33	struct sk_buff *skb)
34	{	34	{
		35	printk("XXXX %s: TX", __func__);
35	local->ops->tx(&local->hw, control, skb);	36	local->ops->tx(&local->hw, control, skb);
36	}	37	}
37		38
Lines 1197-1205 static inline void drv_wake_tx_queue(struct ieee80211_local *local, Link Here
1197	{	1198	{
1198	struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);	1199	struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);
1199		1200
		1201	printk("XXXX %s: called", __func__);
		1202
1200	/* In reconfig don't transmit now, but mark for waking later */	1203	/* In reconfig don't transmit now, but mark for waking later */
1201	if (local->in_reconfig) {	1204	if (local->in_reconfig) {
1202	set_bit(IEEE80211_TXQ_DIRTY, &txq->flags);	1205	set_bit(IEEE80211_TXQ_DIRTY, &txq->flags);
		1206	printk("XXXX %s: mark TID %u dirty", __func__, txq->txq.tid);
1203	return;	1207	return;
1204	}	1208	}
1205		1209
Lines 1208-1213 static inline void drv_wake_tx_queue(struct ieee80211_local *local, Link Here
1208		1212
1209	trace_drv_wake_tx_queue(local, sdata, txq);	1213	trace_drv_wake_tx_queue(local, sdata, txq);
1210	local->ops->wake_tx_queue(&local->hw, &txq->txq);	1214	local->ops->wake_tx_queue(&local->hw, &txq->txq);
		1215	printk("XXXX %s: EXIT", __func__);
1211	}	1216	}
1212		1217
1213	static inline void schedule_and_wake_txq(struct ieee80211_local *local,	1218	static inline void schedule_and_wake_txq(struct ieee80211_local *local,




	u32 flow_idx = fq_flow_idx(fq, skb);

	ieee80211_set_skb_enqueue_time(skb);
	printk("XXXX %s: TID %u", __func__, txqi->txq.tid);

	spin_lock_bh(&fq->lock);
	/*

begin:
	spin_lock(&local->queue_stop_reason_lock);
	q_stopped = local->queue_stop_reasons[q];
	spin_unlock(&local->queue_stop_reason_lock);

	if (unlikely(q_stopped)) {
		/* mark for waking later */
		set_bit(IEEE80211_TXQ_DIRTY, &txqi->flags);
		printk("XXXX %s: mark TID %u dirty. Reason: %lx",
		       __func__,
		       txqi->txq.tid,
		       local->queue_stop_reasons[q]);
		spin_unlock(&local->queue_stop_reason_lock);
		return NULL;
	}
	spin_unlock(&local->queue_stop_reason_lock);

	spin_lock_bh(&fq->lock);


	bool result;
	struct ieee80211_chanctx_conf *chanctx_conf;

	printk("XXXX %s: called", __func__);

	sdata = vif_to_sdata(info->control.vif);

	if (info->control.flags & IEEE80211_TX_INTCFL_NEED_TXPROCESSING) {

		result = __ieee80211_tx(local, &skbs, sta, true);
	}

	printk("XXXX %s: EXIT", __func__);
	return result;
}


	rcu_read_lock();

	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);

	printk("XXXX %s: called", __func__);

	for (i = 0; i < local->hw.queues; i++) {
		/*
		 * If queue is stopped by something other than due to pending

	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);

	rcu_read_unlock();
	printk("XXXX %s: EXIT", __func__);
}

/* functions for drivers to get certain frames */




	local_bh_disable();
	spin_lock(&fq->lock);

	printk("XXXX %s: ENTRY", __func__);
	if (!test_bit(SDATA_STATE_RUNNING, &sdata->state))
		goto out;


				continue;

			if (!test_and_clear_bit(IEEE80211_TXQ_DIRTY,
						&txqi->flags)) {
				printk("XXXX %s: TID %u NOT dirty", __func__, txq->tid);
				continue;
			}

			printk("XXXX %s: waking TID %u", __func__, txq->tid);
			spin_unlock(&fq->lock);
			drv_wake_tx_queue(local, txqi);
			spin_lock(&fq->lock);

	local_bh_enable();
	return;
out:
	printk("XXXX %s: EXIT", __func__);
	spin_unlock(&fq->lock);
	local_bh_enable();
}


void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
{
	printk("XXXX %s: called", __func__);
	ieee80211_wake_queue_by_reason(hw, queue,
				       IEEE80211_QUEUE_STOP_REASON_DRIVER,
				       false);


void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
{
	printk("XXXX %s: called", __func__);
	ieee80211_stop_queue_by_reason(hw, queue,
				       IEEE80211_QUEUE_STOP_REASON_DRIVER,
				       false);

Return to bug 217119

Lines 1465-1470 static void ieee80211_txq_enqueue(struct ieee80211_local *local, Link Here

(-)a/net/mac80211/tx.c (-1 / +14 lines)
1465	u32 flow_idx = fq_flow_idx(fq, skb);	1465	u32 flow_idx = fq_flow_idx(fq, skb);
1466		1466
1467	ieee80211_set_skb_enqueue_time(skb);	1467	ieee80211_set_skb_enqueue_time(skb);
		1468	printk("XXXX %s: TID %u", __func__, txqi->txq.tid);
1468		1469
1469	spin_lock_bh(&fq->lock);	1470	spin_lock_bh(&fq->lock);
1470	/*	1471	/*
Lines 3791-3803 struct sk_buff ieee80211_tx_dequeue(struct ieee80211_hw hw, Link Here
3791	begin:	3792	begin:
3792	spin_lock(&local->queue_stop_reason_lock);	3793	spin_lock(&local->queue_stop_reason_lock);
3793	q_stopped = local->queue_stop_reasons[q];	3794	q_stopped = local->queue_stop_reasons[q];
3794	spin_unlock(&local->queue_stop_reason_lock);
3795		3795
3796	if (unlikely(q_stopped)) {	3796	if (unlikely(q_stopped)) {
3797	/* mark for waking later */	3797	/* mark for waking later */
3798	set_bit(IEEE80211_TXQ_DIRTY, &txqi->flags);	3798	set_bit(IEEE80211_TXQ_DIRTY, &txqi->flags);
		3799	printk("XXXX %s: mark TID %u dirty. Reason: %lx",
		3800	__func__,
		3801	txqi->txq.tid,
		3802	local->queue_stop_reasons[q]);
		3803	spin_unlock(&local->queue_stop_reason_lock);
3799	return NULL;	3804	return NULL;
3800	}	3805	}
		3806	spin_unlock(&local->queue_stop_reason_lock);
3801		3807
3802	spin_lock_bh(&fq->lock);	3808	spin_lock_bh(&fq->lock);
3803		3809
Lines 4751-4756 static bool ieee80211_tx_pending_skb(struct ieee80211_local *local, Link Here
4751	bool result;	4757	bool result;
4752	struct ieee80211_chanctx_conf *chanctx_conf;	4758	struct ieee80211_chanctx_conf *chanctx_conf;
4753		4759
		4760	printk("XXXX %s: called", __func__);
		4761
4754	sdata = vif_to_sdata(info->control.vif);	4762	sdata = vif_to_sdata(info->control.vif);
4755		4763
4756	if (info->control.flags & IEEE80211_TX_INTCFL_NEED_TXPROCESSING) {	4764	if (info->control.flags & IEEE80211_TX_INTCFL_NEED_TXPROCESSING) {
Lines 4787-4792 static bool ieee80211_tx_pending_skb(struct ieee80211_local *local, Link Here
4787	result = __ieee80211_tx(local, &skbs, sta, true);	4795	result = __ieee80211_tx(local, &skbs, sta, true);
4788	}	4796	}
4789		4797
		4798	printk("XXXX %s: EXIT", __func__);
4790	return result;	4799	return result;
4791	}	4800	}
4792		4801
Lines 4804-4809 void ieee80211_tx_pending(struct tasklet_struct *t) Link Here
4804	rcu_read_lock();	4813	rcu_read_lock();
4805		4814
4806	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);	4815	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
		4816
		4817	printk("XXXX %s: called", __func__);
		4818
4807	for (i = 0; i < local->hw.queues; i++) {	4819	for (i = 0; i < local->hw.queues; i++) {
4808	/*	4820	/*
4809	* If queue is stopped by something other than due to pending	4821	* If queue is stopped by something other than due to pending
Lines 4835-4840 void ieee80211_tx_pending(struct tasklet_struct *t) Link Here
4835	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);	4847	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
4836		4848
4837	rcu_read_unlock();	4849	rcu_read_unlock();
		4850	printk("XXXX %s: EXIT", __func__);
4838	}	4851	}
4839		4852
4840	/* functions for drivers to get certain frames */	4853	/* functions for drivers to get certain frames */

Lines 337-342 static void __ieee80211_wake_txqs(struct ieee80211_sub_if_data *sdata, int ac) Link Here

(-)a/net/mac80211/util.c (-1 / +8 lines)
337	local_bh_disable();	337	local_bh_disable();
338	spin_lock(&fq->lock);	338	spin_lock(&fq->lock);
339		339
		340	printk("XXXX %s: ENTRY", __func__);
340	if (!test_bit(SDATA_STATE_RUNNING, &sdata->state))	341	if (!test_bit(SDATA_STATE_RUNNING, &sdata->state))
341	goto out;	342	goto out;
342		343
Lines 359-367 static void __ieee80211_wake_txqs(struct ieee80211_sub_if_data *sdata, int ac) Link Here
359	continue;	360	continue;
360		361
361	if (!test_and_clear_bit(IEEE80211_TXQ_DIRTY,	362	if (!test_and_clear_bit(IEEE80211_TXQ_DIRTY,
362	&txqi->flags))	363	&txqi->flags)) {
		364	printk("XXXX %s: TID %u NOT dirty", __func__, txq->tid);
363	continue;	365	continue;
		366	}
364		367
		368	printk("XXXX %s: waking TID %u", __func__, txq->tid);
365	spin_unlock(&fq->lock);	369	spin_unlock(&fq->lock);
366	drv_wake_tx_queue(local, txqi);	370	drv_wake_tx_queue(local, txqi);
367	spin_lock(&fq->lock);	371	spin_lock(&fq->lock);
Lines 383-388 static void __ieee80211_wake_txqs(struct ieee80211_sub_if_data *sdata, int ac) Link Here
383	local_bh_enable();	387	local_bh_enable();
384	return;	388	return;
385	out:	389	out:
		390	printk("XXXX %s: EXIT", __func__);
386	spin_unlock(&fq->lock);	391	spin_unlock(&fq->lock);
387	local_bh_enable();	392	local_bh_enable();
388	}	393	}
Lines 494-499 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue, Link Here
494		499
495	void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)	500	void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
496	{	501	{
		502	printk("XXXX %s: called", __func__);
497	ieee80211_wake_queue_by_reason(hw, queue,	503	ieee80211_wake_queue_by_reason(hw, queue,
498	IEEE80211_QUEUE_STOP_REASON_DRIVER,	504	IEEE80211_QUEUE_STOP_REASON_DRIVER,
499	false);	505	false);
Lines 533-538 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue, Link Here
533		539
534	void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)	540	void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
535	{	541	{
		542	printk("XXXX %s: called", __func__);
536	ieee80211_stop_queue_by_reason(hw, queue,	543	ieee80211_stop_queue_by_reason(hw, queue,
537	IEEE80211_QUEUE_STOP_REASON_DRIVER,	544	IEEE80211_QUEUE_STOP_REASON_DRIVER,
538	false);	545	false);