recv.c 33 KB
Newer Older
1
/*
2
 * Copyright (c) 2008-2011 Atheros Communications Inc.
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

17
#include <linux/dma-mapping.h>
Sujith's avatar
Sujith committed
18
#include "ath9k.h"
19
#include "ar9003_mac.h"
20

Felix Fietkau's avatar
Felix Fietkau committed
21
22
#define SKB_CB_ATHBUF(__skb)	(*((struct ath_buf **)__skb->cb))

23
24
25
26
27
28
static inline bool ath9k_check_auto_sleep(struct ath_softc *sc)
{
	return sc->ps_enabled &&
	       (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP);
}

29
30
31
32
33
34
35
36
37
38
/*
 * Setup and link descriptors.
 *
 * 11N: we can no longer afford to self link the last descriptor.
 * MAC acknowledges BA status as long as it copies frames to host
 * buffer (or rx fifo). This can incorrectly acknowledge packets
 * to a sender if last desc is self-linked.
 */
static void ath_rx_buf_link(struct ath_softc *sc, struct ath_buf *bf)
{
39
	struct ath_hw *ah = sc->sc_ah;
40
	struct ath_common *common = ath9k_hw_common(ah);
41
42
43
44
45
46
	struct ath_desc *ds;
	struct sk_buff *skb;

	ATH_RXBUF_RESET(bf);

	ds = bf->bf_desc;
Sujith's avatar
Sujith committed
47
	ds->ds_link = 0; /* link to null */
48
49
	ds->ds_data = bf->bf_buf_addr;

Sujith's avatar
Sujith committed
50
	/* virtual addr of the beginning of the buffer. */
51
	skb = bf->bf_mpdu;
52
	BUG_ON(skb == NULL);
53
54
	ds->ds_vdata = skb->data;

55
56
	/*
	 * setup rx descriptors. The rx_bufsize here tells the hardware
57
	 * how much data it can DMA to us and that we are prepared
58
59
	 * to process
	 */
Sujith's avatar
Sujith committed
60
	ath9k_hw_setuprxdesc(ah, ds,
61
			     common->rx_bufsize,
62
63
			     0);

Sujith's avatar
Sujith committed
64
	if (sc->rx.rxlink == NULL)
65
66
		ath9k_hw_putrxbuf(ah, bf->bf_daddr);
	else
Sujith's avatar
Sujith committed
67
		*sc->rx.rxlink = bf->bf_daddr;
68

Sujith's avatar
Sujith committed
69
	sc->rx.rxlink = &ds->ds_link;
70
71
}

Sujith's avatar
Sujith committed
72
73
74
75
static void ath_setdefantenna(struct ath_softc *sc, u32 antenna)
{
	/* XXX block beacon interrupts */
	ath9k_hw_setantenna(sc->sc_ah, antenna);
Sujith's avatar
Sujith committed
76
77
	sc->rx.defant = antenna;
	sc->rx.rxotherant = 0;
Sujith's avatar
Sujith committed
78
79
}

80
81
static void ath_opmode_init(struct ath_softc *sc)
{
82
	struct ath_hw *ah = sc->sc_ah;
83
84
	struct ath_common *common = ath9k_hw_common(ah);

85
86
87
88
89
90
91
	u32 rfilt, mfilt[2];

	/* configure rx filter */
	rfilt = ath_calcrxfilter(sc);
	ath9k_hw_setrxfilter(ah, rfilt);

	/* configure bssid mask */
92
	ath_hw_setbssidmask(common);
93
94
95
96
97
98
99
100
101

	/* configure operational mode */
	ath9k_hw_setopmode(ah);

	/* calculate and install multicast filter */
	mfilt[0] = mfilt[1] = ~0;
	ath9k_hw_setmcastfilter(ah, mfilt[0], mfilt[1]);
}

Felix Fietkau's avatar
Felix Fietkau committed
102
103
static bool ath_rx_edma_buf_link(struct ath_softc *sc,
				 enum ath9k_rx_qtype qtype)
104
{
Felix Fietkau's avatar
Felix Fietkau committed
105
106
	struct ath_hw *ah = sc->sc_ah;
	struct ath_rx_edma *rx_edma;
107
108
109
	struct sk_buff *skb;
	struct ath_buf *bf;

Felix Fietkau's avatar
Felix Fietkau committed
110
111
112
	rx_edma = &sc->rx.rx_edma[qtype];
	if (skb_queue_len(&rx_edma->rx_fifo) >= rx_edma->rx_fifo_hwsize)
		return false;
113

Felix Fietkau's avatar
Felix Fietkau committed
114
115
	bf = list_first_entry(&sc->rx.rxbuf, struct ath_buf, list);
	list_del_init(&bf->list);
116

Felix Fietkau's avatar
Felix Fietkau committed
117
118
119
120
121
122
	skb = bf->bf_mpdu;

	ATH_RXBUF_RESET(bf);
	memset(skb->data, 0, ah->caps.rx_status_len);
	dma_sync_single_for_device(sc->dev, bf->bf_buf_addr,
				ah->caps.rx_status_len, DMA_TO_DEVICE);
123

Felix Fietkau's avatar
Felix Fietkau committed
124
125
126
	SKB_CB_ATHBUF(skb) = bf;
	ath9k_hw_addrxbuf_edma(ah, bf->bf_buf_addr, qtype);
	skb_queue_tail(&rx_edma->rx_fifo, skb);
127

Felix Fietkau's avatar
Felix Fietkau committed
128
129
130
131
132
133
134
	return true;
}

static void ath_rx_addbuffer_edma(struct ath_softc *sc,
				  enum ath9k_rx_qtype qtype, int size)
{
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
135
	struct ath_buf *bf, *tbf;
Felix Fietkau's avatar
Felix Fietkau committed
136
137

	if (list_empty(&sc->rx.rxbuf)) {
138
		ath_dbg(common, QUEUE, "No free rx buf available\n");
Felix Fietkau's avatar
Felix Fietkau committed
139
		return;
140
	}
141

142
	list_for_each_entry_safe(bf, tbf, &sc->rx.rxbuf, list)
Felix Fietkau's avatar
Felix Fietkau committed
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
		if (!ath_rx_edma_buf_link(sc, qtype))
			break;

}

static void ath_rx_remove_buffer(struct ath_softc *sc,
				 enum ath9k_rx_qtype qtype)
{
	struct ath_buf *bf;
	struct ath_rx_edma *rx_edma;
	struct sk_buff *skb;

	rx_edma = &sc->rx.rx_edma[qtype];

	while ((skb = skb_dequeue(&rx_edma->rx_fifo)) != NULL) {
		bf = SKB_CB_ATHBUF(skb);
		BUG_ON(!bf);
		list_add_tail(&bf->list, &sc->rx.rxbuf);
	}
}

static void ath_rx_edma_cleanup(struct ath_softc *sc)
{
166
167
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
Felix Fietkau's avatar
Felix Fietkau committed
168
169
170
171
172
	struct ath_buf *bf;

	ath_rx_remove_buffer(sc, ATH9K_RX_QUEUE_LP);
	ath_rx_remove_buffer(sc, ATH9K_RX_QUEUE_HP);

173
	list_for_each_entry(bf, &sc->rx.rxbuf, list) {
174
175
176
177
		if (bf->bf_mpdu) {
			dma_unmap_single(sc->dev, bf->bf_buf_addr,
					common->rx_bufsize,
					DMA_BIDIRECTIONAL);
Felix Fietkau's avatar
Felix Fietkau committed
178
			dev_kfree_skb_any(bf->bf_mpdu);
179
180
181
			bf->bf_buf_addr = 0;
			bf->bf_mpdu = NULL;
		}
Felix Fietkau's avatar
Felix Fietkau committed
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
	}

	INIT_LIST_HEAD(&sc->rx.rxbuf);

	kfree(sc->rx.rx_bufptr);
	sc->rx.rx_bufptr = NULL;
}

static void ath_rx_edma_init_queue(struct ath_rx_edma *rx_edma, int size)
{
	skb_queue_head_init(&rx_edma->rx_fifo);
	rx_edma->rx_fifo_hwsize = size;
}

static int ath_rx_edma_init(struct ath_softc *sc, int nbufs)
{
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
	struct ath_hw *ah = sc->sc_ah;
	struct sk_buff *skb;
	struct ath_buf *bf;
	int error = 0, i;
	u32 size;

	ath9k_hw_set_rx_bufsize(ah, common->rx_bufsize -
				    ah->caps.rx_status_len);

	ath_rx_edma_init_queue(&sc->rx.rx_edma[ATH9K_RX_QUEUE_LP],
			       ah->caps.rx_lp_qdepth);
	ath_rx_edma_init_queue(&sc->rx.rx_edma[ATH9K_RX_QUEUE_HP],
			       ah->caps.rx_hp_qdepth);

	size = sizeof(struct ath_buf) * nbufs;
	bf = kzalloc(size, GFP_KERNEL);
	if (!bf)
		return -ENOMEM;

	INIT_LIST_HEAD(&sc->rx.rxbuf);
	sc->rx.rx_bufptr = bf;

	for (i = 0; i < nbufs; i++, bf++) {
222
		skb = ath_rxbuf_alloc(common, common->rx_bufsize, GFP_KERNEL);
Felix Fietkau's avatar
Felix Fietkau committed
223
		if (!skb) {
224
			error = -ENOMEM;
Felix Fietkau's avatar
Felix Fietkau committed
225
			goto rx_init_fail;
226
227
		}

Felix Fietkau's avatar
Felix Fietkau committed
228
		memset(skb->data, 0, common->rx_bufsize);
229
		bf->bf_mpdu = skb;
Felix Fietkau's avatar
Felix Fietkau committed
230

231
		bf->bf_buf_addr = dma_map_single(sc->dev, skb->data,
232
						 common->rx_bufsize,
Felix Fietkau's avatar
Felix Fietkau committed
233
						 DMA_BIDIRECTIONAL);
234
		if (unlikely(dma_mapping_error(sc->dev,
Felix Fietkau's avatar
Felix Fietkau committed
235
236
237
						bf->bf_buf_addr))) {
				dev_kfree_skb_any(skb);
				bf->bf_mpdu = NULL;
238
				bf->bf_buf_addr = 0;
239
				ath_err(common,
Felix Fietkau's avatar
Felix Fietkau committed
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
					"dma_mapping_error() on RX init\n");
				error = -ENOMEM;
				goto rx_init_fail;
		}

		list_add_tail(&bf->list, &sc->rx.rxbuf);
	}

	return 0;

rx_init_fail:
	ath_rx_edma_cleanup(sc);
	return error;
}

static void ath_edma_start_recv(struct ath_softc *sc)
{
	spin_lock_bh(&sc->rx.rxbuflock);

	ath9k_hw_rxena(sc->sc_ah);

	ath_rx_addbuffer_edma(sc, ATH9K_RX_QUEUE_HP,
			      sc->rx.rx_edma[ATH9K_RX_QUEUE_HP].rx_fifo_hwsize);

	ath_rx_addbuffer_edma(sc, ATH9K_RX_QUEUE_LP,
			      sc->rx.rx_edma[ATH9K_RX_QUEUE_LP].rx_fifo_hwsize);

	ath_opmode_init(sc);

269
	ath9k_hw_startpcureceive(sc->sc_ah, !!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL));
270
271

	spin_unlock_bh(&sc->rx.rxbuflock);
Felix Fietkau's avatar
Felix Fietkau committed
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
}

static void ath_edma_stop_recv(struct ath_softc *sc)
{
	ath_rx_remove_buffer(sc, ATH9K_RX_QUEUE_HP);
	ath_rx_remove_buffer(sc, ATH9K_RX_QUEUE_LP);
}

int ath_rx_init(struct ath_softc *sc, int nbufs)
{
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
	struct sk_buff *skb;
	struct ath_buf *bf;
	int error = 0;

287
	spin_lock_init(&sc->sc_pcu_lock);
Felix Fietkau's avatar
Felix Fietkau committed
288
	spin_lock_init(&sc->rx.rxbuflock);
289
	clear_bit(SC_OP_RXFLUSH, &sc->sc_flags);
Felix Fietkau's avatar
Felix Fietkau committed
290

291
292
293
	common->rx_bufsize = IEEE80211_MAX_MPDU_LEN / 2 +
			     sc->sc_ah->caps.rx_status_len;

Felix Fietkau's avatar
Felix Fietkau committed
294
295
296
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
		return ath_rx_edma_init(sc, nbufs);
	} else {
297
		ath_dbg(common, CONFIG, "cachelsz %u rxbufsize %u\n",
298
			common->cachelsz, common->rx_bufsize);
Felix Fietkau's avatar
Felix Fietkau committed
299
300
301
302

		/* Initialize rx descriptors */

		error = ath_descdma_setup(sc, &sc->rx.rxdma, &sc->rx.rxbuf,
303
				"rx", nbufs, 1, 0);
Felix Fietkau's avatar
Felix Fietkau committed
304
		if (error != 0) {
305
306
307
			ath_err(common,
				"failed to allocate rx descriptors: %d\n",
				error);
308
309
			goto err;
		}
Felix Fietkau's avatar
Felix Fietkau committed
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326

		list_for_each_entry(bf, &sc->rx.rxbuf, list) {
			skb = ath_rxbuf_alloc(common, common->rx_bufsize,
					      GFP_KERNEL);
			if (skb == NULL) {
				error = -ENOMEM;
				goto err;
			}

			bf->bf_mpdu = skb;
			bf->bf_buf_addr = dma_map_single(sc->dev, skb->data,
					common->rx_bufsize,
					DMA_FROM_DEVICE);
			if (unlikely(dma_mapping_error(sc->dev,
							bf->bf_buf_addr))) {
				dev_kfree_skb_any(skb);
				bf->bf_mpdu = NULL;
327
				bf->bf_buf_addr = 0;
328
329
				ath_err(common,
					"dma_mapping_error() on RX init\n");
Felix Fietkau's avatar
Felix Fietkau committed
330
331
332
333
334
				error = -ENOMEM;
				goto err;
			}
		}
		sc->rx.rxlink = NULL;
335
	}
336

337
err:
338
339
340
341
342
343
344
345
	if (error)
		ath_rx_cleanup(sc);

	return error;
}

void ath_rx_cleanup(struct ath_softc *sc)
{
346
347
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
348
349
350
	struct sk_buff *skb;
	struct ath_buf *bf;

Felix Fietkau's avatar
Felix Fietkau committed
351
352
353
354
355
356
357
358
359
360
361
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
		ath_rx_edma_cleanup(sc);
		return;
	} else {
		list_for_each_entry(bf, &sc->rx.rxbuf, list) {
			skb = bf->bf_mpdu;
			if (skb) {
				dma_unmap_single(sc->dev, bf->bf_buf_addr,
						common->rx_bufsize,
						DMA_FROM_DEVICE);
				dev_kfree_skb(skb);
362
363
				bf->bf_buf_addr = 0;
				bf->bf_mpdu = NULL;
Felix Fietkau's avatar
Felix Fietkau committed
364
			}
365
		}
366

Felix Fietkau's avatar
Felix Fietkau committed
367
368
369
		if (sc->rx.rxdma.dd_desc_len != 0)
			ath_descdma_cleanup(sc, &sc->rx.rxdma, &sc->rx.rxbuf);
	}
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
}

/*
 * Calculate the receive filter according to the
 * operating mode and state:
 *
 * o always accept unicast, broadcast, and multicast traffic
 * o maintain current state of phy error reception (the hal
 *   may enable phy error frames for noise immunity work)
 * o probe request frames are accepted only when operating in
 *   hostap, adhoc, or monitor modes
 * o enable promiscuous mode according to the interface state
 * o accept beacons:
 *   - when operating in adhoc mode so the 802.11 layer creates
 *     node table entries for peers,
 *   - when operating in station mode for collecting rssi data when
 *     the station is otherwise quiet, or
 *   - when operating as a repeater so we see repeater-sta beacons
 *   - when scanning
 */

u32 ath_calcrxfilter(struct ath_softc *sc)
{
	u32 rfilt;

395
	rfilt = ATH9K_RX_FILTER_UCAST | ATH9K_RX_FILTER_BCAST
396
397
		| ATH9K_RX_FILTER_MCAST;

398
	if (sc->rx.rxfilter & FIF_PROBE_REQ)
399
400
		rfilt |= ATH9K_RX_FILTER_PROBEREQ;

401
402
403
404
405
	/*
	 * Set promiscuous mode when FIF_PROMISC_IN_BSS is enabled for station
	 * mode interface or when in monitor mode. AP mode does not need this
	 * since it receives all in-BSS frames anyway.
	 */
406
	if (sc->sc_ah->is_monitoring)
407
408
		rfilt |= ATH9K_RX_FILTER_PROM;

409
410
411
	if (sc->rx.rxfilter & FIF_CONTROL)
		rfilt |= ATH9K_RX_FILTER_CONTROL;

412
	if ((sc->sc_ah->opmode == NL80211_IFTYPE_STATION) &&
413
	    (sc->nvifs <= 1) &&
414
415
416
	    !(sc->rx.rxfilter & FIF_BCN_PRBRESP_PROMISC))
		rfilt |= ATH9K_RX_FILTER_MYBEACON;
	else
417
418
		rfilt |= ATH9K_RX_FILTER_BEACON;

419
	if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) ||
420
	    (sc->rx.rxfilter & FIF_PSPOLL))
421
		rfilt |= ATH9K_RX_FILTER_PSPOLL;
Sujith's avatar
Sujith committed
422

Sujith's avatar
Sujith committed
423
424
425
	if (conf_is_ht(&sc->hw->conf))
		rfilt |= ATH9K_RX_FILTER_COMP_BAR;

426
	if (sc->nvifs > 1 || (sc->rx.rxfilter & FIF_OTHER_BSS)) {
427
428
		/* This is needed for older chips */
		if (sc->sc_ah->hw_version.macVersion <= AR_SREV_VERSION_9160)
429
			rfilt |= ATH9K_RX_FILTER_PROM;
430
431
432
		rfilt |= ATH9K_RX_FILTER_MCAST_BCAST_ALL;
	}

433
434
435
	if (AR_SREV_9550(sc->sc_ah))
		rfilt |= ATH9K_RX_FILTER_4ADDRESS;

436
	return rfilt;
Sujith's avatar
Sujith committed
437

438
439
440
441
}

int ath_startrecv(struct ath_softc *sc)
{
442
	struct ath_hw *ah = sc->sc_ah;
443
444
	struct ath_buf *bf, *tbf;

Felix Fietkau's avatar
Felix Fietkau committed
445
446
447
448
449
	if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
		ath_edma_start_recv(sc);
		return 0;
	}

Sujith's avatar
Sujith committed
450
451
	spin_lock_bh(&sc->rx.rxbuflock);
	if (list_empty(&sc->rx.rxbuf))
452
453
		goto start_recv;

Sujith's avatar
Sujith committed
454
455
	sc->rx.rxlink = NULL;
	list_for_each_entry_safe(bf, tbf, &sc->rx.rxbuf, list) {
456
457
458
459
		ath_rx_buf_link(sc, bf);
	}

	/* We could have deleted elements so the list may be empty now */
Sujith's avatar
Sujith committed
460
	if (list_empty(&sc->rx.rxbuf))
461
462
		goto start_recv;

Sujith's avatar
Sujith committed
463
	bf = list_first_entry(&sc->rx.rxbuf, struct ath_buf, list);
464
	ath9k_hw_putrxbuf(ah, bf->bf_daddr);
Sujith's avatar
Sujith committed
465
	ath9k_hw_rxena(ah);
466
467

start_recv:
Sujith's avatar
Sujith committed
468
	ath_opmode_init(sc);
469
	ath9k_hw_startpcureceive(ah, !!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL));
Sujith's avatar
Sujith committed
470

471
472
	spin_unlock_bh(&sc->rx.rxbuflock);

473
474
475
476
477
	return 0;
}

bool ath_stoprecv(struct ath_softc *sc)
{
478
	struct ath_hw *ah = sc->sc_ah;
479
	bool stopped, reset = false;
480

481
	spin_lock_bh(&sc->rx.rxbuflock);
482
	ath9k_hw_abortpcurecv(ah);
Sujith's avatar
Sujith committed
483
	ath9k_hw_setrxfilter(ah, 0);
484
	stopped = ath9k_hw_stopdmarecv(ah, &reset);
Felix Fietkau's avatar
Felix Fietkau committed
485
486
487
488
489

	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
		ath_edma_stop_recv(sc);
	else
		sc->rx.rxlink = NULL;
490
	spin_unlock_bh(&sc->rx.rxbuflock);
Sujith's avatar
Sujith committed
491

492
493
	if (!(ah->ah_flags & AH_UNPLUGGED) &&
	    unlikely(!stopped)) {
494
495
496
497
498
		ath_err(ath9k_hw_common(sc->sc_ah),
			"Could not stop RX, we could be "
			"confusing the DMA engine when we start RX up\n");
		ATH_DBG_WARN_ON_ONCE(!stopped);
	}
499
	return stopped && !reset;
500
501
502
503
}

void ath_flushrecv(struct ath_softc *sc)
{
504
	set_bit(SC_OP_RXFLUSH, &sc->sc_flags);
Felix Fietkau's avatar
Felix Fietkau committed
505
506
507
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
		ath_rx_tasklet(sc, 1, true);
	ath_rx_tasklet(sc, 1, false);
508
	clear_bit(SC_OP_RXFLUSH, &sc->sc_flags);
509
510
}

511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
static bool ath_beacon_dtim_pending_cab(struct sk_buff *skb)
{
	/* Check whether the Beacon frame has DTIM indicating buffered bc/mc */
	struct ieee80211_mgmt *mgmt;
	u8 *pos, *end, id, elen;
	struct ieee80211_tim_ie *tim;

	mgmt = (struct ieee80211_mgmt *)skb->data;
	pos = mgmt->u.beacon.variable;
	end = skb->data + skb->len;

	while (pos + 2 < end) {
		id = *pos++;
		elen = *pos++;
		if (pos + elen > end)
			break;

		if (id == WLAN_EID_TIM) {
			if (elen < sizeof(*tim))
				break;
			tim = (struct ieee80211_tim_ie *) pos;
			if (tim->dtim_count != 0)
				break;
			return tim->bitmap_ctrl & 0x01;
		}

		pos += elen;
	}

	return false;
}

static void ath_rx_ps_beacon(struct ath_softc *sc, struct sk_buff *skb)
{
545
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
546
547
548
549

	if (skb->len < 24 + 8 + 2 + 2)
		return;

Sujith's avatar
Sujith committed
550
	sc->ps_flags &= ~PS_WAIT_FOR_BEACON;
551

Sujith's avatar
Sujith committed
552
553
	if (sc->ps_flags & PS_BEACON_SYNC) {
		sc->ps_flags &= ~PS_BEACON_SYNC;
554
		ath_dbg(common, PS,
555
			"Reconfigure Beacon timers based on timestamp from the AP\n");
Sujith Manoharan's avatar
Sujith Manoharan committed
556
		ath9k_set_beacon(sc);
557
558
	}

559
560
561
	if (ath_beacon_dtim_pending_cab(skb)) {
		/*
		 * Remain awake waiting for buffered broadcast/multicast
562
563
564
565
		 * frames. If the last broadcast/multicast frame is not
		 * received properly, the next beacon frame will work as
		 * a backup trigger for returning into NETWORK SLEEP state,
		 * so we are waiting for it as well.
566
		 */
567
		ath_dbg(common, PS,
568
			"Received DTIM beacon indicating buffered broadcast/multicast frame(s)\n");
Sujith's avatar
Sujith committed
569
		sc->ps_flags |= PS_WAIT_FOR_CAB | PS_WAIT_FOR_BEACON;
570
571
572
		return;
	}

Sujith's avatar
Sujith committed
573
	if (sc->ps_flags & PS_WAIT_FOR_CAB) {
574
575
576
577
578
		/*
		 * This can happen if a broadcast frame is dropped or the AP
		 * fails to send a frame indicating that all CAB frames have
		 * been delivered.
		 */
Sujith's avatar
Sujith committed
579
		sc->ps_flags &= ~PS_WAIT_FOR_CAB;
580
		ath_dbg(common, PS, "PS wait for CAB frames timed out\n");
581
582
583
	}
}

584
static void ath_rx_ps(struct ath_softc *sc, struct sk_buff *skb, bool mybeacon)
585
586
{
	struct ieee80211_hdr *hdr;
587
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
588
589
590
591

	hdr = (struct ieee80211_hdr *)skb->data;

	/* Process Beacon and CAB receive in PS state */
592
	if (((sc->ps_flags & PS_WAIT_FOR_BEACON) || ath9k_check_auto_sleep(sc))
593
	    && mybeacon) {
594
		ath_rx_ps_beacon(sc, skb);
595
596
597
598
599
	} else if ((sc->ps_flags & PS_WAIT_FOR_CAB) &&
		   (ieee80211_is_data(hdr->frame_control) ||
		    ieee80211_is_action(hdr->frame_control)) &&
		   is_multicast_ether_addr(hdr->addr1) &&
		   !ieee80211_has_moredata(hdr->frame_control)) {
600
601
602
603
		/*
		 * No more broadcast/multicast frames to be received at this
		 * point.
		 */
604
		sc->ps_flags &= ~(PS_WAIT_FOR_CAB | PS_WAIT_FOR_BEACON);
605
		ath_dbg(common, PS,
606
			"All PS CAB frames received, back to sleep\n");
Sujith's avatar
Sujith committed
607
	} else if ((sc->ps_flags & PS_WAIT_FOR_PSPOLL_DATA) &&
608
609
		   !is_multicast_ether_addr(hdr->addr1) &&
		   !ieee80211_has_morefrags(hdr->frame_control)) {
Sujith's avatar
Sujith committed
610
		sc->ps_flags &= ~PS_WAIT_FOR_PSPOLL_DATA;
611
		ath_dbg(common, PS,
612
			"Going back to sleep after having received PS-Poll data (0x%lx)\n",
Sujith's avatar
Sujith committed
613
614
615
616
			sc->ps_flags & (PS_WAIT_FOR_BEACON |
					PS_WAIT_FOR_CAB |
					PS_WAIT_FOR_PSPOLL_DATA |
					PS_WAIT_FOR_TX_ACK));
617
618
619
	}
}

Felix Fietkau's avatar
Felix Fietkau committed
620
static bool ath_edma_get_buffers(struct ath_softc *sc,
621
622
623
				 enum ath9k_rx_qtype qtype,
				 struct ath_rx_status *rs,
				 struct ath_buf **dest)
624
{
Felix Fietkau's avatar
Felix Fietkau committed
625
626
627
628
629
630
631
632
633
634
635
636
637
638
	struct ath_rx_edma *rx_edma = &sc->rx.rx_edma[qtype];
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
	struct sk_buff *skb;
	struct ath_buf *bf;
	int ret;

	skb = skb_peek(&rx_edma->rx_fifo);
	if (!skb)
		return false;

	bf = SKB_CB_ATHBUF(skb);
	BUG_ON(!bf);

Ming Lei's avatar
Ming Lei committed
639
	dma_sync_single_for_cpu(sc->dev, bf->bf_buf_addr,
Felix Fietkau's avatar
Felix Fietkau committed
640
641
				common->rx_bufsize, DMA_FROM_DEVICE);

642
	ret = ath9k_hw_process_rxdesc_edma(ah, rs, skb->data);
Ming Lei's avatar
Ming Lei committed
643
644
645
646
	if (ret == -EINPROGRESS) {
		/*let device gain the buffer again*/
		dma_sync_single_for_device(sc->dev, bf->bf_buf_addr,
				common->rx_bufsize, DMA_FROM_DEVICE);
Felix Fietkau's avatar
Felix Fietkau committed
647
		return false;
Ming Lei's avatar
Ming Lei committed
648
	}
Felix Fietkau's avatar
Felix Fietkau committed
649
650
651
652
653
654
655

	__skb_unlink(skb, &rx_edma->rx_fifo);
	if (ret == -EINVAL) {
		/* corrupt descriptor, skip this one and the following one */
		list_add_tail(&bf->list, &sc->rx.rxbuf);
		ath_rx_edma_buf_link(sc, qtype);

656
657
658
659
660
661
662
663
664
		skb = skb_peek(&rx_edma->rx_fifo);
		if (skb) {
			bf = SKB_CB_ATHBUF(skb);
			BUG_ON(!bf);

			__skb_unlink(skb, &rx_edma->rx_fifo);
			list_add_tail(&bf->list, &sc->rx.rxbuf);
			ath_rx_edma_buf_link(sc, qtype);
		}
665
666

		bf = NULL;
Felix Fietkau's avatar
Felix Fietkau committed
667
668
	}

669
	*dest = bf;
Felix Fietkau's avatar
Felix Fietkau committed
670
671
	return true;
}
672

Felix Fietkau's avatar
Felix Fietkau committed
673
674
675
676
static struct ath_buf *ath_edma_get_next_rx_buf(struct ath_softc *sc,
						struct ath_rx_status *rs,
						enum ath9k_rx_qtype qtype)
{
677
	struct ath_buf *bf = NULL;
Felix Fietkau's avatar
Felix Fietkau committed
678

679
680
681
	while (ath_edma_get_buffers(sc, qtype, rs, &bf)) {
		if (!bf)
			continue;
Felix Fietkau's avatar
Felix Fietkau committed
682

683
684
685
		return bf;
	}
	return NULL;
Felix Fietkau's avatar
Felix Fietkau committed
686
687
688
689
690
691
692
}

static struct ath_buf *ath_get_next_rx_buf(struct ath_softc *sc,
					   struct ath_rx_status *rs)
{
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
693
	struct ath_desc *ds;
Felix Fietkau's avatar
Felix Fietkau committed
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
	struct ath_buf *bf;
	int ret;

	if (list_empty(&sc->rx.rxbuf)) {
		sc->rx.rxlink = NULL;
		return NULL;
	}

	bf = list_first_entry(&sc->rx.rxbuf, struct ath_buf, list);
	ds = bf->bf_desc;

	/*
	 * Must provide the virtual address of the current
	 * descriptor, the physical address, and the virtual
	 * address of the next descriptor in the h/w chain.
	 * This allows the HAL to look ahead to see if the
	 * hardware is done with a descriptor by checking the
	 * done bit in the following descriptor and the address
	 * of the current descriptor the DMA engine is working
	 * on.  All this is necessary because of our use of
	 * a self-linked list to avoid rx overruns.
	 */
716
	ret = ath9k_hw_rxprocdesc(ah, ds, rs);
Felix Fietkau's avatar
Felix Fietkau committed
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
	if (ret == -EINPROGRESS) {
		struct ath_rx_status trs;
		struct ath_buf *tbf;
		struct ath_desc *tds;

		memset(&trs, 0, sizeof(trs));
		if (list_is_last(&bf->list, &sc->rx.rxbuf)) {
			sc->rx.rxlink = NULL;
			return NULL;
		}

		tbf = list_entry(bf->list.next, struct ath_buf, list);

		/*
		 * On some hardware the descriptor status words could
		 * get corrupted, including the done bit. Because of
		 * this, check if the next descriptor's done bit is
		 * set or not.
		 *
		 * If the next descriptor's done bit is set, the current
		 * descriptor has been corrupted. Force s/w to discard
		 * this descriptor and continue...
		 */

		tds = tbf->bf_desc;
742
		ret = ath9k_hw_rxprocdesc(ah, tds, &trs);
Felix Fietkau's avatar
Felix Fietkau committed
743
744
745
746
747
748
749
750
751
752
753
754
		if (ret == -EINPROGRESS)
			return NULL;
	}

	if (!bf->bf_mpdu)
		return bf;

	/*
	 * Synchronize the DMA transfer with CPU before
	 * 1. accessing the frame
	 * 2. requeueing the same buffer to h/w
	 */
Ming Lei's avatar
Ming Lei committed
755
	dma_sync_single_for_cpu(sc->dev, bf->bf_buf_addr,
Felix Fietkau's avatar
Felix Fietkau committed
756
757
758
759
760
761
			common->rx_bufsize,
			DMA_FROM_DEVICE);

	return bf;
}

762
763
/* Assumes you've already done the endian to CPU conversion */
static bool ath9k_rx_accept(struct ath_common *common,
764
			    struct ieee80211_hdr *hdr,
765
766
767
768
			    struct ieee80211_rx_status *rxs,
			    struct ath_rx_status *rx_stats,
			    bool *decrypt_error)
{
769
	struct ath_softc *sc = (struct ath_softc *) common->priv;
770
	bool is_mc, is_valid_tkip, strip_mic, mic_error;
771
772
	struct ath_hw *ah = common->ah;
	__le16 fc;
773
	u8 rx_status_len = ah->caps.rx_status_len;
774
775
776

	fc = hdr->frame_control;

777
778
779
	is_mc = !!is_multicast_ether_addr(hdr->addr1);
	is_valid_tkip = rx_stats->rs_keyix != ATH9K_RXKEYIX_INVALID &&
		test_bit(rx_stats->rs_keyix, common->tkip_keymap);
780
	strip_mic = is_valid_tkip && ieee80211_is_data(fc) &&
781
		ieee80211_has_protected(fc) &&
782
		!(rx_stats->rs_status &
783
784
		(ATH9K_RXERR_DECRYPT | ATH9K_RXERR_CRC | ATH9K_RXERR_MIC |
		 ATH9K_RXERR_KEYMISS));
785

786
787
788
789
790
	/*
	 * Key miss events are only relevant for pairwise keys where the
	 * descriptor does contain a valid key index. This has been observed
	 * mostly with CCMP encryption.
	 */
791
792
	if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID ||
	    !test_bit(rx_stats->rs_keyix, common->ccmp_keymap))
793
794
		rx_stats->rs_status &= ~ATH9K_RXERR_KEYMISS;

Ben Greear's avatar
Ben Greear committed
795
796
	if (!rx_stats->rs_datalen) {
		RX_STAT_INC(rx_len_err);
797
		return false;
Ben Greear's avatar
Ben Greear committed
798
799
	}

800
801
802
803
804
        /*
         * rs_status follows rs_datalen so if rs_datalen is too large
         * we can take a hint that hardware corrupted it, so ignore
         * those frames.
         */
Ben Greear's avatar
Ben Greear committed
805
806
	if (rx_stats->rs_datalen > (common->rx_bufsize - rx_status_len)) {
		RX_STAT_INC(rx_len_err);
807
		return false;
Ben Greear's avatar
Ben Greear committed
808
	}
809

810
	/* Only use error bits from the last fragment */
811
	if (rx_stats->rs_more)
812
		return true;
813

814
815
816
817
818
	mic_error = is_valid_tkip && !ieee80211_is_ctl(fc) &&
		!ieee80211_has_morefrags(fc) &&
		!(le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG) &&
		(rx_stats->rs_status & ATH9K_RXERR_MIC);

819
820
821
822
823
824
825
	/*
	 * The rx_stats->rs_status will not be set until the end of the
	 * chained descriptors so it can be ignored if rs_more is set. The
	 * rs_more will be false at the last element of the chained
	 * descriptors.
	 */
	if (rx_stats->rs_status != 0) {
826
827
		u8 status_mask;

828
		if (rx_stats->rs_status & ATH9K_RXERR_CRC) {
829
			rxs->flag |= RX_FLAG_FAILED_FCS_CRC;
830
831
			mic_error = false;
		}
832
833
834
		if (rx_stats->rs_status & ATH9K_RXERR_PHY)
			return false;

835
836
		if ((rx_stats->rs_status & ATH9K_RXERR_DECRYPT) ||
		    (!is_mc && (rx_stats->rs_status & ATH9K_RXERR_KEYMISS))) {
837
			*decrypt_error = true;
838
			mic_error = false;
839
		}
840

841
842
843
844
845
		/*
		 * Reject error frames with the exception of
		 * decryption and MIC failures. For monitor mode,
		 * we also ignore the CRC error.
		 */
846
847
848
		status_mask = ATH9K_RXERR_DECRYPT | ATH9K_RXERR_MIC |
			      ATH9K_RXERR_KEYMISS;

849
		if (ah->is_monitoring && (sc->rx.rxfilter & FIF_FCSFAIL))
850
851
852
853
			status_mask |= ATH9K_RXERR_CRC;

		if (rx_stats->rs_status & ~status_mask)
			return false;
854
	}
855
856
857
858
859
860
861
862
863
864
865
866

	/*
	 * For unicast frames the MIC error bit can have false positives,
	 * so all MIC error reports need to be validated in software.
	 * False negatives are not common, so skip software verification
	 * if the hardware considers the MIC valid.
	 */
	if (strip_mic)
		rxs->flag |= RX_FLAG_MMIC_STRIPPED;
	else if (is_mc && mic_error)
		rxs->flag |= RX_FLAG_MMIC_ERROR;

867
868
869
870
871
872
	return true;
}

static int ath9k_process_rate(struct ath_common *common,
			      struct ieee80211_hw *hw,
			      struct ath_rx_status *rx_stats,
873
			      struct ieee80211_rx_status *rxs)
874
875
876
877
{
	struct ieee80211_supported_band *sband;
	enum ieee80211_band band;
	unsigned int i = 0;
878
	struct ath_softc __maybe_unused *sc = common->priv;
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909

	band = hw->conf.channel->band;
	sband = hw->wiphy->bands[band];

	if (rx_stats->rs_rate & 0x80) {
		/* HT rate */
		rxs->flag |= RX_FLAG_HT;
		if (rx_stats->rs_flags & ATH9K_RX_2040)
			rxs->flag |= RX_FLAG_40MHZ;
		if (rx_stats->rs_flags & ATH9K_RX_GI)
			rxs->flag |= RX_FLAG_SHORT_GI;
		rxs->rate_idx = rx_stats->rs_rate & 0x7f;
		return 0;
	}

	for (i = 0; i < sband->n_bitrates; i++) {
		if (sband->bitrates[i].hw_value == rx_stats->rs_rate) {
			rxs->rate_idx = i;
			return 0;
		}
		if (sband->bitrates[i].hw_value_short == rx_stats->rs_rate) {
			rxs->flag |= RX_FLAG_SHORTPRE;
			rxs->rate_idx = i;
			return 0;
		}
	}

	/*
	 * No valid hardware bitrate found -- we should not get here
	 * because hardware has already validated this frame as OK.
	 */
910
	ath_dbg(common, ANY,
911
912
		"unsupported hw bitrate detected 0x%02x using 1 Mbit\n",
		rx_stats->rs_rate);
Ben Greear's avatar
Ben Greear committed
913
	RX_STAT_INC(rx_rate_err);
914
915
916
917
918
	return -EINVAL;
}

static void ath9k_process_rssi(struct ath_common *common,
			       struct ieee80211_hw *hw,
919
			       struct ieee80211_hdr *hdr,
920
921
			       struct ath_rx_status *rx_stats)
{
922
	struct ath_softc *sc = hw->priv;
923
	struct ath_hw *ah = common->ah;
924
	int last_rssi;
925
	int rssi = rx_stats->rs_rssi;
926

927
928
929
	if (!rx_stats->is_mybeacon ||
	    ((ah->opmode != NL80211_IFTYPE_STATION) &&
	     (ah->opmode != NL80211_IFTYPE_ADHOC)))
930
931
932
		return;

	if (rx_stats->rs_rssi != ATH9K_RSSI_BAD && !rx_stats->rs_moreaggr)
933
		ATH_RSSI_LPF(sc->last_rssi, rx_stats->rs_rssi);
934

935
	last_rssi = sc->last_rssi;
936
	if (likely(last_rssi != ATH_RSSI_DUMMY_MARKER))
937
938
939
		rssi = ATH_EP_RND(last_rssi, ATH_RSSI_EP_MULTIPLIER);
	if (rssi < 0)
		rssi = 0;
940
941

	/* Update Beacon RSSI, this is used by ANI. */
942
	ah->stats.avgbrssi = rssi;
943
944
945
946
947
948
949
950
951
}

/*
 * For Decrypt or Demic errors, we only mark packet status here and always push
 * up the frame up to let mac80211 handle the actual error case, be it no
 * decryption key or real decryption error. This let us keep statistics there.
 */
static int ath9k_rx_skb_preprocess(struct ath_common *common,
				   struct ieee80211_hw *hw,
952
				   struct ieee80211_hdr *hdr,
953
954
955
956
				   struct ath_rx_status *rx_stats,
				   struct ieee80211_rx_status *rx_status,
				   bool *decrypt_error)
{
957
958
	struct ath_hw *ah = common->ah;

959
960
961
962
	/*
	 * everything but the rate is checked here, the rate check is done
	 * separately to avoid doing two lookups for a rate for each frame.
	 */
963
	if (!ath9k_rx_accept(common, hdr, rx_status, rx_stats, decrypt_error))
964
965
		return -EINVAL;

966
967
968
969
	/* Only use status info from the last fragment */
	if (rx_stats->rs_more)
		return 0;

970
	ath9k_process_rssi(common, hw, hdr, rx_stats);
971

972
	if (ath9k_process_rate(common, hw, rx_stats, rx_status))
973
974
975
976
		return -EINVAL;

	rx_status->band = hw->conf.channel->band;
	rx_status->freq = hw->conf.channel->center_freq;
977
	rx_status->signal = ah->noise + rx_stats->rs_rssi;
978
	rx_status->antenna = rx_stats->rs_antenna;
Johannes Berg's avatar
Johannes Berg committed
979
	rx_status->flag |= RX_FLAG_MACTIME_MPDU;
980
981
	if (rx_stats->rs_moreaggr)
		rx_status->flag |= RX_FLAG_NO_SIGNAL_VAL;
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035

	return 0;
}

static void ath9k_rx_skb_postprocess(struct ath_common *common,
				     struct sk_buff *skb,
				     struct ath_rx_status *rx_stats,
				     struct ieee80211_rx_status *rxs,
				     bool decrypt_error)
{
	struct ath_hw *ah = common->ah;
	struct ieee80211_hdr *hdr;
	int hdrlen, padpos, padsize;
	u8 keyix;
	__le16 fc;

	/* see if any padding is done by the hw and remove it */
	hdr = (struct ieee80211_hdr *) skb->data;
	hdrlen = ieee80211_get_hdrlen_from_skb(skb);
	fc = hdr->frame_control;
	padpos = ath9k_cmn_padpos(hdr->frame_control);

	/* The MAC header is padded to have 32-bit boundary if the
	 * packet payload is non-zero. The general calculation for
	 * padsize would take into account odd header lengths:
	 * padsize = (4 - padpos % 4) % 4; However, since only
	 * even-length headers are used, padding can only be 0 or 2
	 * bytes and we can optimize this a bit. In addition, we must
	 * not try to remove padding from short control frames that do
	 * not have payload. */
	padsize = padpos & 3;
	if (padsize && skb->len>=padpos+padsize+FCS_LEN) {
		memmove(skb->data + padsize, skb->data, padpos);
		skb_pull(skb, padsize);
	}

	keyix = rx_stats->rs_keyix;

	if (!(keyix == ATH9K_RXKEYIX_INVALID) && !decrypt_error &&
	    ieee80211_has_protected(fc)) {
		rxs->flag |= RX_FLAG_DECRYPTED;
	} else if (ieee80211_has_protected(fc)
		   && !decrypt_error && skb->len >= hdrlen + 4) {
		keyix = skb->data[hdrlen + 3] >> 6;

		if (test_bit(keyix, common->keymap))
			rxs->flag |= RX_FLAG_DECRYPTED;
	}
	if (ah->sw_mgmt_crypto &&
	    (rxs->flag & RX_FLAG_DECRYPTED) &&
	    ieee80211_is_mgmt(fc))
		/* Use software decrypt for management frames. */
		rxs->flag &= ~RX_FLAG_DECRYPTED;
}
Felix Fietkau's avatar
Felix Fietkau committed
1036
1037
1038
1039

int ath_rx_tasklet(struct ath_softc *sc, int flush, bool hp)
{
	struct ath_buf *bf;
1040
	struct sk_buff *skb = NULL, *requeue_skb, *hdr_skb;
1041
	struct ieee80211_rx_status *rxs;
1042
	struct ath_hw *ah = sc->sc_ah;
1043
	struct ath_common *common = ath9k_hw_common(ah);
1044
	struct ieee80211_hw *hw = sc->hw;
Sujith's avatar
Sujith committed
1045
	struct ieee80211_hdr *hdr;
1046
	int retval;
1047
	struct ath_rx_status rs;
Felix Fietkau's avatar
Felix Fietkau committed
1048
1049
1050
	enum ath9k_rx_qtype qtype;
	bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA);
	int dma_type;
1051
	u8 rx_status_len = ah->caps.rx_status_len;
1052
1053
	u64 tsf = 0;
	u32 tsf_lower = 0;
1054
	unsigned long flags;
Sujith's avatar
Sujith committed
1055

Felix Fietkau's avatar
Felix Fietkau committed
1056
1057
	if (edma)
		dma_type = DMA_BIDIRECTIONAL;
1058
1059
	else
		dma_type = DMA_FROM_DEVICE;
Felix Fietkau's avatar
Felix Fietkau committed
1060
1061

	qtype = hp ? ATH9K_RX_QUEUE_HP : ATH9K_RX_QUEUE_LP;
Sujith's avatar
Sujith committed
1062
	spin_lock_bh(&sc->rx.rxbuflock);
1063

1064
1065
1066
	tsf = ath9k_hw_gettsf64(ah);
	tsf_lower = tsf & 0xffffffff;

1067
	do {
1068
		bool decrypt_error = false;
1069
		/* If handling rx interrupt and flush is in progress => exit */
1070
		if (test_bit(SC_OP_RXFLUSH, &sc->sc_flags) && (flush == 0))
1071
1072
			break;

1073
		memset(&rs, 0, sizeof(rs));
Felix Fietkau's avatar
Felix Fietkau committed
1074
1075
1076
1077
		if (edma)
			bf = ath_edma_get_next_rx_buf(sc, &rs, qtype);
		else
			bf = ath_get_next_rx_buf(sc, &rs);
1078

Felix Fietkau's avatar
Felix Fietkau committed
1079
1080
		if (!bf)
			break;
1081
1082

		skb = bf->bf_mpdu;
Sujith's avatar
Sujith committed
1083
		if (!skb)
1084
1085
			continue;

1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
		/*
		 * Take frame header from the first fragment and RX status from
		 * the last one.
		 */
		if (sc->rx.frag)
			hdr_skb = sc->rx.frag;
		else
			hdr_skb = skb;

		hdr = (struct ieee80211_hdr *) (hdr_skb->data + rx_status_len);
		rxs = IEEE80211_SKB_RXCB(hdr_skb);
Ben Greear's avatar
Ben Greear committed
1097
1098
1099
		if (ieee80211_is_beacon(hdr->frame_control)) {
			RX_STAT_INC(rx_beacons);
			if (!is_zero_ether_addr(common->curbssid) &&
1100
			    ether_addr_equal(hdr->addr3, common->curbssid))
Ben Greear's avatar
Ben Greear committed
1101
1102
1103
1104
				rs.is_mybeacon = true;
			else
				rs.is_mybeacon = false;
		}
1105
1106
		else
			rs.is_mybeacon = false;
1107

1108
1109
1110
1111
		if (ieee80211_is_data_present(hdr->frame_control) &&
		    !ieee80211_is_qos_nullfunc(hdr->frame_control))
			sc->rx.num_pkts++;

1112
		ath_debug_stat_rx(sc, &rs);
Sujith's avatar
Sujith committed
1113

1114
		/*
Sujith's avatar
Sujith committed
1115
1116
		 * If we're asked to flush receive queue, directly
		 * chain it back at the queue without processing it.
1117
		 */
1118
		if (test_bit(SC_OP_RXFLUSH, &sc->sc_flags)) {
Ben Greear's avatar
Ben Greear committed
1119
			RX_STAT_INC(rx_drop_rxflush);
1120
			goto requeue_drop_frag;
Ben Greear's avatar
Ben Greear committed
1121
		}
1122

1123
1124
		memset(rxs, 0, sizeof(struct ieee80211_rx_status));

1125
1126
1127
1128
1129
1130
1131
1132
1133
		rxs->mactime = (tsf & ~0xffffffffULL) | rs.rs_tstamp;
		if (rs.rs_tstamp > tsf_lower &&
		    unlikely(rs.rs_tstamp - tsf_lower > 0x10000000))
			rxs->mactime -= 0x100000000ULL;

		if (rs.rs_tstamp < tsf_lower &&
		    unlikely(tsf_lower - rs.rs_tstamp > 0x10000000))
			rxs->mactime += 0x100000000ULL;