xref: /linux/drivers/net/wireless/ath/wil6210/rx_reorder.c (revision bfd5bb6f90af092aa345b15cd78143956a13c2a8)
1 /*
2  * Copyright (c) 2014-2017 Qualcomm Atheros, Inc.
3  * Copyright (c) 2018, The Linux Foundation. All rights reserved.
4  *
5  * Permission to use, copy, modify, and/or distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include "wil6210.h"
19 #include "txrx.h"
20 
21 #define SEQ_MODULO 0x1000
22 #define SEQ_MASK   0xfff
23 
24 static inline int seq_less(u16 sq1, u16 sq2)
25 {
26 	return ((sq1 - sq2) & SEQ_MASK) > (SEQ_MODULO >> 1);
27 }
28 
29 static inline u16 seq_inc(u16 sq)
30 {
31 	return (sq + 1) & SEQ_MASK;
32 }
33 
34 static inline u16 seq_sub(u16 sq1, u16 sq2)
35 {
36 	return (sq1 - sq2) & SEQ_MASK;
37 }
38 
39 static inline int reorder_index(struct wil_tid_ampdu_rx *r, u16 seq)
40 {
41 	return seq_sub(seq, r->ssn) % r->buf_size;
42 }
43 
44 static void wil_release_reorder_frame(struct net_device *ndev,
45 				      struct wil_tid_ampdu_rx *r,
46 				      int index)
47 {
48 	struct sk_buff *skb = r->reorder_buf[index];
49 
50 	if (!skb)
51 		goto no_frame;
52 
53 	/* release the frame from the reorder ring buffer */
54 	r->stored_mpdu_num--;
55 	r->reorder_buf[index] = NULL;
56 	wil_netif_rx_any(skb, ndev);
57 
58 no_frame:
59 	r->head_seq_num = seq_inc(r->head_seq_num);
60 }
61 
62 static void wil_release_reorder_frames(struct net_device *ndev,
63 				       struct wil_tid_ampdu_rx *r,
64 				       u16 hseq)
65 {
66 	int index;
67 
68 	/* note: this function is never called with
69 	 * hseq preceding r->head_seq_num, i.e it is always true
70 	 * !seq_less(hseq, r->head_seq_num)
71 	 * and thus on loop exit it should be
72 	 * r->head_seq_num == hseq
73 	 */
74 	while (seq_less(r->head_seq_num, hseq) && r->stored_mpdu_num) {
75 		index = reorder_index(r, r->head_seq_num);
76 		wil_release_reorder_frame(ndev, r, index);
77 	}
78 	r->head_seq_num = hseq;
79 }
80 
81 static void wil_reorder_release(struct net_device *ndev,
82 				struct wil_tid_ampdu_rx *r)
83 {
84 	int index = reorder_index(r, r->head_seq_num);
85 
86 	while (r->reorder_buf[index]) {
87 		wil_release_reorder_frame(ndev, r, index);
88 		index = reorder_index(r, r->head_seq_num);
89 	}
90 }
91 
92 /* called in NAPI context */
93 void wil_rx_reorder(struct wil6210_priv *wil, struct sk_buff *skb)
94 __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
95 {
96 	struct wil6210_vif *vif;
97 	struct net_device *ndev;
98 	struct vring_rx_desc *d = wil_skb_rxdesc(skb);
99 	int tid = wil_rxdesc_tid(d);
100 	int cid = wil_rxdesc_cid(d);
101 	int mid = wil_rxdesc_mid(d);
102 	u16 seq = wil_rxdesc_seq(d);
103 	int mcast = wil_rxdesc_mcast(d);
104 	struct wil_sta_info *sta = &wil->sta[cid];
105 	struct wil_tid_ampdu_rx *r;
106 	u16 hseq;
107 	int index;
108 
109 	wil_dbg_txrx(wil, "MID %d CID %d TID %d Seq 0x%03x mcast %01x\n",
110 		     mid, cid, tid, seq, mcast);
111 
112 	vif = wil->vifs[mid];
113 	if (unlikely(!vif)) {
114 		wil_dbg_txrx(wil, "invalid VIF, mid %d\n", mid);
115 		dev_kfree_skb(skb);
116 		return;
117 	}
118 	ndev = vif_to_ndev(vif);
119 
120 	if (unlikely(mcast)) {
121 		wil_netif_rx_any(skb, ndev);
122 		return;
123 	}
124 
125 	spin_lock(&sta->tid_rx_lock);
126 
127 	r = sta->tid_rx[tid];
128 	if (!r) {
129 		wil_netif_rx_any(skb, ndev);
130 		goto out;
131 	}
132 
133 	r->total++;
134 	hseq = r->head_seq_num;
135 
136 	/** Due to the race between WMI events, where BACK establishment
137 	 * reported, and data Rx, few packets may be pass up before reorder
138 	 * buffer get allocated. Catch up by pretending SSN is what we
139 	 * see in the 1-st Rx packet
140 	 *
141 	 * Another scenario, Rx get delayed and we got packet from before
142 	 * BACK. Pass it to the stack and wait.
143 	 */
144 	if (r->first_time) {
145 		r->first_time = false;
146 		if (seq != r->head_seq_num) {
147 			if (seq_less(seq, r->head_seq_num)) {
148 				wil_err(wil,
149 					"Error: frame with early sequence 0x%03x, should be 0x%03x. Waiting...\n",
150 					seq, r->head_seq_num);
151 				r->first_time = true;
152 				wil_netif_rx_any(skb, ndev);
153 				goto out;
154 			}
155 			wil_err(wil,
156 				"Error: 1-st frame with wrong sequence 0x%03x, should be 0x%03x. Fixing...\n",
157 				seq, r->head_seq_num);
158 			r->head_seq_num = seq;
159 			r->ssn = seq;
160 		}
161 	}
162 
163 	/* frame with out of date sequence number */
164 	if (seq_less(seq, r->head_seq_num)) {
165 		r->ssn_last_drop = seq;
166 		r->drop_old++;
167 		wil_dbg_txrx(wil, "Rx drop: old seq 0x%03x head 0x%03x\n",
168 			     seq, r->head_seq_num);
169 		dev_kfree_skb(skb);
170 		goto out;
171 	}
172 
173 	/*
174 	 * If frame the sequence number exceeds our buffering window
175 	 * size release some previous frames to make room for this one.
176 	 */
177 	if (!seq_less(seq, r->head_seq_num + r->buf_size)) {
178 		hseq = seq_inc(seq_sub(seq, r->buf_size));
179 		/* release stored frames up to new head to stack */
180 		wil_release_reorder_frames(ndev, r, hseq);
181 	}
182 
183 	/* Now the new frame is always in the range of the reordering buffer */
184 
185 	index = reorder_index(r, seq);
186 
187 	/* check if we already stored this frame */
188 	if (r->reorder_buf[index]) {
189 		r->drop_dup++;
190 		wil_dbg_txrx(wil, "Rx drop: dup seq 0x%03x\n", seq);
191 		dev_kfree_skb(skb);
192 		goto out;
193 	}
194 
195 	/*
196 	 * If the current MPDU is in the right order and nothing else
197 	 * is stored we can process it directly, no need to buffer it.
198 	 * If it is first but there's something stored, we may be able
199 	 * to release frames after this one.
200 	 */
201 	if (seq == r->head_seq_num && r->stored_mpdu_num == 0) {
202 		r->head_seq_num = seq_inc(r->head_seq_num);
203 		wil_netif_rx_any(skb, ndev);
204 		goto out;
205 	}
206 
207 	/* put the frame in the reordering buffer */
208 	r->reorder_buf[index] = skb;
209 	r->stored_mpdu_num++;
210 	wil_reorder_release(ndev, r);
211 
212 out:
213 	spin_unlock(&sta->tid_rx_lock);
214 }
215 
216 /* process BAR frame, called in NAPI context */
217 void wil_rx_bar(struct wil6210_priv *wil, struct wil6210_vif *vif,
218 		u8 cid, u8 tid, u16 seq)
219 {
220 	struct wil_sta_info *sta = &wil->sta[cid];
221 	struct net_device *ndev = vif_to_ndev(vif);
222 	struct wil_tid_ampdu_rx *r;
223 
224 	spin_lock(&sta->tid_rx_lock);
225 
226 	r = sta->tid_rx[tid];
227 	if (!r) {
228 		wil_err(wil, "BAR for non-existing CID %d TID %d\n", cid, tid);
229 		goto out;
230 	}
231 	if (seq_less(seq, r->head_seq_num)) {
232 		wil_err(wil, "BAR Seq 0x%03x preceding head 0x%03x\n",
233 			seq, r->head_seq_num);
234 		goto out;
235 	}
236 	wil_dbg_txrx(wil, "BAR: CID %d MID %d TID %d Seq 0x%03x head 0x%03x\n",
237 		     cid, vif->mid, tid, seq, r->head_seq_num);
238 	wil_release_reorder_frames(ndev, r, seq);
239 
240 out:
241 	spin_unlock(&sta->tid_rx_lock);
242 }
243 
244 struct wil_tid_ampdu_rx *wil_tid_ampdu_rx_alloc(struct wil6210_priv *wil,
245 						int size, u16 ssn)
246 {
247 	struct wil_tid_ampdu_rx *r = kzalloc(sizeof(*r), GFP_KERNEL);
248 
249 	if (!r)
250 		return NULL;
251 
252 	r->reorder_buf =
253 		kcalloc(size, sizeof(struct sk_buff *), GFP_KERNEL);
254 	if (!r->reorder_buf) {
255 		kfree(r->reorder_buf);
256 		kfree(r);
257 		return NULL;
258 	}
259 
260 	r->ssn = ssn;
261 	r->head_seq_num = ssn;
262 	r->buf_size = size;
263 	r->stored_mpdu_num = 0;
264 	r->first_time = true;
265 	return r;
266 }
267 
268 void wil_tid_ampdu_rx_free(struct wil6210_priv *wil,
269 			   struct wil_tid_ampdu_rx *r)
270 {
271 	int i;
272 
273 	if (!r)
274 		return;
275 
276 	/* Do not pass remaining frames to the network stack - it may be
277 	 * not expecting to get any more Rx. Rx from here may lead to
278 	 * kernel OOPS since some per-socket accounting info was already
279 	 * released.
280 	 */
281 	for (i = 0; i < r->buf_size; i++)
282 		kfree_skb(r->reorder_buf[i]);
283 
284 	kfree(r->reorder_buf);
285 	kfree(r);
286 }
287 
288 /* ADDBA processing */
289 static u16 wil_agg_size(struct wil6210_priv *wil, u16 req_agg_wsize)
290 {
291 	u16 max_agg_size = min_t(u16, WIL_MAX_AGG_WSIZE, WIL_MAX_AMPDU_SIZE /
292 				 (mtu_max + WIL_MAX_MPDU_OVERHEAD));
293 
294 	if (!req_agg_wsize)
295 		return max_agg_size;
296 
297 	return min(max_agg_size, req_agg_wsize);
298 }
299 
300 /* Block Ack - Rx side (recipient) */
301 int wil_addba_rx_request(struct wil6210_priv *wil, u8 mid,
302 			 u8 cidxtid, u8 dialog_token, __le16 ba_param_set,
303 			 __le16 ba_timeout, __le16 ba_seq_ctrl)
304 __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
305 {
306 	u16 param_set = le16_to_cpu(ba_param_set);
307 	u16 agg_timeout = le16_to_cpu(ba_timeout);
308 	u16 seq_ctrl = le16_to_cpu(ba_seq_ctrl);
309 	struct wil_sta_info *sta;
310 	u8 cid, tid;
311 	u16 agg_wsize = 0;
312 	/* bit 0: A-MSDU supported
313 	 * bit 1: policy (should be 0 for us)
314 	 * bits 2..5: TID
315 	 * bits 6..15: buffer size
316 	 */
317 	u16 req_agg_wsize = WIL_GET_BITS(param_set, 6, 15);
318 	bool agg_amsdu = !!(param_set & BIT(0));
319 	int ba_policy = param_set & BIT(1);
320 	u16 status = WLAN_STATUS_SUCCESS;
321 	u16 ssn = seq_ctrl >> 4;
322 	struct wil_tid_ampdu_rx *r;
323 	int rc = 0;
324 
325 	might_sleep();
326 	parse_cidxtid(cidxtid, &cid, &tid);
327 
328 	/* sanity checks */
329 	if (cid >= WIL6210_MAX_CID) {
330 		wil_err(wil, "BACK: invalid CID %d\n", cid);
331 		rc = -EINVAL;
332 		goto out;
333 	}
334 
335 	sta = &wil->sta[cid];
336 	if (sta->status != wil_sta_connected) {
337 		wil_err(wil, "BACK: CID %d not connected\n", cid);
338 		rc = -EINVAL;
339 		goto out;
340 	}
341 
342 	wil_dbg_wmi(wil,
343 		    "ADDBA request for CID %d %pM TID %d size %d timeout %d AMSDU%s policy %d token %d SSN 0x%03x\n",
344 		    cid, sta->addr, tid, req_agg_wsize, agg_timeout,
345 		    agg_amsdu ? "+" : "-", !!ba_policy, dialog_token, ssn);
346 
347 	/* apply policies */
348 	if (ba_policy) {
349 		wil_err(wil, "BACK requested unsupported ba_policy == 1\n");
350 		status = WLAN_STATUS_INVALID_QOS_PARAM;
351 	}
352 	if (status == WLAN_STATUS_SUCCESS) {
353 		if (req_agg_wsize == 0) {
354 			wil_dbg_misc(wil, "Suggest BACK wsize %d\n",
355 				     WIL_MAX_AGG_WSIZE);
356 			agg_wsize = WIL_MAX_AGG_WSIZE;
357 		} else {
358 			agg_wsize = min_t(u16,
359 					  WIL_MAX_AGG_WSIZE, req_agg_wsize);
360 		}
361 	}
362 
363 	rc = wmi_addba_rx_resp(wil, mid, cid, tid, dialog_token, status,
364 			       agg_amsdu, agg_wsize, agg_timeout);
365 	if (rc || (status != WLAN_STATUS_SUCCESS)) {
366 		wil_err(wil, "do not apply ba, rc(%d), status(%d)\n", rc,
367 			status);
368 		goto out;
369 	}
370 
371 	/* apply */
372 	r = wil_tid_ampdu_rx_alloc(wil, agg_wsize, ssn);
373 	spin_lock_bh(&sta->tid_rx_lock);
374 	wil_tid_ampdu_rx_free(wil, sta->tid_rx[tid]);
375 	sta->tid_rx[tid] = r;
376 	spin_unlock_bh(&sta->tid_rx_lock);
377 
378 out:
379 	return rc;
380 }
381 
382 /* BACK - Tx side (originator) */
383 int wil_addba_tx_request(struct wil6210_priv *wil, u8 ringid, u16 wsize)
384 {
385 	u8 agg_wsize = wil_agg_size(wil, wsize);
386 	u16 agg_timeout = 0;
387 	struct vring_tx_data *txdata = &wil->vring_tx_data[ringid];
388 	int rc = 0;
389 
390 	if (txdata->addba_in_progress) {
391 		wil_dbg_misc(wil, "ADDBA for vring[%d] already in progress\n",
392 			     ringid);
393 		goto out;
394 	}
395 	if (txdata->agg_wsize) {
396 		wil_dbg_misc(wil,
397 			     "ADDBA for vring[%d] already done for wsize %d\n",
398 			     ringid, txdata->agg_wsize);
399 		goto out;
400 	}
401 	txdata->addba_in_progress = true;
402 	rc = wmi_addba(wil, txdata->mid, ringid, agg_wsize, agg_timeout);
403 	if (rc) {
404 		wil_err(wil, "wmi_addba failed, rc (%d)", rc);
405 		txdata->addba_in_progress = false;
406 	}
407 
408 out:
409 	return rc;
410 }
411