1 /*
2 * Linux OS Independent Layer
3 *
4 * Copyright (C) 1999-2017, Broadcom Corporation
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 * Notwithstanding the above, under no circumstances may you combine this
21 * software in any way with any other Broadcom software provided under a license
22 * other than the GPL, without Broadcom's express prior written consent.
23 *
24 *
25 * <<Broadcom-WL-IPTag/Open:>>
26 *
27 * $Id: linux_osl.c 680580 2017-01-20 11:49:58Z $
28 */
29
30 #define LINUX_PORT
31
32 #include <typedefs.h>
33 #include <bcmendian.h>
34 #include <linuxver.h>
35 #include <bcmdefs.h>
36 #ifdef CUSTOMER_HW_ALLWINNER
37 #endif
38
39
40 #if !defined(STBLINUX)
41 #if defined(__ARM_ARCH_7A__) && !defined(DHD_USE_COHERENT_MEM_FOR_RING)
42 #include <asm/cacheflush.h>
43 #endif /* __ARM_ARCH_7A__ && !DHD_USE_COHERENT_MEM_FOR_RING */
44 #endif /* STBLINUX */
45
46 #include <linux/random.h>
47
48 #include <osl.h>
49 #include <bcmutils.h>
50 #include <linux/delay.h>
51 #include <linux/vmalloc.h>
52 #include <pcicfg.h>
53
54
55 #ifdef BCM_SECURE_DMA
56 #include <linux/module.h>
57 #include <linux/kernel.h>
58 #include <linux/io.h>
59 #include <linux/printk.h>
60 #include <linux/errno.h>
61 #include <linux/mm.h>
62 #include <linux/moduleparam.h>
63 #include <asm/io.h>
64 #include <linux/skbuff.h>
65 #include <stbutils.h>
66 #include <linux/highmem.h>
67 #include <linux/dma-mapping.h>
68 #include <asm/memory.h>
69 #endif /* BCM_SECURE_DMA */
70
71 #include <linux/fs.h>
72
73 #if defined(STB)
74 #include <linux/spinlock.h>
75 extern spinlock_t l2x0_reg_lock;
76 #endif
77
78 #ifdef BCM_OBJECT_TRACE
79 #include <bcmutils.h>
80 #endif /* BCM_OBJECT_TRACE */
81
82 #define PCI_CFG_RETRY 10
83
84 #define OS_HANDLE_MAGIC 0x1234abcd /* Magic # to recognize osh */
85 #define BCM_MEM_FILENAME_LEN 24 /* Mem. filename length */
86 #define DUMPBUFSZ 1024
87
88 /* dependancy check */
89 #if !defined(BCMPCIE) && defined(DHD_USE_STATIC_CTRLBUF)
90 #error "DHD_USE_STATIC_CTRLBUF suppored PCIE target only"
91 #endif /* !BCMPCIE && DHD_USE_STATIC_CTRLBUF */
92
93 #ifdef CONFIG_DHD_USE_STATIC_BUF
94 #ifdef DHD_USE_STATIC_CTRLBUF
95 #define DHD_SKB_1PAGE_BUFSIZE (PAGE_SIZE*1)
96 #define DHD_SKB_2PAGE_BUFSIZE (PAGE_SIZE*2)
97 #define DHD_SKB_4PAGE_BUFSIZE (PAGE_SIZE*4)
98
99 #define PREALLOC_FREE_MAGIC 0xFEDC
100 #define PREALLOC_USED_MAGIC 0xFCDE
101 #else
102 #define DHD_SKB_HDRSIZE 336
103 #define DHD_SKB_1PAGE_BUFSIZE ((PAGE_SIZE*1)-DHD_SKB_HDRSIZE)
104 #define DHD_SKB_2PAGE_BUFSIZE ((PAGE_SIZE*2)-DHD_SKB_HDRSIZE)
105 #define DHD_SKB_4PAGE_BUFSIZE ((PAGE_SIZE*4)-DHD_SKB_HDRSIZE)
106 #endif /* DHD_USE_STATIC_CTRLBUF */
107
108 #define STATIC_BUF_MAX_NUM 16
109 #define STATIC_BUF_SIZE (PAGE_SIZE*2)
110 #define STATIC_BUF_TOTAL_LEN (STATIC_BUF_MAX_NUM * STATIC_BUF_SIZE)
111
112 typedef struct bcm_static_buf {
113 spinlock_t static_lock;
114 unsigned char *buf_ptr;
115 unsigned char buf_use[STATIC_BUF_MAX_NUM];
116 } bcm_static_buf_t;
117
118 static bcm_static_buf_t *bcm_static_buf = 0;
119
120 #ifdef DHD_USE_STATIC_CTRLBUF
121 #define STATIC_PKT_4PAGE_NUM 0
122 #define DHD_SKB_MAX_BUFSIZE DHD_SKB_2PAGE_BUFSIZE
123 #elif defined(ENHANCED_STATIC_BUF)
124 #define STATIC_PKT_4PAGE_NUM 1
125 #define DHD_SKB_MAX_BUFSIZE DHD_SKB_4PAGE_BUFSIZE
126 #else
127 #define STATIC_PKT_4PAGE_NUM 0
128 #define DHD_SKB_MAX_BUFSIZE DHD_SKB_2PAGE_BUFSIZE
129 #endif /* DHD_USE_STATIC_CTRLBUF */
130
131 #ifdef DHD_USE_STATIC_CTRLBUF
132 #define STATIC_PKT_1PAGE_NUM 0
133 #define STATIC_PKT_2PAGE_NUM 128
134 #else
135 #define STATIC_PKT_1PAGE_NUM 8
136 #define STATIC_PKT_2PAGE_NUM 8
137 #endif /* DHD_USE_STATIC_CTRLBUF */
138
139 #define STATIC_PKT_1_2PAGE_NUM \
140 ((STATIC_PKT_1PAGE_NUM) + (STATIC_PKT_2PAGE_NUM))
141 #define STATIC_PKT_MAX_NUM \
142 ((STATIC_PKT_1_2PAGE_NUM) + (STATIC_PKT_4PAGE_NUM))
143
144 typedef struct bcm_static_pkt {
145 #ifdef DHD_USE_STATIC_CTRLBUF
146 struct sk_buff *skb_8k[STATIC_PKT_2PAGE_NUM];
147 unsigned char pkt_invalid[STATIC_PKT_2PAGE_NUM];
148 spinlock_t osl_pkt_lock;
149 uint32 last_allocated_index;
150 #else
151 struct sk_buff *skb_4k[STATIC_PKT_1PAGE_NUM];
152 struct sk_buff *skb_8k[STATIC_PKT_2PAGE_NUM];
153 #ifdef ENHANCED_STATIC_BUF
154 struct sk_buff *skb_16k;
155 #endif /* ENHANCED_STATIC_BUF */
156 struct semaphore osl_pkt_sem;
157 #endif /* DHD_USE_STATIC_CTRLBUF */
158 unsigned char pkt_use[STATIC_PKT_MAX_NUM];
159 } bcm_static_pkt_t;
160
161 static bcm_static_pkt_t *bcm_static_skb = 0;
162
163 void* wifi_platform_prealloc(void *adapter, int section, unsigned long size);
164 #endif /* CONFIG_DHD_USE_STATIC_BUF */
165
166 typedef struct bcm_mem_link {
167 struct bcm_mem_link *prev;
168 struct bcm_mem_link *next;
169 uint size;
170 int line;
171 void *osh;
172 char file[BCM_MEM_FILENAME_LEN];
173 } bcm_mem_link_t;
174
175 struct osl_cmn_info {
176 atomic_t malloced;
177 atomic_t pktalloced; /* Number of allocated packet buffers */
178 spinlock_t dbgmem_lock;
179 bcm_mem_link_t *dbgmem_list;
180 bcm_mem_link_t *dbgvmem_list;
181 spinlock_t pktalloc_lock;
182 atomic_t refcount; /* Number of references to this shared structure. */
183 };
184 typedef struct osl_cmn_info osl_cmn_t;
185
186 struct osl_info {
187 osl_pubinfo_t pub;
188 uint32 flags; /* If specific cases to be handled in the OSL */
189 #ifdef CTFPOOL
190 ctfpool_t *ctfpool;
191 #endif /* CTFPOOL */
192 uint magic;
193 void *pdev;
194 uint failed;
195 uint bustype;
196 osl_cmn_t *cmn; /* Common OSL related data shred between two OSH's */
197
198 void *bus_handle;
199 #ifdef BCMDBG_CTRACE
200 spinlock_t ctrace_lock;
201 struct list_head ctrace_list;
202 int ctrace_num;
203 #endif /* BCMDBG_CTRACE */
204 #ifdef BCM_SECURE_DMA
205 struct sec_mem_elem *sec_list_4096;
206 struct sec_mem_elem *sec_list_base_4096;
207 phys_addr_t contig_base;
208 void *contig_base_va;
209 phys_addr_t contig_base_alloc;
210 void *contig_base_alloc_va;
211 phys_addr_t contig_base_alloc_coherent;
212 void *contig_base_alloc_coherent_va;
213 void *contig_base_coherent_va;
214 void *contig_delta_va_pa;
215 struct {
216 phys_addr_t pa;
217 void *va;
218 bool avail;
219 } sec_cma_coherent[SEC_CMA_COHERENT_MAX];
220 int stb_ext_params;
221 #endif /* BCM_SECURE_DMA */
222 };
223 #ifdef BCM_SECURE_DMA
224 static void * osl_sec_dma_ioremap(osl_t *osh, struct page *page, size_t size,
225 bool iscache, bool isdecr);
226 static void osl_sec_dma_iounmap(osl_t *osh, void *contig_base_va, size_t size);
227 static int osl_sec_dma_init_elem_mem_block(osl_t *osh, size_t mbsize, int max,
228 sec_mem_elem_t **list);
229 static void osl_sec_dma_deinit_elem_mem_block(osl_t *osh, size_t mbsize, int max,
230 void *sec_list_base);
231 static sec_mem_elem_t * osl_sec_dma_alloc_mem_elem(osl_t *osh, void *va, uint size,
232 int direction, struct sec_cma_info *ptr_cma_info, uint offset);
233 static void osl_sec_dma_free_mem_elem(osl_t *osh, sec_mem_elem_t *sec_mem_elem);
234 static void osl_sec_dma_init_consistent(osl_t *osh);
235 static void *osl_sec_dma_alloc_consistent(osl_t *osh, uint size, uint16 align_bits,
236 ulong *pap);
237 static void osl_sec_dma_free_consistent(osl_t *osh, void *va, uint size, dmaaddr_t pa);
238 #endif /* BCM_SECURE_DMA */
239
240 #ifdef BCM_OBJECT_TRACE
241 /* don't clear the first 4 byte that is the pkt sn */
242 #define OSL_PKTTAG_CLEAR(p) \
243 do { \
244 struct sk_buff *s = (struct sk_buff *)(p); \
245 ASSERT(OSL_PKTTAG_SZ == 32); \
246 *(uint32 *)(&s->cb[4]) = 0; \
247 *(uint32 *)(&s->cb[8]) = 0; *(uint32 *)(&s->cb[12]) = 0; \
248 *(uint32 *)(&s->cb[16]) = 0; *(uint32 *)(&s->cb[20]) = 0; \
249 *(uint32 *)(&s->cb[24]) = 0; *(uint32 *)(&s->cb[28]) = 0; \
250 } while (0)
251 #else
252 #define OSL_PKTTAG_CLEAR(p) \
253 do { \
254 struct sk_buff *s = (struct sk_buff *)(p); \
255 ASSERT(OSL_PKTTAG_SZ == 32); \
256 *(uint32 *)(&s->cb[0]) = 0; *(uint32 *)(&s->cb[4]) = 0; \
257 *(uint32 *)(&s->cb[8]) = 0; *(uint32 *)(&s->cb[12]) = 0; \
258 *(uint32 *)(&s->cb[16]) = 0; *(uint32 *)(&s->cb[20]) = 0; \
259 *(uint32 *)(&s->cb[24]) = 0; *(uint32 *)(&s->cb[28]) = 0; \
260 } while (0)
261 #endif /* BCM_OBJECT_TRACE */
262
263 /* PCMCIA attribute space access macros */
264
265 uint32 g_assert_type = 0; /* By Default Kernel Panic */
266
267 module_param(g_assert_type, int, 0);
268 #ifdef BCM_SECURE_DMA
269 #define SECDMA_MODULE_PARAMS 0
270 #define SECDMA_EXT_FILE 1
271 unsigned long secdma_addr = 0;
272 unsigned long secdma_addr2 = 0;
273 u32 secdma_size = 0;
274 u32 secdma_size2 = 0;
275 module_param(secdma_addr, ulong, 0);
276 module_param(secdma_size, int, 0);
277 module_param(secdma_addr2, ulong, 0);
278 module_param(secdma_size2, int, 0);
279 static int secdma_found = 0;
280 #endif /* BCM_SECURE_DMA */
281
282 static int16 linuxbcmerrormap[] =
283 { 0, /* 0 */
284 -EINVAL, /* BCME_ERROR */
285 -EINVAL, /* BCME_BADARG */
286 -EINVAL, /* BCME_BADOPTION */
287 -EINVAL, /* BCME_NOTUP */
288 -EINVAL, /* BCME_NOTDOWN */
289 -EINVAL, /* BCME_NOTAP */
290 -EINVAL, /* BCME_NOTSTA */
291 -EINVAL, /* BCME_BADKEYIDX */
292 -EINVAL, /* BCME_RADIOOFF */
293 -EINVAL, /* BCME_NOTBANDLOCKED */
294 -EINVAL, /* BCME_NOCLK */
295 -EINVAL, /* BCME_BADRATESET */
296 -EINVAL, /* BCME_BADBAND */
297 -E2BIG, /* BCME_BUFTOOSHORT */
298 -E2BIG, /* BCME_BUFTOOLONG */
299 -EBUSY, /* BCME_BUSY */
300 -EINVAL, /* BCME_NOTASSOCIATED */
301 -EINVAL, /* BCME_BADSSIDLEN */
302 -EINVAL, /* BCME_OUTOFRANGECHAN */
303 -EINVAL, /* BCME_BADCHAN */
304 -EFAULT, /* BCME_BADADDR */
305 -ENOMEM, /* BCME_NORESOURCE */
306 -EOPNOTSUPP, /* BCME_UNSUPPORTED */
307 -EMSGSIZE, /* BCME_BADLENGTH */
308 -EINVAL, /* BCME_NOTREADY */
309 -EPERM, /* BCME_EPERM */
310 -ENOMEM, /* BCME_NOMEM */
311 -EINVAL, /* BCME_ASSOCIATED */
312 -ERANGE, /* BCME_RANGE */
313 -EINVAL, /* BCME_NOTFOUND */
314 -EINVAL, /* BCME_WME_NOT_ENABLED */
315 -EINVAL, /* BCME_TSPEC_NOTFOUND */
316 -EINVAL, /* BCME_ACM_NOTSUPPORTED */
317 -EINVAL, /* BCME_NOT_WME_ASSOCIATION */
318 -EIO, /* BCME_SDIO_ERROR */
319 -ENODEV, /* BCME_DONGLE_DOWN */
320 -EINVAL, /* BCME_VERSION */
321 -EIO, /* BCME_TXFAIL */
322 -EIO, /* BCME_RXFAIL */
323 -ENODEV, /* BCME_NODEVICE */
324 -EINVAL, /* BCME_NMODE_DISABLED */
325 -ENODATA, /* BCME_NONRESIDENT */
326 -EINVAL, /* BCME_SCANREJECT */
327 -EINVAL, /* BCME_USAGE_ERROR */
328 -EIO, /* BCME_IOCTL_ERROR */
329 -EIO, /* BCME_SERIAL_PORT_ERR */
330 -EOPNOTSUPP, /* BCME_DISABLED, BCME_NOTENABLED */
331 -EIO, /* BCME_DECERR */
332 -EIO, /* BCME_ENCERR */
333 -EIO, /* BCME_MICERR */
334 -ERANGE, /* BCME_REPLAY */
335 -EINVAL, /* BCME_IE_NOTFOUND */
336 -EINVAL, /* BCME_DATA_NOTFOUND */
337 -EINVAL, /* BCME_NOT_GC */
338 -EINVAL, /* BCME_PRS_REQ_FAILED */
339 -EINVAL, /* BCME_NO_P2P_SE */
340 -EINVAL, /* BCME_NOA_PND */
341 -EINVAL, /* BCME_FRAG_Q_FAILED */
342 -EINVAL, /* BCME_GET_AF_FAILED */
343 -EINVAL, /* BCME_MSCH_NOTREADY */
344
345 /* When an new error code is added to bcmutils.h, add os
346 * specific error translation here as well
347 */
348 /* check if BCME_LAST changed since the last time this function was updated */
349 #if BCME_LAST != -60
350 #error "You need to add a OS error translation in the linuxbcmerrormap \
351 for new error code defined in bcmutils.h"
352 #endif
353 };
354 uint lmtest = FALSE;
355
356 /* translate bcmerrors into linux errors */
357 int
osl_error(int bcmerror)358 osl_error(int bcmerror)
359 {
360 if (bcmerror > 0)
361 bcmerror = 0;
362 else if (bcmerror < BCME_LAST)
363 bcmerror = BCME_ERROR;
364
365 /* Array bounds covered by ASSERT in osl_attach */
366 return linuxbcmerrormap[-bcmerror];
367 }
368
369 osl_t *
370 #ifdef SHARED_OSL_CMN
osl_attach(void * pdev,uint bustype,bool pkttag,void ** osl_cmn)371 osl_attach(void *pdev, uint bustype, bool pkttag, void **osl_cmn)
372 #else
373 osl_attach(void *pdev, uint bustype, bool pkttag)
374 #endif /* SHARED_OSL_CMN */
375 {
376 #ifndef SHARED_OSL_CMN
377 void **osl_cmn = NULL;
378 #endif /* SHARED_OSL_CMN */
379 osl_t *osh;
380 gfp_t flags;
381 #ifdef BCM_SECURE_DMA
382 u32 secdma_memsize;
383 #endif
384
385 flags = CAN_SLEEP() ? GFP_KERNEL: GFP_ATOMIC;
386 if (!(osh = kmalloc(sizeof(osl_t), flags)))
387 return osh;
388
389 ASSERT(osh);
390
391 bzero(osh, sizeof(osl_t));
392
393 if (osl_cmn == NULL || *osl_cmn == NULL) {
394 if (!(osh->cmn = kmalloc(sizeof(osl_cmn_t), flags))) {
395 kfree(osh);
396 return NULL;
397 }
398 bzero(osh->cmn, sizeof(osl_cmn_t));
399 if (osl_cmn)
400 *osl_cmn = osh->cmn;
401 atomic_set(&osh->cmn->malloced, 0);
402 osh->cmn->dbgmem_list = NULL;
403 spin_lock_init(&(osh->cmn->dbgmem_lock));
404
405 spin_lock_init(&(osh->cmn->pktalloc_lock));
406 } else {
407 osh->cmn = *osl_cmn;
408 }
409 atomic_add(1, &osh->cmn->refcount);
410
411 bcm_object_trace_init();
412
413 /* Check that error map has the right number of entries in it */
414 ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(linuxbcmerrormap) - 1));
415
416 osh->failed = 0;
417 osh->pdev = pdev;
418 osh->pub.pkttag = pkttag;
419 osh->bustype = bustype;
420 osh->magic = OS_HANDLE_MAGIC;
421 #ifdef BCM_SECURE_DMA
422
423 if ((secdma_addr != 0) && (secdma_size != 0)) {
424 printk("linux_osl.c: Buffer info passed via module params, using it.\n");
425 if (secdma_found == 0) {
426 osh->contig_base_alloc = (phys_addr_t)secdma_addr;
427 secdma_memsize = secdma_size;
428 } else if (secdma_found == 1) {
429 osh->contig_base_alloc = (phys_addr_t)secdma_addr2;
430 secdma_memsize = secdma_size2;
431 } else {
432 printk("linux_osl.c secdma: secDMA instances %d \n", secdma_found);
433 kfree(osh);
434 return NULL;
435 }
436 osh->contig_base = (phys_addr_t)osh->contig_base_alloc;
437 printf("linux_osl.c: secdma_cma_size = 0x%x\n", secdma_memsize);
438 printf("linux_osl.c: secdma_cma_addr = 0x%x \n",
439 (unsigned int)osh->contig_base_alloc);
440 osh->stb_ext_params = SECDMA_MODULE_PARAMS;
441 }
442 else if (stbpriv_init(osh) == 0) {
443 printk("linux_osl.c: stbpriv.txt found. Get buffer info.\n");
444 if (secdma_found == 0) {
445 osh->contig_base_alloc =
446 (phys_addr_t)bcm_strtoul(stbparam_get("secdma_cma_addr"), NULL, 0);
447 secdma_memsize = bcm_strtoul(stbparam_get("secdma_cma_size"), NULL, 0);
448 } else if (secdma_found == 1) {
449 osh->contig_base_alloc =
450 (phys_addr_t)bcm_strtoul(stbparam_get("secdma_cma_addr2"), NULL, 0);
451 secdma_memsize = bcm_strtoul(stbparam_get("secdma_cma_size2"), NULL, 0);
452 } else {
453 printk("linux_osl.c secdma: secDMA instances %d \n", secdma_found);
454 kfree(osh);
455 return NULL;
456 }
457 osh->contig_base = (phys_addr_t)osh->contig_base_alloc;
458 printf("linux_osl.c: secdma_cma_size = 0x%x\n", secdma_memsize);
459 printf("linux_osl.c: secdma_cma_addr = 0x%x \n",
460 (unsigned int)osh->contig_base_alloc);
461 osh->stb_ext_params = SECDMA_EXT_FILE;
462 }
463 else {
464 printk("linux_osl.c: secDMA no longer supports internal buffer allocation.\n");
465 kfree(osh);
466 return NULL;
467 }
468 secdma_found++;
469 osh->contig_base_alloc_coherent_va = osl_sec_dma_ioremap(osh,
470 phys_to_page((u32)osh->contig_base_alloc),
471 CMA_DMA_DESC_MEMBLOCK, FALSE, TRUE);
472
473 if (osh->contig_base_alloc_coherent_va == NULL) {
474 if (osh->cmn)
475 kfree(osh->cmn);
476 kfree(osh);
477 return NULL;
478 }
479 osh->contig_base_coherent_va = osh->contig_base_alloc_coherent_va;
480 osh->contig_base_alloc_coherent = osh->contig_base_alloc;
481 osl_sec_dma_init_consistent(osh);
482
483 osh->contig_base_alloc += CMA_DMA_DESC_MEMBLOCK;
484
485 osh->contig_base_alloc_va = osl_sec_dma_ioremap(osh,
486 phys_to_page((u32)osh->contig_base_alloc), CMA_DMA_DATA_MEMBLOCK, TRUE, FALSE);
487 if (osh->contig_base_alloc_va == NULL) {
488 osl_sec_dma_iounmap(osh, osh->contig_base_coherent_va, CMA_DMA_DESC_MEMBLOCK);
489 if (osh->cmn)
490 kfree(osh->cmn);
491 kfree(osh);
492 return NULL;
493 }
494 osh->contig_base_va = osh->contig_base_alloc_va;
495
496 if (BCME_OK != osl_sec_dma_init_elem_mem_block(osh,
497 CMA_BUFSIZE_4K, CMA_BUFNUM, &osh->sec_list_4096)) {
498 osl_sec_dma_iounmap(osh, osh->contig_base_coherent_va, CMA_DMA_DESC_MEMBLOCK);
499 osl_sec_dma_iounmap(osh, osh->contig_base_va, CMA_DMA_DATA_MEMBLOCK);
500 if (osh->cmn)
501 kfree(osh->cmn);
502 kfree(osh);
503 return NULL;
504 }
505 osh->sec_list_base_4096 = osh->sec_list_4096;
506
507 #endif /* BCM_SECURE_DMA */
508
509 switch (bustype) {
510 case PCI_BUS:
511 case SI_BUS:
512 case PCMCIA_BUS:
513 osh->pub.mmbus = TRUE;
514 break;
515 case JTAG_BUS:
516 case SDIO_BUS:
517 case USB_BUS:
518 case SPI_BUS:
519 case RPC_BUS:
520 osh->pub.mmbus = FALSE;
521 break;
522 default:
523 ASSERT(FALSE);
524 break;
525 }
526
527 #ifdef BCMDBG_CTRACE
528 spin_lock_init(&osh->ctrace_lock);
529 INIT_LIST_HEAD(&osh->ctrace_list);
530 osh->ctrace_num = 0;
531 #endif /* BCMDBG_CTRACE */
532
533
534 return osh;
535 }
536
osl_static_mem_init(osl_t * osh,void * adapter)537 int osl_static_mem_init(osl_t *osh, void *adapter)
538 {
539 #ifdef CONFIG_DHD_USE_STATIC_BUF
540 if (!bcm_static_buf && adapter) {
541 if (!(bcm_static_buf = (bcm_static_buf_t *)wifi_platform_prealloc(adapter,
542 3, STATIC_BUF_SIZE + STATIC_BUF_TOTAL_LEN))) {
543 printk("can not alloc static buf!\n");
544 bcm_static_skb = NULL;
545 ASSERT(osh->magic == OS_HANDLE_MAGIC);
546 return -ENOMEM;
547 } else {
548 printk("alloc static buf at %p!\n", bcm_static_buf);
549 }
550
551 spin_lock_init(&bcm_static_buf->static_lock);
552
553 bcm_static_buf->buf_ptr = (unsigned char *)bcm_static_buf + STATIC_BUF_SIZE;
554 }
555
556 #if defined(BCMSDIO) || defined(DHD_USE_STATIC_CTRLBUF)
557 if (!bcm_static_skb && adapter) {
558 int i;
559 void *skb_buff_ptr = 0;
560 bcm_static_skb = (bcm_static_pkt_t *)((char *)bcm_static_buf + 2048);
561 skb_buff_ptr = wifi_platform_prealloc(adapter, 4, 0);
562 if (!skb_buff_ptr) {
563 printk("cannot alloc static buf!\n");
564 bcm_static_buf = NULL;
565 bcm_static_skb = NULL;
566 ASSERT(osh->magic == OS_HANDLE_MAGIC);
567 return -ENOMEM;
568 }
569
570 bcopy(skb_buff_ptr, bcm_static_skb, sizeof(struct sk_buff *) *
571 (STATIC_PKT_MAX_NUM));
572 for (i = 0; i < STATIC_PKT_MAX_NUM; i++) {
573 bcm_static_skb->pkt_use[i] = 0;
574 }
575
576 #ifdef DHD_USE_STATIC_CTRLBUF
577 spin_lock_init(&bcm_static_skb->osl_pkt_lock);
578 bcm_static_skb->last_allocated_index = 0;
579 #else
580 sema_init(&bcm_static_skb->osl_pkt_sem, 1);
581 #endif /* DHD_USE_STATIC_CTRLBUF */
582 }
583 #endif /* BCMSDIO || DHD_USE_STATIC_CTRLBUF */
584 #endif /* CONFIG_DHD_USE_STATIC_BUF */
585
586 return 0;
587 }
588
osl_set_bus_handle(osl_t * osh,void * bus_handle)589 void osl_set_bus_handle(osl_t *osh, void *bus_handle)
590 {
591 osh->bus_handle = bus_handle;
592 }
593
osl_get_bus_handle(osl_t * osh)594 void* osl_get_bus_handle(osl_t *osh)
595 {
596 return osh->bus_handle;
597 }
598
599 void
osl_detach(osl_t * osh)600 osl_detach(osl_t *osh)
601 {
602 if (osh == NULL)
603 return;
604
605 #ifdef BCM_SECURE_DMA
606 if (osh->stb_ext_params == SECDMA_EXT_FILE)
607 stbpriv_exit(osh);
608 osl_sec_dma_deinit_elem_mem_block(osh, CMA_BUFSIZE_4K, CMA_BUFNUM, osh->sec_list_base_4096);
609 osl_sec_dma_iounmap(osh, osh->contig_base_coherent_va, CMA_DMA_DESC_MEMBLOCK);
610 osl_sec_dma_iounmap(osh, osh->contig_base_va, CMA_DMA_DATA_MEMBLOCK);
611 secdma_found--;
612 #endif /* BCM_SECURE_DMA */
613
614
615 bcm_object_trace_deinit();
616
617 ASSERT(osh->magic == OS_HANDLE_MAGIC);
618 atomic_sub(1, &osh->cmn->refcount);
619 if (atomic_read(&osh->cmn->refcount) == 0) {
620 kfree(osh->cmn);
621 }
622 kfree(osh);
623 }
624
osl_static_mem_deinit(osl_t * osh,void * adapter)625 int osl_static_mem_deinit(osl_t *osh, void *adapter)
626 {
627 #ifdef CONFIG_DHD_USE_STATIC_BUF
628 if (bcm_static_buf) {
629 bcm_static_buf = 0;
630 }
631 #ifdef BCMSDIO
632 if (bcm_static_skb) {
633 bcm_static_skb = 0;
634 }
635 #endif /* BCMSDIO */
636 #endif /* CONFIG_DHD_USE_STATIC_BUF */
637 return 0;
638 }
639
640 /* APIs to set/get specific quirks in OSL layer */
641 void BCMFASTPATH
osl_flag_set(osl_t * osh,uint32 mask)642 osl_flag_set(osl_t *osh, uint32 mask)
643 {
644 osh->flags |= mask;
645 }
646
647 void
osl_flag_clr(osl_t * osh,uint32 mask)648 osl_flag_clr(osl_t *osh, uint32 mask)
649 {
650 osh->flags &= ~mask;
651 }
652
653 #if defined(STB)
654 inline bool BCMFASTPATH
655 #else
656 bool
657 #endif
osl_is_flag_set(osl_t * osh,uint32 mask)658 osl_is_flag_set(osl_t *osh, uint32 mask)
659 {
660 return (osh->flags & mask);
661 }
662
663
664 #if (defined(__ARM_ARCH_7A__) && !defined(DHD_USE_COHERENT_MEM_FOR_RING))
665
666 inline int BCMFASTPATH
osl_arch_is_coherent(void)667 osl_arch_is_coherent(void)
668 {
669 return 0;
670 }
671
672 inline int BCMFASTPATH
osl_acp_war_enab(void)673 osl_acp_war_enab(void)
674 {
675 return 0;
676 }
677
678 inline void BCMFASTPATH
osl_cache_flush(void * va,uint size)679 osl_cache_flush(void *va, uint size)
680 {
681 if (size > 0)
682 dma_sync_single_for_device(OSH_NULL, virt_to_dma(OSH_NULL, va), size, DMA_TO_DEVICE);
683 }
684
685 inline void BCMFASTPATH
osl_cache_inv(void * va,uint size)686 osl_cache_inv(void *va, uint size)
687 {
688 dma_sync_single_for_cpu(OSH_NULL, virt_to_dma(OSH_NULL, va), size, DMA_FROM_DEVICE);
689 }
690
691 inline void BCMFASTPATH
osl_prefetch(const void * ptr)692 osl_prefetch(const void *ptr)
693 {
694 __asm__ __volatile__("pld\t%0" :: "o"(*(char *)ptr) : "cc");
695 }
696
697 #endif
698
699 /*
700 * To avoid ACP latency, a fwder buf will be sent directly to DDR using
701 * DDR aliasing into non-ACP address space. Such Fwder buffers must be
702 * explicitly managed from a coherency perspective.
703 */
704 static inline void BCMFASTPATH
osl_fwderbuf_reset(osl_t * osh,struct sk_buff * skb)705 osl_fwderbuf_reset(osl_t *osh, struct sk_buff *skb)
706 {
707 }
708
osl_alloc_skb(osl_t * osh,unsigned int len)709 static struct sk_buff *osl_alloc_skb(osl_t *osh, unsigned int len)
710 {
711 struct sk_buff *skb;
712 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
713 gfp_t flags = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
714 #ifdef DHD_USE_ATOMIC_PKTGET
715 flags = GFP_ATOMIC;
716 #endif /* DHD_USE_ATOMIC_PKTGET */
717 skb = __dev_alloc_skb(len, flags);
718 #else
719 skb = dev_alloc_skb(len);
720 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25) */
721 return skb;
722 }
723
724 #ifdef CTFPOOL
725
726 #ifdef CTFPOOL_SPINLOCK
727 #define CTFPOOL_LOCK(ctfpool, flags) spin_lock_irqsave(&(ctfpool)->lock, flags)
728 #define CTFPOOL_UNLOCK(ctfpool, flags) spin_unlock_irqrestore(&(ctfpool)->lock, flags)
729 #else
730 #define CTFPOOL_LOCK(ctfpool, flags) spin_lock_bh(&(ctfpool)->lock)
731 #define CTFPOOL_UNLOCK(ctfpool, flags) spin_unlock_bh(&(ctfpool)->lock)
732 #endif /* CTFPOOL_SPINLOCK */
733 /*
734 * Allocate and add an object to packet pool.
735 */
736 void *
osl_ctfpool_add(osl_t * osh)737 osl_ctfpool_add(osl_t *osh)
738 {
739 struct sk_buff *skb;
740 #ifdef CTFPOOL_SPINLOCK
741 unsigned long flags;
742 #endif /* CTFPOOL_SPINLOCK */
743
744 if ((osh == NULL) || (osh->ctfpool == NULL))
745 return NULL;
746
747 CTFPOOL_LOCK(osh->ctfpool, flags);
748 ASSERT(osh->ctfpool->curr_obj <= osh->ctfpool->max_obj);
749
750 /* No need to allocate more objects */
751 if (osh->ctfpool->curr_obj == osh->ctfpool->max_obj) {
752 CTFPOOL_UNLOCK(osh->ctfpool, flags);
753 return NULL;
754 }
755
756 /* Allocate a new skb and add it to the ctfpool */
757 skb = osl_alloc_skb(osh, osh->ctfpool->obj_size);
758 if (skb == NULL) {
759 printf("%s: skb alloc of len %d failed\n", __FUNCTION__,
760 osh->ctfpool->obj_size);
761 CTFPOOL_UNLOCK(osh->ctfpool, flags);
762 return NULL;
763 }
764
765 /* Add to ctfpool */
766 skb->next = (struct sk_buff *)osh->ctfpool->head;
767 osh->ctfpool->head = skb;
768 osh->ctfpool->fast_frees++;
769 osh->ctfpool->curr_obj++;
770
771 /* Hijack a skb member to store ptr to ctfpool */
772 CTFPOOLPTR(osh, skb) = (void *)osh->ctfpool;
773
774 /* Use bit flag to indicate skb from fast ctfpool */
775 PKTFAST(osh, skb) = FASTBUF;
776
777 /* If ctfpool's osh is a fwder osh, reset the fwder buf */
778 osl_fwderbuf_reset(osh->ctfpool->osh, skb);
779
780 CTFPOOL_UNLOCK(osh->ctfpool, flags);
781
782 return skb;
783 }
784
785 /*
786 * Add new objects to the pool.
787 */
788 void
osl_ctfpool_replenish(osl_t * osh,uint thresh)789 osl_ctfpool_replenish(osl_t *osh, uint thresh)
790 {
791 if ((osh == NULL) || (osh->ctfpool == NULL))
792 return;
793
794 /* Do nothing if no refills are required */
795 while ((osh->ctfpool->refills > 0) && (thresh--)) {
796 osl_ctfpool_add(osh);
797 osh->ctfpool->refills--;
798 }
799 }
800
801 /*
802 * Initialize the packet pool with specified number of objects.
803 */
804 int32
osl_ctfpool_init(osl_t * osh,uint numobj,uint size)805 osl_ctfpool_init(osl_t *osh, uint numobj, uint size)
806 {
807 gfp_t flags;
808
809 flags = CAN_SLEEP() ? GFP_KERNEL: GFP_ATOMIC;
810 osh->ctfpool = kzalloc(sizeof(ctfpool_t), flags);
811 ASSERT(osh->ctfpool);
812
813 osh->ctfpool->osh = osh;
814
815 osh->ctfpool->max_obj = numobj;
816 osh->ctfpool->obj_size = size;
817
818 spin_lock_init(&osh->ctfpool->lock);
819
820 while (numobj--) {
821 if (!osl_ctfpool_add(osh))
822 return -1;
823 osh->ctfpool->fast_frees--;
824 }
825
826 return 0;
827 }
828
829 /*
830 * Cleanup the packet pool objects.
831 */
832 void
osl_ctfpool_cleanup(osl_t * osh)833 osl_ctfpool_cleanup(osl_t *osh)
834 {
835 struct sk_buff *skb, *nskb;
836 #ifdef CTFPOOL_SPINLOCK
837 unsigned long flags;
838 #endif /* CTFPOOL_SPINLOCK */
839
840 if ((osh == NULL) || (osh->ctfpool == NULL))
841 return;
842
843 CTFPOOL_LOCK(osh->ctfpool, flags);
844
845 skb = osh->ctfpool->head;
846
847 while (skb != NULL) {
848 nskb = skb->next;
849 dev_kfree_skb(skb);
850 skb = nskb;
851 osh->ctfpool->curr_obj--;
852 }
853
854 ASSERT(osh->ctfpool->curr_obj == 0);
855 osh->ctfpool->head = NULL;
856 CTFPOOL_UNLOCK(osh->ctfpool, flags);
857
858 kfree(osh->ctfpool);
859 osh->ctfpool = NULL;
860 }
861
862 void
osl_ctfpool_stats(osl_t * osh,void * b)863 osl_ctfpool_stats(osl_t *osh, void *b)
864 {
865 struct bcmstrbuf *bb;
866
867 if ((osh == NULL) || (osh->ctfpool == NULL))
868 return;
869
870 #ifdef CONFIG_DHD_USE_STATIC_BUF
871 if (bcm_static_buf) {
872 bcm_static_buf = 0;
873 }
874 #ifdef BCMSDIO
875 if (bcm_static_skb) {
876 bcm_static_skb = 0;
877 }
878 #endif /* BCMSDIO */
879 #endif /* CONFIG_DHD_USE_STATIC_BUF */
880
881 bb = b;
882
883 ASSERT((osh != NULL) && (bb != NULL));
884
885 bcm_bprintf(bb, "max_obj %d obj_size %d curr_obj %d refills %d\n",
886 osh->ctfpool->max_obj, osh->ctfpool->obj_size,
887 osh->ctfpool->curr_obj, osh->ctfpool->refills);
888 bcm_bprintf(bb, "fast_allocs %d fast_frees %d slow_allocs %d\n",
889 osh->ctfpool->fast_allocs, osh->ctfpool->fast_frees,
890 osh->ctfpool->slow_allocs);
891 }
892
893 static inline struct sk_buff *
osl_pktfastget(osl_t * osh,uint len)894 osl_pktfastget(osl_t *osh, uint len)
895 {
896 struct sk_buff *skb;
897 #ifdef CTFPOOL_SPINLOCK
898 unsigned long flags;
899 #endif /* CTFPOOL_SPINLOCK */
900
901 /* Try to do fast allocate. Return null if ctfpool is not in use
902 * or if there are no items in the ctfpool.
903 */
904 if (osh->ctfpool == NULL)
905 return NULL;
906
907 CTFPOOL_LOCK(osh->ctfpool, flags);
908 if (osh->ctfpool->head == NULL) {
909 ASSERT(osh->ctfpool->curr_obj == 0);
910 osh->ctfpool->slow_allocs++;
911 CTFPOOL_UNLOCK(osh->ctfpool, flags);
912 return NULL;
913 }
914
915 if (len > osh->ctfpool->obj_size) {
916 CTFPOOL_UNLOCK(osh->ctfpool, flags);
917 return NULL;
918 }
919
920 ASSERT(len <= osh->ctfpool->obj_size);
921
922 /* Get an object from ctfpool */
923 skb = (struct sk_buff *)osh->ctfpool->head;
924 osh->ctfpool->head = (void *)skb->next;
925
926 osh->ctfpool->fast_allocs++;
927 osh->ctfpool->curr_obj--;
928 ASSERT(CTFPOOLHEAD(osh, skb) == (struct sock *)osh->ctfpool->head);
929 CTFPOOL_UNLOCK(osh->ctfpool, flags);
930
931 /* Init skb struct */
932 skb->next = skb->prev = NULL;
933 #if defined(__ARM_ARCH_7A__)
934 skb->data = skb->head + NET_SKB_PAD;
935 skb->tail = skb->head + NET_SKB_PAD;
936 #else
937 skb->data = skb->head + 16;
938 skb->tail = skb->head + 16;
939 #endif /* __ARM_ARCH_7A__ */
940 skb->len = 0;
941 skb->cloned = 0;
942 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
943 skb->list = NULL;
944 #endif
945 atomic_set(&skb->users, 1);
946
947 PKTSETCLINK(skb, NULL);
948 PKTCCLRATTR(skb);
949 PKTFAST(osh, skb) &= ~(CTFBUF | SKIPCT | CHAINED);
950
951 return skb;
952 }
953 #endif /* CTFPOOL */
954
955 #if defined(BCM_GMAC3)
956 /* Account for a packet delivered to downstream forwarder.
957 * Decrement a GMAC forwarder interface's pktalloced count.
958 */
959 void BCMFASTPATH
osl_pkt_tofwder(osl_t * osh,void * skbs,int skb_cnt)960 osl_pkt_tofwder(osl_t *osh, void *skbs, int skb_cnt)
961 {
962 atomic_sub(skb_cnt, &osh->cmn->pktalloced);
963 }
964
965 /* Account for a downstream forwarder delivered packet to a WL/DHD driver.
966 * Increment a GMAC forwarder interface's pktalloced count.
967 */
968 void BCMFASTPATH
969 #ifdef BCMDBG_CTRACE
osl_pkt_frmfwder(osl_t * osh,void * skbs,int skb_cnt,int line,char * file)970 osl_pkt_frmfwder(osl_t *osh, void *skbs, int skb_cnt, int line, char *file)
971 #else
972 osl_pkt_frmfwder(osl_t *osh, void *skbs, int skb_cnt)
973 #endif /* BCMDBG_CTRACE */
974 {
975 #if defined(BCMDBG_CTRACE)
976 int i;
977 struct sk_buff *skb;
978 #endif
979
980 #if defined(BCMDBG_CTRACE)
981 if (skb_cnt > 1) {
982 struct sk_buff **skb_array = (struct sk_buff **)skbs;
983 for (i = 0; i < skb_cnt; i++) {
984 skb = skb_array[i];
985 #if defined(BCMDBG_CTRACE)
986 ASSERT(!PKTISCHAINED(skb));
987 ADD_CTRACE(osh, skb, file, line);
988 #endif /* BCMDBG_CTRACE */
989 }
990 } else {
991 skb = (struct sk_buff *)skbs;
992 #if defined(BCMDBG_CTRACE)
993 ASSERT(!PKTISCHAINED(skb));
994 ADD_CTRACE(osh, skb, file, line);
995 #endif /* BCMDBG_CTRACE */
996 }
997 #endif
998
999 atomic_add(skb_cnt, &osh->cmn->pktalloced);
1000 }
1001
1002 #endif /* BCM_GMAC3 */
1003
1004 /* Convert a driver packet to native(OS) packet
1005 * In the process, packettag is zeroed out before sending up
1006 * IP code depends on skb->cb to be setup correctly with various options
1007 * In our case, that means it should be 0
1008 */
1009 struct sk_buff * BCMFASTPATH
osl_pkt_tonative(osl_t * osh,void * pkt)1010 osl_pkt_tonative(osl_t *osh, void *pkt)
1011 {
1012 struct sk_buff *nskb;
1013 #ifdef BCMDBG_CTRACE
1014 struct sk_buff *nskb1, *nskb2;
1015 #endif
1016
1017 if (osh->pub.pkttag)
1018 OSL_PKTTAG_CLEAR(pkt);
1019
1020 /* Decrement the packet counter */
1021 for (nskb = (struct sk_buff *)pkt; nskb; nskb = nskb->next) {
1022 atomic_sub(PKTISCHAINED(nskb) ? PKTCCNT(nskb) : 1, &osh->cmn->pktalloced);
1023
1024 #ifdef BCMDBG_CTRACE
1025 for (nskb1 = nskb; nskb1 != NULL; nskb1 = nskb2) {
1026 if (PKTISCHAINED(nskb1)) {
1027 nskb2 = PKTCLINK(nskb1);
1028 } else {
1029 nskb2 = NULL;
1030 }
1031
1032 DEL_CTRACE(osh, nskb1);
1033 }
1034 #endif /* BCMDBG_CTRACE */
1035 }
1036 return (struct sk_buff *)pkt;
1037 }
1038
1039 /* Convert a native(OS) packet to driver packet.
1040 * In the process, native packet is destroyed, there is no copying
1041 * Also, a packettag is zeroed out
1042 */
1043 void * BCMFASTPATH
1044 #ifdef BCMDBG_CTRACE
osl_pkt_frmnative(osl_t * osh,void * pkt,int line,char * file)1045 osl_pkt_frmnative(osl_t *osh, void *pkt, int line, char *file)
1046 #else
1047 osl_pkt_frmnative(osl_t *osh, void *pkt)
1048 #endif /* BCMDBG_CTRACE */
1049 {
1050 struct sk_buff *cskb;
1051 struct sk_buff *nskb;
1052 unsigned long pktalloced = 0;
1053
1054 if (osh->pub.pkttag)
1055 OSL_PKTTAG_CLEAR(pkt);
1056
1057 /* walk the PKTCLINK() list */
1058 for (cskb = (struct sk_buff *)pkt;
1059 cskb != NULL;
1060 cskb = PKTISCHAINED(cskb) ? PKTCLINK(cskb) : NULL) {
1061 /* walk the pkt buffer list */
1062 for (nskb = cskb; nskb; nskb = nskb->next) {
1063 /* Increment the packet counter */
1064 pktalloced++;
1065
1066 /* clean the 'prev' pointer
1067 * Kernel 3.18 is leaving skb->prev pointer set to skb
1068 * to indicate a non-fragmented skb
1069 */
1070 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 18, 0))
1071 nskb->prev = NULL;
1072 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3, 18, 0) */
1073
1074
1075 #ifdef BCMDBG_CTRACE
1076 ADD_CTRACE(osh, nskb, file, line);
1077 #endif /* BCMDBG_CTRACE */
1078 }
1079 }
1080
1081 /* Increment the packet counter */
1082 atomic_add(pktalloced, &osh->cmn->pktalloced);
1083
1084 return (void *)pkt;
1085 }
1086
1087 /* Return a new packet. zero out pkttag */
1088 void * BCMFASTPATH
1089 #ifdef BCMDBG_CTRACE
osl_pktget(osl_t * osh,uint len,int line,char * file)1090 osl_pktget(osl_t *osh, uint len, int line, char *file)
1091 #else
1092 #ifdef BCM_OBJECT_TRACE
1093 osl_pktget(osl_t *osh, uint len, int line, const char *caller)
1094 #else
1095 osl_pktget(osl_t *osh, uint len)
1096 #endif /* BCM_OBJECT_TRACE */
1097 #endif /* BCMDBG_CTRACE */
1098 {
1099 struct sk_buff *skb;
1100 uchar num = 0;
1101 if (lmtest != FALSE) {
1102 get_random_bytes(&num, sizeof(uchar));
1103 if ((num + 1) <= (256 * lmtest / 100))
1104 return NULL;
1105 }
1106
1107 #ifdef CTFPOOL
1108 /* Allocate from local pool */
1109 skb = osl_pktfastget(osh, len);
1110 if ((skb != NULL) || ((skb = osl_alloc_skb(osh, len)) != NULL))
1111 #else /* CTFPOOL */
1112 if ((skb = osl_alloc_skb(osh, len)))
1113 #endif /* CTFPOOL */
1114 {
1115 skb->tail += len;
1116 skb->len += len;
1117 skb->priority = 0;
1118
1119 #ifdef BCMDBG_CTRACE
1120 ADD_CTRACE(osh, skb, file, line);
1121 #endif
1122 atomic_inc(&osh->cmn->pktalloced);
1123 #ifdef BCM_OBJECT_TRACE
1124 bcm_object_trace_opr(skb, BCM_OBJDBG_ADD_PKT, caller, line);
1125 #endif /* BCM_OBJECT_TRACE */
1126 }
1127
1128 return ((void*) skb);
1129 }
1130
1131 #ifdef CTFPOOL
1132 static inline void
osl_pktfastfree(osl_t * osh,struct sk_buff * skb)1133 osl_pktfastfree(osl_t *osh, struct sk_buff *skb)
1134 {
1135 ctfpool_t *ctfpool;
1136 #ifdef CTFPOOL_SPINLOCK
1137 unsigned long flags;
1138 #endif /* CTFPOOL_SPINLOCK */
1139
1140 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
1141 skb->tstamp.tv.sec = 0;
1142 #else
1143 skb->stamp.tv_sec = 0;
1144 #endif
1145
1146 /* We only need to init the fields that we change */
1147 skb->dev = NULL;
1148 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
1149 skb->dst = NULL;
1150 #endif
1151 OSL_PKTTAG_CLEAR(skb);
1152 skb->ip_summed = 0;
1153
1154 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
1155 skb_orphan(skb);
1156 #else
1157 skb->destructor = NULL;
1158 #endif
1159
1160 ctfpool = (ctfpool_t *)CTFPOOLPTR(osh, skb);
1161 ASSERT(ctfpool != NULL);
1162
1163 /* if osh is a fwder osh, reset the fwder buf */
1164 osl_fwderbuf_reset(ctfpool->osh, skb);
1165
1166 /* Add object to the ctfpool */
1167 CTFPOOL_LOCK(ctfpool, flags);
1168 skb->next = (struct sk_buff *)ctfpool->head;
1169 ctfpool->head = (void *)skb;
1170
1171 ctfpool->fast_frees++;
1172 ctfpool->curr_obj++;
1173
1174 ASSERT(ctfpool->curr_obj <= ctfpool->max_obj);
1175 CTFPOOL_UNLOCK(ctfpool, flags);
1176 }
1177 #endif /* CTFPOOL */
1178
1179 /* Free the driver packet. Free the tag if present */
1180 void BCMFASTPATH
1181 #ifdef BCM_OBJECT_TRACE
osl_pktfree(osl_t * osh,void * p,bool send,int line,const char * caller)1182 osl_pktfree(osl_t *osh, void *p, bool send, int line, const char *caller)
1183 #else
1184 osl_pktfree(osl_t *osh, void *p, bool send)
1185 #endif /* BCM_OBJECT_TRACE */
1186 {
1187 struct sk_buff *skb, *nskb;
1188 if (osh == NULL)
1189 return;
1190
1191 skb = (struct sk_buff*) p;
1192
1193 if (send && osh->pub.tx_fn)
1194 osh->pub.tx_fn(osh->pub.tx_ctx, p, 0);
1195
1196 PKTDBG_TRACE(osh, (void *) skb, PKTLIST_PKTFREE);
1197
1198 #if defined(CONFIG_DHD_USE_STATIC_BUF) && defined(DHD_USE_STATIC_CTRLBUF)
1199 if (skb && (skb->mac_len == PREALLOC_USED_MAGIC)) {
1200 printk("%s: pkt %p is from static pool\n",
1201 __FUNCTION__, p);
1202 dump_stack();
1203 return;
1204 }
1205
1206 if (skb && (skb->mac_len == PREALLOC_FREE_MAGIC)) {
1207 printk("%s: pkt %p is from static pool and not in used\n",
1208 __FUNCTION__, p);
1209 dump_stack();
1210 return;
1211 }
1212 #endif /* CONFIG_DHD_USE_STATIC_BUF && DHD_USE_STATIC_CTRLBUF */
1213
1214 /* perversion: we use skb->next to chain multi-skb packets */
1215 while (skb) {
1216 nskb = skb->next;
1217 skb->next = NULL;
1218
1219 #ifdef BCMDBG_CTRACE
1220 DEL_CTRACE(osh, skb);
1221 #endif
1222
1223
1224 #ifdef BCM_OBJECT_TRACE
1225 bcm_object_trace_opr(skb, BCM_OBJDBG_REMOVE, caller, line);
1226 #endif /* BCM_OBJECT_TRACE */
1227
1228 #ifdef CTFPOOL
1229 if (PKTISFAST(osh, skb)) {
1230 if (atomic_read(&skb->users) == 1)
1231 smp_rmb();
1232 else if (!atomic_dec_and_test(&skb->users))
1233 goto next_skb;
1234 osl_pktfastfree(osh, skb);
1235 } else
1236 #endif
1237 {
1238 dev_kfree_skb_any(skb);
1239 }
1240 #ifdef CTFPOOL
1241 next_skb:
1242 #endif
1243 atomic_dec(&osh->cmn->pktalloced);
1244 skb = nskb;
1245 }
1246 }
1247
1248 #ifdef CONFIG_DHD_USE_STATIC_BUF
1249 void*
osl_pktget_static(osl_t * osh,uint len)1250 osl_pktget_static(osl_t *osh, uint len)
1251 {
1252 int i = 0;
1253 struct sk_buff *skb;
1254 #ifdef DHD_USE_STATIC_CTRLBUF
1255 unsigned long flags;
1256 #endif /* DHD_USE_STATIC_CTRLBUF */
1257
1258 if (!bcm_static_skb)
1259 return osl_pktget(osh, len);
1260
1261 if (len > DHD_SKB_MAX_BUFSIZE) {
1262 printk("%s: attempt to allocate huge packet (0x%x)\n", __FUNCTION__, len);
1263 return osl_pktget(osh, len);
1264 }
1265
1266 #ifdef DHD_USE_STATIC_CTRLBUF
1267 spin_lock_irqsave(&bcm_static_skb->osl_pkt_lock, flags);
1268
1269 if (len <= DHD_SKB_2PAGE_BUFSIZE) {
1270 uint32 index;
1271 for (i = 0; i < STATIC_PKT_2PAGE_NUM; i++) {
1272 index = bcm_static_skb->last_allocated_index % STATIC_PKT_2PAGE_NUM;
1273 bcm_static_skb->last_allocated_index++;
1274 if (bcm_static_skb->skb_8k[index] &&
1275 bcm_static_skb->pkt_use[index] == 0) {
1276 break;
1277 }
1278 }
1279
1280 if ((i != STATIC_PKT_2PAGE_NUM) &&
1281 (index >= 0) && (index < STATIC_PKT_2PAGE_NUM)) {
1282 bcm_static_skb->pkt_use[index] = 1;
1283 skb = bcm_static_skb->skb_8k[index];
1284 skb->data = skb->head;
1285 #ifdef NET_SKBUFF_DATA_USES_OFFSET
1286 skb_set_tail_pointer(skb, NET_SKB_PAD);
1287 #else
1288 skb->tail = skb->data + NET_SKB_PAD;
1289 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
1290 skb->data += NET_SKB_PAD;
1291 skb->cloned = 0;
1292 skb->priority = 0;
1293 #ifdef NET_SKBUFF_DATA_USES_OFFSET
1294 skb_set_tail_pointer(skb, len);
1295 #else
1296 skb->tail = skb->data + len;
1297 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
1298 skb->len = len;
1299 skb->mac_len = PREALLOC_USED_MAGIC;
1300 spin_unlock_irqrestore(&bcm_static_skb->osl_pkt_lock, flags);
1301 return skb;
1302 }
1303 }
1304
1305 spin_unlock_irqrestore(&bcm_static_skb->osl_pkt_lock, flags);
1306 printk("%s: all static pkt in use!\n", __FUNCTION__);
1307 return NULL;
1308 #else
1309 down(&bcm_static_skb->osl_pkt_sem);
1310
1311 if (len <= DHD_SKB_1PAGE_BUFSIZE) {
1312 for (i = 0; i < STATIC_PKT_1PAGE_NUM; i++) {
1313 if (bcm_static_skb->skb_4k[i] &&
1314 bcm_static_skb->pkt_use[i] == 0) {
1315 break;
1316 }
1317 }
1318
1319 if (i != STATIC_PKT_1PAGE_NUM) {
1320 bcm_static_skb->pkt_use[i] = 1;
1321
1322 skb = bcm_static_skb->skb_4k[i];
1323 #ifdef NET_SKBUFF_DATA_USES_OFFSET
1324 skb_set_tail_pointer(skb, len);
1325 #else
1326 skb->tail = skb->data + len;
1327 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
1328 skb->len = len;
1329
1330 up(&bcm_static_skb->osl_pkt_sem);
1331 return skb;
1332 }
1333 }
1334
1335 if (len <= DHD_SKB_2PAGE_BUFSIZE) {
1336 for (i = STATIC_PKT_1PAGE_NUM; i < STATIC_PKT_1_2PAGE_NUM; i++) {
1337 if (bcm_static_skb->skb_8k[i - STATIC_PKT_1PAGE_NUM] &&
1338 bcm_static_skb->pkt_use[i] == 0) {
1339 break;
1340 }
1341 }
1342
1343 if ((i >= STATIC_PKT_1PAGE_NUM) && (i < STATIC_PKT_1_2PAGE_NUM)) {
1344 bcm_static_skb->pkt_use[i] = 1;
1345 skb = bcm_static_skb->skb_8k[i - STATIC_PKT_1PAGE_NUM];
1346 #ifdef NET_SKBUFF_DATA_USES_OFFSET
1347 skb_set_tail_pointer(skb, len);
1348 #else
1349 skb->tail = skb->data + len;
1350 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
1351 skb->len = len;
1352
1353 up(&bcm_static_skb->osl_pkt_sem);
1354 return skb;
1355 }
1356 }
1357
1358 #if defined(ENHANCED_STATIC_BUF)
1359 if (bcm_static_skb->skb_16k &&
1360 bcm_static_skb->pkt_use[STATIC_PKT_MAX_NUM - 1] == 0) {
1361 bcm_static_skb->pkt_use[STATIC_PKT_MAX_NUM - 1] = 1;
1362
1363 skb = bcm_static_skb->skb_16k;
1364 #ifdef NET_SKBUFF_DATA_USES_OFFSET
1365 skb_set_tail_pointer(skb, len);
1366 #else
1367 skb->tail = skb->data + len;
1368 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
1369 skb->len = len;
1370
1371 up(&bcm_static_skb->osl_pkt_sem);
1372 return skb;
1373 }
1374 #endif /* ENHANCED_STATIC_BUF */
1375
1376 up(&bcm_static_skb->osl_pkt_sem);
1377 printk("%s: all static pkt in use!\n", __FUNCTION__);
1378 return osl_pktget(osh, len);
1379 #endif /* DHD_USE_STATIC_CTRLBUF */
1380 }
1381
1382 void
osl_pktfree_static(osl_t * osh,void * p,bool send)1383 osl_pktfree_static(osl_t *osh, void *p, bool send)
1384 {
1385 int i;
1386 #ifdef DHD_USE_STATIC_CTRLBUF
1387 struct sk_buff *skb = (struct sk_buff *)p;
1388 unsigned long flags;
1389 #endif /* DHD_USE_STATIC_CTRLBUF */
1390
1391 if (!p) {
1392 return;
1393 }
1394
1395 if (!bcm_static_skb) {
1396 osl_pktfree(osh, p, send);
1397 return;
1398 }
1399
1400 #ifdef DHD_USE_STATIC_CTRLBUF
1401 spin_lock_irqsave(&bcm_static_skb->osl_pkt_lock, flags);
1402
1403 for (i = 0; i < STATIC_PKT_2PAGE_NUM; i++) {
1404 if (p == bcm_static_skb->skb_8k[i]) {
1405 if (bcm_static_skb->pkt_use[i] == 0) {
1406 printk("%s: static pkt idx %d(%p) is double free\n",
1407 __FUNCTION__, i, p);
1408 } else {
1409 bcm_static_skb->pkt_use[i] = 0;
1410 }
1411
1412 if (skb->mac_len != PREALLOC_USED_MAGIC) {
1413 printk("%s: static pkt idx %d(%p) is not in used\n",
1414 __FUNCTION__, i, p);
1415 }
1416
1417 skb->mac_len = PREALLOC_FREE_MAGIC;
1418 spin_unlock_irqrestore(&bcm_static_skb->osl_pkt_lock, flags);
1419 return;
1420 }
1421 }
1422
1423 spin_unlock_irqrestore(&bcm_static_skb->osl_pkt_lock, flags);
1424 printk("%s: packet %p does not exist in the pool\n", __FUNCTION__, p);
1425 #else
1426 down(&bcm_static_skb->osl_pkt_sem);
1427 for (i = 0; i < STATIC_PKT_1PAGE_NUM; i++) {
1428 if (p == bcm_static_skb->skb_4k[i]) {
1429 bcm_static_skb->pkt_use[i] = 0;
1430 up(&bcm_static_skb->osl_pkt_sem);
1431 return;
1432 }
1433 }
1434
1435 for (i = STATIC_PKT_1PAGE_NUM; i < STATIC_PKT_1_2PAGE_NUM; i++) {
1436 if (p == bcm_static_skb->skb_8k[i - STATIC_PKT_1PAGE_NUM]) {
1437 bcm_static_skb->pkt_use[i] = 0;
1438 up(&bcm_static_skb->osl_pkt_sem);
1439 return;
1440 }
1441 }
1442 #ifdef ENHANCED_STATIC_BUF
1443 if (p == bcm_static_skb->skb_16k) {
1444 bcm_static_skb->pkt_use[STATIC_PKT_MAX_NUM - 1] = 0;
1445 up(&bcm_static_skb->osl_pkt_sem);
1446 return;
1447 }
1448 #endif
1449 up(&bcm_static_skb->osl_pkt_sem);
1450 #endif /* DHD_USE_STATIC_CTRLBUF */
1451 osl_pktfree(osh, p, send);
1452 }
1453 #endif /* CONFIG_DHD_USE_STATIC_BUF */
1454
1455 uint32
osl_pci_read_config(osl_t * osh,uint offset,uint size)1456 osl_pci_read_config(osl_t *osh, uint offset, uint size)
1457 {
1458 uint val = 0;
1459 uint retry = PCI_CFG_RETRY;
1460
1461 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
1462
1463 /* only 4byte access supported */
1464 ASSERT(size == 4);
1465
1466 do {
1467 pci_read_config_dword(osh->pdev, offset, &val);
1468 if (val != 0xffffffff)
1469 break;
1470 } while (retry--);
1471
1472
1473 return (val);
1474 }
1475
1476 void
osl_pci_write_config(osl_t * osh,uint offset,uint size,uint val)1477 osl_pci_write_config(osl_t *osh, uint offset, uint size, uint val)
1478 {
1479 uint retry = PCI_CFG_RETRY;
1480
1481 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
1482
1483 /* only 4byte access supported */
1484 ASSERT(size == 4);
1485
1486 do {
1487 pci_write_config_dword(osh->pdev, offset, val);
1488 if (offset != PCI_BAR0_WIN)
1489 break;
1490 if (osl_pci_read_config(osh, offset, size) == val)
1491 break;
1492 } while (retry--);
1493 }
1494
1495 /* return bus # for the pci device pointed by osh->pdev */
1496 uint
osl_pci_bus(osl_t * osh)1497 osl_pci_bus(osl_t *osh)
1498 {
1499 ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
1500
1501 #if defined(__ARM_ARCH_7A__) && LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)
1502 return pci_domain_nr(((struct pci_dev *)osh->pdev)->bus);
1503 #else
1504 return ((struct pci_dev *)osh->pdev)->bus->number;
1505 #endif
1506 }
1507
1508 /* return slot # for the pci device pointed by osh->pdev */
1509 uint
osl_pci_slot(osl_t * osh)1510 osl_pci_slot(osl_t *osh)
1511 {
1512 ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
1513
1514 #if defined(__ARM_ARCH_7A__) && LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)
1515 return PCI_SLOT(((struct pci_dev *)osh->pdev)->devfn) + 1;
1516 #else
1517 return PCI_SLOT(((struct pci_dev *)osh->pdev)->devfn);
1518 #endif
1519 }
1520
1521 /* return domain # for the pci device pointed by osh->pdev */
1522 uint
osl_pcie_domain(osl_t * osh)1523 osl_pcie_domain(osl_t *osh)
1524 {
1525 ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
1526
1527 return pci_domain_nr(((struct pci_dev *)osh->pdev)->bus);
1528 }
1529
1530 /* return bus # for the pci device pointed by osh->pdev */
1531 uint
osl_pcie_bus(osl_t * osh)1532 osl_pcie_bus(osl_t *osh)
1533 {
1534 ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
1535
1536 return ((struct pci_dev *)osh->pdev)->bus->number;
1537 }
1538
1539 /* return the pci device pointed by osh->pdev */
1540 struct pci_dev *
osl_pci_device(osl_t * osh)1541 osl_pci_device(osl_t *osh)
1542 {
1543 ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
1544
1545 return osh->pdev;
1546 }
1547
1548 static void
osl_pcmcia_attr(osl_t * osh,uint offset,char * buf,int size,bool write)1549 osl_pcmcia_attr(osl_t *osh, uint offset, char *buf, int size, bool write)
1550 {
1551 }
1552
1553 void
osl_pcmcia_read_attr(osl_t * osh,uint offset,void * buf,int size)1554 osl_pcmcia_read_attr(osl_t *osh, uint offset, void *buf, int size)
1555 {
1556 osl_pcmcia_attr(osh, offset, (char *) buf, size, FALSE);
1557 }
1558
1559 void
osl_pcmcia_write_attr(osl_t * osh,uint offset,void * buf,int size)1560 osl_pcmcia_write_attr(osl_t *osh, uint offset, void *buf, int size)
1561 {
1562 osl_pcmcia_attr(osh, offset, (char *) buf, size, TRUE);
1563 }
1564
1565 void *
osl_malloc(osl_t * osh,uint size)1566 osl_malloc(osl_t *osh, uint size)
1567 {
1568 void *addr;
1569 gfp_t flags;
1570
1571 /* only ASSERT if osh is defined */
1572 if (osh)
1573 ASSERT(osh->magic == OS_HANDLE_MAGIC);
1574 #ifdef CONFIG_DHD_USE_STATIC_BUF
1575 if (bcm_static_buf)
1576 {
1577 unsigned long irq_flags;
1578 int i = 0;
1579 if ((size >= PAGE_SIZE)&&(size <= STATIC_BUF_SIZE))
1580 {
1581 spin_lock_irqsave(&bcm_static_buf->static_lock, irq_flags);
1582
1583 for (i = 0; i < STATIC_BUF_MAX_NUM; i++)
1584 {
1585 if (bcm_static_buf->buf_use[i] == 0)
1586 break;
1587 }
1588
1589 if (i == STATIC_BUF_MAX_NUM)
1590 {
1591 spin_unlock_irqrestore(&bcm_static_buf->static_lock, irq_flags);
1592 printk("all static buff in use!\n");
1593 goto original;
1594 }
1595
1596 bcm_static_buf->buf_use[i] = 1;
1597 spin_unlock_irqrestore(&bcm_static_buf->static_lock, irq_flags);
1598
1599 bzero(bcm_static_buf->buf_ptr+STATIC_BUF_SIZE*i, size);
1600 if (osh)
1601 atomic_add(size, &osh->cmn->malloced);
1602
1603 return ((void *)(bcm_static_buf->buf_ptr+STATIC_BUF_SIZE*i));
1604 }
1605 }
1606 original:
1607 #endif /* CONFIG_DHD_USE_STATIC_BUF */
1608
1609 flags = CAN_SLEEP() ? GFP_KERNEL: GFP_ATOMIC;
1610 if ((addr = kmalloc(size, flags)) == NULL) {
1611 if (osh)
1612 osh->failed++;
1613 return (NULL);
1614 }
1615 if (osh && osh->cmn)
1616 atomic_add(size, &osh->cmn->malloced);
1617
1618 return (addr);
1619 }
1620
1621 void *
osl_mallocz(osl_t * osh,uint size)1622 osl_mallocz(osl_t *osh, uint size)
1623 {
1624 void *ptr;
1625
1626 ptr = osl_malloc(osh, size);
1627
1628 if (ptr != NULL) {
1629 bzero(ptr, size);
1630 }
1631
1632 return ptr;
1633 }
1634
1635 void
osl_mfree(osl_t * osh,void * addr,uint size)1636 osl_mfree(osl_t *osh, void *addr, uint size)
1637 {
1638 #ifdef CONFIG_DHD_USE_STATIC_BUF
1639 unsigned long flags;
1640
1641 if (bcm_static_buf)
1642 {
1643 if ((addr > (void *)bcm_static_buf) && ((unsigned char *)addr
1644 <= ((unsigned char *)bcm_static_buf + STATIC_BUF_TOTAL_LEN)))
1645 {
1646 int buf_idx = 0;
1647
1648 buf_idx = ((unsigned char *)addr - bcm_static_buf->buf_ptr)/STATIC_BUF_SIZE;
1649
1650 spin_lock_irqsave(&bcm_static_buf->static_lock, flags);
1651 bcm_static_buf->buf_use[buf_idx] = 0;
1652 spin_unlock_irqrestore(&bcm_static_buf->static_lock, flags);
1653
1654 if (osh && osh->cmn) {
1655 ASSERT(osh->magic == OS_HANDLE_MAGIC);
1656 atomic_sub(size, &osh->cmn->malloced);
1657 }
1658 return;
1659 }
1660 }
1661 #endif /* CONFIG_DHD_USE_STATIC_BUF */
1662 if (osh && osh->cmn) {
1663 ASSERT(osh->magic == OS_HANDLE_MAGIC);
1664
1665 ASSERT(size <= osl_malloced(osh));
1666
1667 atomic_sub(size, &osh->cmn->malloced);
1668 }
1669 kfree(addr);
1670 }
1671
1672 void *
osl_vmalloc(osl_t * osh,uint size)1673 osl_vmalloc(osl_t *osh, uint size)
1674 {
1675 void *addr;
1676
1677 /* only ASSERT if osh is defined */
1678 if (osh)
1679 ASSERT(osh->magic == OS_HANDLE_MAGIC);
1680 if ((addr = vmalloc(size)) == NULL) {
1681 if (osh)
1682 osh->failed++;
1683 return (NULL);
1684 }
1685 if (osh && osh->cmn)
1686 atomic_add(size, &osh->cmn->malloced);
1687
1688 return (addr);
1689 }
1690
1691 void *
osl_vmallocz(osl_t * osh,uint size)1692 osl_vmallocz(osl_t *osh, uint size)
1693 {
1694 void *ptr;
1695
1696 ptr = osl_vmalloc(osh, size);
1697
1698 if (ptr != NULL) {
1699 bzero(ptr, size);
1700 }
1701
1702 return ptr;
1703 }
1704
1705 void
osl_vmfree(osl_t * osh,void * addr,uint size)1706 osl_vmfree(osl_t *osh, void *addr, uint size)
1707 {
1708 if (osh && osh->cmn) {
1709 ASSERT(osh->magic == OS_HANDLE_MAGIC);
1710
1711 ASSERT(size <= osl_malloced(osh));
1712
1713 atomic_sub(size, &osh->cmn->malloced);
1714 }
1715 vfree(addr);
1716 }
1717
1718 uint
osl_check_memleak(osl_t * osh)1719 osl_check_memleak(osl_t *osh)
1720 {
1721 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
1722 if (atomic_read(&osh->cmn->refcount) == 1)
1723 return (atomic_read(&osh->cmn->malloced));
1724 else
1725 return 0;
1726 }
1727
1728 uint
osl_malloced(osl_t * osh)1729 osl_malloced(osl_t *osh)
1730 {
1731 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
1732 return (atomic_read(&osh->cmn->malloced));
1733 }
1734
1735 uint
osl_malloc_failed(osl_t * osh)1736 osl_malloc_failed(osl_t *osh)
1737 {
1738 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
1739 return (osh->failed);
1740 }
1741
1742
1743 uint
osl_dma_consistent_align(void)1744 osl_dma_consistent_align(void)
1745 {
1746 return (PAGE_SIZE);
1747 }
1748
1749 void*
osl_dma_alloc_consistent(osl_t * osh,uint size,uint16 align_bits,uint * alloced,dmaaddr_t * pap)1750 osl_dma_alloc_consistent(osl_t *osh, uint size, uint16 align_bits, uint *alloced, dmaaddr_t *pap)
1751 {
1752 void *va;
1753 uint16 align = (1 << align_bits);
1754 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
1755
1756 if (!ISALIGNED(DMA_CONSISTENT_ALIGN, align))
1757 size += align;
1758 *alloced = size;
1759
1760 #ifndef BCM_SECURE_DMA
1761 #if defined(__ARM_ARCH_7A__) && !defined(DHD_USE_COHERENT_MEM_FOR_RING)
1762 va = kmalloc(size, GFP_ATOMIC | __GFP_ZERO);
1763 if (va)
1764 *pap = (ulong)__virt_to_phys((ulong)va);
1765 #else
1766 {
1767 dma_addr_t pap_lin;
1768 struct pci_dev *hwdev = osh->pdev;
1769 gfp_t flags;
1770 #ifdef DHD_ALLOC_COHERENT_MEM_FROM_ATOMIC_POOL
1771 flags = GFP_ATOMIC;
1772 #else
1773 flags = CAN_SLEEP() ? GFP_KERNEL: GFP_ATOMIC;
1774 #endif /* DHD_ALLOC_COHERENT_MEM_FROM_ATOMIC_POOL */
1775 va = dma_alloc_coherent(&hwdev->dev, size, &pap_lin, flags);
1776 #ifdef BCMDMA64OSL
1777 PHYSADDRLOSET(*pap, pap_lin & 0xffffffff);
1778 PHYSADDRHISET(*pap, (pap_lin >> 32) & 0xffffffff);
1779 #else
1780 *pap = (dmaaddr_t)pap_lin;
1781 #endif /* BCMDMA64OSL */
1782 }
1783 #endif /* __ARM_ARCH_7A__ && !DHD_USE_COHERENT_MEM_FOR_RING */
1784 #else
1785 va = osl_sec_dma_alloc_consistent(osh, size, align_bits, pap);
1786 #endif /* BCM_SECURE_DMA */
1787 return va;
1788 }
1789
1790 void
osl_dma_free_consistent(osl_t * osh,void * va,uint size,dmaaddr_t pa)1791 osl_dma_free_consistent(osl_t *osh, void *va, uint size, dmaaddr_t pa)
1792 {
1793 #ifdef BCMDMA64OSL
1794 dma_addr_t paddr;
1795 #endif /* BCMDMA64OSL */
1796 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
1797
1798 #ifndef BCM_SECURE_DMA
1799 #if defined(__ARM_ARCH_7A__) && !defined(DHD_USE_COHERENT_MEM_FOR_RING)
1800 kfree(va);
1801 #else
1802 #ifdef BCMDMA64OSL
1803 PHYSADDRTOULONG(pa, paddr);
1804 pci_free_consistent(osh->pdev, size, va, paddr);
1805 #else
1806 pci_free_consistent(osh->pdev, size, va, (dma_addr_t)pa);
1807 #endif /* BCMDMA64OSL */
1808 #endif /* __ARM_ARCH_7A__ && !DHD_USE_COHERENT_MEM_FOR_RING */
1809 #else
1810 osl_sec_dma_free_consistent(osh, va, size, pa);
1811 #endif /* BCM_SECURE_DMA */
1812 }
1813
1814 dmaaddr_t BCMFASTPATH
osl_dma_map(osl_t * osh,void * va,uint size,int direction,void * p,hnddma_seg_map_t * dmah)1815 osl_dma_map(osl_t *osh, void *va, uint size, int direction, void *p, hnddma_seg_map_t *dmah)
1816 {
1817 int dir;
1818 dmaaddr_t ret_addr;
1819 dma_addr_t map_addr;
1820 int ret;
1821
1822 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
1823 dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
1824
1825
1826
1827
1828 map_addr = pci_map_single(osh->pdev, va, size, dir);
1829 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27))
1830 ret = pci_dma_mapping_error(osh->pdev, map_addr);
1831 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 5))
1832 ret = pci_dma_mapping_error(map_addr);
1833 #else
1834 ret = 0;
1835 #endif
1836 if (ret) {
1837 printk("%s: Failed to map memory\n", __FUNCTION__);
1838 PHYSADDRLOSET(ret_addr, 0);
1839 PHYSADDRHISET(ret_addr, 0);
1840 } else {
1841 PHYSADDRLOSET(ret_addr, map_addr & 0xffffffff);
1842 PHYSADDRHISET(ret_addr, (map_addr >> 32) & 0xffffffff);
1843 }
1844
1845 return ret_addr;
1846 }
1847
1848 void BCMFASTPATH
osl_dma_unmap(osl_t * osh,dmaaddr_t pa,uint size,int direction)1849 osl_dma_unmap(osl_t *osh, dmaaddr_t pa, uint size, int direction)
1850 {
1851 int dir;
1852 #ifdef BCMDMA64OSL
1853 dma_addr_t paddr;
1854 #endif /* BCMDMA64OSL */
1855
1856 ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
1857
1858
1859 dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
1860 #ifdef BCMDMA64OSL
1861 PHYSADDRTOULONG(pa, paddr);
1862 pci_unmap_single(osh->pdev, paddr, size, dir);
1863 #else
1864 pci_unmap_single(osh->pdev, (uint32)pa, size, dir);
1865 #endif /* BCMDMA64OSL */
1866 }
1867
1868 /* OSL function for CPU relax */
1869 inline void BCMFASTPATH
osl_cpu_relax(void)1870 osl_cpu_relax(void)
1871 {
1872 cpu_relax();
1873 }
1874
osl_preempt_disable(osl_t * osh)1875 extern void osl_preempt_disable(osl_t *osh)
1876 {
1877 preempt_disable();
1878 }
1879
osl_preempt_enable(osl_t * osh)1880 extern void osl_preempt_enable(osl_t *osh)
1881 {
1882 preempt_enable();
1883 }
1884
1885 #if defined(BCMASSERT_LOG)
1886 void
osl_assert(const char * exp,const char * file,int line)1887 osl_assert(const char *exp, const char *file, int line)
1888 {
1889 char tempbuf[256];
1890 const char *basename;
1891
1892 basename = strrchr(file, '/');
1893 /* skip the '/' */
1894 if (basename)
1895 basename++;
1896
1897 if (!basename)
1898 basename = file;
1899
1900 #ifdef BCMASSERT_LOG
1901 snprintf(tempbuf, 64, "\"%s\": file \"%s\", line %d\n",
1902 exp, basename, line);
1903 #endif /* BCMASSERT_LOG */
1904
1905
1906 switch (g_assert_type) {
1907 case 0:
1908 panic("%s", tempbuf);
1909 break;
1910 case 1:
1911 /* fall through */
1912 case 3:
1913 printk("%s", tempbuf);
1914 break;
1915 case 2:
1916 printk("%s", tempbuf);
1917 BUG();
1918 break;
1919 default:
1920 break;
1921 }
1922 }
1923 #endif
1924
1925 void
osl_delay(uint usec)1926 osl_delay(uint usec)
1927 {
1928 uint d;
1929
1930 while (usec > 0) {
1931 d = MIN(usec, 1000);
1932 udelay(d);
1933 usec -= d;
1934 }
1935 }
1936
1937 void
osl_sleep(uint ms)1938 osl_sleep(uint ms)
1939 {
1940 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
1941 if (ms < 20)
1942 usleep_range(ms*1000, ms*1000 + 1000);
1943 else
1944 #endif
1945 msleep(ms);
1946 }
1947
1948 uint64
osl_sysuptime_us(void)1949 osl_sysuptime_us(void)
1950 {
1951 struct timespec64 tv;
1952 uint64 usec;
1953 tv = ktime_to_timespec64(ktime_get_boottime());
1954
1955 /* tv_usec content is fraction of a second */
1956 usec = (uint64)tv.tv_sec * 1000000ul + tv.tv_nsec / 1000;
1957 return usec;
1958 }
1959
1960
1961 /* Clone a packet.
1962 * The pkttag contents are NOT cloned.
1963 */
1964 void *
1965 #ifdef BCMDBG_CTRACE
osl_pktdup(osl_t * osh,void * skb,int line,char * file)1966 osl_pktdup(osl_t *osh, void *skb, int line, char *file)
1967 #else
1968 #ifdef BCM_OBJECT_TRACE
1969 osl_pktdup(osl_t *osh, void *skb, int line, const char *caller)
1970 #else
1971 osl_pktdup(osl_t *osh, void *skb)
1972 #endif /* BCM_OBJECT_TRACE */
1973 #endif /* BCMDBG_CTRACE */
1974 {
1975 void * p;
1976
1977 ASSERT(!PKTISCHAINED(skb));
1978
1979 /* clear the CTFBUF flag if set and map the rest of the buffer
1980 * before cloning.
1981 */
1982 PKTCTFMAP(osh, skb);
1983
1984 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
1985 if ((p = pskb_copy((struct sk_buff *)skb, GFP_ATOMIC)) == NULL)
1986 #else
1987 if ((p = skb_clone((struct sk_buff *)skb, GFP_ATOMIC)) == NULL)
1988 #endif
1989 return NULL;
1990
1991 #ifdef CTFPOOL
1992 if (PKTISFAST(osh, skb)) {
1993 ctfpool_t *ctfpool;
1994
1995 /* if the buffer allocated from ctfpool is cloned then
1996 * we can't be sure when it will be freed. since there
1997 * is a chance that we will be losing a buffer
1998 * from our pool, we increment the refill count for the
1999 * object to be alloced later.
2000 */
2001 ctfpool = (ctfpool_t *)CTFPOOLPTR(osh, skb);
2002 ASSERT(ctfpool != NULL);
2003 PKTCLRFAST(osh, p);
2004 PKTCLRFAST(osh, skb);
2005 ctfpool->refills++;
2006 }
2007 #endif /* CTFPOOL */
2008
2009 /* Clear PKTC context */
2010 PKTSETCLINK(p, NULL);
2011 PKTCCLRFLAGS(p);
2012 PKTCSETCNT(p, 1);
2013 PKTCSETLEN(p, PKTLEN(osh, skb));
2014
2015 /* skb_clone copies skb->cb.. we don't want that */
2016 if (osh->pub.pkttag)
2017 OSL_PKTTAG_CLEAR(p);
2018
2019 /* Increment the packet counter */
2020 atomic_inc(&osh->cmn->pktalloced);
2021 #ifdef BCM_OBJECT_TRACE
2022 bcm_object_trace_opr(p, BCM_OBJDBG_ADD_PKT, caller, line);
2023 #endif /* BCM_OBJECT_TRACE */
2024
2025 #ifdef BCMDBG_CTRACE
2026 ADD_CTRACE(osh, (struct sk_buff *)p, file, line);
2027 #endif
2028 return (p);
2029 }
2030
2031 #ifdef BCMDBG_CTRACE
osl_pkt_is_frmnative(osl_t * osh,struct sk_buff * pkt)2032 int osl_pkt_is_frmnative(osl_t *osh, struct sk_buff *pkt)
2033 {
2034 unsigned long flags;
2035 struct sk_buff *skb;
2036 int ck = FALSE;
2037
2038 spin_lock_irqsave(&osh->ctrace_lock, flags);
2039
2040 list_for_each_entry(skb, &osh->ctrace_list, ctrace_list) {
2041 if (pkt == skb) {
2042 ck = TRUE;
2043 break;
2044 }
2045 }
2046
2047 spin_unlock_irqrestore(&osh->ctrace_lock, flags);
2048 return ck;
2049 }
2050
osl_ctrace_dump(osl_t * osh,struct bcmstrbuf * b)2051 void osl_ctrace_dump(osl_t *osh, struct bcmstrbuf *b)
2052 {
2053 unsigned long flags;
2054 struct sk_buff *skb;
2055 int idx = 0;
2056 int i, j;
2057
2058 spin_lock_irqsave(&osh->ctrace_lock, flags);
2059
2060 if (b != NULL)
2061 bcm_bprintf(b, " Total %d sbk not free\n", osh->ctrace_num);
2062 else
2063 printk(" Total %d sbk not free\n", osh->ctrace_num);
2064
2065 list_for_each_entry(skb, &osh->ctrace_list, ctrace_list) {
2066 if (b != NULL)
2067 bcm_bprintf(b, "[%d] skb %p:\n", ++idx, skb);
2068 else
2069 printk("[%d] skb %p:\n", ++idx, skb);
2070
2071 for (i = 0; i < skb->ctrace_count; i++) {
2072 j = (skb->ctrace_start + i) % CTRACE_NUM;
2073 if (b != NULL)
2074 bcm_bprintf(b, " [%s(%d)]\n", skb->func[j], skb->line[j]);
2075 else
2076 printk(" [%s(%d)]\n", skb->func[j], skb->line[j]);
2077 }
2078 if (b != NULL)
2079 bcm_bprintf(b, "\n");
2080 else
2081 printk("\n");
2082 }
2083
2084 spin_unlock_irqrestore(&osh->ctrace_lock, flags);
2085
2086 return;
2087 }
2088 #endif /* BCMDBG_CTRACE */
2089
2090
2091 /*
2092 * OSLREGOPS specifies the use of osl_XXX routines to be used for register access
2093 */
2094
2095 /*
2096 * BINOSL selects the slightly slower function-call-based binary compatible osl.
2097 */
2098
2099 uint
osl_pktalloced(osl_t * osh)2100 osl_pktalloced(osl_t *osh)
2101 {
2102 if (atomic_read(&osh->cmn->refcount) == 1)
2103 return (atomic_read(&osh->cmn->pktalloced));
2104 else
2105 return 0;
2106 }
2107
2108 uint32
osl_rand(void)2109 osl_rand(void)
2110 {
2111 uint32 rand;
2112
2113 get_random_bytes(&rand, sizeof(rand));
2114
2115 return rand;
2116 }
2117
2118 /* Linux Kernel: File Operations: start */
2119 void *
osl_os_open_image(char * filename)2120 osl_os_open_image(char *filename)
2121 {
2122 struct file *fp;
2123
2124 fp = filp_open(filename, O_RDONLY, 0);
2125 /*
2126 * 2.6.11 (FC4) supports filp_open() but later revs don't?
2127 * Alternative:
2128 * fp = open_namei(AT_FDCWD, filename, O_RD, 0);
2129 * ???
2130 */
2131 if (IS_ERR(fp)) {
2132 fp = NULL;
2133 }
2134 return fp;
2135 }
2136
2137 int
osl_os_get_image_block(char * buf,int len,void * image)2138 osl_os_get_image_block(char *buf, int len, void *image)
2139 {
2140 struct file *fp = (struct file *)image;
2141 int rdlen;
2142
2143 if (!image)
2144 return 0;
2145
2146 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 14, 0)
2147 rdlen = kernel_read(fp, buf, len, &fp->f_pos);
2148 #else
2149 rdlen = kernel_read(fp, fp->f_pos, buf, len);
2150 if (rdlen > 0)
2151 fp->f_pos += rdlen;
2152 #endif
2153
2154 return rdlen;
2155 }
2156
2157 void
osl_os_close_image(void * image)2158 osl_os_close_image(void *image)
2159 {
2160 if (image)
2161 filp_close((struct file *)image, NULL);
2162 }
2163
2164 int
osl_os_image_size(void * image)2165 osl_os_image_size(void *image)
2166 {
2167 int len = 0, curroffset;
2168
2169 if (image) {
2170 /* store the current offset */
2171 curroffset = generic_file_llseek(image, 0, 1);
2172 /* goto end of file to get length */
2173 len = generic_file_llseek(image, 0, 2);
2174 /* restore back the offset */
2175 generic_file_llseek(image, curroffset, 0);
2176 }
2177 return len;
2178 }
2179
2180 /* Linux Kernel: File Operations: end */
2181
2182 #if (defined(STB) && defined(__arm__))
osl_pcie_rreg(osl_t * osh,ulong addr,void * v,uint size)2183 inline void osl_pcie_rreg(osl_t *osh, ulong addr, void *v, uint size)
2184 {
2185 unsigned long flags = 0;
2186 int pci_access = 0;
2187 #if defined(BCM_GMAC3)
2188 const int acp_war_enab = 1;
2189 #else /* !BCM_GMAC3 */
2190 int acp_war_enab = ACP_WAR_ENAB();
2191 #endif /* !BCM_GMAC3 */
2192
2193 if (osh && BUSTYPE(osh->bustype) == PCI_BUS)
2194 pci_access = 1;
2195
2196 if (pci_access && acp_war_enab)
2197 spin_lock_irqsave(&l2x0_reg_lock, flags);
2198
2199 switch (size) {
2200 case sizeof(uint8):
2201 *(uint8*)v = readb((volatile uint8*)(addr));
2202 break;
2203 case sizeof(uint16):
2204 *(uint16*)v = readw((volatile uint16*)(addr));
2205 break;
2206 case sizeof(uint32):
2207 *(uint32*)v = readl((volatile uint32*)(addr));
2208 break;
2209 case sizeof(uint64):
2210 *(uint64*)v = *((volatile uint64*)(addr));
2211 break;
2212 }
2213
2214 if (pci_access && acp_war_enab)
2215 spin_unlock_irqrestore(&l2x0_reg_lock, flags);
2216 }
2217 #endif
2218
2219 #ifdef BCM_SECURE_DMA
2220 static void *
osl_sec_dma_ioremap(osl_t * osh,struct page * page,size_t size,bool iscache,bool isdecr)2221 osl_sec_dma_ioremap(osl_t *osh, struct page *page, size_t size, bool iscache, bool isdecr)
2222 {
2223 struct page **map;
2224 int order, i;
2225 void *addr = NULL;
2226
2227 size = PAGE_ALIGN(size);
2228 order = get_order(size);
2229
2230 map = kmalloc(sizeof(struct page *) << order, GFP_ATOMIC);
2231
2232 if (map == NULL)
2233 return NULL;
2234
2235 for (i = 0; i < (size >> PAGE_SHIFT); i++)
2236 map[i] = page + i;
2237
2238 if (iscache) {
2239 addr = vmap(map, size >> PAGE_SHIFT, VM_MAP, __pgprot(PAGE_KERNEL));
2240 if (isdecr) {
2241 osh->contig_delta_va_pa = ((uint8 *)addr - page_to_phys(page));
2242 }
2243 } else {
2244 #if defined(__ARM_ARCH_7A__)
2245 addr = vmap(map, size >> PAGE_SHIFT, VM_MAP,
2246 pgprot_noncached(__pgprot(PAGE_KERNEL)));
2247 #endif
2248 if (isdecr) {
2249 osh->contig_delta_va_pa = ((uint8 *)addr - page_to_phys(page));
2250 }
2251 }
2252
2253 kfree(map);
2254 return (void *)addr;
2255 }
2256
2257 static void
osl_sec_dma_iounmap(osl_t * osh,void * contig_base_va,size_t size)2258 osl_sec_dma_iounmap(osl_t *osh, void *contig_base_va, size_t size)
2259 {
2260 vunmap(contig_base_va);
2261 }
2262
2263 static int
osl_sec_dma_init_elem_mem_block(osl_t * osh,size_t mbsize,int max,sec_mem_elem_t ** list)2264 osl_sec_dma_init_elem_mem_block(osl_t *osh, size_t mbsize, int max, sec_mem_elem_t **list)
2265 {
2266 int i;
2267 int ret = BCME_OK;
2268 sec_mem_elem_t *sec_mem_elem;
2269
2270 if ((sec_mem_elem = kmalloc(sizeof(sec_mem_elem_t)*(max), GFP_ATOMIC)) != NULL) {
2271 *list = sec_mem_elem;
2272 bzero(sec_mem_elem, sizeof(sec_mem_elem_t)*(max));
2273 for (i = 0; i < max-1; i++) {
2274 sec_mem_elem->next = (sec_mem_elem + 1);
2275 sec_mem_elem->size = mbsize;
2276 sec_mem_elem->pa_cma = osh->contig_base_alloc;
2277 sec_mem_elem->vac = osh->contig_base_alloc_va;
2278
2279 sec_mem_elem->pa_cma_page = phys_to_page(sec_mem_elem->pa_cma);
2280 osh->contig_base_alloc += mbsize;
2281 osh->contig_base_alloc_va = ((uint8 *)osh->contig_base_alloc_va + mbsize);
2282
2283 sec_mem_elem = sec_mem_elem + 1;
2284 }
2285 sec_mem_elem->next = NULL;
2286 sec_mem_elem->size = mbsize;
2287 sec_mem_elem->pa_cma = osh->contig_base_alloc;
2288 sec_mem_elem->vac = osh->contig_base_alloc_va;
2289
2290 sec_mem_elem->pa_cma_page = phys_to_page(sec_mem_elem->pa_cma);
2291 osh->contig_base_alloc += mbsize;
2292 osh->contig_base_alloc_va = ((uint8 *)osh->contig_base_alloc_va + mbsize);
2293 } else {
2294 printf("%s sec mem elem kmalloc failed\n", __FUNCTION__);
2295 ret = BCME_ERROR;
2296 }
2297 return ret;
2298 }
2299
2300
2301 static void
osl_sec_dma_deinit_elem_mem_block(osl_t * osh,size_t mbsize,int max,void * sec_list_base)2302 osl_sec_dma_deinit_elem_mem_block(osl_t *osh, size_t mbsize, int max, void *sec_list_base)
2303 {
2304 if (sec_list_base)
2305 kfree(sec_list_base);
2306 }
2307
2308 static sec_mem_elem_t * BCMFASTPATH
osl_sec_dma_alloc_mem_elem(osl_t * osh,void * va,uint size,int direction,struct sec_cma_info * ptr_cma_info,uint offset)2309 osl_sec_dma_alloc_mem_elem(osl_t *osh, void *va, uint size, int direction,
2310 struct sec_cma_info *ptr_cma_info, uint offset)
2311 {
2312 sec_mem_elem_t *sec_mem_elem = NULL;
2313
2314 ASSERT(osh->sec_list_4096);
2315 sec_mem_elem = osh->sec_list_4096;
2316 osh->sec_list_4096 = sec_mem_elem->next;
2317
2318 sec_mem_elem->next = NULL;
2319
2320 if (ptr_cma_info->sec_alloc_list_tail) {
2321 ptr_cma_info->sec_alloc_list_tail->next = sec_mem_elem;
2322 ptr_cma_info->sec_alloc_list_tail = sec_mem_elem;
2323 }
2324 else {
2325 /* First allocation: If tail is NULL, sec_alloc_list MUST also be NULL */
2326 ASSERT(ptr_cma_info->sec_alloc_list == NULL);
2327 ptr_cma_info->sec_alloc_list = sec_mem_elem;
2328 ptr_cma_info->sec_alloc_list_tail = sec_mem_elem;
2329 }
2330 return sec_mem_elem;
2331 }
2332
2333 static void BCMFASTPATH
osl_sec_dma_free_mem_elem(osl_t * osh,sec_mem_elem_t * sec_mem_elem)2334 osl_sec_dma_free_mem_elem(osl_t *osh, sec_mem_elem_t *sec_mem_elem)
2335 {
2336 sec_mem_elem->dma_handle = 0x0;
2337 sec_mem_elem->va = NULL;
2338 sec_mem_elem->next = osh->sec_list_4096;
2339 osh->sec_list_4096 = sec_mem_elem;
2340 }
2341
2342 static sec_mem_elem_t * BCMFASTPATH
osl_sec_dma_find_rem_elem(osl_t * osh,struct sec_cma_info * ptr_cma_info,dma_addr_t dma_handle)2343 osl_sec_dma_find_rem_elem(osl_t *osh, struct sec_cma_info *ptr_cma_info, dma_addr_t dma_handle)
2344 {
2345 sec_mem_elem_t *sec_mem_elem = ptr_cma_info->sec_alloc_list;
2346 sec_mem_elem_t *sec_prv_elem = ptr_cma_info->sec_alloc_list;
2347
2348 if (sec_mem_elem->dma_handle == dma_handle) {
2349 ptr_cma_info->sec_alloc_list = sec_mem_elem->next;
2350
2351 if (sec_mem_elem == ptr_cma_info->sec_alloc_list_tail) {
2352 ptr_cma_info->sec_alloc_list_tail = NULL;
2353 ASSERT(ptr_cma_info->sec_alloc_list == NULL);
2354 }
2355
2356 return sec_mem_elem;
2357 }
2358 sec_mem_elem = sec_mem_elem->next;
2359
2360 while (sec_mem_elem != NULL) {
2361 if (sec_mem_elem->dma_handle == dma_handle) {
2362 sec_prv_elem->next = sec_mem_elem->next;
2363 if (sec_mem_elem == ptr_cma_info->sec_alloc_list_tail)
2364 ptr_cma_info->sec_alloc_list_tail = sec_prv_elem;
2365
2366 return sec_mem_elem;
2367 }
2368 sec_prv_elem = sec_mem_elem;
2369 sec_mem_elem = sec_mem_elem->next;
2370 }
2371 return NULL;
2372 }
2373
2374 static sec_mem_elem_t *
osl_sec_dma_rem_first_elem(osl_t * osh,struct sec_cma_info * ptr_cma_info)2375 osl_sec_dma_rem_first_elem(osl_t *osh, struct sec_cma_info *ptr_cma_info)
2376 {
2377 sec_mem_elem_t *sec_mem_elem = ptr_cma_info->sec_alloc_list;
2378
2379 if (sec_mem_elem) {
2380 ptr_cma_info->sec_alloc_list = sec_mem_elem->next;
2381
2382 if (ptr_cma_info->sec_alloc_list == NULL)
2383 ptr_cma_info->sec_alloc_list_tail = NULL;
2384
2385 return sec_mem_elem;
2386 } else
2387 return NULL;
2388 }
2389
2390 static void * BCMFASTPATH
osl_sec_dma_last_elem(osl_t * osh,struct sec_cma_info * ptr_cma_info)2391 osl_sec_dma_last_elem(osl_t *osh, struct sec_cma_info *ptr_cma_info)
2392 {
2393 return ptr_cma_info->sec_alloc_list_tail;
2394 }
2395
2396 dma_addr_t BCMFASTPATH
osl_sec_dma_map_txmeta(osl_t * osh,void * va,uint size,int direction,void * p,hnddma_seg_map_t * dmah,void * ptr_cma_info)2397 osl_sec_dma_map_txmeta(osl_t *osh, void *va, uint size, int direction, void *p,
2398 hnddma_seg_map_t *dmah, void *ptr_cma_info)
2399 {
2400 sec_mem_elem_t *sec_mem_elem;
2401 struct page *pa_cma_page;
2402 uint loffset;
2403 void *vaorig = ((uint8 *)va + size);
2404 dma_addr_t dma_handle = 0x0;
2405 /* packet will be the one added with osl_sec_dma_map() just before this call */
2406
2407 sec_mem_elem = osl_sec_dma_last_elem(osh, ptr_cma_info);
2408
2409 if (sec_mem_elem && sec_mem_elem->va == vaorig) {
2410 pa_cma_page = phys_to_page(sec_mem_elem->pa_cma);
2411 loffset = sec_mem_elem->pa_cma -(sec_mem_elem->pa_cma & ~(PAGE_SIZE-1));
2412
2413 dma_handle = dma_map_page(OSH_NULL, pa_cma_page, loffset, size,
2414 (direction == DMA_TX ? DMA_TO_DEVICE:DMA_FROM_DEVICE));
2415 } else {
2416 printf("%s: error orig va not found va = 0x%p \n",
2417 __FUNCTION__, vaorig);
2418 }
2419 return dma_handle;
2420 }
2421
2422 dma_addr_t BCMFASTPATH
osl_sec_dma_map(osl_t * osh,void * va,uint size,int direction,void * p,hnddma_seg_map_t * dmah,void * ptr_cma_info,uint offset)2423 osl_sec_dma_map(osl_t *osh, void *va, uint size, int direction, void *p,
2424 hnddma_seg_map_t *dmah, void *ptr_cma_info, uint offset)
2425 {
2426 sec_mem_elem_t *sec_mem_elem;
2427 struct page *pa_cma_page;
2428 void *pa_cma_kmap_va = NULL;
2429 uint buflen = 0;
2430 dma_addr_t dma_handle = 0x0;
2431 uint loffset;
2432
2433 ASSERT((direction == DMA_RX) || (direction == DMA_TX));
2434 sec_mem_elem = osl_sec_dma_alloc_mem_elem(osh, va, size, direction, ptr_cma_info, offset);
2435
2436 sec_mem_elem->va = va;
2437 sec_mem_elem->direction = direction;
2438 pa_cma_page = sec_mem_elem->pa_cma_page;
2439
2440 loffset = sec_mem_elem->pa_cma -(sec_mem_elem->pa_cma & ~(PAGE_SIZE-1));
2441
2442 pa_cma_kmap_va = sec_mem_elem->vac;
2443 pa_cma_kmap_va = ((uint8 *)pa_cma_kmap_va + offset);
2444 buflen = size;
2445
2446 if (direction == DMA_TX) {
2447 memcpy((uint8*)pa_cma_kmap_va+offset, va, size);
2448
2449 if (dmah) {
2450 dmah->nsegs = 1;
2451 dmah->origsize = buflen;
2452 }
2453 }
2454 else
2455 {
2456 if ((p != NULL) && (dmah != NULL)) {
2457 dmah->nsegs = 1;
2458 dmah->origsize = buflen;
2459 }
2460 *(uint32 *)(pa_cma_kmap_va) = 0x0;
2461 }
2462
2463 if (direction == DMA_RX) {
2464 flush_kernel_vmap_range(pa_cma_kmap_va, sizeof(int));
2465 }
2466 dma_handle = dma_map_page(OSH_NULL, pa_cma_page, loffset+offset, buflen,
2467 (direction == DMA_TX ? DMA_TO_DEVICE:DMA_FROM_DEVICE));
2468 if (dmah) {
2469 dmah->segs[0].addr = dma_handle;
2470 dmah->segs[0].length = buflen;
2471 }
2472 sec_mem_elem->dma_handle = dma_handle;
2473 return dma_handle;
2474 }
2475
2476 dma_addr_t BCMFASTPATH
osl_sec_dma_dd_map(osl_t * osh,void * va,uint size,int direction,void * p,hnddma_seg_map_t * map)2477 osl_sec_dma_dd_map(osl_t *osh, void *va, uint size, int direction, void *p, hnddma_seg_map_t *map)
2478 {
2479 struct page *pa_cma_page;
2480 phys_addr_t pa_cma;
2481 dma_addr_t dma_handle = 0x0;
2482 uint loffset;
2483
2484 pa_cma = ((uint8 *)va - (uint8 *)osh->contig_delta_va_pa);
2485 pa_cma_page = phys_to_page(pa_cma);
2486 loffset = pa_cma -(pa_cma & ~(PAGE_SIZE-1));
2487
2488 dma_handle = dma_map_page(OSH_NULL, pa_cma_page, loffset, size,
2489 (direction == DMA_TX ? DMA_TO_DEVICE:DMA_FROM_DEVICE));
2490
2491 return dma_handle;
2492 }
2493
2494 void BCMFASTPATH
osl_sec_dma_unmap(osl_t * osh,dma_addr_t dma_handle,uint size,int direction,void * p,hnddma_seg_map_t * map,void * ptr_cma_info,uint offset)2495 osl_sec_dma_unmap(osl_t *osh, dma_addr_t dma_handle, uint size, int direction,
2496 void *p, hnddma_seg_map_t *map, void *ptr_cma_info, uint offset)
2497 {
2498 sec_mem_elem_t *sec_mem_elem;
2499 void *pa_cma_kmap_va = NULL;
2500 uint buflen = 0;
2501 dma_addr_t pa_cma;
2502 void *va;
2503 int read_count = 0;
2504 BCM_REFERENCE(buflen);
2505 BCM_REFERENCE(read_count);
2506
2507 sec_mem_elem = osl_sec_dma_find_rem_elem(osh, ptr_cma_info, dma_handle);
2508 ASSERT(sec_mem_elem);
2509
2510 va = sec_mem_elem->va;
2511 va = (uint8 *)va - offset;
2512 pa_cma = sec_mem_elem->pa_cma;
2513
2514
2515 if (direction == DMA_RX) {
2516 if (p == NULL) {
2517 pa_cma_kmap_va = sec_mem_elem->vac;
2518
2519 do {
2520 invalidate_kernel_vmap_range(pa_cma_kmap_va, sizeof(int));
2521
2522 buflen = *(uint *)(pa_cma_kmap_va);
2523 if (buflen)
2524 break;
2525
2526 OSL_DELAY(1);
2527 read_count++;
2528 } while (read_count < 200);
2529 dma_unmap_page(OSH_NULL, pa_cma, size, DMA_FROM_DEVICE);
2530 memcpy(va, pa_cma_kmap_va, size);
2531 }
2532 } else {
2533 dma_unmap_page(OSH_NULL, pa_cma, size+offset, DMA_TO_DEVICE);
2534 }
2535
2536 osl_sec_dma_free_mem_elem(osh, sec_mem_elem);
2537 }
2538
2539 void
osl_sec_dma_unmap_all(osl_t * osh,void * ptr_cma_info)2540 osl_sec_dma_unmap_all(osl_t *osh, void *ptr_cma_info)
2541 {
2542 sec_mem_elem_t *sec_mem_elem;
2543
2544 sec_mem_elem = osl_sec_dma_rem_first_elem(osh, ptr_cma_info);
2545
2546 while (sec_mem_elem != NULL) {
2547 dma_unmap_page(OSH_NULL, sec_mem_elem->pa_cma, sec_mem_elem->size,
2548 sec_mem_elem->direction == DMA_TX ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
2549 osl_sec_dma_free_mem_elem(osh, sec_mem_elem);
2550
2551 sec_mem_elem = osl_sec_dma_rem_first_elem(osh, ptr_cma_info);
2552 }
2553 }
2554
2555 static void
osl_sec_dma_init_consistent(osl_t * osh)2556 osl_sec_dma_init_consistent(osl_t *osh)
2557 {
2558 int i;
2559 void *temp_va = osh->contig_base_alloc_coherent_va;
2560 phys_addr_t temp_pa = osh->contig_base_alloc_coherent;
2561
2562 for (i = 0; i < SEC_CMA_COHERENT_MAX; i++) {
2563 osh->sec_cma_coherent[i].avail = TRUE;
2564 osh->sec_cma_coherent[i].va = temp_va;
2565 osh->sec_cma_coherent[i].pa = temp_pa;
2566 temp_va = ((uint8 *)temp_va)+SEC_CMA_COHERENT_BLK;
2567 temp_pa += SEC_CMA_COHERENT_BLK;
2568 }
2569 }
2570
2571 static void *
osl_sec_dma_alloc_consistent(osl_t * osh,uint size,uint16 align_bits,ulong * pap)2572 osl_sec_dma_alloc_consistent(osl_t *osh, uint size, uint16 align_bits, ulong *pap)
2573 {
2574 void *temp_va = NULL;
2575 ulong temp_pa = 0;
2576 int i;
2577
2578 if (size > SEC_CMA_COHERENT_BLK) {
2579 printf("%s unsupported size\n", __FUNCTION__);
2580 return NULL;
2581 }
2582
2583 for (i = 0; i < SEC_CMA_COHERENT_MAX; i++) {
2584 if (osh->sec_cma_coherent[i].avail == TRUE) {
2585 temp_va = osh->sec_cma_coherent[i].va;
2586 temp_pa = osh->sec_cma_coherent[i].pa;
2587 osh->sec_cma_coherent[i].avail = FALSE;
2588 break;
2589 }
2590 }
2591
2592 if (i == SEC_CMA_COHERENT_MAX)
2593 printf("%s:No coherent mem: va = 0x%p pa = 0x%lx size = %d\n", __FUNCTION__,
2594 temp_va, (ulong)temp_pa, size);
2595
2596 *pap = (unsigned long)temp_pa;
2597 return temp_va;
2598 }
2599
2600 static void
osl_sec_dma_free_consistent(osl_t * osh,void * va,uint size,dmaaddr_t pa)2601 osl_sec_dma_free_consistent(osl_t *osh, void *va, uint size, dmaaddr_t pa)
2602 {
2603 int i = 0;
2604
2605 for (i = 0; i < SEC_CMA_COHERENT_MAX; i++) {
2606 if (osh->sec_cma_coherent[i].va == va) {
2607 osh->sec_cma_coherent[i].avail = TRUE;
2608 break;
2609 }
2610 }
2611 if (i == SEC_CMA_COHERENT_MAX)
2612 printf("%s:Error: va = 0x%p pa = 0x%lx size = %d\n", __FUNCTION__,
2613 va, (ulong)pa, size);
2614 }
2615
2616 #endif /* BCM_SECURE_DMA */
2617
2618 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0) && defined(TSQ_MULTIPLIER)
2619 #include <linux/kallsyms.h>
2620 #include <net/sock.h>
2621 void
osl_pkt_orphan_partial(struct sk_buff * skb,int tsq)2622 osl_pkt_orphan_partial(struct sk_buff *skb, int tsq)
2623 {
2624 uint32 fraction;
2625 static void *p_tcp_wfree = NULL;
2626
2627 if (tsq <= 0)
2628 return;
2629
2630 if (!skb->destructor || skb->destructor == sock_wfree)
2631 return;
2632
2633 if (unlikely(!p_tcp_wfree)) {
2634 char sym[KSYM_SYMBOL_LEN];
2635 sprint_symbol(sym, (unsigned long)skb->destructor);
2636 sym[9] = 0;
2637 if (!strcmp(sym, "tcp_wfree"))
2638 p_tcp_wfree = skb->destructor;
2639 else
2640 return;
2641 }
2642
2643 if (unlikely(skb->destructor != p_tcp_wfree || !skb->sk))
2644 return;
2645
2646 /* abstract a certain portion of skb truesize from the socket
2647 * sk_wmem_alloc to allow more skb can be allocated for this
2648 * socket for better cusion meeting WiFi device requirement
2649 */
2650 fraction = skb->truesize * (tsq - 1) / tsq;
2651 skb->truesize -= fraction;
2652 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 13, 0)
2653 atomic_sub(fraction, &skb->sk->sk_wmem_alloc.refs);
2654 #else
2655 atomic_sub(fraction, &skb->sk->sk_wmem_alloc);
2656 #endif /* LINUX_VERSION >= 4.13.0 */
2657 skb_orphan(skb);
2658 }
2659 #endif /* LINUX_VERSION >= 3.6.0 && TSQ_MULTIPLIER */
2660
2661 /* timer apis */
2662 /* Note: All timer api's are thread unsafe and should be protected with locks by caller */
2663
2664 #ifdef REPORT_FATAL_TIMEOUTS
2665 osl_timer_t *
osl_timer_init(osl_t * osh,const char * name,void (* fn)(void * arg),void * arg)2666 osl_timer_init(osl_t *osh, const char *name, void (*fn)(void *arg), void *arg)
2667 {
2668 osl_timer_t *t;
2669 BCM_REFERENCE(fn);
2670 if ((t = MALLOCZ(NULL, sizeof(osl_timer_t))) == NULL) {
2671 printk(KERN_ERR "osl_timer_init: malloced failed for osl_timer_t\n");
2672 return (NULL);
2673 }
2674 bzero(t, sizeof(osl_timer_t));
2675 if ((t->timer = MALLOCZ(NULL, sizeof(struct timer_list))) == NULL) {
2676 printk(KERN_ERR "osl_timer_init: malloc failed\n");
2677 MFREE(NULL, t, sizeof(osl_timer_t));
2678 return (NULL);
2679 }
2680 t->timer->data = (ulong)arg;
2681 t->timer->function = (linux_timer_fn)fn;
2682 t->set = TRUE;
2683
2684 init_timer(t->timer);
2685
2686 return (t);
2687 }
2688
2689 void
osl_timer_add(osl_t * osh,osl_timer_t * t,uint32 ms,bool periodic)2690 osl_timer_add(osl_t *osh, osl_timer_t *t, uint32 ms, bool periodic)
2691 {
2692 if (t == NULL) {
2693 printf("%s: Timer handle is NULL\n", __FUNCTION__);
2694 return;
2695 }
2696 ASSERT(!t->set);
2697
2698 t->set = TRUE;
2699 if (periodic) {
2700 printf("Periodic timers are not supported by Linux timer apis\n");
2701 }
2702 t->timer->expires = jiffies + ms*HZ/1000;
2703
2704 add_timer(t->timer);
2705
2706 return;
2707 }
2708
2709 void
osl_timer_update(osl_t * osh,osl_timer_t * t,uint32 ms,bool periodic)2710 osl_timer_update(osl_t *osh, osl_timer_t *t, uint32 ms, bool periodic)
2711 {
2712 if (t == NULL) {
2713 printf("%s: Timer handle is NULL\n", __FUNCTION__);
2714 return;
2715 }
2716 if (periodic) {
2717 printf("Periodic timers are not supported by Linux timer apis\n");
2718 }
2719 t->set = TRUE;
2720 t->timer->expires = jiffies + ms*HZ/1000;
2721
2722 mod_timer(t->timer, t->timer->expires);
2723
2724 return;
2725 }
2726
2727 /*
2728 * Return TRUE if timer successfully deleted, FALSE if still pending
2729 */
2730 bool
osl_timer_del(osl_t * osh,osl_timer_t * t)2731 osl_timer_del(osl_t *osh, osl_timer_t *t)
2732 {
2733 if (t == NULL) {
2734 printf("%s: Timer handle is NULL\n", __FUNCTION__);
2735 return (FALSE);
2736 }
2737 if (t->set) {
2738 t->set = FALSE;
2739 if (t->timer) {
2740 del_timer(t->timer);
2741 MFREE(NULL, t->timer, sizeof(struct timer_list));
2742 }
2743 MFREE(NULL, t, sizeof(osl_timer_t));
2744 }
2745 return (TRUE);
2746 }
2747 #endif
2748
2749 MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
2750