sys/dev/qlnx/qlnxe/bcm_osal.h

   1 /*
   2  * Copyright (c) 2017-2018 Cavium, Inc.
   3  * All rights reserved.
   4  *
   5  *  Redistribution and use in source and binary forms, with or without
   6  *  modification, are permitted provided that the following conditions
   7  *  are met:
   8  *
   9  *  1. Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  *  2. Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  *
  15  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  19  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  20  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  21  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  22  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  24  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  25  *  POSSIBILITY OF SUCH DAMAGE.
  26  *
  27  * $FreeBSD$
  28  */
  29
  30 #ifndef __BCM_OSAL_ECORE_PACKAGE
  31 #define __BCM_OSAL_ECORE_PACKAGE
  32
  33 #include "qlnx_os.h"
  34 #include "ecore_status.h"
  35 #include <sys/bitstring.h>
  36
  37 #if __FreeBSD_version >= 1200032
  38 #include <linux/bitmap.h>
  39 #else
  40 #if __FreeBSD_version >= 1100090
  41 #include <compat/linuxkpi/common/include/linux/bitops.h>
  42 #else
  43 #include <ofed/include/linux/bitops.h>
  44 #endif
  45 #endif
  46
  47 #define OSAL_NUM_CPUS() mp_ncpus
  48 /*
  49  * prototypes of freebsd specific functions required by ecore
  50  */
  51 extern uint32_t qlnx_pci_bus_get_bar_size(void *ecore_dev, uint8_t bar_id);
  52 extern uint32_t qlnx_pci_read_config_byte(void *ecore_dev, uint32_t pci_reg,
  53                         uint8_t *reg_value);
  54 extern uint32_t qlnx_pci_read_config_word(void *ecore_dev, uint32_t pci_reg,
  55                         uint16_t *reg_value);
  56 extern uint32_t qlnx_pci_read_config_dword(void *ecore_dev, uint32_t pci_reg,
  57                         uint32_t *reg_value);
  58 extern void qlnx_pci_write_config_byte(void *ecore_dev, uint32_t pci_reg,
  59                         uint8_t reg_value);
  60 extern void qlnx_pci_write_config_word(void *ecore_dev, uint32_t pci_reg,
  61                         uint16_t reg_value);
  62 extern void qlnx_pci_write_config_dword(void *ecore_dev, uint32_t pci_reg,
  63                         uint32_t reg_value);
  64 extern int qlnx_pci_find_capability(void *ecore_dev, int cap);
  65 extern int qlnx_pci_find_ext_capability(void *ecore_dev, int ext_cap);
  66
  67 extern uint32_t qlnx_direct_reg_rd32(void *p_hwfn, uint32_t *reg_addr);
  68 extern void qlnx_direct_reg_wr32(void *p_hwfn, void *reg_addr, uint32_t value);
  69 extern void qlnx_direct_reg_wr64(void *p_hwfn, void *reg_addr, uint64_t value);
  70
  71 extern uint32_t qlnx_reg_rd32(void *p_hwfn, uint32_t reg_addr);
  72 extern void qlnx_reg_wr32(void *p_hwfn, uint32_t reg_addr, uint32_t value);
  73 extern void qlnx_reg_wr16(void *p_hwfn, uint32_t reg_addr, uint16_t value);
  74
  75 extern void qlnx_dbell_wr32(void *p_hwfn, uint32_t reg_addr, uint32_t value);
  76 extern void qlnx_dbell_wr32_db(void *p_hwfn, void *reg_addr, uint32_t value);
  77
  78 extern void *qlnx_dma_alloc_coherent(void *ecore_dev, bus_addr_t *phys,
  79                         uint32_t size);
  80 extern void qlnx_dma_free_coherent(void *ecore_dev, void *v_addr,
  81                         bus_addr_t phys, uint32_t size);
  82
  83 extern void qlnx_link_update(void *p_hwfn);
  84 extern void qlnx_barrier(void *p_hwfn);
  85
  86 extern void *qlnx_zalloc(uint32_t size);
  87
  88 extern void qlnx_get_protocol_stats(void *cdev, int proto_type,
  89                 void *proto_stats);
  90
  91 extern void qlnx_sp_isr(void *arg);
  92
  93
  94 extern void qlnx_osal_vf_fill_acquire_resc_req(void *p_hwfn, void *p_resc_req,
  95                         void *p_sw_info);
  96 extern void qlnx_osal_iov_vf_cleanup(void *p_hwfn, uint8_t relative_vf_id);
  97 extern int qlnx_iov_chk_ucast(void *p_hwfn, int vfid, void *params);
  98 extern int qlnx_iov_update_vport(void *p_hwfn, uint8_t vfid, void *params,
  99                 uint16_t *tlvs);
 100 extern int qlnx_pf_vf_msg(void *p_hwfn, uint16_t relative_vf_id);
 101 extern void qlnx_vf_flr_update(void *p_hwfn);
 102
 103 #define nothing                 do {} while(0)
 104 #ifdef ECORE_PACKAGE
 105
 106 /* Memory Types */
 107 #define u8 uint8_t
 108 #define u16 uint16_t
 109 #define u32 uint32_t
 110 #define u64 uint64_t
 111 #define s16 uint16_t
 112 #define s32 uint32_t
 113
 114 #ifndef QLNX_RDMA
 115
 116 typedef uint16_t __le16;
 117 typedef uint32_t __le32;
 118 typedef uint16_t __be16;
 119 typedef uint32_t __be32;
 120
 121 static __inline unsigned long
 122 roundup_pow_of_two(unsigned long x)
 123 {
 124         return (1UL << flsl(x - 1));
 125 }
 126
 127 static __inline int
 128 is_power_of_2(unsigned long n)
 129 {
 130         return (n == roundup_pow_of_two(n));
 131 }
 132
 133 static __inline unsigned long
 134 rounddown_pow_of_two(unsigned long x)
 135 {
 136         return (1UL << (flsl(x) - 1));
 137 }
 138
 139 #define max_t(type, val1, val2) \
 140         ((type)(val1) > (type)(val2) ? (type)(val1) : (val2))
 141 #define min_t(type, val1, val2) \
 142         ((type)(val1) < (type)(val2) ? (type)(val1) : (val2))
 143
 144 #define ARRAY_SIZE(arr)         (sizeof(arr) / sizeof(arr[0]))
 145 #define BUILD_BUG_ON(cond)      nothing
 146
 147 #endif /* #ifndef QLNX_RDMA */
 148
 149 #define OSAL_UNUSED
 150
 151 #define OSAL_CPU_TO_BE64(val) htobe64(val)
 152 #define OSAL_BE64_TO_CPU(val) be64toh(val)
 153
 154 #define OSAL_CPU_TO_BE32(val) htobe32(val)
 155 #define OSAL_BE32_TO_CPU(val) be32toh(val)
 156
 157 #define OSAL_CPU_TO_LE32(val) htole32(val)
 158 #define OSAL_LE32_TO_CPU(val) le32toh(val)
 159
 160 #define OSAL_CPU_TO_BE16(val) htobe16(val)
 161 #define OSAL_BE16_TO_CPU(val) be16toh(val)
 162
 163 #define OSAL_CPU_TO_LE16(val) htole16(val)
 164 #define OSAL_LE16_TO_CPU(val) le16toh(val)
 165
 166 static __inline uint32_t
 167 qlnx_get_cache_line_size(void)
 168 {
 169         return (CACHE_LINE_SIZE);
 170 }
 171
 172 #define OSAL_CACHE_LINE_SIZE qlnx_get_cache_line_size()
 173
 174 #define OSAL_BE32 uint32_t
 175 #define dma_addr_t bus_addr_t
 176 #define osal_size_t size_t
 177
 178 typedef struct mtx  osal_spinlock_t;
 179 typedef struct mtx  osal_mutex_t;
 180
 181 typedef void * osal_dpc_t;
 182
 183 typedef struct _osal_list_entry_t
 184 {
 185     struct _osal_list_entry_t *next, *prev;
 186 } osal_list_entry_t;
 187
 188 typedef struct osal_list_t
 189 {
 190     osal_list_entry_t *head, *tail;
 191     unsigned long cnt;
 192 } osal_list_t;
 193
 194 /* OSAL functions */
 195
 196 #define OSAL_UDELAY(time)  DELAY(time)
 197 #define OSAL_MSLEEP(time)  qlnx_mdelay(__func__, time)
 198
 199 #define OSAL_ALLOC(dev, GFP, size) qlnx_zalloc(size)
 200 #define OSAL_ZALLOC(dev, GFP, size) qlnx_zalloc(size)
 201 #define OSAL_VALLOC(dev, size) qlnx_zalloc(size)
 202 #define OSAL_VZALLOC(dev, size) qlnx_zalloc(size)
 203
 204 #define OSAL_FREE(dev, memory) free(memory, M_QLNXBUF)
 205 #define OSAL_VFREE(dev, memory) free(memory, M_QLNXBUF)
 206
 207 #define OSAL_MEM_ZERO(mem, size) bzero(mem, size)
 208
 209 #define OSAL_MEMCPY(dst, src, size) memcpy(dst, src, size)
 210
 211 #define OSAL_DMA_ALLOC_COHERENT(dev, phys, size) \
 212                 qlnx_dma_alloc_coherent(dev, phys, size)
 213
 214 #define OSAL_DMA_FREE_COHERENT(dev, virt, phys, size) \
 215                 qlnx_dma_free_coherent(dev, virt, phys, size)
 216 #define OSAL_VF_CQE_COMPLETION(_dev_p, _cqe, _protocol) (0)
 217
 218 #define REG_WR(hwfn, addr, val)  qlnx_reg_wr32(hwfn, addr, val)
 219 #define REG_WR16(hwfn, addr, val) qlnx_reg_wr16(hwfn, addr, val)
 220 #define DIRECT_REG_WR(p_hwfn, addr, value) qlnx_direct_reg_wr32(p_hwfn, addr, value)
 221 #define DIRECT_REG_WR64(p_hwfn, addr, value) \
 222                 qlnx_direct_reg_wr64(p_hwfn, addr, value)
 223 #define DIRECT_REG_WR_DB(p_hwfn, addr, value) qlnx_dbell_wr32_db(p_hwfn, addr, value)
 224 #define DIRECT_REG_RD(p_hwfn, addr) qlnx_direct_reg_rd32(p_hwfn, addr)
 225 #define REG_RD(hwfn, addr) qlnx_reg_rd32(hwfn, addr)
 226 #define DOORBELL(hwfn, addr, value) \
 227                 qlnx_dbell_wr32(hwfn, addr, value)
 228
 229 #define OSAL_SPIN_LOCK_ALLOC(p_hwfn, mutex)
 230 #define OSAL_SPIN_LOCK_DEALLOC(mutex) mtx_destroy(mutex)
 231 #define OSAL_SPIN_LOCK_INIT(lock) {\
 232                 mtx_init(lock, __func__, MTX_NETWORK_LOCK, MTX_SPIN); \
 233         }
 234
 235 #define OSAL_SPIN_UNLOCK(lock) {\
 236                 mtx_unlock(lock); \
 237         }
 238 #define OSAL_SPIN_LOCK(lock) {\
 239                 mtx_lock(lock); \
 240         }
 241
 242 #define OSAL_MUTEX_ALLOC(p_hwfn, mutex)
 243 #define OSAL_MUTEX_DEALLOC(mutex) mtx_destroy(mutex)
 244 #define OSAL_MUTEX_INIT(lock) {\
 245                 mtx_init(lock, __func__, MTX_NETWORK_LOCK, MTX_DEF);\
 246         }
 247
 248 #define OSAL_MUTEX_ACQUIRE(lock) mtx_lock(lock)
 249 #define OSAL_MUTEX_RELEASE(lock) mtx_unlock(lock)
 250
 251 #define OSAL_DPC_ALLOC(hwfn) malloc(PAGE_SIZE, M_QLNXBUF, M_NOWAIT)
 252 #define OSAL_DPC_INIT(dpc, hwfn) nothing
 253 extern void qlnx_schedule_recovery(void *p_hwfn);
 254 #define OSAL_SCHEDULE_RECOVERY_HANDLER(x) do {qlnx_schedule_recovery(x);} while(0)
 255 #define OSAL_HW_ERROR_OCCURRED(hwfn, err_type) nothing
 256 #define OSAL_DPC_SYNC(hwfn) nothing
 257
 258 static inline void OSAL_DCBX_AEN(void *p_hwfn, u32 mib_type)
 259 {
 260         return;
 261 }
 262
 263 static inline bool OSAL_NVM_IS_ACCESS_ENABLED(void *p_hwfn)
 264 {
 265         return 1;
 266 }
 267
 268 #define OSAL_LIST_INIT(list) \
 269     do {                       \
 270         (list)->head = NULL;  \
 271         (list)->tail = NULL;  \
 272         (list)->cnt  = 0;     \
 273     } while (0)
 274
 275 #define OSAL_LIST_INSERT_ENTRY_AFTER(entry, entry_prev, list) \
 276 do {                                            \
 277         (entry)->prev = (entry_prev);           \
 278         (entry)->next = (entry_prev)->next;     \
 279         (entry)->next->prev = (entry);          \
 280         (entry_prev)->next = (entry);           \
 281         (list)->cnt++;                          \
 282 } while (0);
 283
 284 #define OSAL_LIST_SPLICE_TAIL_INIT(new_list, list)      \
 285 do {                                                    \
 286         ((new_list)->tail)->next = ((list)->head);      \
 287         ((list)->head)->prev = ((new_list)->tail);      \
 288         (list)->head = (new_list)->head;                \
 289         (list)->cnt = (list)->cnt + (new_list)->cnt;    \
 290         OSAL_LIST_INIT(new_list);                       \
 291 } while (0);
 292
 293 #define OSAL_LIST_PUSH_HEAD(entry, list) \
 294     do {                                                \
 295         (entry)->prev = (osal_list_entry_t *)0;        \
 296         (entry)->next = (list)->head;                  \
 297         if ((list)->tail == (osal_list_entry_t *)0) { \
 298             (list)->tail = (entry);                    \
 299         } else {                                        \
 300             (list)->head->prev = (entry);              \
 301         }                                               \
 302         (list)->head = (entry);                        \
 303         (list)->cnt++;                                 \
 304     } while (0)
 305
 306 #define OSAL_LIST_PUSH_TAIL(entry, list) \
 307     do {                                         \
 308         (entry)->next = (osal_list_entry_t *)0; \
 309         (entry)->prev = (list)->tail;           \
 310         if ((list)->tail) {                     \
 311             (list)->tail->next = (entry);       \
 312         } else {                                 \
 313             (list)->head = (entry);             \
 314         }                                        \
 315         (list)->tail = (entry);                 \
 316         (list)->cnt++;                          \
 317     } while (0)
 318
 319 #define OSAL_LIST_FIRST_ENTRY(list, type, field) \
 320         (type *)((list)->head)
 321
 322 #define OSAL_LIST_REMOVE_ENTRY(entry, list) \
 323     do {                                                           \
 324         if ((list)->head == (entry)) {                            \
 325             if ((list)->head) {                                   \
 326                 (list)->head = (list)->head->next;               \
 327                 if ((list)->head) {                               \
 328                     (list)->head->prev = (osal_list_entry_t *)0; \
 329                 } else {                                           \
 330                     (list)->tail = (osal_list_entry_t *)0;       \
 331                 }                                                  \
 332                 (list)->cnt--;                                    \
 333             }                                                      \
 334         } else if ((list)->tail == (entry)) {                     \
 335             if ((list)->tail) {                                   \
 336                 (list)->tail = (list)->tail->prev;               \
 337                 if ((list)->tail) {                               \
 338                     (list)->tail->next = (osal_list_entry_t *)0; \
 339                 } else {                                           \
 340                     (list)->head = (osal_list_entry_t *)0;       \
 341                 }                                                  \
 342                 (list)->cnt--;                                    \
 343             }                                                      \
 344         } else {                                                   \
 345             (entry)->prev->next = (entry)->next;                   \
 346             (entry)->next->prev = (entry)->prev;                   \
 347             (list)->cnt--;                                        \
 348         }                                                          \
 349     } while (0)
 350
 351
 352 #define OSAL_LIST_IS_EMPTY(list) \
 353         ((list)->cnt == 0)
 354
 355 #define OSAL_LIST_NEXT(entry, field, type) \
 356     (type *)((&((entry)->field))->next)
 357
 358 #define OSAL_LIST_FOR_EACH_ENTRY(entry, list, field, type) \
 359         for (entry = OSAL_LIST_FIRST_ENTRY(list, type, field); \
 360                 entry;                                              \
 361                 entry = OSAL_LIST_NEXT(entry, field, type))
 362
 363 #define OSAL_LIST_FOR_EACH_ENTRY_SAFE(entry, tmp_entry, list, field, type) \
 364      for (entry = OSAL_LIST_FIRST_ENTRY(list, type, field),        \
 365           tmp_entry = (entry) ? OSAL_LIST_NEXT(entry, field, type) : NULL;    \
 366           entry != NULL;                                             \
 367           entry = (type *)tmp_entry,                                         \
 368           tmp_entry = (entry) ? OSAL_LIST_NEXT(entry, field, type) : NULL)
 369
 370
 371 #define OSAL_BAR_SIZE(dev, bar_id) qlnx_pci_bus_get_bar_size(dev, bar_id)
 372
 373 #define OSAL_PCI_READ_CONFIG_BYTE(dev, reg, value) \
 374                 qlnx_pci_read_config_byte(dev, reg, value);
 375 #define OSAL_PCI_READ_CONFIG_WORD(dev, reg, value) \
 376                 qlnx_pci_read_config_word(dev, reg, value);
 377 #define OSAL_PCI_READ_CONFIG_DWORD(dev, reg, value) \
 378                 qlnx_pci_read_config_dword(dev, reg, value);
 379
 380 #define OSAL_PCI_WRITE_CONFIG_BYTE(dev, reg, value) \
 381                 qlnx_pci_write_config_byte(dev, reg, value);
 382 #define OSAL_PCI_WRITE_CONFIG_WORD(dev, reg, value) \
 383                 qlnx_pci_write_config_word(dev, reg, value);
 384 #define OSAL_PCI_WRITE_CONFIG_DWORD(dev, reg, value) \
 385                 qlnx_pci_write_config_dword(dev, reg, value);
 386
 387 #define OSAL_PCI_FIND_CAPABILITY(dev, cap) qlnx_pci_find_capability(dev, cap)
 388 #define OSAL_PCI_FIND_EXT_CAPABILITY(dev, ext_cap) \
 389                                 qlnx_pci_find_ext_capability(dev, ext_cap)
 390
 391 #define OSAL_MMIOWB(dev) qlnx_barrier(dev)
 392 #define OSAL_BARRIER(dev) qlnx_barrier(dev)
 393
 394 #define OSAL_SMP_MB(dev) mb()
 395 #define OSAL_SMP_RMB(dev) rmb()
 396 #define OSAL_SMP_WMB(dev) wmb()
 397 #define OSAL_RMB(dev) rmb()
 398 #define OSAL_WMB(dev) wmb()
 399 #define OSAL_DMA_SYNC(dev, addr, length, is_post)
 400
 401 #define OSAL_FIND_FIRST_BIT find_first_bit
 402 #define OSAL_SET_BIT(bit, bitmap) bit_set((bitstr_t *)bitmap, bit)
 403 #define OSAL_CLEAR_BIT(bit, bitmap) bit_clear((bitstr_t *)bitmap, bit)
 404 #define OSAL_TEST_BIT(bit, bitmap) bit_test((bitstr_t *)bitmap, bit)
 405 #define OSAL_FIND_FIRST_ZERO_BIT(bitmap, length) \
 406                 find_first_zero_bit(bitmap, length)
 407
 408 #define OSAL_LINK_UPDATE(hwfn, ptt) qlnx_link_update(hwfn)
 409
 410 #define QLNX_DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
 411 #define QLNX_ROUNDUP(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
 412
 413 #define OSAL_NUM_ACTIVE_CPU() mp_ncpus
 414
 415 #ifndef DIV_ROUND_UP
 416 #define DIV_ROUND_UP(size, to_what) QLNX_DIV_ROUND_UP((size), (to_what))
 417 #endif
 418
 419 #define ROUNDUP(value, to_what) QLNX_ROUNDUP((value), (to_what))
 420
 421 #define OSAL_ROUNDUP_POW_OF_TWO(val) roundup_pow_of_two((val))
 422
 423 static __inline uint32_t
 424 qlnx_log2(uint32_t x)
 425 {
 426         uint32_t log = 0;
 427
 428         while (x >>= 1) log++;
 429
 430         return (log);
 431 }
 432
 433 #define OSAL_LOG2(val) qlnx_log2(val)
 434 #define OFFSETOF(str, field) offsetof(str, field)
 435 #define PRINT device_printf
 436 #define PRINT_ERR device_printf
 437 #define OSAL_ASSERT(is_assert) nothing
 438 #define OSAL_BEFORE_PF_START(cdev, my_id) {};
 439 #define OSAL_AFTER_PF_STOP(cdev, my_id) {};
 440
 441 #define INLINE __inline
 442 #define OSAL_INLINE __inline
 443 #define OSAL_UNLIKELY
 444 #define OSAL_NULL NULL
 445
 446
 447 #define OSAL_MAX_T(type, __max1, __max2) max_t(type, __max1, __max2)
 448 #define OSAL_MIN_T(type, __max1, __max2) min_t(type, __max1, __max2)
 449
 450 #define __iomem
 451 #define OSAL_IOMEM
 452
 453 #define int_ptr_t void *
 454 #define osal_int_ptr_t void *
 455 #define OSAL_BUILD_BUG_ON(cond) nothing
 456 #define REG_ADDR(hwfn, offset) (void *)((u8 *)(hwfn->regview) + (offset))
 457 #define OSAL_REG_ADDR(hwfn, offset) (void *)((u8 *)(hwfn->regview) + (offset))
 458
 459 #define OSAL_PAGE_SIZE PAGE_SIZE
 460
 461 #define OSAL_STRCPY(dst, src) strcpy(dst, src)
 462 #define OSAL_STRNCPY(dst, src, bytes) strncpy(dst, src, bytes)
 463 #define OSAL_STRLEN(src) strlen(src)
 464 #define OSAL_SPRINTF    sprintf
 465 #define OSAL_SNPRINTF   snprintf
 466 #define OSAL_MEMSET     memset
 467 #define OSAL_ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
 468 #define osal_uintptr_t u64
 469
 470 #define OSAL_SLOWPATH_IRQ_REQ(p_hwfn) (0)
 471 #define OSAL_GET_PROTOCOL_STATS(p_hwfn, type, stats) \
 472                 qlnx_get_protocol_stats(p_hwfn, type, stats);
 473 #define OSAL_POLL_MODE_DPC(hwfn) {if (cold) qlnx_sp_isr(hwfn);}
 474 #define OSAL_WARN(cond, fmt, args...) \
 475         if (cond) printf("%s: WARNING: " fmt, __func__, ## args);
 476
 477 #define OSAL_BITMAP_WEIGHT(bitmap, nbits) bitmap_weight(bitmap, nbits)
 478 #define OSAL_GET_RDMA_SB_ID(p_hwfn, cnq_id) ecore_rdma_get_sb_id(p_hwfn, cnq_id)
 479
 480 static inline int
 481 qlnx_test_and_change_bit(long bit, volatile unsigned long *var)
 482 {
 483         long val;
 484
 485         var += BIT_WORD(bit);
 486         bit %= BITS_PER_LONG;
 487         bit = (1UL << bit);
 488
 489         val = *var;
 490
 491 #if __FreeBSD_version >= 1100000
 492         if (val & bit)
 493                 return (test_and_clear_bit(bit, var));
 494
 495         return (test_and_set_bit(bit, var));
 496 #else
 497         if (val & bit)
 498                 return (test_and_clear_bit(bit, (long *)var));
 499
 500         return (test_and_set_bit(bit, (long *)var));
 501
 502 #endif
 503 }
 504
 505 #if __FreeBSD_version < 1100000
 506 static inline unsigned
 507 bitmap_weight(unsigned long *bitmap, unsigned nbits)
 508 {
 509         unsigned bit;
 510         unsigned retval = 0;
 511
 512         for_each_set_bit(bit, bitmap, nbits)
 513                 retval++;
 514         return (retval);
 515 }
 516
 517 #endif
 518
 519
 520 #define OSAL_TEST_AND_FLIP_BIT qlnx_test_and_change_bit
 521 #define OSAL_TEST_AND_CLEAR_BIT test_and_clear_bit
 522 #define OSAL_MEMCMP memcmp
 523 #define OSAL_SPIN_LOCK_IRQSAVE(x,y) {y=0; mtx_lock(x);}
 524 #define OSAL_SPIN_UNLOCK_IRQSAVE(x,y) {y= 0; mtx_unlock(x);}
 525
 526 static inline u32
 527 OSAL_CRC32(u32 crc, u8 *ptr, u32 length)
 528 {
 529         int i;
 530
 531         while (length--) {
 532                 crc ^= *ptr++;
 533                 for (i = 0; i < 8; i++)
 534                         crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
 535         }
 536         return crc;
 537 }
 538
 539 static inline void
 540 OSAL_CRC8_POPULATE(u8 * cdu_crc8_table, u8 polynomial)
 541 {
 542         return;
 543 }
 544
 545 static inline u8
 546 OSAL_CRC8(u8 * cdu_crc8_table, u8 * data_to_crc, int data_to_crc_len, u8 init_value)
 547 {
 548     return ECORE_NOTIMPL;
 549 }
 550
 551 #define OSAL_HW_INFO_CHANGE(p_hwfn, offset)
 552 #define OSAL_MFW_TLV_REQ(p_hwfn)
 553 #define OSAL_LLDP_RX_TLVS(p_hwfn, buffer, len)
 554 #define OSAL_MFW_CMD_PREEMPT(p_hwfn)
 555 #define OSAL_TRANSCEIVER_UPDATE(p_hwfn)
 556 #define OSAL_MFW_FILL_TLV_DATA(p_hwfn, group, data) (0)
 557
 558 #define OSAL_VF_UPDATE_ACQUIRE_RESC_RESP(p_hwfn, res) (0)
 559
 560 #define OSAL_VF_FILL_ACQUIRE_RESC_REQ(p_hwfn, req, vf_sw_info) \
 561                 qlnx_osal_vf_fill_acquire_resc_req(p_hwfn, req, vf_sw_info)
 562
 563 #define OSAL_IOV_PF_RESP_TYPE(p_hwfn, relative_vf_id, status)
 564 #define OSAL_IOV_VF_CLEANUP(p_hwfn, relative_vf_id) \
 565                 qlnx_osal_iov_vf_cleanup(p_hwfn, relative_vf_id)
 566
 567 #define OSAL_IOV_VF_ACQUIRE(p_hwfn, relative_vf_id) ECORE_SUCCESS
 568 #define OSAL_IOV_GET_OS_TYPE()  VFPF_ACQUIRE_OS_FREEBSD
 569 #define OSAL_IOV_PRE_START_VPORT(p_hwfn, relative_vf_id, params) ECORE_SUCCESS
 570 #define OSAL_IOV_POST_START_VPORT(p_hwfn, relative_vf_id, vport_id, opaque_fid)
 571 #define OSAL_PF_VALIDATE_MODIFY_TUNN_CONFIG(p_hwfn, x, y, z) ECORE_SUCCESS
 572 #define OSAL_IOV_CHK_UCAST(p_hwfn, vfid, params) \
 573                         qlnx_iov_chk_ucast(p_hwfn, vfid, params);
 574 #define OSAL_PF_VF_MALICIOUS(p_hwfn, relative_vf_id)
 575 #define OSAL_IOV_VF_MSG_TYPE(p_hwfn, relative_vf_id, type)
 576 #define OSAL_IOV_VF_VPORT_UPDATE(p_hwfn, vfid, params, tlvs) \
 577                 qlnx_iov_update_vport(p_hwfn, vfid, params, tlvs)
 578 #define OSAL_PF_VF_MSG(p_hwfn, relative_vf_id) \
 579                 qlnx_pf_vf_msg(p_hwfn, relative_vf_id)
 580
 581 #define OSAL_VF_FLR_UPDATE(p_hwfn) qlnx_vf_flr_update(p_hwfn)
 582 #define OSAL_IOV_VF_VPORT_STOP(p_hwfn, vf)
 583
 584 #endif /* #ifdef ECORE_PACKAGE */
 585
 586 #endif /* #ifdef __BCM_OSAL_ECORE_PACKAGE */