Commit a0eaad71 authored by Emmanuel Grumbach's avatar Emmanuel Grumbach Committed by John W. Linville
Browse files

iwlagn: reclaim the packets in transport layer 



The reclaim flow is really transport related. Define a simple API to allow the
upper layer to request from the transport layer to reclaim packets until an
index written in the Tx response / BA notification.
The transport layer prepares a list of the packets that are being freed and
passes this list to the upper layer.
Between the two layers, the CB of the skb is used to pass a pointer to the
context (BSS / PAN) in which the skb was sent.

Signed-off-by: default avatarEmmanuel Grumbach <emmanuel.grumbach@intel.com>
Signed-off-by: default avatarWey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: default avatarJohn W. Linville <linville@tuxdriver.com>
parent 1f7b6172

drivers/net/wireless/iwlwifi/iwl-agn-lib.c

+3 −268
Original line number Diff line number Diff line
@@ -42,12 +42,6 @@ 
#include "iwl-trans.h"

#include "iwl-shared.h"



static inline u32 iwlagn_get_scd_ssn(struct iwlagn_tx_resp *tx_resp)

{

	return le32_to_cpup((__le32 *)&tx_resp->status +

			    tx_resp->frame_count) & MAX_SN;

}



static void iwlagn_count_tx_err_status(struct iwl_priv *priv, u16 status)

{

	status &= TX_STATUS_MSK;
@@ -125,7 +119,7 @@ static void iwlagn_count_tx_err_status(struct iwl_priv *priv, u16 status) 
	}

}



static void iwlagn_count_agg_tx_err_status(struct iwl_priv *priv, u16 status)

void iwlagn_count_agg_tx_err_status(struct iwl_priv *priv, u16 status)

{

	status &= AGG_TX_STATUS_MSK;
@@ -172,11 +166,10 @@ static void iwlagn_count_agg_tx_err_status(struct iwl_priv *priv, u16 status) 
	}

}



static void iwlagn_set_tx_status(struct iwl_priv *priv,

void iwlagn_set_tx_status(struct iwl_priv *priv,

				 struct ieee80211_tx_info *info,

				 struct iwl_rxon_context *ctx,

				 struct iwlagn_tx_resp *tx_resp,

				 int txq_id, bool is_agg)

				 bool is_agg)

{

	u16  status = le16_to_cpu(tx_resp->status.status);
@@ -188,20 +181,6 @@ static void iwlagn_set_tx_status(struct iwl_priv *priv, 
				    info);

	if (!iwl_is_tx_success(status))

		iwlagn_count_tx_err_status(priv, status);



	if (status == TX_STATUS_FAIL_PASSIVE_NO_RX &&

	    iwl_is_associated_ctx(ctx) && ctx->vif &&

	    ctx->vif->type == NL80211_IFTYPE_STATION) {

		ctx->last_tx_rejected = true;

		iwl_stop_queue(priv, &priv->txq[txq_id]);

	}



	IWL_DEBUG_TX_REPLY(priv, "TXQ %d status %s (0x%08x) rate_n_flags "

			   "0x%x retries %d\n",

			   txq_id,

			   iwl_get_tx_fail_reason(status), status,

			   le32_to_cpu(tx_resp->rate_n_flags),

			   tx_resp->failure_frame);

}



#ifdef CONFIG_IWLWIFI_DEBUG
@@ -231,157 +210,6 @@ const char *iwl_get_agg_tx_fail_reason(u16 status) 
}

#endif /* CONFIG_IWLWIFI_DEBUG */



static int iwlagn_tx_status_reply_tx(struct iwl_priv *priv,

				      struct iwl_ht_agg *agg,

				      struct iwlagn_tx_resp *tx_resp,

				      int txq_id, u16 start_idx)

{

	u16 status;

	struct agg_tx_status *frame_status = &tx_resp->status;

	struct ieee80211_hdr *hdr = NULL;

	int i, sh, idx;

	u16 seq;



	if (agg->wait_for_ba)

		IWL_DEBUG_TX_REPLY(priv, "got tx response w/o block-ack\n");



	agg->frame_count = tx_resp->frame_count;

	agg->start_idx = start_idx;

	agg->rate_n_flags = le32_to_cpu(tx_resp->rate_n_flags);

	agg->bitmap = 0;



	/* # frames attempted by Tx command */

	if (agg->frame_count == 1) {

		struct iwl_tx_info *txb;



		/* Only one frame was attempted; no block-ack will arrive */

		idx = start_idx;



		IWL_DEBUG_TX_REPLY(priv, "FrameCnt = %d, StartIdx=%d idx=%d\n",

				   agg->frame_count, agg->start_idx, idx);

		txb = &priv->txq[txq_id].txb[idx];

		iwlagn_set_tx_status(priv, IEEE80211_SKB_CB(txb->skb),

				     txb->ctx, tx_resp, txq_id, true);

		agg->wait_for_ba = 0;

	} else {

		/* Two or more frames were attempted; expect block-ack */

		u64 bitmap = 0;



		/*

		 * Start is the lowest frame sent. It may not be the first

		 * frame in the batch; we figure this out dynamically during

		 * the following loop.

		 */

		int start = agg->start_idx;



		/* Construct bit-map of pending frames within Tx window */

		for (i = 0; i < agg->frame_count; i++) {

			u16 sc;

			status = le16_to_cpu(frame_status[i].status);

			seq  = le16_to_cpu(frame_status[i].sequence);

			idx = SEQ_TO_INDEX(seq);

			txq_id = SEQ_TO_QUEUE(seq);



			if (status & AGG_TX_STATUS_MSK)

				iwlagn_count_agg_tx_err_status(priv, status);



			if (status & (AGG_TX_STATE_FEW_BYTES_MSK |

				      AGG_TX_STATE_ABORT_MSK))

				continue;



			IWL_DEBUG_TX_REPLY(priv, "FrameCnt = %d, txq_id=%d idx=%d\n",

					   agg->frame_count, txq_id, idx);

			IWL_DEBUG_TX_REPLY(priv, "status %s (0x%08x), "

					   "try-count (0x%08x)\n",

					   iwl_get_agg_tx_fail_reason(status),

					   status & AGG_TX_STATUS_MSK,

					   status & AGG_TX_TRY_MSK);



			hdr = iwl_tx_queue_get_hdr(priv, txq_id, idx);

			if (!hdr) {

				IWL_ERR(priv,

					"BUG_ON idx doesn't point to valid skb"

					" idx=%d, txq_id=%d\n", idx, txq_id);

				return -1;

			}



			sc = le16_to_cpu(hdr->seq_ctrl);

			if (idx != (SEQ_TO_SN(sc) & 0xff)) {

				IWL_ERR(priv,

					"BUG_ON idx doesn't match seq control"

					" idx=%d, seq_idx=%d, seq=%d\n",

					  idx, SEQ_TO_SN(sc),

					  hdr->seq_ctrl);

				return -1;

			}



			IWL_DEBUG_TX_REPLY(priv, "AGG Frame i=%d idx %d seq=%d\n",

					   i, idx, SEQ_TO_SN(sc));



			/*

			 * sh -> how many frames ahead of the starting frame is

			 * the current one?

			 *

			 * Note that all frames sent in the batch must be in a

			 * 64-frame window, so this number should be in [0,63].

			 * If outside of this window, then we've found a new

			 * "first" frame in the batch and need to change start.

			 */

			sh = idx - start;



			/*

			 * If >= 64, out of window. start must be at the front

			 * of the circular buffer, idx must be near the end of

			 * the buffer, and idx is the new "first" frame. Shift

			 * the indices around.

			 */

			if (sh >= 64) {

				/* Shift bitmap by start - idx, wrapped */

				sh = 0x100 - idx + start;

				bitmap = bitmap << sh;

				/* Now idx is the new start so sh = 0 */

				sh = 0;

				start = idx;

			/*

			 * If <= -64 then wraps the 256-pkt circular buffer

			 * (e.g., start = 255 and idx = 0, sh should be 1)

			 */

			} else if (sh <= -64) {

				sh  = 0x100 - start + idx;

			/*

			 * If < 0 but > -64, out of window. idx is before start

			 * but not wrapped. Shift the indices around.

			 */

			} else if (sh < 0) {

				/* Shift by how far start is ahead of idx */

				sh = start - idx;

				bitmap = bitmap << sh;

				/* Now idx is the new start so sh = 0 */

				start = idx;

				sh = 0;

			}

			/* Sequence number start + sh was sent in this batch */

			bitmap |= 1ULL << sh;

			IWL_DEBUG_TX_REPLY(priv, "start=%d bitmap=0x%llx\n",

					   start, (unsigned long long)bitmap);

		}



		/*

		 * Store the bitmap and possibly the new start, if we wrapped

		 * the buffer above

		 */

		agg->bitmap = bitmap;

		agg->start_idx = start;

		IWL_DEBUG_TX_REPLY(priv, "Frames %d start_idx=%d bitmap=0x%llx\n",

				   agg->frame_count, agg->start_idx,

				   (unsigned long long)agg->bitmap);



		if (bitmap)

			agg->wait_for_ba = 1;

	}

	return 0;

}



void iwl_check_abort_status(struct iwl_priv *priv,

			    u8 frame_count, u32 status)

{
@@ -392,99 +220,6 @@ void iwl_check_abort_status(struct iwl_priv *priv, 
	}

}



void iwlagn_rx_reply_tx(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)

{

	struct iwl_rx_packet *pkt = rxb_addr(rxb);

	u16 sequence = le16_to_cpu(pkt->hdr.sequence);

	int txq_id = SEQ_TO_QUEUE(sequence);

	int index = SEQ_TO_INDEX(sequence);

	struct iwl_tx_queue *txq = &priv->txq[txq_id];

	struct ieee80211_tx_info *info;

	struct iwlagn_tx_resp *tx_resp = (void *)&pkt->u.raw[0];

	struct ieee80211_hdr *hdr;

	struct iwl_tx_info *txb;

	u32 status = le16_to_cpu(tx_resp->status.status);

	int tid;

	int sta_id;

	int freed;

	unsigned long flags;



	if ((index >= txq->q.n_bd) || (iwl_queue_used(&txq->q, index) == 0)) {

		IWL_ERR(priv, "%s: Read index for DMA queue txq_id (%d) "

			  "index %d is out of range [0-%d] %d %d\n", __func__,

			  txq_id, index, txq->q.n_bd, txq->q.write_ptr,

			  txq->q.read_ptr);

		return;

	}



	txq->time_stamp = jiffies;

	txb = &txq->txb[txq->q.read_ptr];

	info = IEEE80211_SKB_CB(txb->skb);

	memset(&info->status, 0, sizeof(info->status));



	tid = (tx_resp->ra_tid & IWLAGN_TX_RES_TID_MSK) >>

		IWLAGN_TX_RES_TID_POS;

	sta_id = (tx_resp->ra_tid & IWLAGN_TX_RES_RA_MSK) >>

		IWLAGN_TX_RES_RA_POS;



	spin_lock_irqsave(&priv->shrd->sta_lock, flags);



	hdr = (void *)txb->skb->data;

	if (!ieee80211_is_data_qos(hdr->frame_control))

		priv->last_seq_ctl = tx_resp->seq_ctl;



	if (txq->sched_retry) {

		const u32 scd_ssn = iwlagn_get_scd_ssn(tx_resp);

		struct iwl_ht_agg *agg;



		agg = &priv->stations[sta_id].tid[tid].agg;

		/*

		 * If the BT kill count is non-zero, we'll get this

		 * notification again.

		 */

		if (tx_resp->bt_kill_count && tx_resp->frame_count == 1 &&

		    priv->cfg->bt_params &&

		    priv->cfg->bt_params->advanced_bt_coexist) {

			IWL_DEBUG_COEX(priv, "receive reply tx with bt_kill\n");

		}

		iwlagn_tx_status_reply_tx(priv, agg, tx_resp, txq_id, index);



		/* check if BAR is needed */

		if ((tx_resp->frame_count == 1) && !iwl_is_tx_success(status))

			info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;



		if (txq->q.read_ptr != (scd_ssn & 0xff)) {

			index = iwl_queue_dec_wrap(scd_ssn & 0xff, txq->q.n_bd);

			IWL_DEBUG_TX_REPLY(priv, "Retry scheduler reclaim "

					"scd_ssn=%d idx=%d txq=%d swq=%d\n",

					scd_ssn , index, txq_id, txq->swq_id);



			freed = iwlagn_tx_queue_reclaim(priv, txq_id, index);

			iwl_free_tfds_in_queue(priv, sta_id, tid, freed);



			if (priv->mac80211_registered &&

			    (iwl_queue_space(&txq->q) > txq->q.low_mark) &&

			    (agg->state != IWL_EMPTYING_HW_QUEUE_DELBA))

				iwl_wake_queue(priv, txq);

		}

	} else {

		iwlagn_set_tx_status(priv, info, txb->ctx, tx_resp,

				     txq_id, false);

		freed = iwlagn_tx_queue_reclaim(priv, txq_id, index);

		iwl_free_tfds_in_queue(priv, sta_id, tid, freed);



		if (priv->mac80211_registered &&

		    iwl_queue_space(&txq->q) > txq->q.low_mark &&

		    status != TX_STATUS_FAIL_PASSIVE_NO_RX)

			iwl_wake_queue(priv, txq);

	}



	iwlagn_txq_check_empty(priv, sta_id, tid, txq_id);



	iwl_check_abort_status(priv, tx_resp->frame_count, status);

	spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);

}



int iwlagn_hw_valid_rtc_data_addr(u32 addr)

{

	return (addr >= IWLAGN_RTC_DATA_LOWER_BOUND) &&

drivers/net/wireless/iwlwifi/iwl-agn-tx.c

+256 −172

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/wireless/iwlwifi/iwl-agn.h

+7 −1
Original line number Diff line number Diff line
@@ -146,6 +146,11 @@ int iwlagn_load_ucode_wait_alive(struct iwl_priv *priv, 
				 enum iwlagn_ucode_type ucode_type);



/* lib */

void iwlagn_set_tx_status(struct iwl_priv *priv,

				 struct ieee80211_tx_info *info,

				 struct iwlagn_tx_resp *tx_resp,

				 bool is_agg);

void iwlagn_count_agg_tx_err_status(struct iwl_priv *priv, u16 status);

void iwl_check_abort_status(struct iwl_priv *priv,

			    u8 frame_count, u32 status);

int iwlagn_hw_valid_rtc_data_addr(u32 addr);
@@ -178,7 +183,8 @@ int iwlagn_txq_check_empty(struct iwl_priv *priv, 
void iwlagn_rx_reply_compressed_ba(struct iwl_priv *priv,

				struct iwl_rx_mem_buffer *rxb);

void iwlagn_rx_reply_tx(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb);

int iwlagn_tx_queue_reclaim(struct iwl_priv *priv, int txq_id, int index);

void iwl_tx_queue_reclaim(struct iwl_trans *trans, int txq_id, int index,

	struct sk_buff_head *skbs);



static inline u32 iwl_tx_status_to_mac80211(u32 status)

{

drivers/net/wireless/iwlwifi/iwl-dev.h

+5 −0
Original line number Diff line number Diff line
@@ -166,6 +166,8 @@ struct iwl_tx_info { 
 * @time_stamp: time (in jiffies) of last read_ptr change

 * @need_update: indicates need to update read/write index

 * @sched_retry: indicates queue is high-throughput aggregation (HT AGG) enabled

 * @sta_id: valid if sched_retry is set

 * @tid: valid if sched_retry is set

 *

 * A Tx queue consists of circular buffer of BDs (a.k.a. TFDs, transmit frame

 * descriptors) and required locking structures.
@@ -184,6 +186,9 @@ struct iwl_tx_queue { 
	u8 sched_retry;

	u8 active;

	u8 swq_id;



	u16 sta_id;

	u16 tid;

};



#define IWL_NUM_SCAN_RATES         (2)

drivers/net/wireless/iwlwifi/iwl-helpers.h

+6 −0
Original line number Diff line number Diff line
@@ -90,6 +90,9 @@ static inline void iwl_wake_queue(struct iwl_priv *priv, 
	u8 ac = queue & 3;

	u8 hwq = (queue >> 2) & 0x1f;



	if (unlikely(!priv->mac80211_registered))

		return;



	if (test_and_clear_bit(hwq, priv->queue_stopped))

		if (atomic_dec_return(&priv->queue_stop_count[ac]) <= 0)

			ieee80211_wake_queue(priv->hw, ac);
@@ -102,6 +105,9 @@ static inline void iwl_stop_queue(struct iwl_priv *priv, 
	u8 ac = queue & 3;

	u8 hwq = (queue >> 2) & 0x1f;



	if (unlikely(!priv->mac80211_registered))

		return;



	if (!test_and_set_bit(hwq, priv->queue_stopped))

		if (atomic_inc_return(&priv->queue_stop_count[ac]) > 0)

			ieee80211_stop_queue(priv->hw, ac);

CRA Git | Maintained and supported by SUSTech CRA and CCSE