1 /* 2 * Copyright (c) 2014-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /** 21 * DOC: qdf_mem 22 * QCA driver framework (QDF) memory management APIs 23 */ 24 25 #if !defined(__QDF_MEMORY_H) 26 #define __QDF_MEMORY_H 27 28 /* Include Files */ 29 #include <qdf_types.h> 30 #include <i_qdf_mem.h> 31 #include <i_qdf_trace.h> 32 #include <qdf_atomic.h> 33 34 #define QDF_CACHE_LINE_SZ __qdf_cache_line_sz 35 36 /** 37 * qdf_align() - align to the given size. 38 * @a: input that needs to be aligned. 39 * @align_size: boundary on which 'a' has to be aligned. 40 * 41 * Return: aligned value. 42 */ 43 #define qdf_align(a, align_size) __qdf_align(a, align_size) 44 #define qdf_page_size __page_size 45 46 /** 47 * struct qdf_mem_dma_page_t - Allocated dmaable page 48 * @page_v_addr_start: Page start virtual address 49 * @page_v_addr_end: Page end virtual address 50 * @page_p_addr: Page start physical address 51 */ 52 struct qdf_mem_dma_page_t { 53 char *page_v_addr_start; 54 char *page_v_addr_end; 55 qdf_dma_addr_t page_p_addr; 56 }; 57 58 /** 59 * struct qdf_mem_multi_page_t - multiple page allocation information storage 60 * @num_element_per_page: Number of element in single page 61 * @num_pages: Number of allocation needed pages 62 * @dma_pages: page information storage in case of coherent memory 63 * @cacheable_pages: page information storage in case of cacheable memory 64 * @page_size: page size 65 * @is_mem_prealloc: flag for multiple pages pre-alloc or not 66 * @contiguous_dma_pages: flag for contiguous dma pages or not 67 */ 68 struct qdf_mem_multi_page_t { 69 uint16_t num_element_per_page; 70 uint16_t num_pages; 71 struct qdf_mem_dma_page_t *dma_pages; 72 void **cacheable_pages; 73 qdf_size_t page_size; 74 #ifdef DP_MEM_PRE_ALLOC 75 uint8_t is_mem_prealloc; 76 #endif 77 #ifdef ALLOC_CONTIGUOUS_MULTI_PAGE 78 bool contiguous_dma_pages; 79 #endif 80 }; 81 82 83 /* Preprocessor definitions and constants */ 84 85 typedef __qdf_mempool_t qdf_mempool_t; 86 87 /** 88 * qdf_mem_init() - Initialize QDF memory module 89 * 90 * Return: None 91 * 92 */ 93 void qdf_mem_init(void); 94 95 /** 96 * qdf_mem_exit() - Exit QDF memory module 97 * 98 * Return: None 99 * 100 */ 101 void qdf_mem_exit(void); 102 103 #ifdef QCA_WIFI_MODULE_PARAMS_FROM_INI 104 #define qdf_untracked_mem_malloc(size) \ 105 __qdf_untracked_mem_malloc(size, __func__, __LINE__) 106 107 #define qdf_untracked_mem_free(ptr) \ 108 __qdf_untracked_mem_free(ptr) 109 #endif 110 111 #define QDF_MEM_FUNC_NAME_SIZE 48 112 113 #ifdef MEMORY_DEBUG 114 /** 115 * qdf_mem_debug_config_get() - Get the user configuration of mem_debug_disabled 116 * 117 * Return: value of mem_debug_disabled qdf module argument 118 */ 119 bool qdf_mem_debug_config_get(void); 120 121 #ifdef QCA_WIFI_MODULE_PARAMS_FROM_INI 122 /** 123 * qdf_mem_debug_disabled_config_set() - Set mem_debug_disabled 124 * @str_value: value of the module param 125 * 126 * This function will set qdf module param mem_debug_disabled 127 * 128 * Return: QDF_STATUS_SUCCESS on Success 129 */ 130 QDF_STATUS qdf_mem_debug_disabled_config_set(const char *str_value); 131 #endif 132 133 /** 134 * qdf_mem_malloc_atomic_debug() - debug version of QDF memory allocation API 135 * @size: Number of bytes of memory to allocate. 136 * @func: Function name of the call site 137 * @line: Line number of the call site 138 * @caller: Address of the caller function 139 * 140 * This function will dynamically allocate the specified number of bytes of 141 * memory and add it to the qdf tracking list to check for memory leaks and 142 * corruptions 143 * 144 * Return: A valid memory location on success, or NULL on failure 145 */ 146 void *qdf_mem_malloc_atomic_debug(size_t size, const char *func, 147 uint32_t line, void *caller); 148 149 /** 150 * qdf_mem_malloc_atomic_debug_fl() - allocation QDF memory atomically 151 * @size: Number of bytes of memory to allocate. 152 * @func: Function name of the call site 153 * @line: Line number of the call site 154 * 155 * This function will dynamically allocate the specified number of bytes of 156 * memory. 157 * 158 * Return: 159 * Upon successful allocate, returns a non-NULL pointer to the allocated 160 * memory. If this function is unable to allocate the amount of memory 161 * specified (for any reason) it returns NULL. 162 */ 163 void *qdf_mem_malloc_atomic_debug_fl(qdf_size_t size, const char *func, 164 uint32_t line); 165 166 /** 167 * qdf_mem_malloc_debug() - debug version of QDF memory allocation API 168 * @size: Number of bytes of memory to allocate. 169 * @func: Function name of the call site 170 * @line: Line number of the call site 171 * @caller: Address of the caller function 172 * @flag: GFP flag 173 * 174 * This function will dynamically allocate the specified number of bytes of 175 * memory and add it to the qdf tracking list to check for memory leaks and 176 * corruptions 177 * 178 * Return: A valid memory location on success, or NULL on failure 179 */ 180 void *qdf_mem_malloc_debug(size_t size, const char *func, uint32_t line, 181 void *caller, uint32_t flag); 182 183 #define qdf_mem_malloc(size) \ 184 qdf_mem_malloc_debug(size, __func__, __LINE__, QDF_RET_IP, 0) 185 186 #define qdf_mem_malloc_fl(size, func, line) \ 187 qdf_mem_malloc_debug(size, func, line, QDF_RET_IP, 0) 188 189 #define qdf_mem_malloc_atomic(size) \ 190 qdf_mem_malloc_atomic_debug(size, __func__, __LINE__, QDF_RET_IP) 191 192 /** 193 * qdf_mem_free() - free allocate memory 194 * @ptr: Pointer to the starting address of the memory to be freed. 195 * 196 * This function will free the memory pointed to by 'ptr'. It also checks for 197 * memory corruption, underrun, overrun, double free, domain mismatch, etc. 198 * 199 * Return: none 200 */ 201 #define qdf_mem_free(ptr) \ 202 qdf_mem_free_debug(ptr, __func__, __LINE__) 203 void qdf_mem_free_debug(void *ptr, const char *file, uint32_t line); 204 205 /** 206 * qdf_mem_multi_pages_alloc_debug() - Debug version of 207 * qdf_mem_multi_pages_alloc 208 * @osdev: OS device handle pointer 209 * @pages: Multi page information storage 210 * @element_size: Each element size 211 * @element_num: Total number of elements should be allocated 212 * @memctxt: Memory context 213 * @cacheable: Coherent memory or cacheable memory 214 * @func: Caller of this allocator 215 * @line: Line number of the caller 216 * @caller: Return address of the caller 217 * 218 * This function will allocate large size of memory over multiple pages. 219 * Large size of contiguous memory allocation will fail frequently, then 220 * instead of allocate large memory by one shot, allocate through multiple, non 221 * contiguous memory and combine pages when actual usage 222 * 223 * Return: None 224 */ 225 void qdf_mem_multi_pages_alloc_debug(qdf_device_t osdev, 226 struct qdf_mem_multi_page_t *pages, 227 size_t element_size, uint32_t element_num, 228 qdf_dma_context_t memctxt, bool cacheable, 229 const char *func, uint32_t line, 230 void *caller); 231 232 /** 233 * qdf_mem_multi_pages_alloc() - allocate large size of kernel memory 234 * @osdev: OS device handle pointer 235 * @pages: Multi page information storage 236 * @element_size: Each element size 237 * @element_num: Total number of elements should be allocated 238 * @memctxt: Memory context 239 * @cacheable: Coherent memory or cacheable memory 240 * 241 * This function will allocate large size of memory over multiple pages. 242 * Large size of contiguous memory allocation will fail frequently, then 243 * instead of allocate large memory by one shot, allocate through multiple, non 244 * contiguous memory and combine pages when actual usage 245 * 246 * Return: None 247 */ 248 #define qdf_mem_multi_pages_alloc(osdev, pages, element_size, element_num,\ 249 memctxt, cacheable) \ 250 qdf_mem_multi_pages_alloc_debug(osdev, pages, element_size, \ 251 element_num, memctxt, cacheable, \ 252 __func__, __LINE__, QDF_RET_IP) 253 254 /** 255 * qdf_mem_multi_pages_free_debug() - Debug version of qdf_mem_multi_pages_free 256 * @osdev: OS device handle pointer 257 * @pages: Multi page information storage 258 * @memctxt: Memory context 259 * @cacheable: Coherent memory or cacheable memory 260 * @func: Caller of this allocator 261 * @line: Line number of the caller 262 * 263 * This function will free large size of memory over multiple pages. 264 * 265 * Return: None 266 */ 267 void qdf_mem_multi_pages_free_debug(qdf_device_t osdev, 268 struct qdf_mem_multi_page_t *pages, 269 qdf_dma_context_t memctxt, bool cacheable, 270 const char *func, uint32_t line); 271 272 /** 273 * qdf_mem_multi_pages_free() - free large size of kernel memory 274 * @osdev: OS device handle pointer 275 * @pages: Multi page information storage 276 * @memctxt: Memory context 277 * @cacheable: Coherent memory or cacheable memory 278 * 279 * This function will free large size of memory over multiple pages. 280 * 281 * Return: None 282 */ 283 #define qdf_mem_multi_pages_free(osdev, pages, memctxt, cacheable) \ 284 qdf_mem_multi_pages_free_debug(osdev, pages, memctxt, cacheable, \ 285 __func__, __LINE__) 286 287 /** 288 * qdf_mem_check_for_leaks() - Assert that the current memory domain is empty 289 * 290 * Call this to ensure there are no active memory allocations being tracked 291 * against the current debug domain. For example, one should call this function 292 * immediately before a call to qdf_debug_domain_set() as a memory leak 293 * detection mechanism. 294 * 295 * e.g. 296 * qdf_debug_domain_set(QDF_DEBUG_DOMAIN_ACTIVE); 297 * 298 * ... 299 * 300 * // memory is allocated and freed 301 * 302 * ... 303 * 304 * // before transitioning back to inactive state, 305 * // make sure all active memory has been freed 306 * qdf_mem_check_for_leaks(); 307 * qdf_debug_domain_set(QDF_DEBUG_DOMAIN_INIT); 308 * 309 * ... 310 * 311 * // also, before program exit, make sure init time memory is freed 312 * qdf_mem_check_for_leaks(); 313 * exit(); 314 * 315 * Return: None 316 */ 317 void qdf_mem_check_for_leaks(void); 318 319 /** 320 * qdf_mem_alloc_consistent() - allocates consistent qdf memory 321 * @osdev: OS device handle 322 * @dev: Pointer to device handle 323 * @size: Size to be allocated 324 * @paddr: Physical address 325 * 326 * Return: pointer of allocated memory or null if memory alloc fails 327 */ 328 #define qdf_mem_alloc_consistent(osdev, dev, size, paddr) \ 329 qdf_mem_alloc_consistent_debug(osdev, dev, size, paddr, \ 330 __func__, __LINE__, QDF_RET_IP) 331 void *qdf_mem_alloc_consistent_debug(qdf_device_t osdev, void *dev, 332 qdf_size_t size, qdf_dma_addr_t *paddr, 333 const char *func, uint32_t line, 334 void *caller); 335 336 /** 337 * qdf_mem_free_consistent() - free consistent qdf memory 338 * @osdev: OS device handle 339 * @dev: OS device 340 * @size: Size to be allocated 341 * @vaddr: virtual address 342 * @paddr: Physical address 343 * @memctx: Pointer to DMA context 344 * 345 * Return: none 346 */ 347 #define qdf_mem_free_consistent(osdev, dev, size, vaddr, paddr, memctx) \ 348 qdf_mem_free_consistent_debug(osdev, dev, size, vaddr, paddr, memctx, \ 349 __func__, __LINE__) 350 void qdf_mem_free_consistent_debug(qdf_device_t osdev, void *dev, 351 qdf_size_t size, void *vaddr, 352 qdf_dma_addr_t paddr, 353 qdf_dma_context_t memctx, 354 const char *func, uint32_t line); 355 356 #else 357 static inline bool qdf_mem_debug_config_get(void) 358 { 359 return false; 360 } 361 362 static inline 363 QDF_STATUS qdf_mem_debug_disabled_config_set(const char *str_value) 364 { 365 return QDF_STATUS_SUCCESS; 366 } 367 368 /** 369 * qdf_mem_malloc() - allocation QDF memory 370 * @size: Number of bytes of memory to allocate. 371 * 372 * This function will dynamically allocate the specified number of bytes of 373 * memory. 374 * 375 * Return: 376 * Upon successful allocate, returns a non-NULL pointer to the allocated 377 * memory. If this function is unable to allocate the amount of memory 378 * specified (for any reason) it returns NULL. 379 */ 380 #define qdf_mem_malloc(size) \ 381 __qdf_mem_malloc(size, __func__, __LINE__) 382 383 #define qdf_mem_malloc_fl(size, func, line) \ 384 __qdf_mem_malloc(size, func, line) 385 386 /** 387 * qdf_mem_malloc_atomic() - allocation QDF memory atomically 388 * @size: Number of bytes of memory to allocate. 389 * 390 * This function will dynamically allocate the specified number of bytes of 391 * memory. 392 * 393 * Return: 394 * Upon successful allocate, returns a non-NULL pointer to the allocated 395 * memory. If this function is unable to allocate the amount of memory 396 * specified (for any reason) it returns NULL. 397 */ 398 #define qdf_mem_malloc_atomic(size) \ 399 qdf_mem_malloc_atomic_fl(size, __func__, __LINE__) 400 401 void *qdf_mem_malloc_atomic_fl(qdf_size_t size, 402 const char *func, 403 uint32_t line); 404 405 #define qdf_mem_free(ptr) \ 406 __qdf_mem_free(ptr) 407 408 static inline void qdf_mem_check_for_leaks(void) { } 409 410 #define qdf_mem_alloc_consistent(osdev, dev, size, paddr) \ 411 __qdf_mem_alloc_consistent(osdev, dev, size, paddr, __func__, __LINE__) 412 413 #define qdf_mem_free_consistent(osdev, dev, size, vaddr, paddr, memctx) \ 414 __qdf_mem_free_consistent(osdev, dev, size, vaddr, paddr, memctx) 415 416 void qdf_mem_multi_pages_alloc(qdf_device_t osdev, 417 struct qdf_mem_multi_page_t *pages, 418 size_t element_size, uint32_t element_num, 419 qdf_dma_context_t memctxt, bool cacheable); 420 421 void qdf_mem_multi_pages_free(qdf_device_t osdev, 422 struct qdf_mem_multi_page_t *pages, 423 qdf_dma_context_t memctxt, bool cacheable); 424 425 #endif /* MEMORY_DEBUG */ 426 427 /** 428 * qdf_mem_malloc_flags: Get mem allocation flags 429 * 430 * Return the flag to be use for memory allocation 431 * based on the context 432 * 433 * Returns: Based on the context, returns the GFP flag 434 * for memory alloaction 435 */ 436 int qdf_mem_malloc_flags(void); 437 438 /** 439 * qdf_prealloc_disabled_config_get() - Get the user configuration of 440 * prealloc_disabled 441 * 442 * Return: value of prealloc_disabled qdf module argument 443 */ 444 bool qdf_prealloc_disabled_config_get(void); 445 446 #ifdef QCA_WIFI_MODULE_PARAMS_FROM_INI 447 /** 448 * qdf_prealloc_disabled_config_set() - Set prealloc_disabled 449 * @str_value: value of the module param 450 * 451 * This function will set qdf module param prealloc_disabled 452 * 453 * Return: QDF_STATUS_SUCCESS on Success 454 */ 455 QDF_STATUS qdf_prealloc_disabled_config_set(const char *str_value); 456 #endif 457 458 /** 459 * qdf_mem_multi_pages_zero() - zero out each page memory 460 * @pages: Multi page information storage 461 * @cacheable: Coherent memory or cacheable memory 462 * 463 * This function will zero out each page memory 464 * 465 * Return: None 466 */ 467 void qdf_mem_multi_pages_zero(struct qdf_mem_multi_page_t *pages, 468 bool cacheable); 469 470 /** 471 * qdf_aligned_malloc() - allocates aligned QDF memory. 472 * @size: Size to be allocated 473 * @vaddr_unaligned: Unaligned virtual address. 474 * @paddr_unaligned: Unaligned physical address. 475 * @paddr_aligned: Aligned physical address. 476 * @align: Base address alignment. 477 * 478 * This function will dynamically allocate the specified number of bytes of 479 * memory. Checks if the allocated base address is aligned with base_align. 480 * If not, it frees the allocated memory, adds base_align to alloc size and 481 * re-allocates the memory. 482 * 483 * Return: 484 * Upon successful allocate, returns an aligned base address of the allocated 485 * memory. If this function is unable to allocate the amount of memory 486 * specified (for any reason) it returns NULL. 487 */ 488 #define qdf_aligned_malloc(size, vaddr_unaligned, paddr_unaligned, \ 489 paddr_aligned, align) \ 490 qdf_aligned_malloc_fl(size, vaddr_unaligned, paddr_unaligned, \ 491 paddr_aligned, align, __func__, __LINE__) 492 493 void *qdf_aligned_malloc_fl(uint32_t *size, void **vaddr_unaligned, 494 qdf_dma_addr_t *paddr_unaligned, 495 qdf_dma_addr_t *paddr_aligned, 496 uint32_t align, 497 const char *func, uint32_t line); 498 499 /** 500 * qdf_aligned_mem_alloc_consistent() - allocates consistent qdf memory 501 * @osdev: OS device handle 502 * @size: Size to be allocated 503 * @vaddr_unaligned: Unaligned virtual address. 504 * @paddr_unaligned: Unaligned physical address. 505 * @paddr_aligned: Aligned physical address. 506 * @align: Base address alignment. 507 * 508 * Return: pointer of allocated memory or null if memory alloc fails. 509 */ 510 #define qdf_aligned_mem_alloc_consistent(osdev, size, vaddr_unaligned, \ 511 paddr_unaligned, paddr_aligned, \ 512 align) \ 513 qdf_aligned_mem_alloc_consistent_fl(osdev, size, vaddr_unaligned, \ 514 paddr_unaligned, paddr_aligned, \ 515 align, __func__, __LINE__) 516 517 void *qdf_aligned_mem_alloc_consistent_fl(qdf_device_t osdev, uint32_t *size, 518 void **vaddr_unaligned, 519 qdf_dma_addr_t *paddr_unaligned, 520 qdf_dma_addr_t *paddr_aligned, 521 uint32_t align, const char *func, 522 uint32_t line); 523 524 /** 525 * qdf_mem_virt_to_phys() - Convert virtual address to physical 526 * @vaddr: virtual address 527 * 528 * Return: physical address 529 */ 530 #define qdf_mem_virt_to_phys(vaddr) __qdf_mem_virt_to_phys(vaddr) 531 532 /** 533 * qdf_mem_set_io() - set (fill) memory with a specified byte value. 534 * @ptr: Pointer to memory that will be set 535 * @value: Byte set in memory 536 * @num_bytes: Number of bytes to be set 537 * 538 * Return: None 539 */ 540 void qdf_mem_set_io(void *ptr, uint32_t num_bytes, uint32_t value); 541 542 /** 543 * qdf_mem_copy_toio() - copy memory 544 * @dst_addr: Pointer to destination memory location (to copy to) 545 * @src_addr: Pointer to source memory location (to copy from) 546 * @num_bytes: Number of bytes to copy. 547 * 548 * Return: none 549 */ 550 void qdf_mem_copy_toio(void *dst_addr, const void *src_addr, 551 uint32_t num_bytes); 552 553 /** 554 * qdf_mem_set() - set (fill) memory with a specified byte value. 555 * @ptr: Pointer to memory that will be set 556 * @num_bytes: Number of bytes to be set 557 * @value: Byte set in memory 558 * 559 * WARNING: parameter @num_bytes and @value are swapped comparing with 560 * standard C function "memset", please ensure correct usage of this function! 561 * 562 * Return: None 563 */ 564 void qdf_mem_set(void *ptr, uint32_t num_bytes, uint32_t value); 565 566 /** 567 * qdf_mem_zero() - zero out memory 568 * @ptr: pointer to memory that will be set to zero 569 * @num_bytes: number of bytes zero 570 * 571 * This function sets the memory location to all zeros, essentially clearing 572 * the memory. 573 * 574 * Return: None 575 */ 576 static inline void qdf_mem_zero(void *ptr, uint32_t num_bytes) 577 { 578 qdf_mem_set(ptr, num_bytes, 0); 579 } 580 581 /** 582 * qdf_mem_copy() - copy memory 583 * @dst_addr: Pointer to destination memory location (to copy to) 584 * @src_addr: Pointer to source memory location (to copy from) 585 * @num_bytes: Number of bytes to copy. 586 * 587 * Copy host memory from one location to another, similar to memcpy in 588 * standard C. Note this function does not specifically handle overlapping 589 * source and destination memory locations. Calling this function with 590 * overlapping source and destination memory locations will result in 591 * unpredictable results. Use qdf_mem_move() if the memory locations 592 * for the source and destination are overlapping (or could be overlapping!) 593 * 594 * Return: none 595 */ 596 void qdf_mem_copy(void *dst_addr, const void *src_addr, uint32_t num_bytes); 597 598 /** 599 * qdf_mem_move() - move memory 600 * @dst_addr: pointer to destination memory location (to move to) 601 * @src_addr: pointer to source memory location (to move from) 602 * @num_bytes: number of bytes to move. 603 * 604 * Move host memory from one location to another, similar to memmove in 605 * standard C. Note this function *does* handle overlapping 606 * source and destination memory locations. 607 * 608 * Return: None 609 */ 610 void qdf_mem_move(void *dst_addr, const void *src_addr, uint32_t num_bytes); 611 612 /** 613 * qdf_mem_cmp() - memory compare 614 * @left: pointer to one location in memory to compare 615 * @right: pointer to second location in memory to compare 616 * @size: the number of bytes to compare 617 * 618 * Function to compare two pieces of memory, similar to memcmp function 619 * in standard C. 620 * 621 * Return: 622 * 0 -- equal 623 * < 0 -- *memory1 is less than *memory2 624 * > 0 -- *memory1 is bigger than *memory2 625 */ 626 int qdf_mem_cmp(const void *left, const void *right, size_t size); 627 628 /** 629 * qdf_ether_addr_copy() - copy an Ethernet address 630 * @dst_addr: A six-byte array Ethernet address destination 631 * @src_addr: A six-byte array Ethernet address source 632 * 633 * Please note: dst & src must both be aligned to u16. 634 * 635 * Return: none 636 */ 637 void qdf_ether_addr_copy(void *dst_addr, const void *src_addr); 638 639 /** 640 * qdf_mem_map_nbytes_single - Map memory for DMA 641 * @osdev: pomter OS device context 642 * @buf: pointer to memory to be dma mapped 643 * @dir: DMA map direction 644 * @nbytes: number of bytes to be mapped. 645 * @phy_addr: pointer to receive physical address. 646 * 647 * Return: success/failure 648 */ 649 static inline uint32_t qdf_mem_map_nbytes_single(qdf_device_t osdev, void *buf, 650 qdf_dma_dir_t dir, int nbytes, 651 qdf_dma_addr_t *phy_addr) 652 { 653 #if defined(HIF_PCI) || defined(HIF_IPCI) 654 return __qdf_mem_map_nbytes_single(osdev, buf, dir, nbytes, phy_addr); 655 #else 656 return 0; 657 #endif 658 } 659 660 static inline void qdf_mem_dma_cache_sync(qdf_device_t osdev, 661 qdf_dma_addr_t buf, 662 qdf_dma_dir_t dir, 663 int nbytes) 664 { 665 __qdf_mem_dma_cache_sync(osdev, buf, dir, nbytes); 666 } 667 668 /** 669 * qdf_mem_unmap_nbytes_single() - un_map memory for DMA 670 * @osdev: pomter OS device context 671 * @phy_addr: physical address of memory to be dma unmapped 672 * @dir: DMA unmap direction 673 * @nbytes: number of bytes to be unmapped. 674 * 675 * Return: none 676 */ 677 static inline void qdf_mem_unmap_nbytes_single(qdf_device_t osdev, 678 qdf_dma_addr_t phy_addr, 679 qdf_dma_dir_t dir, 680 int nbytes) 681 { 682 #if defined(HIF_PCI) || defined(HIF_IPCI) 683 __qdf_mem_unmap_nbytes_single(osdev, phy_addr, dir, nbytes); 684 #endif 685 } 686 687 /** 688 * qdf_mempool_init - Create and initialize memory pool 689 * @osdev: platform device object 690 * @pool_addr: address of the pool created 691 * @elem_cnt: no. of elements in pool 692 * @elem_size: size of each pool element in bytes 693 * @flags: flags 694 * Return: Handle to memory pool or NULL if allocation failed 695 */ 696 static inline int qdf_mempool_init(qdf_device_t osdev, 697 qdf_mempool_t *pool_addr, int elem_cnt, 698 size_t elem_size, uint32_t flags) 699 { 700 return __qdf_mempool_init(osdev, pool_addr, elem_cnt, elem_size, 701 flags); 702 } 703 704 /** 705 * qdf_mempool_destroy() - Destroy memory pool 706 * @osdev: platform device object 707 * @pool: to memory pool 708 * 709 * Return: none 710 */ 711 static inline void qdf_mempool_destroy(qdf_device_t osdev, qdf_mempool_t pool) 712 { 713 __qdf_mempool_destroy(osdev, pool); 714 } 715 716 /** 717 * qdf_mempool_alloc() - Allocate an element memory pool 718 * @osdev: platform device object 719 * @pool: to memory pool 720 * 721 * Return: Pointer to the allocated element or NULL if the pool is empty 722 */ 723 static inline void *qdf_mempool_alloc(qdf_device_t osdev, qdf_mempool_t pool) 724 { 725 return (void *)__qdf_mempool_alloc(osdev, pool); 726 } 727 728 /** 729 * qdf_mempool_free() - Free a memory pool element 730 * @osdev: Platform device object 731 * @pool: Handle to memory pool 732 * @buf: Element to be freed 733 * 734 * Return: none 735 */ 736 static inline void qdf_mempool_free(qdf_device_t osdev, qdf_mempool_t pool, 737 void *buf) 738 { 739 __qdf_mempool_free(osdev, pool, buf); 740 } 741 742 /** 743 * qdf_kmem_cache_create() - OS abstraction for cache creation 744 * @c: Cache name 745 * @z: Size of the object to be created 746 * 747 * Return: Cache address on successful creation, else NULL 748 */ 749 #ifdef QCA_KMEM_CACHE_SUPPORT 750 #define qdf_kmem_cache_create(c, z) __qdf_kmem_cache_create(c, z) 751 #else 752 #define qdf_kmem_cache_create(c, z) NULL 753 #endif 754 755 /** 756 * qdf_kmem_cache_destroy() - OS abstraction for cache destruction 757 * @cache: Cache pointer 758 * 759 * Return: void 760 */ 761 static inline void qdf_kmem_cache_destroy(qdf_kmem_cache_t cache) 762 { 763 __qdf_kmem_cache_destroy(cache); 764 } 765 766 /** 767 * qdf_kmem_cache_alloc() - Function to allocation object from a cache 768 * @cache: Cache address 769 * 770 * Return: Object from cache 771 * 772 */ 773 static inline void *qdf_kmem_cache_alloc(qdf_kmem_cache_t cache) 774 { 775 return __qdf_kmem_cache_alloc(cache); 776 } 777 778 /** 779 * qdf_kmem_cache_free() - Function to free cache object 780 * @cache: Cache address 781 * @node: Object to be returned to cache 782 * 783 * Return: void 784 */ 785 static inline void qdf_kmem_cache_free(qdf_kmem_cache_t cache, void *node) 786 { 787 __qdf_kmem_cache_free(cache, node); 788 } 789 790 /** 791 * qdf_mem_dma_sync_single_for_device() - assign memory to device 792 * @osdev: OS device handle 793 * @bus_addr: dma address to give to the device 794 * @size: Size of the memory block 795 * @direction: direction data will be DMAed 796 * 797 * Assign memory to the remote device. 798 * The cache lines are flushed to ram or invalidated as needed. 799 * 800 * Return: none 801 */ 802 void qdf_mem_dma_sync_single_for_device(qdf_device_t osdev, 803 qdf_dma_addr_t bus_addr, 804 qdf_size_t size, 805 __dma_data_direction direction); 806 807 /** 808 * qdf_mem_dma_sync_single_for_cpu() - assign memory to CPU 809 * @osdev: OS device handle 810 * @bus_addr: dma address to give to the cpu 811 * @size: Size of the memory block 812 * @direction: direction data will be DMAed 813 * 814 * Assign memory to the CPU. 815 * 816 * Return: none 817 */ 818 void qdf_mem_dma_sync_single_for_cpu(qdf_device_t osdev, 819 qdf_dma_addr_t bus_addr, 820 qdf_size_t size, 821 __dma_data_direction direction); 822 823 /** 824 * qdf_mem_multi_page_link() - Make links for multi page elements 825 * @osdev: OS device handle pointer 826 * @pages: Multi page information storage 827 * @elem_size: Single element size 828 * @elem_count: elements count should be linked 829 * @cacheable: Coherent memory or cacheable memory 830 * 831 * This function will make links for multi page allocated structure 832 * 833 * Return: 0 success 834 */ 835 int qdf_mem_multi_page_link(qdf_device_t osdev, 836 struct qdf_mem_multi_page_t *pages, 837 uint32_t elem_size, uint32_t elem_count, 838 uint8_t cacheable); 839 840 /** 841 * qdf_mem_kmalloc_inc() - increment kmalloc allocated bytes count 842 * @size: number of bytes to increment by 843 * 844 * Return: None 845 */ 846 void qdf_mem_kmalloc_inc(qdf_size_t size); 847 848 /** 849 * qdf_mem_kmalloc_dec() - decrement kmalloc allocated bytes count 850 * @size: number of bytes to decrement by 851 * 852 * Return: None 853 */ 854 void qdf_mem_kmalloc_dec(qdf_size_t size); 855 856 #ifdef CONFIG_WLAN_SYSFS_MEM_STATS 857 /** 858 * qdf_mem_skb_inc() - increment total skb allocation size 859 * @size: size to be added 860 * 861 * Return: none 862 */ 863 void qdf_mem_skb_inc(qdf_size_t size); 864 865 /** 866 * qdf_mem_skb_dec() - decrement total skb allocation size 867 * @size: size to be decremented 868 * 869 * Return: none 870 */ 871 void qdf_mem_skb_dec(qdf_size_t size); 872 873 /** 874 * qdf_mem_skb_total_inc() - increment total skb allocation size 875 * in host driver in both debug and perf builds 876 * @size: size to be added 877 * 878 * Return: none 879 */ 880 void qdf_mem_skb_total_inc(qdf_size_t size); 881 882 /** 883 * qdf_mem_skb_total_dec() - decrement total skb allocation size 884 * in the host driver in debug and perf flavors 885 * @size: size to be decremented 886 * 887 * Return: none 888 */ 889 void qdf_mem_skb_total_dec(qdf_size_t size); 890 891 /** 892 * qdf_mem_dp_tx_skb_inc() - Increment Tx skb allocation size 893 * @size: size to be added 894 * 895 * Return: none 896 */ 897 void qdf_mem_dp_tx_skb_inc(qdf_size_t size); 898 899 /** 900 * qdf_mem_dp_tx_skb_dec() - Decrement Tx skb allocation size 901 * @size: size to be decreased 902 * 903 * Return: none 904 */ 905 void qdf_mem_dp_tx_skb_dec(qdf_size_t size); 906 907 /** 908 * qdf_mem_dp_rx_skb_inc() - Increment Rx skb allocation size 909 * @size: size to be added 910 * 911 * Return: none 912 */ 913 void qdf_mem_dp_rx_skb_inc(qdf_size_t size); 914 915 /** 916 * qdf_mem_dp_rx_skb_dec() - Decrement Rx skb allocation size 917 * @size: size to be decreased 918 * 919 * Return: none 920 */ 921 void qdf_mem_dp_rx_skb_dec(qdf_size_t size); 922 923 /** 924 * qdf_mem_dp_tx_skb_cnt_inc() - Increment Tx buffer count 925 * 926 * Return: none 927 */ 928 void qdf_mem_dp_tx_skb_cnt_inc(void); 929 930 /** 931 * qdf_mem_dp_tx_skb_cnt_dec() - Decrement Tx buffer count 932 * 933 * Return: none 934 */ 935 void qdf_mem_dp_tx_skb_cnt_dec(void); 936 937 /** 938 * qdf_mem_dp_rx_skb_cnt_inc() - Increment Rx buffer count 939 * 940 * Return: none 941 */ 942 void qdf_mem_dp_rx_skb_cnt_inc(void); 943 944 /** 945 * qdf_mem_dp_rx_skb_cnt_dec() - Decrement Rx buffer count 946 * 947 * Return: none 948 */ 949 void qdf_mem_dp_rx_skb_cnt_dec(void); 950 #else 951 952 static inline void qdf_mem_skb_inc(qdf_size_t size) 953 { 954 } 955 956 static inline void qdf_mem_skb_dec(qdf_size_t size) 957 { 958 } 959 960 static inline void qdf_mem_skb_total_inc(qdf_size_t size) 961 { 962 } 963 964 static inline void qdf_mem_skb_total_dec(qdf_size_t size) 965 { 966 } 967 968 static inline void qdf_mem_dp_tx_skb_inc(qdf_size_t size) 969 { 970 } 971 972 static inline void qdf_mem_dp_tx_skb_dec(qdf_size_t size) 973 { 974 } 975 976 static inline void qdf_mem_dp_rx_skb_inc(qdf_size_t size) 977 { 978 } 979 980 static inline void qdf_mem_dp_rx_skb_dec(qdf_size_t size) 981 { 982 } 983 984 static inline void qdf_mem_dp_tx_skb_cnt_inc(void) 985 { 986 } 987 988 static inline void qdf_mem_dp_tx_skb_cnt_dec(void) 989 { 990 } 991 992 static inline void qdf_mem_dp_rx_skb_cnt_inc(void) 993 { 994 } 995 996 static inline void qdf_mem_dp_rx_skb_cnt_dec(void) 997 { 998 } 999 #endif /* CONFIG_WLAN_SYSFS_MEM_STATS */ 1000 1001 /** 1002 * qdf_mem_map_table_alloc() - Allocate shared memory info structure 1003 * @num: number of required storage 1004 * 1005 * Allocate mapping table for DMA memory allocation. This is needed for 1006 * IPA-WLAN buffer sharing when SMMU Stage1 Translation is enabled. 1007 * 1008 * Return: shared memory info storage table pointer 1009 */ 1010 static inline qdf_mem_info_t *qdf_mem_map_table_alloc(uint32_t num) 1011 { 1012 qdf_mem_info_t *mem_info_arr; 1013 1014 mem_info_arr = qdf_mem_malloc(num * sizeof(mem_info_arr[0])); 1015 return mem_info_arr; 1016 } 1017 1018 #ifdef ENHANCED_OS_ABSTRACTION 1019 /** 1020 * qdf_update_mem_map_table() - Update DMA memory map info 1021 * @osdev: Parent device instance 1022 * @mem_info: Pointer to shared memory information 1023 * @dma_addr: dma address 1024 * @mem_size: memory size allocated 1025 * 1026 * Store DMA shared memory information 1027 * 1028 * Return: none 1029 */ 1030 void qdf_update_mem_map_table(qdf_device_t osdev, 1031 qdf_mem_info_t *mem_info, 1032 qdf_dma_addr_t dma_addr, 1033 uint32_t mem_size); 1034 1035 /** 1036 * qdf_mem_paddr_from_dmaaddr() - get actual physical address from dma address 1037 * @osdev: Parent device instance 1038 * @dma_addr: DMA/IOVA address 1039 * 1040 * Get actual physical address from dma_addr based on SMMU enablement status. 1041 * IF SMMU Stage 1 translation is enabled, DMA APIs return IO virtual address 1042 * (IOVA) otherwise returns physical address. So get SMMU physical address 1043 * mapping from IOVA. 1044 * 1045 * Return: dmaable physical address 1046 */ 1047 qdf_dma_addr_t qdf_mem_paddr_from_dmaaddr(qdf_device_t osdev, 1048 qdf_dma_addr_t dma_addr); 1049 #else 1050 static inline 1051 void qdf_update_mem_map_table(qdf_device_t osdev, 1052 qdf_mem_info_t *mem_info, 1053 qdf_dma_addr_t dma_addr, 1054 uint32_t mem_size) 1055 { 1056 if (!mem_info) { 1057 qdf_nofl_err("%s: NULL mem_info", __func__); 1058 return; 1059 } 1060 1061 __qdf_update_mem_map_table(osdev, mem_info, dma_addr, mem_size); 1062 } 1063 1064 static inline 1065 qdf_dma_addr_t qdf_mem_paddr_from_dmaaddr(qdf_device_t osdev, 1066 qdf_dma_addr_t dma_addr) 1067 { 1068 return __qdf_mem_paddr_from_dmaaddr(osdev, dma_addr); 1069 } 1070 #endif 1071 1072 /** 1073 * qdf_mem_smmu_s1_enabled() - Return SMMU stage 1 translation enable status 1074 * @osdev: parent device instance 1075 * 1076 * Return: true if smmu s1 enabled, false if smmu s1 is bypassed 1077 */ 1078 static inline bool qdf_mem_smmu_s1_enabled(qdf_device_t osdev) 1079 { 1080 return __qdf_mem_smmu_s1_enabled(osdev); 1081 } 1082 1083 /** 1084 * qdf_mem_dma_get_sgtable() - Returns DMA memory scatter gather table 1085 * @dev: device instance 1086 * @sgt: scatter gather table pointer 1087 * @cpu_addr: HLOS virtual address 1088 * @dma_addr: dma address 1089 * @size: allocated memory size 1090 * 1091 * Return: physical address 1092 */ 1093 static inline int 1094 qdf_mem_dma_get_sgtable(struct device *dev, void *sgt, void *cpu_addr, 1095 qdf_dma_addr_t dma_addr, size_t size) 1096 { 1097 return __qdf_os_mem_dma_get_sgtable(dev, sgt, cpu_addr, dma_addr, size); 1098 } 1099 1100 /** 1101 * qdf_mem_free_sgtable() - Free a previously allocated sg table 1102 * @sgt: the mapped sg table header 1103 * 1104 * Return: None 1105 */ 1106 static inline void 1107 qdf_mem_free_sgtable(struct sg_table *sgt) 1108 { 1109 __qdf_os_mem_free_sgtable(sgt); 1110 } 1111 1112 /** 1113 * qdf_dma_get_sgtable_dma_addr() - Assigns DMA address to scatterlist elements 1114 * @sgt: scatter gather table pointer 1115 * 1116 * Return: None 1117 */ 1118 static inline void 1119 qdf_dma_get_sgtable_dma_addr(struct sg_table *sgt) 1120 { 1121 __qdf_dma_get_sgtable_dma_addr(sgt); 1122 } 1123 1124 /** 1125 * qdf_mem_get_dma_addr() - Return dma address based on SMMU translation status. 1126 * @osdev: Parent device instance 1127 * @mem_info: Pointer to allocated memory information 1128 * 1129 * Get dma address based on SMMU enablement status. If SMMU Stage 1 1130 * translation is enabled, DMA APIs return IO virtual address otherwise 1131 * returns physical address. 1132 * 1133 * Return: dma address 1134 */ 1135 static inline qdf_dma_addr_t qdf_mem_get_dma_addr(qdf_device_t osdev, 1136 qdf_mem_info_t *mem_info) 1137 { 1138 return __qdf_mem_get_dma_addr(osdev, mem_info); 1139 } 1140 1141 /** 1142 * qdf_mem_get_dma_addr_ptr() - Return DMA address pointer from mem info struct 1143 * @osdev: Parent device instance 1144 * @mem_info: Pointer to allocated memory information 1145 * 1146 * Based on smmu stage 1 translation enablement, return corresponding dma 1147 * address storage pointer. 1148 * 1149 * Return: dma address storage pointer 1150 */ 1151 static inline qdf_dma_addr_t *qdf_mem_get_dma_addr_ptr(qdf_device_t osdev, 1152 qdf_mem_info_t *mem_info) 1153 { 1154 return __qdf_mem_get_dma_addr_ptr(osdev, mem_info); 1155 } 1156 1157 1158 /** 1159 * qdf_mem_get_dma_size() - Return DMA memory size 1160 * @osdev: parent device instance 1161 * @mem_info: Pointer to allocated memory information 1162 * 1163 * Return: DMA memory size 1164 */ 1165 static inline uint32_t 1166 qdf_mem_get_dma_size(qdf_device_t osdev, 1167 qdf_mem_info_t *mem_info) 1168 { 1169 return __qdf_mem_get_dma_size(osdev, mem_info); 1170 } 1171 1172 /** 1173 * qdf_mem_set_dma_size() - Set DMA memory size 1174 * @osdev: parent device instance 1175 * @mem_info: Pointer to allocated memory information 1176 * @mem_size: memory size allocated 1177 * 1178 * Return: none 1179 */ 1180 static inline void 1181 qdf_mem_set_dma_size(qdf_device_t osdev, 1182 qdf_mem_info_t *mem_info, 1183 uint32_t mem_size) 1184 { 1185 __qdf_mem_set_dma_size(osdev, mem_info, mem_size); 1186 } 1187 1188 /** 1189 * qdf_mem_get_dma_pa() - Return DMA physical address 1190 * @osdev: parent device instance 1191 * @mem_info: Pointer to allocated memory information 1192 * 1193 * Return: DMA physical address 1194 */ 1195 static inline qdf_dma_addr_t 1196 qdf_mem_get_dma_pa(qdf_device_t osdev, 1197 qdf_mem_info_t *mem_info) 1198 { 1199 return __qdf_mem_get_dma_pa(osdev, mem_info); 1200 } 1201 1202 /** 1203 * qdf_mem_set_dma_pa() - Set DMA physical address 1204 * @osdev: parent device instance 1205 * @mem_info: Pointer to allocated memory information 1206 * @dma_pa: DMA phsical address 1207 * 1208 * Return: none 1209 */ 1210 static inline void 1211 qdf_mem_set_dma_pa(qdf_device_t osdev, 1212 qdf_mem_info_t *mem_info, 1213 qdf_dma_addr_t dma_pa) 1214 { 1215 __qdf_mem_set_dma_pa(osdev, mem_info, dma_pa); 1216 } 1217 1218 /** 1219 * qdf_mem_shared_mem_alloc() - Allocate DMA memory for shared resource 1220 * @osdev: parent device instance 1221 * @size: size to be allocated 1222 * 1223 * Allocate DMA memory which will be shared with external kernel module. This 1224 * information is needed for SMMU mapping. 1225 * 1226 * Return: Pointer to allocated DMA memory on success, NULL on failure 1227 */ 1228 qdf_shared_mem_t *qdf_mem_shared_mem_alloc(qdf_device_t osdev, uint32_t size); 1229 1230 #ifdef DP_UMAC_HW_RESET_SUPPORT 1231 /** 1232 * qdf_tx_desc_pool_free_bufs() - Go through elems and call the registered cb 1233 * @ctxt: Context to be passed to the cb 1234 * @pages: Multi page information storage 1235 * @elem_size: Each element size 1236 * @elem_count: Total number of elements in the pool. 1237 * @cacheable: Coherent memory or cacheable memory 1238 * @cb: Callback to free the elements 1239 * @elem_list: elem list for delayed free 1240 * 1241 * Return: 0 on Succscc, or Error code 1242 */ 1243 int qdf_tx_desc_pool_free_bufs(void *ctxt, struct qdf_mem_multi_page_t *pages, 1244 uint32_t elem_size, uint32_t elem_count, 1245 uint8_t cacheable, qdf_mem_release_cb cb, 1246 void *elem_list); 1247 #endif 1248 1249 /** 1250 * qdf_mem_shared_mem_free() - Free shared memory 1251 * @osdev: parent device instance 1252 * @shared_mem: shared memory information storage 1253 * 1254 * Free DMA shared memory resource 1255 * 1256 * Return: None 1257 */ 1258 static inline void qdf_mem_shared_mem_free(qdf_device_t osdev, 1259 qdf_shared_mem_t *shared_mem) 1260 { 1261 if (!shared_mem) { 1262 qdf_nofl_err("%s: NULL shared mem struct passed", 1263 __func__); 1264 return; 1265 } 1266 1267 if (shared_mem->vaddr) { 1268 qdf_mem_free_consistent(osdev, osdev->dev, 1269 qdf_mem_get_dma_size(osdev, 1270 &shared_mem->mem_info), 1271 shared_mem->vaddr, 1272 qdf_mem_get_dma_addr(osdev, 1273 &shared_mem->mem_info), 1274 qdf_get_dma_mem_context(shared_mem, 1275 memctx)); 1276 } 1277 qdf_mem_free_sgtable(&shared_mem->sgtable); 1278 qdf_mem_free(shared_mem); 1279 } 1280 1281 /** 1282 * qdf_dma_mem_stats_read() - Return the DMA memory allocated in 1283 * host driver 1284 * 1285 * Return: Total DMA memory allocated 1286 */ 1287 int32_t qdf_dma_mem_stats_read(void); 1288 1289 /** 1290 * qdf_heap_mem_stats_read() - Return the heap memory allocated 1291 * in host driver 1292 * 1293 * Return: Total heap memory allocated 1294 */ 1295 int32_t qdf_heap_mem_stats_read(void); 1296 1297 /** 1298 * qdf_skb_mem_stats_read() - Return the SKB memory allocated in 1299 * host driver 1300 * 1301 * Return: Total SKB memory allocated 1302 */ 1303 int32_t qdf_skb_mem_stats_read(void); 1304 1305 /** 1306 * qdf_skb_total_mem_stats_read() - Return the SKB memory allocated 1307 * in the host driver tracked in both debug and perf builds 1308 * 1309 * Return: Total SKB memory allocated 1310 */ 1311 int32_t qdf_skb_total_mem_stats_read(void); 1312 1313 /** 1314 * qdf_skb_max_mem_stats_read() - Return the max SKB memory 1315 * allocated in host driver. This is the high watermark for the 1316 * total SKB allocated in the host driver 1317 * 1318 * Return: None 1319 */ 1320 int32_t qdf_skb_max_mem_stats_read(void); 1321 1322 /** 1323 * qdf_mem_tx_desc_cnt_read() - Return the outstanding Tx descs 1324 * which are waiting on Tx completions 1325 * 1326 * Return: Outstanding Tx desc count 1327 */ 1328 int32_t qdf_mem_tx_desc_cnt_read(void); 1329 1330 /** 1331 * qdf_mem_tx_desc_max_read() - Return the max outstanding Tx 1332 * descs which are waiting on Tx completions. This is the high 1333 * watermark for the pending desc count 1334 * 1335 * Return: Max outstanding Tx desc count 1336 */ 1337 int32_t qdf_mem_tx_desc_max_read(void); 1338 1339 /** 1340 * qdf_mem_stats_init() - Initialize the qdf memstats fields on 1341 * creating the sysfs node 1342 * 1343 * Return: None 1344 */ 1345 void qdf_mem_stats_init(void); 1346 1347 /** 1348 * qdf_dp_tx_skb_mem_stats_read() - Return the SKB memory 1349 * allocated for Tx data path 1350 * 1351 * Return: Tx SKB memory allocated 1352 */ 1353 int32_t qdf_dp_tx_skb_mem_stats_read(void); 1354 1355 /** 1356 * qdf_dp_rx_skb_mem_stats_read() - Return the SKB memory 1357 * allocated for Rx data path 1358 * 1359 * Return: Rx SKB memory allocated 1360 */ 1361 int32_t qdf_dp_rx_skb_mem_stats_read(void); 1362 1363 /** 1364 * qdf_dp_tx_skb_max_mem_stats_read() - Return the high 1365 * watermark for the SKB memory allocated for Tx data path 1366 * 1367 * Return: Max Tx SKB memory allocated 1368 */ 1369 int32_t qdf_dp_tx_skb_max_mem_stats_read(void); 1370 1371 /** 1372 * qdf_dp_rx_skb_max_mem_stats_read() - Return the high 1373 * watermark for the SKB memory allocated for Rx data path 1374 * 1375 * Return: Max Rx SKB memory allocated 1376 */ 1377 int32_t qdf_dp_rx_skb_max_mem_stats_read(void); 1378 1379 /** 1380 * qdf_mem_dp_tx_skb_cnt_read() - Return number of buffers 1381 * allocated in the Tx data path by the host driver or 1382 * buffers coming from the n/w stack 1383 * 1384 * Return: Number of DP Tx buffers allocated 1385 */ 1386 int32_t qdf_mem_dp_tx_skb_cnt_read(void); 1387 1388 /** 1389 * qdf_mem_dp_tx_skb_max_cnt_read() - Return max number of 1390 * buffers allocated in the Tx data path 1391 * 1392 * Return: Max number of DP Tx buffers allocated 1393 */ 1394 int32_t qdf_mem_dp_tx_skb_max_cnt_read(void); 1395 1396 /** 1397 * qdf_mem_dp_rx_skb_cnt_read() - Return number of buffers 1398 * allocated in the Rx data path 1399 * 1400 * Return: Number of DP Rx buffers allocated 1401 */ 1402 int32_t qdf_mem_dp_rx_skb_cnt_read(void); 1403 1404 /** 1405 * qdf_mem_dp_rx_skb_max_cnt_read() - Return max number of 1406 * buffers allocated in the Rx data path 1407 * 1408 * Return: Max number of DP Rx buffers allocated 1409 */ 1410 int32_t qdf_mem_dp_rx_skb_max_cnt_read(void); 1411 1412 /** 1413 * qdf_mem_tx_desc_cnt_update() - Update the pending tx desc 1414 * count and the high watermark for pending tx desc count 1415 * 1416 * @pending_tx_descs: outstanding Tx desc count 1417 * @tx_descs_max: high watermark for outstanding Tx desc count 1418 * 1419 * Return: None 1420 */ 1421 void qdf_mem_tx_desc_cnt_update(qdf_atomic_t pending_tx_descs, 1422 int32_t tx_descs_max); 1423 1424 /** 1425 * qdf_mem_vfree() - Free the virtual memory pointed to by ptr 1426 * @ptr: Pointer to the starting address of the memory to 1427 * be freed. 1428 * 1429 * Return: None 1430 */ 1431 #define qdf_mem_vfree(ptr) __qdf_mem_vfree(ptr) 1432 1433 /** 1434 * qdf_mem_valloc() - Allocate virtual memory for the given 1435 * size 1436 * @size: Number of bytes of memory to be allocated 1437 * 1438 * Return: Pointer to the starting address of the allocated virtual memory 1439 */ 1440 #define qdf_mem_valloc(size) __qdf_mem_valloc(size, __func__, __LINE__) 1441 1442 #ifdef ENABLE_VALLOC_REPLACE_MALLOC 1443 /** 1444 * qdf_mem_common_alloc() - Common function to allocate memory for the 1445 * given size, allocation method decided by ENABLE_VALLOC_REPLACE_MALLOC 1446 * @size: Number of bytes of memory to be allocated 1447 * 1448 * Return: Pointer to the starting address of the allocated memory 1449 */ 1450 #define qdf_mem_common_alloc(size) qdf_mem_valloc(size) 1451 1452 /** 1453 * qdf_mem_common_free() - Common function to free the memory pointed 1454 * to by ptr, memory free method decided by ENABLE_VALLOC_REPLACE_MALLOC 1455 * @ptr: Pointer to the starting address of the memory to 1456 * be freed. 1457 * 1458 * Return: None 1459 */ 1460 #define qdf_mem_common_free(ptr) qdf_mem_vfree(ptr) 1461 #else 1462 #define qdf_mem_common_alloc(size) qdf_mem_malloc(size) 1463 #define qdf_mem_common_free(ptr) qdf_mem_free(ptr) 1464 #endif 1465 1466 /** 1467 * qdf_ioremap() - map bus memory into cpu space 1468 * @HOST_CE_ADDRESS: bus address of the memory 1469 * @HOST_CE_SIZE: memory size to map 1470 */ 1471 #define qdf_ioremap(HOST_CE_ADDRESS, HOST_CE_SIZE) \ 1472 __qdf_ioremap(HOST_CE_ADDRESS, HOST_CE_SIZE) 1473 1474 #if IS_ENABLED(CONFIG_ARM_SMMU) && defined(ENABLE_SMMU_S1_TRANSLATION) 1475 /* 1476 * typedef qdf_iommu_domain_t: Platform independent iommu domain 1477 * abstraction 1478 */ 1479 typedef __qdf_iommu_domain_t qdf_iommu_domain_t; 1480 1481 /** 1482 * qdf_iommu_domain_get_attr() - API to get iommu domain attributes 1483 * @domain: iommu domain 1484 * @attr: iommu attribute 1485 * @data: data pointer 1486 * 1487 * Return: 0 on success, else errno 1488 */ 1489 int 1490 qdf_iommu_domain_get_attr(qdf_iommu_domain_t *domain, 1491 enum qdf_iommu_attr attr, void *data); 1492 #endif 1493 1494 #define DEFAULT_DEBUG_DOMAIN_INIT 0 1495 #ifdef QCA_DMA_PADDR_CHECK 1496 /** 1497 * qdf_dma_invalid_buf_list_init() - Initialize dma invalid buffer list 1498 * 1499 * Return: none 1500 */ 1501 void qdf_dma_invalid_buf_list_init(void); 1502 1503 /** 1504 * qdf_dma_invalid_buf_list_deinit() - Deinitialize dma invalid buffer list 1505 * 1506 * Return: none 1507 */ 1508 void qdf_dma_invalid_buf_list_deinit(void); 1509 1510 /** 1511 * qdf_dma_invalid_buf_free() - Free dma invalid buffer 1512 * @dev: Pointer to device handle 1513 * @domain: Debug domain 1514 * 1515 * Return: none 1516 */ 1517 void qdf_dma_invalid_buf_free(void *dev, uint8_t domain); 1518 #else 1519 static inline void 1520 qdf_dma_invalid_buf_list_init(void) 1521 { 1522 } 1523 1524 static inline void 1525 qdf_dma_invalid_buf_list_deinit(void) 1526 { 1527 } 1528 1529 static inline void 1530 qdf_dma_invalid_buf_free(void *dev, uint8_t domain) 1531 { 1532 } 1533 #endif /* QCA_DMA_PADDR_CHECK */ 1534 #endif /* __QDF_MEMORY_H */ 1535