1 /*
2 * Linux Packet (skb) interface
3 *
4 * Copyright (C) 2020, Broadcom.
5 *
6 * Unless you and Broadcom execute a separate written software license
7 * agreement governing use of this software, this software is licensed to you
8 * under the terms of the GNU General Public License version 2 (the "GPL"),
9 * available at http://www.broadcom.com/licenses/GPLv2.php, with the
10 * following added to such license:
11 *
12 * As a special exception, the copyright holders of this software give you
13 * permission to link this software with independent modules, and to copy and
14 * distribute the resulting executable under terms of your choice, provided that
15 * you also meet, for each linked independent module, the terms and conditions of
16 * the license of that module. An independent module is a module which is not
17 * derived from this software. The special exception does not apply to any
18 * modifications of the software.
19 *
20 *
21 * <<Broadcom-WL-IPTag/Dual:>>
22 */
23
24 #include <typedefs.h>
25 #include <bcmendian.h>
26 #include <linuxver.h>
27 #include <bcmdefs.h>
28
29 #include <linux/random.h>
30
31 #include <osl.h>
32 #include <bcmutils.h>
33 #include <pcicfg.h>
34 #include <dngl_stats.h>
35 #include <dhd.h>
36
37 #if defined(BCMASSERT_LOG) && !defined(OEM_ANDROID)
38 #include <bcm_assert_log.h>
39 #endif
40 #include <linux/fs.h>
41 #include "linux_osl_priv.h"
42
43 #ifdef CONFIG_DHD_USE_STATIC_BUF
44
45 bcm_static_buf_t *bcm_static_buf = 0;
46 bcm_static_pkt_t *bcm_static_skb = 0;
47
48 void* wifi_platform_prealloc(void *adapter, int section, unsigned long size);
49 #endif /* CONFIG_DHD_USE_STATIC_BUF */
50
51 #ifdef BCM_OBJECT_TRACE
52 /* don't clear the first 4 byte that is the pkt sn */
53 #define OSL_PKTTAG_CLEAR(p) \
54 do { \
55 struct sk_buff *s = (struct sk_buff *)(p); \
56 uint tagsz = sizeof(s->cb); \
57 ASSERT(OSL_PKTTAG_SZ <= tagsz); \
58 memset(s->cb + 4, 0, tagsz - 4); \
59 } while (0)
60 #else
61 #define OSL_PKTTAG_CLEAR(p) \
62 do { \
63 struct sk_buff *s = (struct sk_buff *)(p); \
64 uint tagsz = sizeof(s->cb); \
65 ASSERT(OSL_PKTTAG_SZ <= tagsz); \
66 memset(s->cb, 0, tagsz); \
67 } while (0)
68 #endif /* BCM_OBJECT_TRACE */
69
osl_static_mem_init(osl_t * osh,void * adapter)70 int osl_static_mem_init(osl_t *osh, void *adapter)
71 {
72 #ifdef CONFIG_DHD_USE_STATIC_BUF
73 if (!bcm_static_buf && adapter) {
74 if (!(bcm_static_buf = (bcm_static_buf_t *)wifi_platform_prealloc(adapter,
75 DHD_PREALLOC_OSL_BUF, STATIC_BUF_SIZE + STATIC_BUF_TOTAL_LEN))) {
76 printf("can not alloc static buf!\n");
77 bcm_static_skb = NULL;
78 ASSERT(osh->magic == OS_HANDLE_MAGIC);
79 return -ENOMEM;
80 } else {
81 printf("succeed to alloc static buf\n");
82 }
83
84 spin_lock_init(&bcm_static_buf->static_lock);
85
86 bcm_static_buf->buf_ptr = (unsigned char *)bcm_static_buf + STATIC_BUF_SIZE;
87 }
88
89 #if defined(BCMSDIO) || defined(DHD_USE_STATIC_CTRLBUF)
90 if (!bcm_static_skb && adapter) {
91 int i;
92 void *skb_buff_ptr = 0;
93 bcm_static_skb = (bcm_static_pkt_t *)((char *)bcm_static_buf + 2048);
94 skb_buff_ptr = wifi_platform_prealloc(adapter, DHD_PREALLOC_SKB_BUF, 0);
95 if (!skb_buff_ptr) {
96 printf("cannot alloc static buf!\n");
97 bcm_static_buf = NULL;
98 bcm_static_skb = NULL;
99 ASSERT(osh->magic == OS_HANDLE_MAGIC);
100 return -ENOMEM;
101 }
102
103 bcopy(skb_buff_ptr, bcm_static_skb, sizeof(struct sk_buff *) *
104 (STATIC_PKT_MAX_NUM));
105 for (i = 0; i < STATIC_PKT_MAX_NUM; i++) {
106 bcm_static_skb->pkt_use[i] = 0;
107 }
108
109 #ifdef DHD_USE_STATIC_CTRLBUF
110 spin_lock_init(&bcm_static_skb->osl_pkt_lock);
111 bcm_static_skb->last_allocated_index = 0;
112 #else
113 sema_init(&bcm_static_skb->osl_pkt_sem, 1);
114 #endif /* DHD_USE_STATIC_CTRLBUF */
115 }
116 #endif /* BCMSDIO || DHD_USE_STATIC_CTRLBUF */
117 #endif /* CONFIG_DHD_USE_STATIC_BUF */
118
119 return 0;
120 }
121
osl_static_mem_deinit(osl_t * osh,void * adapter)122 int osl_static_mem_deinit(osl_t *osh, void *adapter)
123 {
124 #ifdef CONFIG_DHD_USE_STATIC_BUF
125 if (bcm_static_buf) {
126 bcm_static_buf = 0;
127 }
128 #ifdef BCMSDIO
129 if (bcm_static_skb) {
130 bcm_static_skb = 0;
131 }
132 #endif /* BCMSDIO */
133 #endif /* CONFIG_DHD_USE_STATIC_BUF */
134 return 0;
135 }
136
137 static struct sk_buff *
BCMFASTPATH(osl_alloc_skb)138 BCMFASTPATH(osl_alloc_skb)(osl_t *osh, unsigned int len)
139 {
140 struct sk_buff *skb;
141 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
142 gfp_t flags = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
143
144 #ifdef DHD_USE_ATOMIC_PKTGET
145 flags = GFP_ATOMIC;
146 #endif /* DHD_USE_ATOMIC_PKTGET */
147 skb = __dev_alloc_skb(len, flags);
148 #else
149 skb = dev_alloc_skb(len);
150 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25) */
151
152 return skb;
153 }
154
155 /* Convert a driver packet to native(OS) packet
156 * In the process, packettag is zeroed out before sending up
157 * IP code depends on skb->cb to be setup correctly with various options
158 * In our case, that means it should be 0
159 */
160 struct sk_buff *
BCMFASTPATH(osl_pkt_tonative)161 BCMFASTPATH(osl_pkt_tonative)(osl_t *osh, void *pkt)
162 {
163 struct sk_buff *nskb;
164 #ifdef BCMDBG_CTRACE
165 struct sk_buff *nskb1, *nskb2;
166 #endif
167 #ifdef BCMDBG_PKT
168 unsigned long flags;
169 #endif
170
171 if (osh->pub.pkttag)
172 OSL_PKTTAG_CLEAR(pkt);
173
174 /* Decrement the packet counter */
175 for (nskb = (struct sk_buff *)pkt; nskb; nskb = nskb->next) {
176 #ifdef BCMDBG_PKT
177 OSL_PKTLIST_LOCK(&osh->cmn->pktlist_lock, flags);
178 pktlist_remove(&(osh->cmn->pktlist), (void *) nskb);
179 OSL_PKTLIST_UNLOCK(&osh->cmn->pktlist_lock, flags);
180 #endif /* BCMDBG_PKT */
181 atomic_sub(PKTISCHAINED(nskb) ? PKTCCNT(nskb) : 1, &osh->cmn->pktalloced);
182
183 #ifdef BCMDBG_CTRACE
184 for (nskb1 = nskb; nskb1 != NULL; nskb1 = nskb2) {
185 if (PKTISCHAINED(nskb1)) {
186 nskb2 = PKTCLINK(nskb1);
187 } else {
188 nskb2 = NULL;
189 }
190
191 DEL_CTRACE(osh, nskb1);
192 }
193 #endif /* BCMDBG_CTRACE */
194 }
195 return (struct sk_buff *)pkt;
196 }
197
198 /* Convert a native(OS) packet to driver packet.
199 * In the process, native packet is destroyed, there is no copying
200 * Also, a packettag is zeroed out
201 */
202 #ifdef BCMDBG_PKT
203 void *
osl_pkt_frmnative(osl_t * osh,void * pkt,int line,char * file)204 osl_pkt_frmnative(osl_t *osh, void *pkt, int line, char *file)
205 #else /* BCMDBG_PKT pkt logging for debugging */
206 #ifdef BCMDBG_CTRACE
207 void *
208 BCMFASTPATH(osl_pkt_frmnative)(osl_t *osh, void *pkt, int line, char *file)
209 #else
210 void *
211 BCMFASTPATH(osl_pkt_frmnative)(osl_t *osh, void *pkt)
212 #endif /* BCMDBG_CTRACE */
213 #endif /* BCMDBG_PKT */
214 {
215 struct sk_buff *cskb;
216 struct sk_buff *nskb;
217 unsigned long pktalloced = 0;
218 #ifdef BCMDBG_PKT
219 unsigned long flags;
220 #endif
221
222 if (osh->pub.pkttag)
223 OSL_PKTTAG_CLEAR(pkt);
224
225 /* walk the PKTCLINK() list */
226 for (cskb = (struct sk_buff *)pkt;
227 cskb != NULL;
228 cskb = PKTISCHAINED(cskb) ? PKTCLINK(cskb) : NULL) {
229
230 /* walk the pkt buffer list */
231 for (nskb = cskb; nskb; nskb = nskb->next) {
232
233 /* Increment the packet counter */
234 pktalloced++;
235
236 /* clean the 'prev' pointer
237 * Kernel 3.18 is leaving skb->prev pointer set to skb
238 * to indicate a non-fragmented skb
239 */
240 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 18, 0))
241 nskb->prev = NULL;
242 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3, 18, 0) */
243
244 #ifdef BCMDBG_PKT
245 OSL_PKTLIST_LOCK(&osh->cmn->pktlist_lock, flags);
246 pktlist_add(&(osh->cmn->pktlist), (void *) nskb, line, file);
247 OSL_PKTLIST_UNLOCK(&osh->cmn->pktlist_lock, flags);
248 #endif /* BCMDBG_PKT */
249
250 #ifdef BCMDBG_CTRACE
251 ADD_CTRACE(osh, nskb, file, line);
252 #endif /* BCMDBG_CTRACE */
253 }
254 }
255
256 /* Increment the packet counter */
257 atomic_add(pktalloced, &osh->cmn->pktalloced);
258
259 return (void *)pkt;
260 }
261
262 /* Return a new packet. zero out pkttag */
263 #ifdef BCMDBG_PKT
264 void *
BCMFASTPATH(linux_pktget)265 BCMFASTPATH(linux_pktget)(osl_t *osh, uint len, int line, char *file)
266 #else /* BCMDBG_PKT */
267 #ifdef BCMDBG_CTRACE
268 void *
269 BCMFASTPATH(linux_pktget)(osl_t *osh, uint len, int line, char *file)
270 #else
271 #ifdef BCM_OBJECT_TRACE
272 void *
273 BCMFASTPATH(linux_pktget)(osl_t *osh, uint len, int line, const char *caller)
274 #else
275 void *
276 BCMFASTPATH(linux_pktget)(osl_t *osh, uint len)
277 #endif /* BCM_OBJECT_TRACE */
278 #endif /* BCMDBG_CTRACE */
279 #endif /* BCMDBG_PKT */
280 {
281 struct sk_buff *skb;
282 #ifdef BCMDBG_PKT
283 unsigned long flags;
284 #endif
285 uchar num = 0;
286 if (lmtest != FALSE) {
287 get_random_bytes(&num, sizeof(uchar));
288 if ((num + 1) <= (256 * lmtest / 100))
289 return NULL;
290 }
291
292 if ((skb = osl_alloc_skb(osh, len))) {
293 #ifdef BCMDBG
294 skb_put(skb, len);
295 #else
296 skb->tail += len;
297 skb->len += len;
298 #endif
299 skb->priority = 0;
300
301 #ifdef BCMDBG_CTRACE
302 ADD_CTRACE(osh, skb, file, line);
303 #endif
304 #ifdef BCMDBG_PKT
305 OSL_PKTLIST_LOCK(&osh->cmn->pktlist_lock, flags);
306 pktlist_add(&(osh->cmn->pktlist), (void *) skb, line, file);
307 OSL_PKTLIST_UNLOCK(&osh->cmn->pktlist_lock, flags);
308 #endif
309 atomic_inc(&osh->cmn->pktalloced);
310 #ifdef BCM_OBJECT_TRACE
311 bcm_object_trace_opr(skb, BCM_OBJDBG_ADD_PKT, caller, line);
312 #endif /* BCM_OBJECT_TRACE */
313 }
314
315 return ((void*) skb);
316 }
317
318 /* Free the driver packet. Free the tag if present */
319 #ifdef BCM_OBJECT_TRACE
320 void
BCMFASTPATH(linux_pktfree)321 BCMFASTPATH(linux_pktfree)(osl_t *osh, void *p, bool send, int line, const char *caller)
322 #else
323 void
324 BCMFASTPATH(linux_pktfree)(osl_t *osh, void *p, bool send)
325 #endif /* BCM_OBJECT_TRACE */
326 {
327 struct sk_buff *skb, *nskb;
328 #ifdef BCMDBG_PKT
329 unsigned long flags;
330 #endif
331 if (osh == NULL)
332 return;
333
334 skb = (struct sk_buff*) p;
335
336 if (send) {
337 if (osh->pub.tx_fn) {
338 osh->pub.tx_fn(osh->pub.tx_ctx, p, 0);
339 }
340 } else {
341 if (osh->pub.rx_fn) {
342 osh->pub.rx_fn(osh->pub.rx_ctx, p);
343 }
344 }
345
346 PKTDBG_TRACE(osh, (void *) skb, PKTLIST_PKTFREE);
347
348 #if defined(CONFIG_DHD_USE_STATIC_BUF) && defined(DHD_USE_STATIC_CTRLBUF)
349 if (skb && (skb->mac_len == PREALLOC_USED_MAGIC)) {
350 printf("%s: pkt %p is from static pool\n",
351 __FUNCTION__, p);
352 dump_stack();
353 return;
354 }
355
356 if (skb && (skb->mac_len == PREALLOC_FREE_MAGIC)) {
357 printf("%s: pkt %p is from static pool and not in used\n",
358 __FUNCTION__, p);
359 dump_stack();
360 return;
361 }
362 #endif /* CONFIG_DHD_USE_STATIC_BUF && DHD_USE_STATIC_CTRLBUF */
363
364 /* perversion: we use skb->next to chain multi-skb packets */
365 while (skb) {
366 nskb = skb->next;
367 skb->next = NULL;
368
369 #ifdef BCMDBG_CTRACE
370 DEL_CTRACE(osh, skb);
371 #endif
372 #ifdef BCMDBG_PKT
373 OSL_PKTLIST_LOCK(&osh->cmn->pktlist_lock, flags);
374 pktlist_remove(&(osh->cmn->pktlist), (void *) skb);
375 OSL_PKTLIST_UNLOCK(&osh->cmn->pktlist_lock, flags);
376 #endif
377
378 #ifdef BCM_OBJECT_TRACE
379 bcm_object_trace_opr(skb, BCM_OBJDBG_REMOVE, caller, line);
380 #endif /* BCM_OBJECT_TRACE */
381
382 if (skb->destructor || irqs_disabled()) {
383 /* cannot kfree_skb() on hard IRQ (net/core/skbuff.c) if
384 * destructor exists
385 */
386 dev_kfree_skb_any(skb);
387 } else {
388 /* can free immediately (even in_irq()) if destructor
389 * does not exist
390 */
391 dev_kfree_skb(skb);
392 }
393 atomic_dec(&osh->cmn->pktalloced);
394 skb = nskb;
395 }
396 }
397
398 #ifdef CONFIG_DHD_USE_STATIC_BUF
399 void*
osl_pktget_static(osl_t * osh,uint len)400 osl_pktget_static(osl_t *osh, uint len)
401 {
402 int i = 0;
403 struct sk_buff *skb;
404 #ifdef DHD_USE_STATIC_CTRLBUF
405 unsigned long flags;
406 #endif /* DHD_USE_STATIC_CTRLBUF */
407
408 if (!bcm_static_skb)
409 return linux_pktget(osh, len);
410
411 if (len > DHD_SKB_MAX_BUFSIZE) {
412 printf("%s: attempt to allocate huge packet (0x%x)\n", __FUNCTION__, len);
413 return linux_pktget(osh, len);
414 }
415
416 #ifdef DHD_USE_STATIC_CTRLBUF
417 OSL_STATIC_PKT_LOCK(&bcm_static_skb->osl_pkt_lock, flags);
418
419 if (len <= DHD_SKB_2PAGE_BUFSIZE) {
420 uint32 index;
421 for (i = 0; i < STATIC_PKT_2PAGE_NUM; i++) {
422 index = bcm_static_skb->last_allocated_index % STATIC_PKT_2PAGE_NUM;
423 bcm_static_skb->last_allocated_index++;
424 if (bcm_static_skb->skb_8k[index] &&
425 bcm_static_skb->pkt_use[index] == 0) {
426 break;
427 }
428 }
429
430 if (i < STATIC_PKT_2PAGE_NUM) {
431 bcm_static_skb->pkt_use[index] = 1;
432 skb = bcm_static_skb->skb_8k[index];
433 skb->data = skb->head;
434 #ifdef NET_SKBUFF_DATA_USES_OFFSET
435 skb_set_tail_pointer(skb, PKT_HEADROOM_DEFAULT);
436 #else
437 skb->tail = skb->data + PKT_HEADROOM_DEFAULT;
438 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
439 skb->data += PKT_HEADROOM_DEFAULT;
440 skb->cloned = 0;
441 skb->priority = 0;
442 #ifdef NET_SKBUFF_DATA_USES_OFFSET
443 skb_set_tail_pointer(skb, len);
444 #else
445 skb->tail = skb->data + len;
446 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
447 skb->len = len;
448 skb->mac_len = PREALLOC_USED_MAGIC;
449 OSL_STATIC_PKT_UNLOCK(&bcm_static_skb->osl_pkt_lock, flags);
450 return skb;
451 }
452 }
453
454 OSL_STATIC_PKT_UNLOCK(&bcm_static_skb->osl_pkt_lock, flags);
455 printf("%s: all static pkt in use!\n", __FUNCTION__);
456 return NULL;
457 #else
458 down(&bcm_static_skb->osl_pkt_sem);
459
460 if (len <= DHD_SKB_1PAGE_BUFSIZE) {
461 for (i = 0; i < STATIC_PKT_1PAGE_NUM; i++) {
462 if (bcm_static_skb->skb_4k[i] &&
463 bcm_static_skb->pkt_use[i] == 0) {
464 break;
465 }
466 }
467
468 if (i != STATIC_PKT_1PAGE_NUM) {
469 bcm_static_skb->pkt_use[i] = 1;
470
471 skb = bcm_static_skb->skb_4k[i];
472 #ifdef NET_SKBUFF_DATA_USES_OFFSET
473 skb_set_tail_pointer(skb, len);
474 #else
475 skb->tail = skb->data + len;
476 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
477 skb->len = len;
478
479 up(&bcm_static_skb->osl_pkt_sem);
480 return skb;
481 }
482 }
483
484 if (len <= DHD_SKB_2PAGE_BUFSIZE) {
485 for (i = STATIC_PKT_1PAGE_NUM; i < STATIC_PKT_1_2PAGE_NUM; i++) {
486 if (bcm_static_skb->skb_8k[i - STATIC_PKT_1PAGE_NUM] &&
487 bcm_static_skb->pkt_use[i] == 0) {
488 break;
489 }
490 }
491
492 if ((i >= STATIC_PKT_1PAGE_NUM) && (i < STATIC_PKT_1_2PAGE_NUM)) {
493 bcm_static_skb->pkt_use[i] = 1;
494 skb = bcm_static_skb->skb_8k[i - STATIC_PKT_1PAGE_NUM];
495 #ifdef NET_SKBUFF_DATA_USES_OFFSET
496 skb_set_tail_pointer(skb, len);
497 #else
498 skb->tail = skb->data + len;
499 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
500 skb->len = len;
501
502 up(&bcm_static_skb->osl_pkt_sem);
503 return skb;
504 }
505 }
506
507 #if defined (ENHANCED_STATIC_BUF)
508 if (bcm_static_skb->skb_16k &&
509 bcm_static_skb->pkt_use[STATIC_PKT_MAX_NUM - 1] == 0) {
510 bcm_static_skb->pkt_use[STATIC_PKT_MAX_NUM - 1] = 1;
511
512 skb = bcm_static_skb->skb_16k;
513 #ifdef NET_SKBUFF_DATA_USES_OFFSET
514 skb_set_tail_pointer(skb, len);
515 #else
516 skb->tail = skb->data + len;
517 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
518 skb->len = len;
519
520 up(&bcm_static_skb->osl_pkt_sem);
521 return skb;
522 }
523 #endif /* ENHANCED_STATIC_BUF */
524
525 up(&bcm_static_skb->osl_pkt_sem);
526 printf("%s: all static pkt in use!\n", __FUNCTION__);
527 return linux_pktget(osh, len);
528 #endif /* DHD_USE_STATIC_CTRLBUF */
529 }
530
531 void
osl_pktfree_static(osl_t * osh,void * p,bool send)532 osl_pktfree_static(osl_t *osh, void *p, bool send)
533 {
534 int i;
535 #ifdef DHD_USE_STATIC_CTRLBUF
536 struct sk_buff *skb = (struct sk_buff *)p;
537 unsigned long flags;
538 #endif /* DHD_USE_STATIC_CTRLBUF */
539
540 if (!p) {
541 return;
542 }
543
544 if (!bcm_static_skb) {
545 linux_pktfree(osh, p, send);
546 return;
547 }
548
549 #ifdef DHD_USE_STATIC_CTRLBUF
550 OSL_STATIC_PKT_LOCK(&bcm_static_skb->osl_pkt_lock, flags);
551
552 for (i = 0; i < STATIC_PKT_2PAGE_NUM; i++) {
553 if (p == bcm_static_skb->skb_8k[i]) {
554 if (bcm_static_skb->pkt_use[i] == 0) {
555 printf("%s: static pkt idx %d(%p) is double free\n",
556 __FUNCTION__, i, p);
557 } else {
558 bcm_static_skb->pkt_use[i] = 0;
559 }
560
561 if (skb->mac_len != PREALLOC_USED_MAGIC) {
562 printf("%s: static pkt idx %d(%p) is not in used\n",
563 __FUNCTION__, i, p);
564 }
565
566 skb->mac_len = PREALLOC_FREE_MAGIC;
567 OSL_STATIC_PKT_UNLOCK(&bcm_static_skb->osl_pkt_lock, flags);
568 return;
569 }
570 }
571
572 OSL_STATIC_PKT_UNLOCK(&bcm_static_skb->osl_pkt_lock, flags);
573 printf("%s: packet %p does not exist in the pool\n", __FUNCTION__, p);
574 #else
575 down(&bcm_static_skb->osl_pkt_sem);
576 for (i = 0; i < STATIC_PKT_1PAGE_NUM; i++) {
577 if (p == bcm_static_skb->skb_4k[i]) {
578 bcm_static_skb->pkt_use[i] = 0;
579 up(&bcm_static_skb->osl_pkt_sem);
580 return;
581 }
582 }
583
584 for (i = STATIC_PKT_1PAGE_NUM; i < STATIC_PKT_1_2PAGE_NUM; i++) {
585 if (p == bcm_static_skb->skb_8k[i - STATIC_PKT_1PAGE_NUM]) {
586 bcm_static_skb->pkt_use[i] = 0;
587 up(&bcm_static_skb->osl_pkt_sem);
588 return;
589 }
590 }
591 #ifdef ENHANCED_STATIC_BUF
592 if (p == bcm_static_skb->skb_16k) {
593 bcm_static_skb->pkt_use[STATIC_PKT_MAX_NUM - 1] = 0;
594 up(&bcm_static_skb->osl_pkt_sem);
595 return;
596 }
597 #endif
598 up(&bcm_static_skb->osl_pkt_sem);
599 #endif /* DHD_USE_STATIC_CTRLBUF */
600 linux_pktfree(osh, p, send);
601 }
602 #endif /* CONFIG_DHD_USE_STATIC_BUF */
603
604 /* Clone a packet.
605 * The pkttag contents are NOT cloned.
606 */
607 #ifdef BCMDBG_PKT
608 void *
osl_pktdup(osl_t * osh,void * skb,int line,char * file)609 osl_pktdup(osl_t *osh, void *skb, int line, char *file)
610 #else /* BCMDBG_PKT */
611 #ifdef BCMDBG_CTRACE
612 void *
613 osl_pktdup(osl_t *osh, void *skb, int line, char *file)
614 #else
615 #ifdef BCM_OBJECT_TRACE
616 void *
617 osl_pktdup(osl_t *osh, void *skb, int line, const char *caller)
618 #else
619 void *
620 osl_pktdup(osl_t *osh, void *skb)
621 #endif /* BCM_OBJECT_TRACE */
622 #endif /* BCMDBG_CTRACE */
623 #endif /* BCMDBG_PKT */
624 {
625 void * p;
626 #ifdef BCMDBG_PKT
627 unsigned long irqflags;
628 #endif
629
630 ASSERT(!PKTISCHAINED(skb));
631
632 if ((p = skb_clone((struct sk_buff *)skb, GFP_ATOMIC)) == NULL)
633 return NULL;
634
635 /* skb_clone copies skb->cb.. we don't want that */
636 if (osh->pub.pkttag)
637 OSL_PKTTAG_CLEAR(p);
638
639 /* Increment the packet counter */
640 atomic_inc(&osh->cmn->pktalloced);
641 #ifdef BCM_OBJECT_TRACE
642 bcm_object_trace_opr(p, BCM_OBJDBG_ADD_PKT, caller, line);
643 #endif /* BCM_OBJECT_TRACE */
644
645 #ifdef BCMDBG_CTRACE
646 ADD_CTRACE(osh, (struct sk_buff *)p, file, line);
647 #endif
648 #ifdef BCMDBG_PKT
649 OSL_PKTLIST_LOCK(&osh->cmn->pktlist_lock, irqflags);
650 pktlist_add(&(osh->cmn->pktlist), (void *) p, line, file);
651 OSL_PKTLIST_UNLOCK(&osh->cmn->pktlist_lock, irqflags);
652 #endif
653 return (p);
654 }
655
656 #ifdef BCMDBG_CTRACE
osl_pkt_is_frmnative(osl_t * osh,struct sk_buff * pkt)657 int osl_pkt_is_frmnative(osl_t *osh, struct sk_buff *pkt)
658 {
659 unsigned long flags;
660 struct sk_buff *skb;
661 int ck = FALSE;
662
663 OSL_CTRACE_LOCK(&osh->ctrace_lock, flags);
664
665 list_for_each_entry(skb, &osh->ctrace_list, ctrace_list) {
666 if (pkt == skb) {
667 ck = TRUE;
668 break;
669 }
670 }
671
672 OSL_CTRACE_UNLOCK(&osh->ctrace_lock, flags);
673 return ck;
674 }
675
osl_ctrace_dump(osl_t * osh,struct bcmstrbuf * b)676 void osl_ctrace_dump(osl_t *osh, struct bcmstrbuf *b)
677 {
678 unsigned long flags;
679 struct sk_buff *skb;
680 int idx = 0;
681 int i, j;
682
683 OSL_CTRACE_LOCK(&osh->ctrace_lock, flags);
684
685 if (b != NULL)
686 bcm_bprintf(b, " Total %d sbk not free\n", osh->ctrace_num);
687 else
688 printf(" Total %d sbk not free\n", osh->ctrace_num);
689
690 list_for_each_entry(skb, &osh->ctrace_list, ctrace_list) {
691 if (b != NULL)
692 bcm_bprintf(b, "[%d] skb %p:\n", ++idx, skb);
693 else
694 printk("[%d] skb %p:\n", ++idx, skb);
695
696 for (i = 0; i < skb->ctrace_count; i++) {
697 j = (skb->ctrace_start + i) % CTRACE_NUM;
698 if (b != NULL)
699 bcm_bprintf(b, " [%s(%d)]\n", skb->func[j], skb->line[j]);
700 else
701 printk(" [%s(%d)]\n", skb->func[j], skb->line[j]);
702 }
703 if (b != NULL)
704 bcm_bprintf(b, "\n");
705 else
706 printk("\n");
707 }
708
709 OSL_CTRACE_UNLOCK(&osh->ctrace_lock, flags);
710
711 return;
712 }
713 #endif /* BCMDBG_CTRACE */
714
715 #ifdef BCMDBG_PKT
716 #ifdef BCMDBG_PTRACE
717 void
osl_pkttrace(osl_t * osh,void * pkt,uint16 bit)718 osl_pkttrace(osl_t *osh, void *pkt, uint16 bit)
719 {
720 pktlist_trace(&(osh->cmn->pktlist), pkt, bit);
721 }
722 #endif /* BCMDBG_PTRACE */
723
724 char *
osl_pktlist_dump(osl_t * osh,char * buf)725 osl_pktlist_dump(osl_t *osh, char *buf)
726 {
727 pktlist_dump(&(osh->cmn->pktlist), buf);
728 return buf;
729 }
730
731 void
osl_pktlist_add(osl_t * osh,void * p,int line,char * file)732 osl_pktlist_add(osl_t *osh, void *p, int line, char *file)
733 {
734 unsigned long flags;
735 OSL_PKTLIST_LOCK(&osh->cmn->pktlist_lock, flags);
736 pktlist_add(&(osh->cmn->pktlist), p, line, file);
737 OSL_PKTLIST_UNLOCK(&osh->cmn->pktlist_lock, flags);
738 }
739
740 void
osl_pktlist_remove(osl_t * osh,void * p)741 osl_pktlist_remove(osl_t *osh, void *p)
742 {
743 unsigned long flags;
744 OSL_PKTLIST_LOCK(&osh->cmn->pktlist_lock, flags);
745 pktlist_remove(&(osh->cmn->pktlist), p);
746 OSL_PKTLIST_UNLOCK(&osh->cmn->pktlist_lock, flags);
747 }
748 #endif /* BCMDBG_PKT */
749
750 /*
751 * BINOSL selects the slightly slower function-call-based binary compatible osl.
752 */
753 #ifdef BINOSL
754 bool
osl_pktshared(void * skb)755 osl_pktshared(void *skb)
756 {
757 return (((struct sk_buff*)skb)->cloned);
758 }
759
760 uchar*
osl_pktdata(osl_t * osh,void * skb)761 osl_pktdata(osl_t *osh, void *skb)
762 {
763 return (((struct sk_buff*)skb)->data);
764 }
765
766 uint
osl_pktlen(osl_t * osh,void * skb)767 osl_pktlen(osl_t *osh, void *skb)
768 {
769 return (((struct sk_buff*)skb)->len);
770 }
771
772 uint
osl_pktheadroom(osl_t * osh,void * skb)773 osl_pktheadroom(osl_t *osh, void *skb)
774 {
775 return (uint) skb_headroom((struct sk_buff *) skb);
776 }
777
778 uint
osl_pkttailroom(osl_t * osh,void * skb)779 osl_pkttailroom(osl_t *osh, void *skb)
780 {
781 return (uint) skb_tailroom((struct sk_buff *) skb);
782 }
783
784 void*
osl_pktnext(osl_t * osh,void * skb)785 osl_pktnext(osl_t *osh, void *skb)
786 {
787 return (((struct sk_buff*)skb)->next);
788 }
789
790 void
osl_pktsetnext(void * skb,void * x)791 osl_pktsetnext(void *skb, void *x)
792 {
793 ((struct sk_buff*)skb)->next = (struct sk_buff*)x;
794 }
795
796 void
osl_pktsetlen(osl_t * osh,void * skb,uint len)797 osl_pktsetlen(osl_t *osh, void *skb, uint len)
798 {
799 __skb_trim((struct sk_buff*)skb, len);
800 }
801
802 uchar*
osl_pktpush(osl_t * osh,void * skb,int bytes)803 osl_pktpush(osl_t *osh, void *skb, int bytes)
804 {
805 return (skb_push((struct sk_buff*)skb, bytes));
806 }
807
808 uchar*
osl_pktpull(osl_t * osh,void * skb,int bytes)809 osl_pktpull(osl_t *osh, void *skb, int bytes)
810 {
811 return (skb_pull((struct sk_buff*)skb, bytes));
812 }
813
814 void*
osl_pkttag(void * skb)815 osl_pkttag(void *skb)
816 {
817 return ((void*)(((struct sk_buff*)skb)->cb));
818 }
819
820 void*
osl_pktlink(void * skb)821 osl_pktlink(void *skb)
822 {
823 return (((struct sk_buff*)skb)->prev);
824 }
825
826 void
osl_pktsetlink(void * skb,void * x)827 osl_pktsetlink(void *skb, void *x)
828 {
829 ((struct sk_buff*)skb)->prev = (struct sk_buff*)x;
830 }
831
832 uint
osl_pktprio(void * skb)833 osl_pktprio(void *skb)
834 {
835 return (((struct sk_buff*)skb)->priority);
836 }
837
838 void
osl_pktsetprio(void * skb,uint x)839 osl_pktsetprio(void *skb, uint x)
840 {
841 ((struct sk_buff*)skb)->priority = x;
842 }
843 #endif /* BINOSL */
844
845 uint
osl_pktalloced(osl_t * osh)846 osl_pktalloced(osl_t *osh)
847 {
848 if (atomic_read(&osh->cmn->refcount) == 1)
849 return (atomic_read(&osh->cmn->pktalloced));
850 else
851 return 0;
852 }
853
854 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0) && defined(TSQ_MULTIPLIER)
855 #include <linux/kallsyms.h>
856 #include <net/sock.h>
857 void
osl_pkt_orphan_partial(struct sk_buff * skb,int tsq)858 osl_pkt_orphan_partial(struct sk_buff *skb, int tsq)
859 {
860 uint32 fraction;
861 static void *p_tcp_wfree = NULL;
862
863 if (tsq <= 0)
864 return;
865
866 if (!skb->destructor || skb->destructor == sock_wfree)
867 return;
868
869 if (unlikely(!p_tcp_wfree)) {
870 /* this is a hack to get tcp_wfree pointer since it's not
871 * exported. There are two possible call back function pointer
872 * stored in skb->destructor: tcp_wfree and sock_wfree.
873 * This expansion logic should only apply to TCP traffic which
874 * uses tcp_wfree as skb destructor
875 */
876 char sym[KSYM_SYMBOL_LEN];
877 sprint_symbol(sym, (unsigned long)skb->destructor);
878 sym[9] = 0;
879 if (!strcmp(sym, "tcp_wfree"))
880 p_tcp_wfree = skb->destructor;
881 else
882 return;
883 }
884
885 if (unlikely(skb->destructor != p_tcp_wfree || !skb->sk))
886 return;
887
888 /* abstract a certain portion of skb truesize from the socket
889 * sk_wmem_alloc to allow more skb can be allocated for this
890 * socket for better cusion meeting WiFi device requirement
891 */
892 fraction = skb->truesize * (tsq - 1) / tsq;
893 skb->truesize -= fraction;
894 atomic_sub(fraction, (atomic_t *)&skb->sk->sk_wmem_alloc);
895 skb_orphan(skb);
896 }
897 #endif /* LINUX_VERSION >= 3.6.0 && TSQ_MULTIPLIER */
898