1 // SPDX-License-Identifier: ISC
2 /*
3  * Copyright (C) 2018 Felix Fietkau <nbd@nbd.name>
4  */
5 #include "mt76.h"
6 
7 static unsigned long mt76_aggr_tid_to_timeo(u8 tidno)
8 {
9 	/* Currently voice traffic (AC_VO) always runs without aggregation,
10 	 * no special handling is needed. AC_BE/AC_BK use tids 0-3. Just check
11 	 * for non AC_BK/AC_BE and set smaller timeout for it. */
12 	return HZ / (tidno >= 4 ? 25 : 10);
13 }
14 
15 static void
16 mt76_aggr_release(struct mt76_rx_tid *tid, struct sk_buff_head *frames, int idx)
17 {
18 	struct sk_buff *skb;
19 
20 	tid->head = ieee80211_sn_inc(tid->head);
21 
22 	skb = tid->reorder_buf[idx];
23 	if (!skb)
24 		return;
25 
26 	tid->reorder_buf[idx] = NULL;
27 	tid->nframes--;
28 	__skb_queue_tail(frames, skb);
29 }
30 
31 static void
32 mt76_rx_aggr_release_frames(struct mt76_rx_tid *tid,
33 			    struct sk_buff_head *frames,
34 			    u16 head)
35 {
36 	int idx;
37 
38 	while (ieee80211_sn_less(tid->head, head)) {
39 		idx = tid->head % tid->size;
40 		mt76_aggr_release(tid, frames, idx);
41 	}
42 }
43 
44 static void
45 mt76_rx_aggr_release_head(struct mt76_rx_tid *tid, struct sk_buff_head *frames)
46 {
47 	int idx = tid->head % tid->size;
48 
49 	while (tid->reorder_buf[idx]) {
50 		mt76_aggr_release(tid, frames, idx);
51 		idx = tid->head % tid->size;
52 	}
53 }
54 
55 static void
56 mt76_rx_aggr_check_release(struct mt76_rx_tid *tid, struct sk_buff_head *frames)
57 {
58 	struct mt76_rx_status *status;
59 	struct sk_buff *skb;
60 	int start, idx, nframes;
61 
62 	if (!tid->nframes)
63 		return;
64 
65 	mt76_rx_aggr_release_head(tid, frames);
66 
67 	start = tid->head % tid->size;
68 	nframes = tid->nframes;
69 
70 	for (idx = (tid->head + 1) % tid->size;
71 	     idx != start && nframes;
72 	     idx = (idx + 1) % tid->size) {
73 		skb = tid->reorder_buf[idx];
74 		if (!skb)
75 			continue;
76 
77 		nframes--;
78 		status = (struct mt76_rx_status *)skb->cb;
79 		if (!time_after32(jiffies,
80 				  status->reorder_time +
81 				  mt76_aggr_tid_to_timeo(tid->num)))
82 			continue;
83 
84 		mt76_rx_aggr_release_frames(tid, frames, status->seqno);
85 	}
86 
87 	mt76_rx_aggr_release_head(tid, frames);
88 }
89 
90 static void
91 mt76_rx_aggr_reorder_work(struct work_struct *work)
92 {
93 	struct mt76_rx_tid *tid = container_of(work, struct mt76_rx_tid,
94 					       reorder_work.work);
95 	struct mt76_dev *dev = tid->dev;
96 	struct sk_buff_head frames;
97 	int nframes;
98 
99 	__skb_queue_head_init(&frames);
100 
101 	local_bh_disable();
102 	rcu_read_lock();
103 
104 	spin_lock(&tid->lock);
105 	mt76_rx_aggr_check_release(tid, &frames);
106 	nframes = tid->nframes;
107 	spin_unlock(&tid->lock);
108 
109 	if (nframes)
110 		ieee80211_queue_delayed_work(tid->dev->hw, &tid->reorder_work,
111 					     mt76_aggr_tid_to_timeo(tid->num));
112 	mt76_rx_complete(dev, &frames, NULL);
113 
114 	rcu_read_unlock();
115 	local_bh_enable();
116 }
117 
118 static void
119 mt76_rx_aggr_check_ctl(struct sk_buff *skb, struct sk_buff_head *frames)
120 {
121 	struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
122 	struct ieee80211_bar *bar = mt76_skb_get_hdr(skb);
123 	struct mt76_wcid *wcid = status->wcid;
124 	struct mt76_rx_tid *tid;
125 	u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK;
126 	u16 seqno;
127 
128 	if (!ieee80211_is_ctl(bar->frame_control))
129 		return;
130 
131 	if (!ieee80211_is_back_req(bar->frame_control))
132 		return;
133 
134 	status->qos_ctl = tidno = le16_to_cpu(bar->control) >> 12;
135 	seqno = IEEE80211_SEQ_TO_SN(le16_to_cpu(bar->start_seq_num));
136 	tid = rcu_dereference(wcid->aggr[tidno]);
137 	if (!tid)
138 		return;
139 
140 	spin_lock_bh(&tid->lock);
141 	if (!tid->stopped) {
142 		mt76_rx_aggr_release_frames(tid, frames, seqno);
143 		mt76_rx_aggr_release_head(tid, frames);
144 	}
145 	spin_unlock_bh(&tid->lock);
146 }
147 
148 void mt76_rx_aggr_reorder(struct sk_buff *skb, struct sk_buff_head *frames)
149 {
150 	struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
151 	struct mt76_wcid *wcid = status->wcid;
152 	struct ieee80211_sta *sta;
153 	struct mt76_rx_tid *tid;
154 	bool sn_less;
155 	u16 seqno, head, size, idx;
156 	u8 tidno = status->qos_ctl & IEEE80211_QOS_CTL_TID_MASK;
157 	u8 ackp;
158 
159 	__skb_queue_tail(frames, skb);
160 
161 	sta = wcid_to_sta(wcid);
162 	if (!sta)
163 		return;
164 
165 	if (!status->aggr) {
166 		if (!(status->flag & RX_FLAG_8023))
167 			mt76_rx_aggr_check_ctl(skb, frames);
168 		return;
169 	}
170 
171 	/* not part of a BA session */
172 	ackp = status->qos_ctl & IEEE80211_QOS_CTL_ACK_POLICY_MASK;
173 	if (ackp == IEEE80211_QOS_CTL_ACK_POLICY_NOACK)
174 		return;
175 
176 	tid = rcu_dereference(wcid->aggr[tidno]);
177 	if (!tid)
178 		return;
179 
180 	status->flag |= RX_FLAG_DUP_VALIDATED;
181 	spin_lock_bh(&tid->lock);
182 
183 	if (tid->stopped)
184 		goto out;
185 
186 	head = tid->head;
187 	seqno = status->seqno;
188 	size = tid->size;
189 	sn_less = ieee80211_sn_less(seqno, head);
190 
191 	if (!tid->started) {
192 		if (sn_less)
193 			goto out;
194 
195 		tid->started = true;
196 	}
197 
198 	if (sn_less) {
199 		__skb_unlink(skb, frames);
200 		dev_kfree_skb(skb);
201 		goto out;
202 	}
203 
204 	if (seqno == head) {
205 		tid->head = ieee80211_sn_inc(head);
206 		if (tid->nframes)
207 			mt76_rx_aggr_release_head(tid, frames);
208 		goto out;
209 	}
210 
211 	__skb_unlink(skb, frames);
212 
213 	/*
214 	 * Frame sequence number exceeds buffering window, free up some space
215 	 * by releasing previous frames
216 	 */
217 	if (!ieee80211_sn_less(seqno, head + size)) {
218 		head = ieee80211_sn_inc(ieee80211_sn_sub(seqno, size));
219 		mt76_rx_aggr_release_frames(tid, frames, head);
220 	}
221 
222 	idx = seqno % size;
223 
224 	/* Discard if the current slot is already in use */
225 	if (tid->reorder_buf[idx]) {
226 		dev_kfree_skb(skb);
227 		goto out;
228 	}
229 
230 	status->reorder_time = jiffies;
231 	tid->reorder_buf[idx] = skb;
232 	tid->nframes++;
233 	mt76_rx_aggr_release_head(tid, frames);
234 
235 	ieee80211_queue_delayed_work(tid->dev->hw, &tid->reorder_work,
236 				     mt76_aggr_tid_to_timeo(tid->num));
237 
238 out:
239 	spin_unlock_bh(&tid->lock);
240 }
241 
242 int mt76_rx_aggr_start(struct mt76_dev *dev, struct mt76_wcid *wcid, u8 tidno,
243 		       u16 ssn, u16 size)
244 {
245 	struct mt76_rx_tid *tid;
246 
247 	mt76_rx_aggr_stop(dev, wcid, tidno);
248 
249 	tid = kzalloc(struct_size(tid, reorder_buf, size), GFP_KERNEL);
250 	if (!tid)
251 		return -ENOMEM;
252 
253 	tid->dev = dev;
254 	tid->head = ssn;
255 	tid->size = size;
256 	tid->num = tidno;
257 	INIT_DELAYED_WORK(&tid->reorder_work, mt76_rx_aggr_reorder_work);
258 	spin_lock_init(&tid->lock);
259 
260 	rcu_assign_pointer(wcid->aggr[tidno], tid);
261 
262 	return 0;
263 }
264 EXPORT_SYMBOL_GPL(mt76_rx_aggr_start);
265 
266 static void mt76_rx_aggr_shutdown(struct mt76_dev *dev, struct mt76_rx_tid *tid)
267 {
268 	u16 size = tid->size;
269 	int i;
270 
271 	spin_lock_bh(&tid->lock);
272 
273 	tid->stopped = true;
274 	for (i = 0; tid->nframes && i < size; i++) {
275 		struct sk_buff *skb = tid->reorder_buf[i];
276 
277 		if (!skb)
278 			continue;
279 
280 		tid->reorder_buf[i] = NULL;
281 		tid->nframes--;
282 		dev_kfree_skb(skb);
283 	}
284 
285 	spin_unlock_bh(&tid->lock);
286 
287 	cancel_delayed_work_sync(&tid->reorder_work);
288 }
289 
290 void mt76_rx_aggr_stop(struct mt76_dev *dev, struct mt76_wcid *wcid, u8 tidno)
291 {
292 	struct mt76_rx_tid *tid = NULL;
293 
294 	tid = rcu_replace_pointer(wcid->aggr[tidno], tid,
295 				  lockdep_is_held(&dev->mutex));
296 	if (tid) {
297 		mt76_rx_aggr_shutdown(dev, tid);
298 		kfree_rcu(tid, rcu_head);
299 	}
300 }
301 EXPORT_SYMBOL_GPL(mt76_rx_aggr_stop);
302