1 /* 2 * Copyright (c) 2020 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022-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_nbuf_frag.h 22 * This file defines the nbuf frag abstraction. 23 */ 24 25 #ifndef _QDF_NBUF_FRAG_H 26 #define _QDF_NBUF_FRAG_H 27 28 #include <qdf_util.h> 29 #include <i_qdf_trace.h> 30 #include <i_qdf_nbuf_frag.h> 31 32 /* 33 * typedef qdf_frag_cache_t - Platform independent 34 * frag cache abstraction 35 */ 36 typedef __qdf_frag_cache_t qdf_frag_cache_t; 37 38 /* 39 * typedef qdf_frag_t - Platform independent frag address abstraction 40 */ 41 typedef __qdf_frag_t qdf_frag_t; 42 43 /* 44 * Maximum number of frags an SKB can hold 45 */ 46 #define QDF_NBUF_MAX_FRAGS __QDF_NBUF_MAX_FRAGS 47 48 #ifdef NBUF_FRAG_MEMORY_DEBUG 49 /** 50 * qdf_frag_debug_init() - Initialize frag debug tracker 51 * 52 * Return: none 53 */ 54 void qdf_frag_debug_init(void); 55 56 /** 57 * qdf_frag_debug_exit() - Exit network frag debug functionality 58 * 59 * Exit network frag tracking debug functionality and log frag memory leaks 60 * 61 * Return: none 62 */ 63 void qdf_frag_debug_exit(void); 64 65 /** 66 * qdf_frag_debug_add_node() - Add frag node in the debug hash table 67 * @fragp: Pointer to frag 68 * @func_name: Caller function name 69 * @line_num: Caller function line no. 70 * 71 * Return: none 72 */ 73 void qdf_frag_debug_add_node(qdf_frag_t fragp, const char *func_name, 74 uint32_t line_num); 75 76 /** 77 * qdf_frag_debug_refcount_inc() - Increment refcount for frag node 78 * @fragp: Pointer to frag 79 * @func_name: Caller function name 80 * @line_num: Caller function line no. 81 * 82 * Return: none 83 */ 84 void qdf_frag_debug_refcount_inc(qdf_frag_t fragp, const char *func_name, 85 uint32_t line_num); 86 87 /** 88 * qdf_frag_debug_refcount_dec() - Decrement refcount for frag node 89 * @fragp: Pointer to frag 90 * @func_name: Caller function name 91 * @line_num: Caller function line no. 92 * 93 * Return: none 94 */ 95 void qdf_frag_debug_refcount_dec(qdf_frag_t fragp, const char *func_name, 96 uint32_t line_num); 97 98 /** 99 * qdf_frag_debug_delete_node() - Remove frag node from debug hash table 100 * @fragp: Pointer to frag 101 * @func_name: Caller function name 102 * @line_num: Caller function line no. 103 * 104 * Return: none 105 */ 106 void qdf_frag_debug_delete_node(qdf_frag_t fragp, const char *func_name, 107 uint32_t line_num); 108 109 /** 110 * qdf_frag_debug_update_addr() - Update frag address in debug tracker 111 * @p_fragp: Previous frag address 112 * @n_fragp: New frag address 113 * @func_name: Caller function name 114 * @line_num: Caller function line no. 115 * 116 * Return: none 117 */ 118 void qdf_frag_debug_update_addr(qdf_frag_t p_fragp, qdf_frag_t n_fragp, 119 const char *func_name, uint32_t line_num); 120 121 #define qdf_frag_alloc(p, s) \ 122 qdf_frag_alloc_debug(p, s, __func__, __LINE__) 123 124 /** 125 * qdf_frag_alloc_debug() - Allocate frag memory 126 * @pf_cache: page frag cache 127 * @fragsz: Size of frag memory to be allocated 128 * @func_name: Caller function name 129 * @line_num: Caller function line no. 130 * 131 * Return: Allocated frag address 132 */ 133 qdf_frag_t qdf_frag_alloc_debug(qdf_frag_cache_t *pf_cache, 134 unsigned int fragsz, 135 const char *func_name, 136 uint32_t line_num); 137 138 #define qdf_frag_free(p) \ 139 qdf_frag_free_debug(p, __func__, __LINE__) 140 141 /** 142 * qdf_frag_free_debug() - Free allocated frag memory 143 * @vaddr: Frag address to be freed 144 * @func_name: Caller function name 145 * @line_num: Caller function line no. 146 * 147 * Return: none 148 */ 149 void qdf_frag_free_debug(qdf_frag_t vaddr, const char *func_name, 150 uint32_t line_num); 151 152 #else /* NBUF_FRAG_MEMORY_DEBUG */ 153 154 static inline void qdf_frag_debug_init(void) 155 { 156 } 157 158 static inline void qdf_frag_debug_exit(void) 159 { 160 } 161 162 static inline void qdf_frag_debug_add_node(qdf_frag_t fragp, 163 const char *func_name, 164 uint32_t line_num) 165 { 166 } 167 168 static inline void qdf_frag_debug_refcount_inc(qdf_frag_t fragp, 169 const char *func_name, 170 uint32_t line_num) 171 { 172 } 173 174 static inline void qdf_frag_debug_refcount_dec(qdf_frag_t fragp, 175 const char *func_name, 176 uint32_t line_num) 177 { 178 } 179 180 static inline void qdf_frag_debug_delete_node(qdf_frag_t fragp, 181 const char *func_name, 182 uint32_t line_num) 183 { 184 } 185 186 static inline void qdf_frag_debug_update_addr(qdf_frag_t p_fragp, 187 qdf_frag_t n_fragp, 188 const char *func_name, 189 uint32_t line_num) 190 { 191 } 192 193 /** 194 * qdf_frag_alloc() - Allocate frag memory 195 * @pf_cache: page frag cache 196 * @fragsz: Size of frag memory to be allocated 197 * 198 * Return: Allocated frag address 199 */ 200 static inline qdf_frag_t qdf_frag_alloc(qdf_frag_cache_t *pf_cache, 201 unsigned int fragsz) 202 { 203 return __qdf_frag_alloc(pf_cache, fragsz); 204 } 205 206 /** 207 * qdf_frag_free() - Free allocated frag memory 208 * @vaddr: Frag address to be freed 209 * 210 * Return: none 211 */ 212 static inline void qdf_frag_free(qdf_frag_t vaddr) 213 { 214 __qdf_frag_free(vaddr); 215 } 216 217 #endif /* NBUF_FRAG_MEMORY_DEBUG */ 218 219 /** 220 * qdf_frag_count_get() - Get global frag gauge 221 * 222 * Return: Global frag gauge 223 */ 224 static inline uint32_t qdf_frag_count_get(void) 225 { 226 return __qdf_frag_count_get(); 227 } 228 229 /** 230 * qdf_frag_count_inc() - Increment global frag count 231 * @value: Increment value 232 * 233 * Return: none 234 */ 235 static inline void qdf_frag_count_inc(uint32_t value) 236 { 237 return __qdf_frag_count_inc(value); 238 } 239 240 /** 241 * qdf_frag_count_dec() - Decrement global frag count 242 * @value: Decrement value 243 * 244 * Return: none 245 */ 246 static inline void qdf_frag_count_dec(uint32_t value) 247 { 248 return __qdf_frag_count_dec(value); 249 } 250 251 /** 252 * qdf_frag_mod_init() - Initialization routine for qdf_frag 253 * 254 * Return: none 255 */ 256 static inline void qdf_frag_mod_init(void) 257 { 258 return __qdf_frag_mod_init(); 259 } 260 261 /** 262 * qdf_frag_mod_exit() - Unintialization routine for qdf_frag 263 * 264 * Return: none 265 */ 266 static inline void qdf_frag_mod_exit(void) 267 { 268 return __qdf_frag_mod_exit(); 269 } 270 271 /** 272 * qdf_mem_map_page() - Map Page 273 * @osdev: qdf_device_t 274 * @buf: Virtual page address to be mapped 275 * @dir: qdf_dma_dir_t 276 * @nbytes: Size of memory to be mapped 277 * @phy_addr: Corresponding mapped physical address 278 * 279 * Return: QDF_STATUS 280 */ 281 static inline QDF_STATUS qdf_mem_map_page(qdf_device_t osdev, qdf_frag_t buf, 282 qdf_dma_dir_t dir, size_t nbytes, 283 qdf_dma_addr_t *phy_addr) 284 { 285 return __qdf_mem_map_page(osdev, buf, dir, nbytes, phy_addr); 286 } 287 288 /** 289 * qdf_mem_unmap_page() - Unmap Page 290 * @osdev: qdf_device_t 291 * @paddr: Physical memory to be unmapped 292 * @nbytes: Size of memory to be unmapped 293 * @dir: qdf_dma_dir_t 294 */ 295 static inline void qdf_mem_unmap_page(qdf_device_t osdev, qdf_dma_addr_t paddr, 296 size_t nbytes, qdf_dma_dir_t dir) 297 { 298 __qdf_mem_unmap_page(osdev, paddr, nbytes, dir); 299 } 300 301 /* 302 * qdf_frag_cache_drain() - Drain page frag cache 303 * 304 * @pf_cache: page frag cache 305 * 306 * Return: void 307 */ 308 static inline void qdf_frag_cache_drain(qdf_frag_cache_t *pf_cache) 309 { 310 __qdf_frag_cache_drain(pf_cache); 311 } 312 #endif /* _QDF_NBUF_FRAG_H */ 313