forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2024-10-22 8ac6c7a54ed1b98d142dce24b11c6de6a1e239a5 
 kernel/drivers/net/wireless/rockchip_wlan/cywdhd/bcmdhd/hnd_pktq.c
....@@ -1,15 +1,16 @@
1
-/* SPDX-License-Identifier: GPL-2.0 */
21 /*
32  * HND generic pktq operation primitives
43  *
5
- * Copyright (C) 1999-2019, Broadcom Corporation
6
- * 
4
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
5
+ *
6
+ * Copyright (C) 1999-2017, Broadcom Corporation
7
+ *
78  *      Unless you and Broadcom execute a separate written software license
89  * agreement governing use of this software, this software is licensed to you
910  * under the terms of the GNU General Public License version 2 (the "GPL"),
1011  * available at http://www.broadcom.com/licenses/GPLv2.php, with the
1112  * following added to such license:
12
- * 
13
+ *
1314  *      As a special exception, the copyright holders of this software give you
1415  * permission to link this software with independent modules, and to copy and
1516  * distribute the resulting executable under terms of your choice, provided that
....@@ -17,7 +18,7 @@
1718  * the license of that module.  An independent module is a module which is not
1819  * derived from this software.  The special exception does not apply to any
1920  * modifications of the software.
20
- * 
21
+ *
2122  *      Notwithstanding the above, under no circumstances may you combine this
2223  * software in any way with any other Broadcom software provided under a license
2324  * other than the GPL, without Broadcom's express prior written consent.
....@@ -25,7 +26,7 @@
2526  *
2627  * <<Broadcom-WL-IPTag/Open:>>
2728  *
28
- * $Id: $
29
+ * $Id: hnd_pktq.c 698847 2017-05-11 00:10:48Z $
2930  */
3031 
3132 #include <typedefs.h>
....@@ -45,8 +46,13 @@
4546 #define HND_PKTQ_MUTEX_DELETE(mutex)		OSL_EXT_SUCCESS
4647 #define HND_PKTQ_MUTEX_ACQUIRE(mutex, msec)	OSL_EXT_SUCCESS
4748 #define HND_PKTQ_MUTEX_RELEASE(mutex)		OSL_EXT_SUCCESS
48
-#endif
49
+#endif /* HND_PKTQ_THREAD_SAFE */
4950 
51
+/* status during txfifo sync */
52
+#if defined(WLAMPDU_MAC) && defined(PROP_TXSTATUS)
53
+#define TXQ_PKT_DEL		0x01
54
+#define HEAD_PKT_FLUSHED	0xFF
55
+#endif /* defined(WLAMPDU_MAC) && defined(PROP_TXSTATUS) */
5056 /*
5157  * osl multiple-precedence packet queue
5258  * hi_prec is always >= the number of the highest non-empty precedence
....@@ -61,12 +67,10 @@
6167 		return NULL;
6268 
6369 	ASSERT(prec >= 0 && prec < pq->num_prec);
64
-	/* queueing chains not allowed and no segmented SKB (Kernel-3.18.y) */
65
-	//ASSERT(!((PKTLINK(p) != NULL) && (PKTLINK(p) != p)));
70
+	ASSERT(PKTLINK(p) == NULL);		/* queueing chains not allowed */
6671 
6772 	ASSERT(!pktq_full(pq));
68
-	ASSERT(!pktq_pfull(pq, prec));
69
-	PKTSETLINK(p, NULL);
73
+	ASSERT(!pktqprec_full(pq, prec));
7074 
7175 	q = &pq->q[prec];
7276 
....@@ -76,15 +80,48 @@
7680 		q->head = p;
7781 
7882 	q->tail = p;
79
-	q->len++;
83
+	q->n_pkts++;
8084 
81
-	pq->len++;
85
+	pq->n_pkts_tot++;
8286 
8387 	if (pq->hi_prec < prec)
8488 		pq->hi_prec = (uint8)prec;
8589 
8690 	/* protect shared resource */
8791 	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
92
+		return NULL;
93
+
94
+	return p;
95
+}
96
+
97
+/*
98
+ * osl simple, non-priority packet queue
99
+ */
100
+void * BCMFASTPATH
101
+spktq_enq(struct spktq *spq, void *p)
102
+{
103
+	struct pktq_prec *q;
104
+
105
+	/* protect shared resource */
106
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
107
+		return NULL;
108
+
109
+	ASSERT(!spktq_full(spq));
110
+
111
+	PKTSETLINK(p, NULL);
112
+
113
+	q = &spq->q;
114
+
115
+	if (q->head)
116
+		PKTSETLINK(q->tail, p);
117
+	else
118
+		q->head = p;
119
+
120
+	q->tail = p;
121
+	q->n_pkts++;
122
+
123
+	/* protect shared resource */
124
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
88125 		return NULL;
89126 
90127 	return p;
....@@ -100,12 +137,10 @@
100137 		return NULL;
101138 
102139 	ASSERT(prec >= 0 && prec < pq->num_prec);
103
-	/* queueing chains not allowed and no segmented SKB (Kernel-3.18.y) */
104
-	//ASSERT(!((PKTLINK(p) != NULL) && (PKTLINK(p) != p)));
140
+	ASSERT(PKTLINK(p) == NULL);		/* queueing chains not allowed */
105141 
106142 	ASSERT(!pktq_full(pq));
107
-	ASSERT(!pktq_pfull(pq, prec));
108
-	PKTSETLINK(p, NULL);
143
+	ASSERT(!pktqprec_full(pq, prec));
109144 
110145 	q = &pq->q[prec];
111146 
....@@ -114,9 +149,9 @@
114149 
115150 	PKTSETLINK(p, q->head);
116151 	q->head = p;
117
-	q->len++;
152
+	q->n_pkts++;
118153 
119
-	pq->len++;
154
+	pq->n_pkts_tot++;
120155 
121156 	if (pq->hi_prec < prec)
122157 		pq->hi_prec = (uint8)prec;
....@@ -128,110 +163,33 @@
128163 	return p;
129164 }
130165 
131
-/*
132
- * Append spktq 'list' to the tail of pktq 'pq'
133
- */
134
-void BCMFASTPATH
135
-pktq_append(struct pktq *pq, int prec, struct spktq *list)
166
+void * BCMFASTPATH
167
+spktq_enq_head(struct spktq *spq, void *p)
136168 {
137169 	struct pktq_prec *q;
138
-	struct pktq_prec *list_q;
139170 
140171 	/* protect shared resource */
141
-	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
142
-		return;
172
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
173
+		return NULL;
143174 
144
-	list_q = &list->q[0];
175
+	ASSERT(!spktq_full(spq));
145176 
146
-	/* empty list check */
147
-	if (list_q->head == NULL)
148
-		goto done;
177
+	PKTSETLINK(p, NULL);
149178 
150
-	ASSERT(prec >= 0 && prec < pq->num_prec);
151
-	ASSERT(PKTLINK(list_q->tail) == NULL);         /* terminated list */
179
+	q = &spq->q;
152180 
153
-	ASSERT(!pktq_full(pq));
154
-	ASSERT(!pktq_pfull(pq, prec));
181
+	if (q->head == NULL)
182
+		q->tail = p;
155183 
156
-	q = &pq->q[prec];
157
-
158
-	if (q->head)
159
-		PKTSETLINK(q->tail, list_q->head);
160
-	else
161
-		q->head = list_q->head;
162
-
163
-	q->tail = list_q->tail;
164
-	q->len += list_q->len;
165
-	pq->len += list_q->len;
166
-
167
-	if (pq->hi_prec < prec)
168
-		pq->hi_prec = (uint8)prec;
169
-
170
-	list_q->head = NULL;
171
-	list_q->tail = NULL;
172
-	list_q->len = 0;
173
-	list->len = 0;
174
-
175
-done:
176
-	/* protect shared resource */
177
-	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
178
-		return;
179
-}
180
-
181
-/*
182
- * Prepend spktq 'list' to the head of pktq 'pq'
183
- */
184
-void BCMFASTPATH
185
-pktq_prepend(struct pktq *pq, int prec, struct spktq *list)
186
-{
187
-	struct pktq_prec *q;
188
-	struct pktq_prec *list_q;
184
+	PKTSETLINK(p, q->head);
185
+	q->head = p;
186
+	q->n_pkts++;
189187 
190188 	/* protect shared resource */
191
-	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
192
-		return;
189
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
190
+		return NULL;
193191 
194
-	list_q = &list->q[0];
195
-
196
-	/* empty list check */
197
-	if (list_q->head == NULL)
198
-		goto done;
199
-
200
-	ASSERT(prec >= 0 && prec < pq->num_prec);
201
-	ASSERT(PKTLINK(list_q->tail) == NULL);         /* terminated list */
202
-
203
-	ASSERT(!pktq_full(pq));
204
-	ASSERT(!pktq_pfull(pq, prec));
205
-
206
-	q = &pq->q[prec];
207
-
208
-	/* set the tail packet of list to point at the former pq head */
209
-	PKTSETLINK(list_q->tail, q->head);
210
-	/* the new q head is the head of list */
211
-	q->head = list_q->head;
212
-
213
-	/* If the q tail was non-null, then it stays as is.
214
-	 * If the q tail was null, it is now the tail of list
215
-	 */
216
-	if (q->tail == NULL) {
217
-		q->tail = list_q->tail;
218
-	}
219
-
220
-	q->len += list_q->len;
221
-	pq->len += list_q->len;
222
-
223
-	if (pq->hi_prec < prec)
224
-		pq->hi_prec = (uint8)prec;
225
-
226
-	list_q->head = NULL;
227
-	list_q->tail = NULL;
228
-	list_q->len = 0;
229
-	list->len = 0;
230
-
231
-done:
232
-	/* protect shared resource */
233
-	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
234
-		return;
192
+	return p;
235193 }
236194 
237195 void * BCMFASTPATH
....@@ -254,9 +212,13 @@
254212 	if ((q->head = PKTLINK(p)) == NULL)
255213 		q->tail = NULL;
256214 
257
-	q->len--;
215
+	q->n_pkts--;
258216 
259
-	pq->len--;
217
+	pq->n_pkts_tot--;
218
+
219
+#ifdef WL_TXQ_STALL
220
+	q->dequeue_count++;
221
+#endif // endif
260222 
261223 	PKTSETLINK(p, NULL);
262224 
....@@ -266,6 +228,360 @@
266228 		return NULL;
267229 
268230 	return p;
231
+}
232
+
233
+void * BCMFASTPATH
234
+spktq_deq(struct spktq *spq)
235
+{
236
+	struct pktq_prec *q;
237
+	void *p;
238
+
239
+	/* protect shared resource */
240
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
241
+		return NULL;
242
+
243
+	q = &spq->q;
244
+
245
+	if ((p = q->head) == NULL)
246
+		goto done;
247
+
248
+	if ((q->head = PKTLINK(p)) == NULL)
249
+		q->tail = NULL;
250
+
251
+	q->n_pkts--;
252
+
253
+#ifdef WL_TXQ_STALL
254
+	q->dequeue_count++;
255
+#endif // endif
256
+
257
+	PKTSETLINK(p, NULL);
258
+
259
+done:
260
+	/* protect shared resource */
261
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
262
+		return NULL;
263
+
264
+	return p;
265
+}
266
+
267
+void * BCMFASTPATH
268
+pktq_pdeq_tail(struct pktq *pq, int prec)
269
+{
270
+	struct pktq_prec *q;
271
+	void *p, *prev;
272
+
273
+	/* protect shared resource */
274
+	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
275
+		return NULL;
276
+
277
+	ASSERT(prec >= 0 && prec < pq->num_prec);
278
+
279
+	q = &pq->q[prec];
280
+
281
+	if ((p = q->head) == NULL)
282
+		goto done;
283
+
284
+	for (prev = NULL; p != q->tail; p = PKTLINK(p))
285
+		prev = p;
286
+
287
+	if (prev)
288
+		PKTSETLINK(prev, NULL);
289
+	else
290
+		q->head = NULL;
291
+
292
+	q->tail = prev;
293
+	q->n_pkts--;
294
+
295
+	pq->n_pkts_tot--;
296
+
297
+#ifdef WL_TXQ_STALL
298
+	q->dequeue_count++;
299
+#endif // endif
300
+done:
301
+	/* protect shared resource */
302
+	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
303
+		return NULL;
304
+
305
+	return p;
306
+}
307
+
308
+void * BCMFASTPATH
309
+spktq_deq_tail(struct spktq *spq)
310
+{
311
+	struct pktq_prec *q;
312
+	void *p, *prev;
313
+
314
+	/* protect shared resource */
315
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
316
+		return NULL;
317
+
318
+	q = &spq->q;
319
+
320
+	if ((p = q->head) == NULL)
321
+		goto done;
322
+
323
+	for (prev = NULL; p != q->tail; p = PKTLINK(p))
324
+		prev = p;
325
+
326
+	if (prev)
327
+		PKTSETLINK(prev, NULL);
328
+	else
329
+		q->head = NULL;
330
+
331
+	q->tail = prev;
332
+	q->n_pkts--;
333
+
334
+#ifdef WL_TXQ_STALL
335
+	q->dequeue_count++;
336
+#endif // endif
337
+done:
338
+	/* protect shared resource */
339
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
340
+		return NULL;
341
+
342
+	return p;
343
+}
344
+
345
+void *
346
+pktq_peek_tail(struct pktq *pq, int *prec_out)
347
+{
348
+	int prec;
349
+	void *p = NULL;
350
+
351
+	/* protect shared resource */
352
+	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
353
+		return NULL;
354
+
355
+	if (pq->n_pkts_tot == 0)
356
+		goto done;
357
+
358
+	for (prec = 0; prec < pq->hi_prec; prec++)
359
+		if (pq->q[prec].head)
360
+			break;
361
+
362
+	if (prec_out)
363
+		*prec_out = prec;
364
+
365
+	p = pq->q[prec].tail;
366
+
367
+done:
368
+	/* protect shared resource */
369
+	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
370
+		return NULL;
371
+
372
+	return p;
373
+}
374
+
375
+/*
376
+ * Append spktq 'list' to the tail of pktq 'pq'
377
+ */
378
+void BCMFASTPATH
379
+pktq_append(struct pktq *pq, int prec, struct spktq *list)
380
+{
381
+	struct pktq_prec *q;
382
+	struct pktq_prec *list_q;
383
+
384
+	/* protect shared resource */
385
+	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
386
+		return;
387
+
388
+	list_q = &list->q;
389
+
390
+	/* empty list check */
391
+	if (list_q->head == NULL)
392
+		goto done;
393
+
394
+	ASSERT(prec >= 0 && prec < pq->num_prec);
395
+	ASSERT(PKTLINK(list_q->tail) == NULL);         /* terminated list */
396
+
397
+	ASSERT(!pktq_full(pq));
398
+	ASSERT(!pktqprec_full(pq, prec));
399
+
400
+	q = &pq->q[prec];
401
+
402
+	if (q->head)
403
+		PKTSETLINK(q->tail, list_q->head);
404
+	else
405
+		q->head = list_q->head;
406
+
407
+	q->tail = list_q->tail;
408
+	q->n_pkts += list_q->n_pkts;
409
+	pq->n_pkts_tot += list_q->n_pkts;
410
+
411
+	if (pq->hi_prec < prec)
412
+		pq->hi_prec = (uint8)prec;
413
+
414
+#ifdef WL_TXQ_STALL
415
+	list_q->dequeue_count += list_q->n_pkts;
416
+#endif // endif
417
+
418
+	list_q->head = NULL;
419
+	list_q->tail = NULL;
420
+	list_q->n_pkts = 0;
421
+
422
+done:
423
+	/* protect shared resource */
424
+	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
425
+		return;
426
+}
427
+
428
+/*
429
+ * Append spktq 'list' to the tail of spktq 'spq'
430
+ */
431
+void BCMFASTPATH
432
+spktq_append(struct spktq *spq, struct spktq *list)
433
+{
434
+	struct pktq_prec *q;
435
+	struct pktq_prec *list_q;
436
+
437
+	/* protect shared resource */
438
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
439
+		return;
440
+
441
+	list_q = &list->q;
442
+
443
+	/* empty list check */
444
+	if (list_q->head == NULL)
445
+		goto done;
446
+
447
+	ASSERT(PKTLINK(list_q->tail) == NULL);         /* terminated list */
448
+
449
+	ASSERT(!spktq_full(spq));
450
+
451
+	q = &spq->q;
452
+
453
+	if (q->head)
454
+		PKTSETLINK(q->tail, list_q->head);
455
+	else
456
+		q->head = list_q->head;
457
+
458
+	q->tail = list_q->tail;
459
+	q->n_pkts += list_q->n_pkts;
460
+
461
+#ifdef WL_TXQ_STALL
462
+	list_q->dequeue_count += list_q->n_pkts;
463
+#endif // endif
464
+
465
+	list_q->head = NULL;
466
+	list_q->tail = NULL;
467
+	list_q->n_pkts = 0;
468
+
469
+done:
470
+	/* protect shared resource */
471
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
472
+		return;
473
+}
474
+
475
+/*
476
+ * Prepend spktq 'list' to the head of pktq 'pq'
477
+ */
478
+void BCMFASTPATH
479
+pktq_prepend(struct pktq *pq, int prec, struct spktq *list)
480
+{
481
+	struct pktq_prec *q;
482
+	struct pktq_prec *list_q;
483
+
484
+	/* protect shared resource */
485
+	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
486
+		return;
487
+
488
+	list_q = &list->q;
489
+
490
+	/* empty list check */
491
+	if (list_q->head == NULL)
492
+		goto done;
493
+
494
+	ASSERT(prec >= 0 && prec < pq->num_prec);
495
+	ASSERT(PKTLINK(list_q->tail) == NULL);         /* terminated list */
496
+
497
+	ASSERT(!pktq_full(pq));
498
+	ASSERT(!pktqprec_full(pq, prec));
499
+
500
+	q = &pq->q[prec];
501
+
502
+	/* set the tail packet of list to point at the former pq head */
503
+	PKTSETLINK(list_q->tail, q->head);
504
+	/* the new q head is the head of list */
505
+	q->head = list_q->head;
506
+
507
+	/* If the q tail was non-null, then it stays as is.
508
+	 * If the q tail was null, it is now the tail of list
509
+	 */
510
+	if (q->tail == NULL) {
511
+		q->tail = list_q->tail;
512
+	}
513
+
514
+	q->n_pkts += list_q->n_pkts;
515
+	pq->n_pkts_tot += list_q->n_pkts;
516
+
517
+	if (pq->hi_prec < prec)
518
+		pq->hi_prec = (uint8)prec;
519
+
520
+#ifdef WL_TXQ_STALL
521
+	list_q->dequeue_count += list_q->n_pkts;
522
+#endif // endif
523
+
524
+	list_q->head = NULL;
525
+	list_q->tail = NULL;
526
+	list_q->n_pkts = 0;
527
+
528
+done:
529
+	/* protect shared resource */
530
+	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
531
+		return;
532
+}
533
+
534
+/*
535
+ * Prepend spktq 'list' to the head of spktq 'spq'
536
+ */
537
+void BCMFASTPATH
538
+spktq_prepend(struct spktq *spq, struct spktq *list)
539
+{
540
+	struct pktq_prec *q;
541
+	struct pktq_prec *list_q;
542
+
543
+	/* protect shared resource */
544
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
545
+		return;
546
+
547
+	list_q = &list->q;
548
+
549
+	/* empty list check */
550
+	if (list_q->head == NULL)
551
+		goto done;
552
+
553
+	ASSERT(PKTLINK(list_q->tail) == NULL);         /* terminated list */
554
+
555
+	ASSERT(!spktq_full(spq));
556
+
557
+	q = &spq->q;
558
+
559
+	/* set the tail packet of list to point at the former pq head */
560
+	PKTSETLINK(list_q->tail, q->head);
561
+	/* the new q head is the head of list */
562
+	q->head = list_q->head;
563
+
564
+	/* If the q tail was non-null, then it stays as is.
565
+	 * If the q tail was null, it is now the tail of list
566
+	 */
567
+	if (q->tail == NULL) {
568
+		q->tail = list_q->tail;
569
+	}
570
+
571
+	q->n_pkts += list_q->n_pkts;
572
+
573
+#ifdef WL_TXQ_STALL
574
+	list_q->dequeue_count += list_q->n_pkts;
575
+#endif // endif
576
+
577
+	list_q->head = NULL;
578
+	list_q->tail = NULL;
579
+	list_q->n_pkts = 0;
580
+
581
+done:
582
+	/* protect shared resource */
583
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
584
+		return;
269585 }
270586 
271587 void * BCMFASTPATH
....@@ -288,10 +604,13 @@
288604 	if ((p = PKTLINK(prev_p)) == NULL)
289605 		goto done;
290606 
291
-	q->len--;
607
+	q->n_pkts--;
292608 
293
-	pq->len--;
609
+	pq->n_pkts_tot--;
294610 
611
+#ifdef WL_TXQ_STALL
612
+	q->dequeue_count++;
613
+#endif // endif
295614 	PKTSETLINK(prev_p, PKTLINK(p));
296615 	PKTSETLINK(p, NULL);
297616 
....@@ -340,10 +659,13 @@
340659 		}
341660 	}
342661 
343
-	q->len--;
662
+	q->n_pkts--;
344663 
345
-	pq->len--;
664
+	pq->n_pkts_tot--;
346665 
666
+#ifdef WL_TXQ_STALL
667
+	q->dequeue_count++;
668
+#endif // endif
347669 	PKTSETLINK(p, NULL);
348670 
349671 done:
....@@ -352,84 +674,6 @@
352674 		return NULL;
353675 
354676 	return p;
355
-}
356
-
357
-void * BCMFASTPATH
358
-pktq_pdeq_tail(struct pktq *pq, int prec)
359
-{
360
-	struct pktq_prec *q;
361
-	void *p, *prev;
362
-
363
-	/* protect shared resource */
364
-	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
365
-		return NULL;
366
-
367
-	ASSERT(prec >= 0 && prec < pq->num_prec);
368
-
369
-	q = &pq->q[prec];
370
-
371
-	if ((p = q->head) == NULL)
372
-		goto done;
373
-
374
-	for (prev = NULL; p != q->tail; p = PKTLINK(p))
375
-		prev = p;
376
-
377
-	if (prev)
378
-		PKTSETLINK(prev, NULL);
379
-	else
380
-		q->head = NULL;
381
-
382
-	q->tail = prev;
383
-	q->len--;
384
-
385
-	pq->len--;
386
-
387
-done:
388
-	/* protect shared resource */
389
-	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
390
-		return NULL;
391
-
392
-	return p;
393
-}
394
-
395
-void
396
-pktq_pflush(osl_t *osh, struct pktq *pq, int prec, bool dir, ifpkt_cb_t fn, int arg)
397
-{
398
-	struct pktq_prec *q;
399
-	void *p, *prev = NULL;
400
-
401
-	/* protect shared resource */
402
-	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
403
-		return;
404
-
405
-	q = &pq->q[prec];
406
-	p = q->head;
407
-	while (p) {
408
-		if (fn == NULL || (*fn)(p, arg)) {
409
-			bool head = (p == q->head);
410
-			if (head)
411
-				q->head = PKTLINK(p);
412
-			else
413
-				PKTSETLINK(prev, PKTLINK(p));
414
-			PKTSETLINK(p, NULL);
415
-			PKTFREE(osh, p, dir);
416
-			q->len--;
417
-			pq->len--;
418
-			p = (head ? q->head : PKTLINK(prev));
419
-		} else {
420
-			prev = p;
421
-			p = PKTLINK(p);
422
-		}
423
-	}
424
-
425
-	if (q->head == NULL) {
426
-		ASSERT(q->len == 0);
427
-		q->tail = NULL;
428
-	}
429
-
430
-	/* protect shared resource */
431
-	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
432
-		return;
433677 }
434678 
435679 bool BCMFASTPATH
....@@ -465,8 +709,13 @@
465709 			q->tail = p;
466710 	}
467711 
468
-	q->len--;
469
-	pq->len--;
712
+	q->n_pkts--;
713
+	pq->n_pkts_tot--;
714
+
715
+#ifdef WL_TXQ_STALL
716
+	q->dequeue_count++;
717
+#endif // endif
718
+
470719 	PKTSETLINK(pktbuf, NULL);
471720 	ret = TRUE;
472721 
....@@ -478,25 +727,226 @@
478727 	return ret;
479728 }
480729 
730
+static void
731
+_pktq_pfilter(struct pktq *pq, int prec, pktq_filter_t fltr, void* fltr_ctx,
732
+              defer_free_pkt_fn_t defer, void *defer_ctx)
733
+{
734
+	struct pktq_prec wq;
735
+	struct pktq_prec *q;
736
+	void *p;
737
+
738
+	/* protect shared resource */
739
+	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
740
+		return;
741
+
742
+	/* move the prec queue aside to a work queue */
743
+	q = &pq->q[prec];
744
+
745
+	wq = *q;
746
+
747
+	q->head = NULL;
748
+	q->tail = NULL;
749
+	q->n_pkts = 0;
750
+
751
+#ifdef WL_TXQ_STALL
752
+	q->dequeue_count += wq.n_pkts;
753
+#endif // endif
754
+
755
+	pq->n_pkts_tot -= wq.n_pkts;
756
+
757
+	/* protect shared resource */
758
+	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
759
+		return;
760
+
761
+	/* start with the head of the work queue */
762
+	while ((p = wq.head) != NULL) {
763
+		/* unlink the current packet from the list */
764
+		wq.head = PKTLINK(p);
765
+		PKTSETLINK(p, NULL);
766
+		wq.n_pkts--;
767
+
768
+#ifdef WL_TXQ_STALL
769
+		wq.dequeue_count++;
770
+#endif // endif
771
+
772
+		/* call the filter function on current packet */
773
+		ASSERT(fltr != NULL);
774
+		switch ((*fltr)(fltr_ctx, p)) {
775
+		case PKT_FILTER_NOACTION:
776
+			/* put this packet back */
777
+			pktq_penq(pq, prec, p);
778
+			break;
779
+
780
+		case PKT_FILTER_DELETE:
781
+			/* delete this packet */
782
+			ASSERT(defer != NULL);
783
+			(*defer)(defer_ctx, p);
784
+			break;
785
+
786
+		case PKT_FILTER_REMOVE:
787
+			/* pkt already removed from list */
788
+			break;
789
+
790
+		default:
791
+			ASSERT(0);
792
+			break;
793
+		}
794
+	}
795
+
796
+	ASSERT(wq.n_pkts == 0);
797
+}
798
+
799
+void
800
+pktq_pfilter(struct pktq *pq, int prec, pktq_filter_t fltr, void* fltr_ctx,
801
+	defer_free_pkt_fn_t defer, void *defer_ctx, flush_free_pkt_fn_t flush, void *flush_ctx)
802
+{
803
+	_pktq_pfilter(pq, prec, fltr, fltr_ctx, defer, defer_ctx);
804
+
805
+	ASSERT(flush != NULL);
806
+	(*flush)(flush_ctx);
807
+}
808
+
809
+void
810
+pktq_filter(struct pktq *pq, pktq_filter_t fltr, void* fltr_ctx,
811
+	defer_free_pkt_fn_t defer, void *defer_ctx, flush_free_pkt_fn_t flush, void *flush_ctx)
812
+{
813
+	bool filter = FALSE;
814
+
815
+	/* protect shared resource */
816
+	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
817
+		return;
818
+
819
+	/* Optimize if pktq n_pkts = 0, just return.
820
+	 * pktq len of 0 means pktq's prec q's are all empty.
821
+	 */
822
+	if (pq->n_pkts_tot > 0) {
823
+		filter = TRUE;
824
+	}
825
+
826
+	/* protect shared resource */
827
+	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
828
+		return;
829
+
830
+	if (filter) {
831
+		int prec;
832
+
833
+		PKTQ_PREC_ITER(pq, prec) {
834
+			_pktq_pfilter(pq, prec, fltr, fltr_ctx, defer, defer_ctx);
835
+		}
836
+
837
+		ASSERT(flush != NULL);
838
+		(*flush)(flush_ctx);
839
+	}
840
+}
841
+
842
+void
843
+spktq_filter(struct spktq *spq, pktq_filter_t fltr, void* fltr_ctx,
844
+	defer_free_pkt_fn_t defer, void *defer_ctx, flush_free_pkt_fn_t flush, void *flush_ctx)
845
+{
846
+	struct pktq_prec wq;
847
+	struct pktq_prec *q;
848
+	void *p = NULL;
849
+
850
+	/* protect shared resource */
851
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
852
+		return;
853
+
854
+	q = &spq->q;
855
+
856
+	/* Optimize if pktq_prec n_pkts = 0, just return. */
857
+	if (q->n_pkts == 0) {
858
+		(void)HND_PKTQ_MUTEX_RELEASE(&spq->mutex);
859
+		return;
860
+	}
861
+
862
+	wq = *q;
863
+
864
+	q->head = NULL;
865
+	q->tail = NULL;
866
+	q->n_pkts = 0;
867
+
868
+#ifdef WL_TXQ_STALL
869
+	q->dequeue_count += wq.n_pkts;
870
+#endif // endif
871
+
872
+	/* protect shared resource */
873
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
874
+		return;
875
+
876
+	/* start with the head of the work queue */
877
+
878
+	while ((p = wq.head) != NULL) {
879
+		/* unlink the current packet from the list */
880
+		wq.head = PKTLINK(p);
881
+		PKTSETLINK(p, NULL);
882
+		wq.n_pkts--;
883
+
884
+#ifdef WL_TXQ_STALL
885
+		wq.dequeue_count++;
886
+#endif // endif
887
+
888
+		/* call the filter function on current packet */
889
+		ASSERT(fltr != NULL);
890
+		switch ((*fltr)(fltr_ctx, p)) {
891
+		case PKT_FILTER_NOACTION:
892
+			/* put this packet back */
893
+			spktq_enq(spq, p);
894
+			break;
895
+
896
+		case PKT_FILTER_DELETE:
897
+			/* delete this packet */
898
+			ASSERT(defer != NULL);
899
+			(*defer)(defer_ctx, p);
900
+			break;
901
+
902
+		case PKT_FILTER_REMOVE:
903
+			/* pkt already removed from list */
904
+			break;
905
+
906
+		default:
907
+			ASSERT(0);
908
+			break;
909
+		}
910
+	}
911
+
912
+	ASSERT(wq.n_pkts == 0);
913
+
914
+	ASSERT(flush != NULL);
915
+	(*flush)(flush_ctx);
916
+}
917
+
481918 bool
482
-pktq_init(struct pktq *pq, int num_prec, int max_len)
919
+pktq_init(struct pktq *pq, int num_prec, int max_pkts)
483920 {
484921 	int prec;
485
-
486
-	if (HND_PKTQ_MUTEX_CREATE("pktq", &pq->mutex) != OSL_EXT_SUCCESS)
487
-		return FALSE;
488922 
489923 	ASSERT(num_prec > 0 && num_prec <= PKTQ_MAX_PREC);
490924 
491925 	/* pq is variable size; only zero out what's requested */
492926 	bzero(pq, OFFSETOF(struct pktq, q) + (sizeof(struct pktq_prec) * num_prec));
493927 
928
+	if (HND_PKTQ_MUTEX_CREATE("pktq", &pq->mutex) != OSL_EXT_SUCCESS)
929
+		return FALSE;
930
+
494931 	pq->num_prec = (uint16)num_prec;
495932 
496
-	pq->max = (uint16)max_len;
933
+	pq->max_pkts = (uint16)max_pkts;
497934 
498935 	for (prec = 0; prec < num_prec; prec++)
499
-		pq->q[prec].max = pq->max;
936
+		pq->q[prec].max_pkts = pq->max_pkts;
937
+
938
+	return TRUE;
939
+}
940
+
941
+bool
942
+spktq_init(struct spktq *spq, int max_pkts)
943
+{
944
+	bzero(spq, sizeof(struct spktq));
945
+
946
+	if (HND_PKTQ_MUTEX_CREATE("spktq", &spq->mutex) != OSL_EXT_SUCCESS)
947
+		return FALSE;
948
+
949
+	spq->q.max_pkts = (uint16)max_pkts;
500950 
501951 	return TRUE;
502952 }
....@@ -504,14 +954,25 @@
504954 bool
505955 pktq_deinit(struct pktq *pq)
506956 {
957
+	BCM_REFERENCE(pq);
507958 	if (HND_PKTQ_MUTEX_DELETE(&pq->mutex) != OSL_EXT_SUCCESS)
508959 		return FALSE;
509960 
510961 	return TRUE;
511962 }
512963 
964
+bool
965
+spktq_deinit(struct spktq *spq)
966
+{
967
+	BCM_REFERENCE(spq);
968
+	if (HND_PKTQ_MUTEX_DELETE(&spq->mutex) != OSL_EXT_SUCCESS)
969
+		return FALSE;
970
+
971
+	return TRUE;
972
+}
973
+
513974 void
514
-pktq_set_max_plen(struct pktq *pq, int prec, int max_len)
975
+pktq_set_max_plen(struct pktq *pq, int prec, int max_pkts)
515976 {
516977 	ASSERT(prec >= 0 && prec < pq->num_prec);
517978 
....@@ -520,7 +981,7 @@
520981 		return;
521982 
522983 	if (prec < pq->num_prec)
523
-		pq->q[prec].max = (uint16)max_len;
984
+		pq->q[prec].max_pkts = (uint16)max_pkts;
524985 
525986 	/* protect shared resource */
526987 	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
....@@ -538,7 +999,7 @@
538999 	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
5391000 		return NULL;
5401001 
541
-	if (pq->len == 0)
1002
+	if (pq->n_pkts_tot == 0)
5421003 		goto done;
5431004 
5441005 	while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
....@@ -552,9 +1013,13 @@
5521013 	if ((q->head = PKTLINK(p)) == NULL)
5531014 		q->tail = NULL;
5541015 
555
-	q->len--;
1016
+	q->n_pkts--;
5561017 
557
-	pq->len--;
1018
+	pq->n_pkts_tot--;
1019
+
1020
+#ifdef WL_TXQ_STALL
1021
+	q->dequeue_count++;
1022
+#endif // endif
5581023 
5591024 	if (prec_out)
5601025 		*prec_out = prec;
....@@ -580,7 +1045,7 @@
5801045 	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
5811046 		return NULL;
5821047 
583
-	if (pq->len == 0)
1048
+	if (pq->n_pkts_tot == 0)
5841049 		goto done;
5851050 
5861051 	for (prec = 0; prec < pq->hi_prec; prec++)
....@@ -601,9 +1066,13 @@
6011066 		q->head = NULL;
6021067 
6031068 	q->tail = prev;
604
-	q->len--;
1069
+	q->n_pkts--;
6051070 
606
-	pq->len--;
1071
+	pq->n_pkts_tot--;
1072
+
1073
+#ifdef WL_TXQ_STALL
1074
+	q->dequeue_count++;
1075
+#endif // endif
6071076 
6081077 	if (prec_out)
6091078 		*prec_out = prec;
....@@ -628,7 +1097,7 @@
6281097 	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
6291098 		return NULL;
6301099 
631
-	if (pq->len == 0)
1100
+	if (pq->n_pkts_tot == 0)
6321101 		goto done;
6331102 
6341103 	while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
....@@ -648,59 +1117,84 @@
6481117 }
6491118 
6501119 void *
651
-pktq_peek_tail(struct pktq *pq, int *prec_out)
1120
+spktq_peek(struct spktq *spq)
6521121 {
653
-	int prec;
6541122 	void *p = NULL;
6551123 
6561124 	/* protect shared resource */
657
-	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
1125
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
6581126 		return NULL;
6591127 
660
-	if (pq->len == 0)
1128
+	if (spq->q.n_pkts == 0)
6611129 		goto done;
6621130 
663
-	for (prec = 0; prec < pq->hi_prec; prec++)
664
-		if (pq->q[prec].head)
665
-			break;
666
-
667
-	if (prec_out)
668
-		*prec_out = prec;
669
-
670
-	p = pq->q[prec].tail;
1131
+	p = spq->q.head;
6711132 
6721133 done:
6731134 	/* protect shared resource */
674
-	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
1135
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
6751136 		return NULL;
6761137 
6771138 	return p;
6781139 }
6791140 
6801141 void
681
-pktq_flush(osl_t *osh, struct pktq *pq, bool dir, ifpkt_cb_t fn, int arg)
1142
+pktq_pflush(osl_t *osh, struct pktq *pq, int prec, bool dir)
6821143 {
683
-	int prec;
1144
+	void *p;
1145
+
1146
+	/* no need for a mutex protection! */
1147
+
1148
+	/* start with the head of the list */
1149
+	while ((p = pktq_pdeq(pq, prec)) != NULL) {
1150
+
1151
+		/* delete this packet */
1152
+		PKTFREE(osh, p, dir);
1153
+	}
1154
+}
1155
+
1156
+void
1157
+spktq_flush(osl_t *osh, struct spktq *spq, bool dir)
1158
+{
1159
+	void *p;
1160
+
1161
+	/* no need for a mutex protection! */
1162
+
1163
+	/* start with the head of the list */
1164
+	while ((p = spktq_deq(spq)) != NULL) {
1165
+
1166
+		/* delete this packet */
1167
+		PKTFREE(osh, p, dir);
1168
+	}
1169
+}
1170
+
1171
+void
1172
+pktq_flush(osl_t *osh, struct pktq *pq, bool dir)
1173
+{
1174
+	bool flush = FALSE;
6841175 
6851176 	/* protect shared resource */
6861177 	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
6871178 		return;
6881179 
689
-	/* Optimize flush, if pktq len = 0, just return.
1180
+	/* Optimize flush, if pktq n_pkts_tot = 0, just return.
6901181 	 * pktq len of 0 means pktq's prec q's are all empty.
6911182 	 */
692
-	if (pq->len == 0)
693
-		goto done;
1183
+	if (pq->n_pkts_tot > 0) {
1184
+		flush = TRUE;
1185
+	}
6941186 
695
-	for (prec = 0; prec < pq->num_prec; prec++)
696
-		pktq_pflush(osh, pq, prec, dir, fn, arg);
697
-	if (fn == NULL)
698
-		ASSERT(pq->len == 0);
699
-
700
-done:
7011187 	/* protect shared resource */
7021188 	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
7031189 		return;
1190
+
1191
+	if (flush) {
1192
+		int prec;
1193
+
1194
+		PKTQ_PREC_ITER(pq, prec) {
1195
+			pktq_pflush(osh, pq, prec, dir);
1196
+		}
1197
+	}
7041198 }
7051199 
7061200 /* Return sum of lengths of a specific set of precedences */
....@@ -717,7 +1211,7 @@
7171211 
7181212 	for (prec = 0; prec <= pq->hi_prec; prec++)
7191213 		if (prec_bmp & (1 << prec))
720
-			len += pq->q[prec].len;
1214
+			len += pq->q[prec].n_pkts;
7211215 
7221216 	/* protect shared resource */
7231217 	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
....@@ -738,7 +1232,7 @@
7381232 	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
7391233 		return NULL;
7401234 
741
-	if (pq->len == 0)
1235
+	if (pq->n_pkts_tot == 0)
7421236 		goto done;
7431237 
7441238 	while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
....@@ -775,7 +1269,7 @@
7751269 	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
7761270 		return NULL;
7771271 
778
-	if (pq->len == 0)
1272
+	if (pq->n_pkts_tot == 0)
7791273 		goto done;
7801274 
7811275 	while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
....@@ -793,12 +1287,16 @@
7931287 	if ((q->head = PKTLINK(p)) == NULL)
7941288 		q->tail = NULL;
7951289 
796
-	q->len--;
1290
+	q->n_pkts--;
1291
+
1292
+#ifdef WL_TXQ_STALL
1293
+	q->dequeue_count++;
1294
+#endif // endif
7971295 
7981296 	if (prec_out)
7991297 		*prec_out = prec;
8001298 
801
-	pq->len--;
1299
+	pq->n_pkts_tot--;
8021300 
8031301 	PKTSETLINK(p, NULL);
8041302 
....@@ -812,7 +1310,7 @@
8121310 
8131311 #ifdef HND_PKTQ_THREAD_SAFE
8141312 int
815
-pktq_pavail(struct pktq *pq, int prec)
1313
+pktqprec_avail_pkts(struct pktq *pq, int prec)
8161314 {
8171315 	int ret;
8181316 
....@@ -822,7 +1320,7 @@
8221320 
8231321 	ASSERT(prec >= 0 && prec < pq->num_prec);
8241322 
825
-	ret = pq->q[prec].max - pq->q[prec].len;
1323
+	ret = pq->q[prec].max_pkts - pq->q[prec].n_pkts;
8261324 
8271325 	/* protect shared resource */
8281326 	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
....@@ -832,7 +1330,7 @@
8321330 }
8331331 
8341332 bool
835
-pktq_pfull(struct pktq *pq, int prec)
1333
+pktqprec_full(struct pktq *pq, int prec)
8361334 {
8371335 	bool ret;
8381336 
....@@ -842,7 +1340,7 @@
8421340 
8431341 	ASSERT(prec >= 0 && prec < pq->num_prec);
8441342 
845
-	ret = pq->q[prec].len >= pq->q[prec].max;
1343
+	ret = pq->q[prec].n_pkts >= pq->q[prec].max_pkts;
8461344 
8471345 	/* protect shared resource */
8481346 	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
....@@ -860,10 +1358,28 @@
8601358 	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
8611359 		return 0;
8621360 
863
-	ret = pq->max - pq->len;
1361
+	ret = pq->max_pkts - pq->n_pkts_tot;
8641362 
8651363 	/* protect shared resource */
8661364 	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
1365
+		return 0;
1366
+
1367
+	return ret;
1368
+}
1369
+
1370
+int
1371
+spktq_avail(struct spktq *spq)
1372
+{
1373
+	int ret;
1374
+
1375
+	/* protect shared resource */
1376
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
1377
+		return 0;
1378
+
1379
+	ret = spq->q.max_pkts - spq->q.n_pkts;
1380
+
1381
+	/* protect shared resource */
1382
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
8671383 		return 0;
8681384 
8691385 	return ret;
....@@ -878,7 +1394,7 @@
8781394 	if (HND_PKTQ_MUTEX_ACQUIRE(&pq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
8791395 		return FALSE;
8801396 
881
-	ret = pq->len >= pq->max;
1397
+	ret = pq->n_pkts_tot >= pq->max_pkts;
8821398 
8831399 	/* protect shared resource */
8841400 	if (HND_PKTQ_MUTEX_RELEASE(&pq->mutex) != OSL_EXT_SUCCESS)
....@@ -886,4 +1402,23 @@
8861402 
8871403 	return ret;
8881404 }
1405
+
1406
+bool
1407
+spktq_full(struct spktq *spq)
1408
+{
1409
+	bool ret;
1410
+
1411
+	/* protect shared resource */
1412
+	if (HND_PKTQ_MUTEX_ACQUIRE(&spq->mutex, OSL_EXT_TIME_FOREVER) != OSL_EXT_SUCCESS)
1413
+		return FALSE;
1414
+
1415
+	ret = spq->q.n_pkts >= spq->q.max_pkts;
1416
+
1417
+	/* protect shared resource */
1418
+	if (HND_PKTQ_MUTEX_RELEASE(&spq->mutex) != OSL_EXT_SUCCESS)
1419
+		return FALSE;
1420
+
1421
+	return ret;
1422
+}
1423
+
8891424 #endif	/* HND_PKTQ_THREAD_SAFE */