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_util.h 22 * This file defines utility functions. 23 */ 24 25 #ifndef _QDF_UTIL_H 26 #define _QDF_UTIL_H 27 28 #include <i_qdf_util.h> 29 30 #ifdef QCA_CONFIG_SMP 31 #define QDF_MAX_AVAILABLE_CPU NR_CPUS 32 #else 33 #define QDF_MAX_AVAILABLE_CPU 1 34 #endif 35 36 typedef __qdf_wait_queue_head_t qdf_wait_queue_head_t; 37 38 /** 39 * qdf_unlikely - Compiler-dependent macro denoting code unlikely to execute 40 * @_expr: expression to be checked 41 */ 42 #define qdf_unlikely(_expr) __qdf_unlikely(_expr) 43 44 /** 45 * qdf_likely - Compiler-dependent macro denoting code likely to execute 46 * @_expr: expression to be checked 47 */ 48 #define qdf_likely(_expr) __qdf_likely(_expr) 49 50 /** 51 * qdf_wmb - write memory barrier. 52 */ 53 #define qdf_wmb() __qdf_wmb() 54 55 /** 56 * qdf_rmb - read memory barrier. 57 */ 58 #define qdf_rmb() __qdf_rmb() 59 60 /** 61 * qdf_mb - read + write memory barrier. 62 */ 63 #define qdf_mb() __qdf_mb() 64 65 /** 66 * qdf_ioread32 - read a register 67 * @offset: register address 68 */ 69 #define qdf_ioread32(offset) __qdf_ioread32(offset) 70 71 /** 72 * qdf_iowrite32 - write a register 73 * @offset: register address 74 * @value: value to write (32bit value) 75 */ 76 #define qdf_iowrite32(offset, value) __qdf_iowrite32(offset, value) 77 78 /** 79 * qdf_assert - assert "expr" evaluates to false. 80 * @expr: expression to test 81 */ 82 #ifdef QDF_DEBUG 83 #define qdf_assert(expr) __qdf_assert(expr) 84 #else 85 #define qdf_assert(expr) 86 #endif /* QDF_DEBUG */ 87 88 /** 89 * qdf_assert_always - always assert "expr" evaluates to false. 90 * @expr: expression to test 91 */ 92 #define qdf_assert_always(expr) __qdf_assert(expr) 93 94 /** 95 * qdf_assert_with_debug - invoke function to dump needed info before assert 96 * @expr: expression to test 97 * @debug_fp: function pointer to be invoked for debugging 98 */ 99 #define qdf_assert_with_debug(expr, debug_fp, ...) \ 100 __qdf_assert_with_debug(expr, debug_fp, ...) 101 102 /** 103 * qdf_target_assert_always - always target assert "expr" evaluates to false. 104 * @expr: expression to test 105 */ 106 #define qdf_target_assert_always(expr) __qdf_target_assert(expr) 107 108 #define QDF_SET_PARAM(__param, __val) ((__param) |= (1 << (__val))) 109 #define QDF_HAS_PARAM(__param, __val) ((__param) & (1 << (__val))) 110 #define QDF_CLEAR_PARAM(__param, __val) ((__param) &= (~(1 << (__val)))) 111 112 /** 113 * QDF_MAX - get maximum of two values 114 * @_x: 1st argument 115 * @_y: 2nd argument 116 */ 117 #define QDF_MAX(_x, _y) (((_x) > (_y)) ? (_x) : (_y)) 118 119 /** 120 * QDF_MIN - get minimum of two values 121 * @_x: 1st argument 122 * @_y: 2nd argument 123 */ 124 #define QDF_MIN(_x, _y) (((_x) < (_y)) ? (_x) : (_y)) 125 126 /** 127 * QDF_IS_ADDR_BROADCAST - is mac address broadcast mac address 128 * @_a: pointer to mac address 129 */ 130 #define QDF_IS_ADDR_BROADCAST(_a) \ 131 ((_a)[0] == 0xff && \ 132 (_a)[1] == 0xff && \ 133 (_a)[2] == 0xff && \ 134 (_a)[3] == 0xff && \ 135 (_a)[4] == 0xff && \ 136 (_a)[5] == 0xff) 137 138 /** 139 * QDF_IS_LAST_3_BYTES_OF_MAC_SAME - check the last 3 bytes 140 * same or not for two mac addresses 141 * @mac1: mac address 1 142 * @mac2: mac address 2 143 */ 144 #define QDF_IS_LAST_3_BYTES_OF_MAC_SAME(mac1, mac2) \ 145 ((mac1)->bytes[3] == (mac2)->bytes[3] && \ 146 (mac1)->bytes[4] == (mac2)->bytes[4] && \ 147 (mac1)->bytes[5] == (mac2)->bytes[5]) 148 149 /* Get number of bits from the index bit */ 150 #define QDF_GET_BITS(_val, _index, _num_bits) \ 151 (((_val) >> (_index)) & ((1 << (_num_bits)) - 1)) 152 153 /* Set val to number of bits from the index bit */ 154 #define QDF_SET_BITS(_var, _index, _num_bits, _val) do { \ 155 (_var) &= ~(((1 << (_num_bits)) - 1) << (_index)); \ 156 (_var) |= (((_val) & ((1 << (_num_bits)) - 1)) << (_index)); \ 157 } while (0) 158 159 #define QDF_SET_BITS64(_var, _tmp, _index, _num_bits, _val) do { \ 160 (_var) = (((_var) & 0xffffffff00000000) >> 32); \ 161 (_var) &= ~(((1 << (_num_bits)) - 1) << ((_index) - 32)); \ 162 (_var) |= (((_val) & ((1 << (_num_bits)) - 1)) << ((_index) - 32)); \ 163 (_var) = (((_var) & 0x00000000ffffffff) << 32); \ 164 (_var) |= ((_tmp) & 0x00000000ffffffff); \ 165 } while (0) 166 167 /* Get number of bits from the index bit supporting 64 bits */ 168 #define QDF_GET_BITS64(_val, _index, _num_bits) \ 169 (((_val) >> (_index)) & ((1LLU << (_num_bits)) - 1)) 170 171 #define QDF_DECLARE_EWMA(name, factor, weight) \ 172 __QDF_DECLARE_EWMA(name, factor, weight) 173 174 #define qdf_ewma_tx_lag __qdf_ewma_tx_lag 175 176 #define qdf_ewma_tx_lag_init(tx_lag) \ 177 __qdf_ewma_tx_lag_init(tx_lag) 178 179 #define qdf_ewma_tx_lag_add(tx_lag, value) \ 180 __qdf_ewma_tx_lag_add(tx_lag, value) 181 182 #define qdf_ewma_tx_lag_read(tx_lag) \ 183 __qdf_ewma_tx_lag_read(tx_lag) 184 185 #define qdf_ewma_rx_rssi __qdf_ewma_rx_rssi 186 187 #define qdf_ewma_rx_rssi_init(rx_rssi) \ 188 __qdf_ewma_rx_rssi_init(rx_rssi) 189 190 #define qdf_ewma_rx_rssi_add(rx_rssi, value) \ 191 __qdf_ewma_rx_rssi_add(rx_rssi, value) 192 193 #define qdf_ewma_rx_rssi_read(rx_rssi) \ 194 __qdf_ewma_rx_rssi_read(rx_rssi) 195 196 #define QDF_CHAR_BIT 8 197 198 /** 199 * qdf_bitmap - Define a bitmap 200 * @name: name of the bitmap 201 * @bits: num of bits in the bitmap 202 * 203 * Return: none 204 */ 205 #define qdf_bitmap(name, bits) __qdf_bitmap(name, bits) 206 207 /** 208 * qdf_set_bit() - set bit in address 209 * @nr: bit number to be set 210 * @addr: address buffer pointer 211 * 212 * Return: none 213 */ 214 #define qdf_set_bit(nr, addr) __qdf_set_bit(nr, addr) 215 216 /** 217 * qdf_clear_bit() - clear bit in address 218 * @nr: bit number to be clear 219 * @addr: address buffer pointer 220 * 221 * Return: none 222 */ 223 #define qdf_clear_bit(nr, addr) __qdf_clear_bit(nr, addr) 224 225 /** 226 * qdf_test_bit() - test bit position in address 227 * @nr: bit number to be tested 228 * @addr: address buffer pointer 229 * 230 * Return: none 231 */ 232 #define qdf_test_bit(nr, addr) __qdf_test_bit(nr, addr) 233 234 /** 235 * qdf_test_and_clear_bit() - test and clear bit position in address 236 * @nr: bit number to be tested 237 * @addr: address buffer pointer 238 * 239 * Return: none 240 */ 241 #define qdf_test_and_clear_bit(nr, addr) __qdf_test_and_clear_bit(nr, addr) 242 243 /** 244 * qdf_find_first_bit() - find first bit position in address 245 * @addr: address buffer pointer 246 * @nbits: number of bits 247 * 248 * Return: position first set bit in addr 249 */ 250 #define qdf_find_first_bit(addr, nbits) __qdf_find_first_bit(addr, nbits) 251 252 /** 253 * qdf_bitmap_empty() - Check if bitmap is empty 254 * @addr: Address buffer pointer 255 * @nbits: Number of bits 256 * 257 * Return: True if no bit set, else false 258 */ 259 #define qdf_bitmap_empty(addr, nbits) __qdf_bitmap_empty(addr, nbits) 260 261 /** 262 * qdf_bitmap_and() - AND operation on the bitmap 263 * @dst: Destination buffer pointer 264 * @src1: First source buffer pointer 265 * @src2: Second source buffer pointer 266 * @nbits: Number of bits 267 * 268 * Return: Bitwise and of src1 and src2 in dst 269 */ 270 #define qdf_bitmap_and(dst, src1, src2, nbits) \ 271 __qdf_bitmap_and(dst, src1, src2, nbits) 272 273 #define qdf_wait_queue_interruptible(wait_queue, condition) \ 274 __qdf_wait_queue_interruptible(wait_queue, condition) 275 276 /** 277 * qdf_wait_queue_timeout() - wait for specified time on given condition 278 * @wait_queue: wait queue to wait on 279 * @condition: condition to wait on 280 * @timeout: timeout value in jiffies 281 * 282 * Return: 0 if condition becomes false after timeout 283 * 1 or remaining jiffies, if condition becomes true during timeout 284 */ 285 #define qdf_wait_queue_timeout(wait_queue, condition, timeout) \ 286 __qdf_wait_queue_timeout(wait_queue, \ 287 condition, timeout) 288 289 290 #define qdf_init_waitqueue_head(_q) __qdf_init_waitqueue_head(_q) 291 292 #define qdf_wake_up_interruptible(_q) __qdf_wake_up_interruptible(_q) 293 294 /** 295 * qdf_wake_up() - wakes up sleeping waitqueue 296 * @_q: wait queue, which needs wake up 297 * 298 * Return: none 299 */ 300 #define qdf_wake_up(_q) __qdf_wake_up(_q) 301 302 #define qdf_wake_up_completion(_q) __qdf_wake_up_completion(_q) 303 304 /** 305 * qdf_container_of() - cast a member of a structure out to the containing 306 * structure 307 * @ptr: the pointer to the member. 308 * @type: the type of the container struct this is embedded in. 309 * @member: the name of the member within the struct. 310 */ 311 #define qdf_container_of(ptr, type, member) \ 312 __qdf_container_of(ptr, type, member) 313 314 /** 315 * QDF_IS_PWR2() - test input value is power of 2 integer 316 * @value: input integer 317 */ 318 #define QDF_IS_PWR2(value) (((value) ^ ((value)-1)) == ((value) << 1) - 1) 319 320 /** 321 * qdf_roundup() - roundup the input value 322 * @x: value to roundup 323 * @y: input value rounded to multiple of this 324 * 325 * Return: rounded value 326 */ 327 #define qdf_roundup(x, y) __qdf_roundup(x, y) 328 329 /** 330 * qdf_ceil() - roundup of x/y 331 * @x: dividend 332 * @y: divisor 333 * 334 * Return: rounded value 335 */ 336 #define qdf_ceil(x, y) __qdf_ceil(x, y) 337 338 /** 339 * qdf_in_interrupt - returns true if in interrupt context 340 */ 341 #define qdf_in_interrupt __qdf_in_interrupt 342 343 /** 344 * qdf_is_macaddr_equal() - compare two QDF MacAddress 345 * @mac_addr1: Pointer to one qdf MacAddress to compare 346 * @mac_addr2: Pointer to the other qdf MacAddress to compare 347 * 348 * This function returns a bool that tells if a two QDF MacAddress' 349 * are equivalent. 350 * 351 * Return: true if the MacAddress's are equal 352 * not true if the MacAddress's are not equal 353 */ qdf_is_macaddr_equal(const struct qdf_mac_addr * mac_addr1,const struct qdf_mac_addr * mac_addr2)354 static inline bool qdf_is_macaddr_equal(const struct qdf_mac_addr *mac_addr1, 355 const struct qdf_mac_addr *mac_addr2) 356 { 357 return __qdf_is_macaddr_equal(mac_addr1, mac_addr2); 358 } 359 360 361 /** 362 * qdf_is_macaddr_zero() - check for a MacAddress of all zeros. 363 * @mac_addr: pointer to the struct qdf_mac_addr to check. 364 * 365 * This function returns a bool that tells if a MacAddress is made up of 366 * all zeros. 367 * 368 * Return: true if the MacAddress is all Zeros 369 * false if the MacAddress is not all Zeros. 370 */ qdf_is_macaddr_zero(const struct qdf_mac_addr * mac_addr)371 static inline bool qdf_is_macaddr_zero(const struct qdf_mac_addr *mac_addr) 372 { 373 struct qdf_mac_addr zero_mac_addr = QDF_MAC_ADDR_ZERO_INIT; 374 375 return qdf_is_macaddr_equal(mac_addr, &zero_mac_addr); 376 } 377 378 /** 379 * qdf_zero_macaddr() - zero out a MacAddress 380 * @mac_addr: pointer to the struct qdf_mac_addr to zero. 381 * 382 * This function zeros out a QDF MacAddress type. 383 * 384 * Return: none 385 */ qdf_zero_macaddr(struct qdf_mac_addr * mac_addr)386 static inline void qdf_zero_macaddr(struct qdf_mac_addr *mac_addr) 387 { 388 __qdf_zero_macaddr(mac_addr); 389 } 390 391 392 /** 393 * qdf_is_macaddr_group() - check for a MacAddress is a 'group' address 394 * @mac_addr: pointer to the qdf MacAddress to check 395 * 396 * This function returns a bool that tells if a the input QDF MacAddress 397 * is a "group" address. Group addresses have the 'group address bit' turned 398 * on in the MacAddress. Group addresses are made up of Broadcast and 399 * Multicast addresses. 400 * 401 * Return: true if the input MacAddress is a Group address 402 * false if the input MacAddress is not a Group address 403 */ qdf_is_macaddr_group(struct qdf_mac_addr * mac_addr)404 static inline bool qdf_is_macaddr_group(struct qdf_mac_addr *mac_addr) 405 { 406 return mac_addr->bytes[0] & 0x01; 407 } 408 409 410 /** 411 * qdf_is_macaddr_broadcast() - check for a MacAddress is a broadcast address 412 * @mac_addr: Pointer to the qdf MacAddress to check 413 * 414 * This function returns a bool that tells if a the input QDF MacAddress 415 * is a "broadcast" address. 416 * 417 * Return: true if the input MacAddress is a broadcast address 418 * flase if the input MacAddress is not a broadcast address 419 */ qdf_is_macaddr_broadcast(const struct qdf_mac_addr * mac_addr)420 static inline bool qdf_is_macaddr_broadcast(const struct qdf_mac_addr *mac_addr) 421 { 422 struct qdf_mac_addr broadcast_mac_addr = QDF_MAC_ADDR_BCAST_INIT; 423 return qdf_is_macaddr_equal(mac_addr, &broadcast_mac_addr); 424 } 425 426 /** 427 * qdf_copy_macaddr() - copy a QDF MacAddress 428 * @dst_addr: pointer to the qdf MacAddress to copy TO (the destination) 429 * @src_addr: pointer to the qdf MacAddress to copy FROM (the source) 430 * 431 * This function copies a QDF MacAddress into another QDF MacAddress. 432 * 433 * Return: none 434 */ qdf_copy_macaddr(struct qdf_mac_addr * dst_addr,const struct qdf_mac_addr * src_addr)435 static inline void qdf_copy_macaddr(struct qdf_mac_addr *dst_addr, 436 const struct qdf_mac_addr *src_addr) 437 { 438 *dst_addr = *src_addr; 439 } 440 441 /** 442 * qdf_set_macaddr_broadcast() - set a QDF MacAddress to the 'broadcast' 443 * @mac_addr: pointer to the qdf MacAddress to set to broadcast 444 * 445 * This function sets a QDF MacAddress to the 'broadcast' MacAddress. Broadcast 446 * MacAddress contains all 0xFF bytes. 447 * 448 * Return: none 449 */ qdf_set_macaddr_broadcast(struct qdf_mac_addr * mac_addr)450 static inline void qdf_set_macaddr_broadcast(struct qdf_mac_addr *mac_addr) 451 { 452 __qdf_set_macaddr_broadcast(mac_addr); 453 } 454 455 /** 456 * qdf_set_u16() - Assign 16-bit unsigned value to a byte array base on CPU's 457 * endianness. 458 * @ptr: Starting address of a byte array 459 * @value: The value to assign to the byte array 460 * 461 * Caller must validate the byte array has enough space to hold the value 462 * 463 * Return: The address to the byte after the assignment. This may or may not 464 * be valid. Caller to verify. 465 */ qdf_set_u16(uint8_t * ptr,uint16_t value)466 static inline uint8_t *qdf_set_u16(uint8_t *ptr, uint16_t value) 467 { 468 #if defined(ANI_BIG_BYTE_ENDIAN) 469 *(ptr) = (uint8_t) (value >> 8); 470 *(ptr + 1) = (uint8_t) (value); 471 #else 472 *(ptr + 1) = (uint8_t) (value >> 8); 473 *(ptr) = (uint8_t) (value); 474 #endif 475 return ptr + 2; 476 } 477 478 /** 479 * qdf_get_u16() - Retrieve a 16-bit unsigned value from a byte array base on 480 * CPU's endianness. 481 * @ptr: Starting address of a byte array 482 * @value: Pointer to a caller allocated buffer for 16 bit value. Value is to 483 * assign to this location. 484 * 485 * Caller must validate the byte array has enough space to hold the value 486 * 487 * Return: The address to the byte after the assignment. This may or may not 488 * be valid. Caller to verify. 489 */ qdf_get_u16(uint8_t * ptr,uint16_t * value)490 static inline uint8_t *qdf_get_u16(uint8_t *ptr, uint16_t *value) 491 { 492 #if defined(ANI_BIG_BYTE_ENDIAN) 493 *value = (((uint16_t) (*ptr << 8)) | ((uint16_t) (*(ptr + 1)))); 494 #else 495 *value = (((uint16_t) (*(ptr + 1) << 8)) | ((uint16_t) (*ptr))); 496 #endif 497 return ptr + 2; 498 } 499 500 /** 501 * qdf_get_u32() - retrieve a 32-bit unsigned value from a byte array base on 502 * CPU's endianness. 503 * @ptr: Starting address of a byte array 504 * @value: Pointer to a caller allocated buffer for 32 bit value. Value is to 505 * assign to this location. 506 * 507 * Caller must validate the byte array has enough space to hold the value 508 * 509 * Return: The address to the byte after the assignment. This may or may not 510 * be valid. Caller to verify. 511 */ qdf_get_u32(uint8_t * ptr,uint32_t * value)512 static inline uint8_t *qdf_get_u32(uint8_t *ptr, uint32_t *value) 513 { 514 #if defined(ANI_BIG_BYTE_ENDIAN) 515 *value = ((uint32_t) (*(ptr) << 24) | 516 (uint32_t) (*(ptr + 1) << 16) | 517 (uint32_t) (*(ptr + 2) << 8) | (uint32_t) (*(ptr + 3))); 518 #else 519 *value = ((uint32_t) (*(ptr + 3) << 24) | 520 (uint32_t) (*(ptr + 2) << 16) | 521 (uint32_t) (*(ptr + 1) << 8) | (uint32_t) (*(ptr))); 522 #endif 523 return ptr + 4; 524 } 525 526 /** 527 * qdf_abs() - Get absolute value 528 * @x: value to be converted 529 */ 530 #define qdf_abs(x) __qdf_abs(x) 531 532 /** 533 * qdf_ntohs() - Convert a 16-bit value from network byte order to host byte order 534 * @x: value to be converted 535 */ 536 #define qdf_ntohs(x) __qdf_ntohs(x) 537 538 /** 539 * qdf_ntohl() - Convert a 32-bit value from network byte order to host byte order 540 * @x: value to be converted 541 */ 542 #define qdf_ntohl(x) __qdf_ntohl(x) 543 544 /** 545 * qdf_htons() - Convert a 16-bit value from host byte order to network byte order 546 * @x: value to be converted 547 */ 548 #define qdf_htons(x) __qdf_htons(x) 549 550 /** 551 * qdf_htonl() - Convert a 32-bit value from host byte order to network byte order 552 * @x: value to be converted 553 */ 554 #define qdf_htonl(x) __qdf_htonl(x) 555 556 /** 557 * qdf_cpu_to_le16() - Convert a 16-bit value from CPU byte order to 558 * little-endian byte order 559 * 560 * @x: value to be converted 561 */ 562 #define qdf_cpu_to_le16(x) __qdf_cpu_to_le16(x) 563 564 /** 565 * qdf_cpu_to_le32() - Convert a 32-bit value from CPU byte order to 566 * little-endian byte order 567 * 568 * @x: value to be converted 569 */ 570 #define qdf_cpu_to_le32(x) __qdf_cpu_to_le32(x) 571 572 /** 573 * qdf_cpu_to_le64() - Convert a 64-bit value from CPU byte order to 574 * little-endian byte order 575 * 576 * @x: value to be converted 577 */ 578 #define qdf_cpu_to_le64(x) __qdf_cpu_to_le64(x) 579 580 /** 581 * qdf_le16_to_cpu() - Convert a 16-bit value from little-endian byte order 582 * to CPU byte order 583 * 584 * @x: value to be converted 585 */ 586 #define qdf_le16_to_cpu(x) __qdf_le16_to_cpu(x) 587 588 /** 589 * qdf_le32_to_cpu() - Convert a 32-bit value from little-endian byte 590 * order to CPU byte order 591 * 592 * @x: value to be converted 593 */ 594 #define qdf_le32_to_cpu(x) __qdf_le32_to_cpu(x) 595 596 /** 597 * qdf_le64_to_cpu() - Convert a 64-bit value from little-endian byte 598 * order to CPU byte order 599 * 600 * @x: value to be converted 601 */ 602 #define qdf_le64_to_cpu(x) __qdf_le64_to_cpu(x) 603 604 /** 605 * qdf_cpu_to_be16() - Convert a 16-bit value from CPU byte order to 606 * big-endian byte order 607 * 608 * @x: value to be converted 609 */ 610 #define qdf_cpu_to_be16(x) __qdf_cpu_to_be16(x) 611 612 /** 613 * qdf_cpu_to_be32() - Convert a 32-bit value from CPU byte order to 614 * big-endian byte order 615 * 616 * @x: value to be converted 617 */ 618 #define qdf_cpu_to_be32(x) __qdf_cpu_to_be32(x) 619 620 /** 621 * qdf_cpu_to_be64() - Convert a 64-bit value from CPU byte order to 622 * big-endian byte order 623 * 624 * @x: value to be converted 625 */ 626 #define qdf_cpu_to_be64(x) __qdf_cpu_to_be64(x) 627 628 629 /** 630 * qdf_be16_to_cpu() - Convert a 16-bit value from big-endian byte order 631 * to CPU byte order 632 * 633 * @x: value to be converted 634 */ 635 #define qdf_be16_to_cpu(x) __qdf_be16_to_cpu(x) 636 637 /** 638 * qdf_be32_to_cpu() - Convert a 32-bit value from big-endian byte order 639 * to CPU byte order 640 * 641 * @x: value to be converted 642 */ 643 #define qdf_be32_to_cpu(x) __qdf_be32_to_cpu(x) 644 645 /** 646 * qdf_be64_to_cpu() - Convert a 64-bit value from big-endian byte order 647 * to CPU byte order 648 * 649 * @x: value to be converted 650 */ 651 #define qdf_be64_to_cpu(x) __qdf_be64_to_cpu(x) 652 653 /** 654 * qdf_function - replace with the name of the current function 655 */ 656 #define qdf_function __qdf_function 657 658 /** 659 * qdf_min() - minimum of two numbers 660 * @a: first number 661 * @b: second number 662 */ 663 #define qdf_min(a, b) __qdf_min(a, b) 664 665 /** 666 * qdf_ffz() - find first (least significant) zero bit 667 * @mask: the bitmask to check 668 * 669 * Return: The zero-based index of the first zero bit, or -1 if none are found 670 */ 671 #define qdf_ffz(mask) __qdf_ffz(mask) 672 673 /** 674 * qdf_prefetch - prefetches the cacheline for read 675 * 676 * @x: address to be prefetched 677 */ 678 #define qdf_prefetch(x) __qdf_prefetch(x) 679 680 /** 681 * qdf_get_pwr2() - get next power of 2 integer from input value 682 * @value: input value to find next power of 2 integer 683 * 684 * Get next power of 2 integer from input value 685 * 686 * Return: Power of 2 integer 687 */ qdf_get_pwr2(int value)688 static inline int qdf_get_pwr2(int value) 689 { 690 int log2; 691 692 if (QDF_IS_PWR2(value)) 693 return value; 694 695 log2 = 0; 696 while (value) { 697 value >>= 1; 698 log2++; 699 } 700 return 1 << log2; 701 } 702 703 static inline qdf_get_cpu(void)704 int qdf_get_cpu(void) 705 { 706 return __qdf_get_cpu(); 707 } 708 709 /** 710 * qdf_get_hweight8() - count num of 1's in 8-bit bitmap 711 * @w: input bitmap 712 * 713 * Count num of 1's set in the 8-bit bitmap 714 * 715 * Return: num of 1's 716 */ 717 static inline qdf_get_hweight8(unsigned int w)718 unsigned int qdf_get_hweight8(unsigned int w) 719 { 720 unsigned int res = w - ((w >> 1) & 0x55); 721 res = (res & 0x33) + ((res >> 2) & 0x33); 722 return (res + (res >> 4)) & 0x0F; 723 } 724 725 /** 726 * qdf_get_hweight16() - count num of 1's in 16-bit bitmap 727 * @w: input bitmap 728 * 729 * Count num of 1's set in the 16-bit bitmap 730 * 731 * Return: num of 1's 732 */ 733 static inline qdf_get_hweight16(unsigned int w)734 unsigned int qdf_get_hweight16(unsigned int w) 735 { 736 unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555); 737 738 res = (res & 0x3333) + ((res >> 2) & 0x3333); 739 res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F); 740 return (res & 0x00FF) + ((res >> 8) & 0x00FF); 741 } 742 743 /** 744 * qdf_get_hweight32() - count num of 1's in 32-bit bitmap 745 * @w: input bitmap 746 * 747 * Count num of 1's set in the 32-bit bitmap 748 * 749 * Return: num of 1's 750 */ 751 static inline qdf_get_hweight32(unsigned int w)752 unsigned int qdf_get_hweight32(unsigned int w) 753 { 754 unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555); 755 756 res = (res & 0x33333333) + ((res >> 2) & 0x33333333); 757 res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F); 758 res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF); 759 return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF); 760 } 761 762 /** 763 * qdf_device_init_wakeup() - allow a device to wake up the aps system 764 * @qdf_dev: the qdf device context 765 * @enable: enable/disable the device as a wakeup source 766 * 767 * Return: 0 or errno 768 */ qdf_device_init_wakeup(qdf_device_t qdf_dev,bool enable)769 static inline int qdf_device_init_wakeup(qdf_device_t qdf_dev, bool enable) 770 { 771 return __qdf_device_init_wakeup(qdf_dev, enable); 772 } 773 774 static inline qdf_get_totalramsize(void)775 uint64_t qdf_get_totalramsize(void) 776 { 777 return __qdf_get_totalramsize(); 778 } 779 780 /** 781 * qdf_get_lower_32_bits() - get lower 32 bits from an address. 782 * @addr: address 783 * 784 * This api returns the lower 32 bits of an address. 785 * 786 * Return: lower 32 bits. 787 */ 788 static inline qdf_get_lower_32_bits(qdf_dma_addr_t addr)789 uint32_t qdf_get_lower_32_bits(qdf_dma_addr_t addr) 790 { 791 return __qdf_get_lower_32_bits(addr); 792 } 793 794 /** 795 * qdf_get_upper_32_bits() - get upper 32 bits from an address. 796 * @addr: address 797 * 798 * This api returns the upper 32 bits of an address. 799 * 800 * Return: upper 32 bits. 801 */ 802 static inline qdf_get_upper_32_bits(qdf_dma_addr_t addr)803 uint32_t qdf_get_upper_32_bits(qdf_dma_addr_t addr) 804 { 805 return __qdf_get_upper_32_bits(addr); 806 } 807 808 /** 809 * qdf_rounddown_pow_of_two() - Round down to nearest power of two 810 * @n: number to be tested 811 * 812 * Test if the input number is power of two, and return the nearest power of two 813 * 814 * Return: number rounded down to the nearest power of two 815 */ 816 static inline qdf_rounddown_pow_of_two(unsigned long n)817 unsigned long qdf_rounddown_pow_of_two(unsigned long n) 818 { 819 return __qdf_rounddown_pow_of_two(n); 820 } 821 822 /** 823 * qdf_set_dma_coherent_mask() - set max number of bits allowed in dma addr 824 * @dev: device pointer 825 * @addr_bits: max number of bits allowed in dma address 826 * 827 * This API sets the maximum allowed number of bits in the dma address. 828 * 829 * Return: 0 - success, non zero - failure 830 */ 831 static inline qdf_set_dma_coherent_mask(struct device * dev,uint8_t addr_bits)832 int qdf_set_dma_coherent_mask(struct device *dev, uint8_t addr_bits) 833 { 834 return __qdf_set_dma_coherent_mask(dev, addr_bits); 835 } 836 837 /** 838 * qdf_do_div() - wrapper function for kernel macro(do_div). 839 * @dividend: Dividend value 840 * @divisor : Divisor value 841 * 842 * Return: Quotient 843 */ 844 static inline qdf_do_div(uint64_t dividend,uint32_t divisor)845 uint64_t qdf_do_div(uint64_t dividend, uint32_t divisor) 846 { 847 return __qdf_do_div(dividend, divisor); 848 } 849 850 /** 851 * qdf_do_div_rem() - wrapper function for kernel macro(do_div) 852 * to get remainder. 853 * @dividend: Dividend value 854 * @divisor : Divisor value 855 * 856 * Return: remainder 857 */ 858 static inline qdf_do_div_rem(uint64_t dividend,uint32_t divisor)859 uint64_t qdf_do_div_rem(uint64_t dividend, uint32_t divisor) 860 { 861 return __qdf_do_div_rem(dividend, divisor); 862 } 863 864 /** 865 * qdf_get_random_bytes() - returns nbytes bytes of random data 866 * @buf: buffer to fill 867 * @nbytes: number of bytes to fill 868 * 869 * Return: random bytes of data 870 */ 871 static inline qdf_get_random_bytes(void * buf,int nbytes)872 void qdf_get_random_bytes(void *buf, int nbytes) 873 { 874 return __qdf_get_random_bytes(buf, nbytes); 875 } 876 877 /** 878 * qdf_hex_to_bin() - QDF API to Convert hexa decimal ASCII character to 879 * unsigned integer value. 880 * @ch: hexa decimal ASCII character 881 * 882 * Return: For hexa decimal ASCII char return actual decimal value 883 * else -1 for bad input. 884 */ 885 static inline qdf_hex_to_bin(char ch)886 int qdf_hex_to_bin(char ch) 887 { 888 return __qdf_hex_to_bin(ch); 889 } 890 891 /** 892 * qdf_hex_str_to_binary() - QDF API to Convert string of hexa decimal 893 * ASCII characters to array of unsigned integers. 894 * @dst: output array to hold converted values 895 * @src: input string of hexa decimal ASCII characters 896 * @count: size of dst string 897 * 898 * This function is used to convert string of hexa decimal characters to 899 * array of unsigned integers and caller should ensure: 900 * a) @dst, @src are not NULL, 901 * b) size of @dst should be (size of src / 2) 902 * 903 * Example 1: 904 * src = 11aa, means, src[0] = '1', src[1] = '2', src[2] = 'a', src[3] = 'a' 905 * count = (size of src / 2) = 2 906 * after conversion, dst[0] = 0x11, dst[1] = oxAA and return (0). 907 * 908 * Example 2: 909 * src = 11az, means, src[0] = '1', src[1] = '2', src[2] = 'a', src[3] = 'z' 910 * src[3] is not ASCII hexa decimal character, return negative value (-1). 911 * 912 * Return: For a string of hexa decimal ASCII characters return 0 913 * else -1 for bad input. 914 */ 915 static inline qdf_hex_str_to_binary(u8 * dst,const char * src,size_t count)916 int qdf_hex_str_to_binary(u8 *dst, const char *src, size_t count) 917 { 918 return __qdf_hex_str_to_binary(dst, src, count); 919 } 920 921 /** 922 * qdf_fls() - find last set bit in a given 32 bit input 923 * @x: 32 bit mask 924 * 925 * Return: zero if the input is zero, otherwise returns the bit 926 * position of the last set bit, where the LSB is 1 and MSB is 32. 927 */ 928 static inline qdf_fls(uint32_t x)929 int qdf_fls(uint32_t x) 930 { 931 return __qdf_fls(x); 932 } 933 934 935 /** 936 * qdf_ffs() - find first set bit in a given 32 bit input 937 * @x: 32 bit mask 938 * 939 * Return: zero if the input is zero, otherwise returns the bit 940 * position of the first set bit, where the LSB is 1 and MSB is 32. 941 */ 942 static inline qdf_ffs(uint32_t x)943 int qdf_ffs(uint32_t x) 944 { 945 return __qdf_ffs(x); 946 } 947 948 /** 949 * qdf_get_smp_processor_id() - Get the current CPU id 950 * 951 * Return: current CPU id 952 */ qdf_get_smp_processor_id(void)953 static inline int qdf_get_smp_processor_id(void) 954 { 955 return __qdf_get_smp_processor_id(); 956 } 957 958 /** 959 * qdf_in_atomic: Check whether current thread running in atomic context 960 * 961 * Return: true if current thread is running in the atomic context 962 * else it will be return false. 963 */ qdf_in_atomic(void)964 static inline bool qdf_in_atomic(void) 965 { 966 return __qdf_in_atomic(); 967 } 968 #endif /*_QDF_UTIL_H*/ 969