drivers/net/qede/base/bcm_osal.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright (c) 2016 - 2018 Cavium Inc.
   3  * All rights reserved.
   4  * www.cavium.com
   5  */
   6
   7 #ifndef __BCM_OSAL_H
   8 #define __BCM_OSAL_H
   9
  10 #include <stdbool.h>
  11 #include <time.h>
  12 #include <rte_bitops.h>
  13 #include <rte_byteorder.h>
  14 #include <rte_spinlock.h>
  15 #include <rte_malloc.h>
  16 #include <rte_atomic.h>
  17 #include <rte_memcpy.h>
  18 #include <rte_log.h>
  19 #include <rte_cycles.h>
  20 #include <rte_debug.h>
  21 #include <rte_ether.h>
  22 #include <rte_io.h>
  23 #include <rte_version.h>
  24 #include <rte_bus_pci.h>
  25
  26 /* Forward declaration */
  27 struct ecore_dev;
  28 struct ecore_hwfn;
  29 struct ecore_ptt;
  30 struct ecore_vf_acquire_sw_info;
  31 struct vf_pf_resc_request;
  32 enum ecore_mcp_protocol_type;
  33 union ecore_mcp_protocol_stats;
  34 enum ecore_hw_err_type;
  35
  36 void qed_link_update(struct ecore_hwfn *hwfn);
  37
  38 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
  39 #undef __BIG_ENDIAN
  40 #ifndef __LITTLE_ENDIAN
  41 #define __LITTLE_ENDIAN
  42 #endif
  43 #else
  44 #undef __LITTLE_ENDIAN
  45 #ifndef __BIG_ENDIAN
  46 #define __BIG_ENDIAN
  47 #endif
  48 #endif
  49
  50 #define OSAL_WARN(arg1, arg2, arg3, ...) (0)
  51
  52 #define UNUSED(x)       (void)(x)
  53
  54 /* Memory Types */
  55 typedef uint8_t u8;
  56 typedef uint16_t u16;
  57 typedef uint32_t u32;
  58 typedef uint64_t u64;
  59
  60 typedef int16_t s16;
  61 typedef int32_t s32;
  62
  63 typedef u16 __le16;
  64 typedef u32 __le32;
  65 typedef u32 OSAL_BE32;
  66
  67 #define osal_uintptr_t uintptr_t
  68
  69 typedef rte_iova_t dma_addr_t;
  70
  71 typedef rte_spinlock_t osal_spinlock_t;
  72
  73 typedef void *osal_dpc_t;
  74
  75 typedef size_t osal_size_t;
  76
  77 typedef intptr_t osal_int_ptr_t;
  78
  79 #define nothing do {} while (0)
  80
  81 /* Delays */
  82
  83 #define DELAY(x) rte_delay_us(x)
  84 #define usec_delay(x) DELAY(x)
  85 #define OSAL_UDELAY(time) usec_delay(time)
  86 #define OSAL_MSLEEP(time) rte_delay_us_sleep(1000 * (time))
  87
  88 /* Memory allocations and deallocations */
  89
  90 #define OSAL_NULL ((void *)0)
  91 #define OSAL_ALLOC(dev, GFP, size) rte_malloc("qede", size, 0)
  92 #define OSAL_ZALLOC(dev, GFP, size) rte_zmalloc("qede", size, 0)
  93 #define OSAL_CALLOC(dev, GFP, num, size) rte_calloc("qede", num, size, 0)
  94 #define OSAL_VZALLOC(dev, size) rte_zmalloc("qede", size, 0)
  95 #define OSAL_FREE(dev, memory)            \
  96         do {                              \
  97                 rte_free((void *)memory); \
  98                 memory = OSAL_NULL;       \
  99         } while (0)
 100 #define OSAL_VFREE(dev, memory) OSAL_FREE(dev, memory)
 101 #define OSAL_MEM_ZERO(mem, size) bzero(mem, size)
 102 #define OSAL_MEMCPY(dst, src, size) rte_memcpy(dst, src, size)
 103 #define OSAL_MEMCMP(s1, s2, size) memcmp(s1, s2, size)
 104 #define OSAL_MEMSET(dst, val, length) \
 105         memset(dst, val, length)
 106
 107 void *osal_dma_alloc_coherent(struct ecore_dev *, dma_addr_t *, size_t);
 108
 109 void *osal_dma_alloc_coherent_aligned(struct ecore_dev *, dma_addr_t *,
 110                                       size_t, int);
 111
 112 void osal_dma_free_mem(struct ecore_dev *edev, dma_addr_t phys);
 113
 114 #define OSAL_DMA_ALLOC_COHERENT(dev, phys, size) \
 115         osal_dma_alloc_coherent(dev, phys, size)
 116
 117 #define OSAL_DMA_ALLOC_COHERENT_ALIGNED(dev, phys, size, align) \
 118         osal_dma_alloc_coherent_aligned(dev, phys, size, align)
 119
 120 #define OSAL_DMA_FREE_COHERENT(dev, virt, phys, size) \
 121         osal_dma_free_mem(dev, phys)
 122
 123 /* HW reads/writes */
 124
 125 #define DIRECT_REG_RD(_dev, _reg_addr) rte_read32(_reg_addr)
 126
 127 #define REG_RD(_p_hwfn, _reg_offset) \
 128         DIRECT_REG_RD(_p_hwfn,          \
 129                         ((u8 *)(uintptr_t)(_p_hwfn->regview) + (_reg_offset)))
 130
 131 #define DIRECT_REG_WR16(_reg_addr, _val) rte_write16((_val), (_reg_addr))
 132
 133 #define DIRECT_REG_WR(_dev, _reg_addr, _val) rte_write32((_val), (_reg_addr))
 134
 135 #define DIRECT_REG_WR_RELAXED(_dev, _reg_addr, _val) \
 136         rte_write32_relaxed((_val), (_reg_addr))
 137
 138 #define REG_WR(_p_hwfn, _reg_offset, _val) \
 139         DIRECT_REG_WR(NULL,  \
 140         ((u8 *)((uintptr_t)(_p_hwfn->regview)) + (_reg_offset)), (u32)_val)
 141
 142 #define REG_WR16(_p_hwfn, _reg_offset, _val) \
 143         DIRECT_REG_WR16(((u8 *)(uintptr_t)(_p_hwfn->regview) + \
 144                         (_reg_offset)), (u16)_val)
 145
 146 #define DOORBELL(_p_hwfn, _db_addr, _val)                               \
 147         DIRECT_REG_WR_RELAXED((_p_hwfn),                                \
 148                               ((u8 *)(uintptr_t)(_p_hwfn->doorbells) +  \
 149                               (_db_addr)), (u32)_val)
 150
 151 #define DIRECT_REG_RD64(hwfn, addr) rte_read64(addr)
 152 #define DIRECT_REG_WR64(hwfn, addr, value) rte_write64((value), (addr))
 153
 154 /* Mutexes */
 155
 156 typedef pthread_mutex_t osal_mutex_t;
 157 #define OSAL_MUTEX_RELEASE(lock) pthread_mutex_unlock(lock)
 158 #define OSAL_MUTEX_INIT(lock) pthread_mutex_init(lock, NULL)
 159 #define OSAL_MUTEX_ACQUIRE(lock) pthread_mutex_lock(lock)
 160 #define OSAL_MUTEX_ALLOC(hwfn, lock) nothing
 161 #define OSAL_MUTEX_DEALLOC(lock) nothing
 162
 163 /* Spinlocks */
 164
 165 #define OSAL_SPIN_LOCK_INIT(lock) rte_spinlock_init(lock)
 166 #define OSAL_SPIN_LOCK(lock) rte_spinlock_lock(lock)
 167 #define OSAL_SPIN_UNLOCK(lock) rte_spinlock_unlock(lock)
 168 #define OSAL_SPIN_LOCK_IRQSAVE(lock, flags)     \
 169         do {                                    \
 170                 UNUSED(lock);                   \
 171                 flags = 0;                      \
 172                 UNUSED(flags);                  \
 173         } while (0)
 174 #define OSAL_SPIN_UNLOCK_IRQSAVE(lock, flags) nothing
 175 #define OSAL_SPIN_LOCK_ALLOC(hwfn, lock) nothing
 176 #define OSAL_SPIN_LOCK_DEALLOC(lock) nothing
 177
 178 /* DPC */
 179
 180 void osal_poll_mode_dpc(osal_int_ptr_t hwfn_cookie);
 181 #define OSAL_DPC_ALLOC(hwfn) OSAL_ALLOC(hwfn, GFP, sizeof(osal_dpc_t))
 182 #define OSAL_DPC_INIT(dpc, hwfn) \
 183         OSAL_SPIN_LOCK_INIT(&(hwfn)->spq_lock)
 184 #define OSAL_POLL_MODE_DPC(hwfn) \
 185         osal_poll_mode_dpc((osal_int_ptr_t)(p_hwfn))
 186 #define OSAL_DPC_SYNC(hwfn) nothing
 187
 188 /* Lists */
 189
 190 #define OSAL_LIST_SPLICE_INIT(new_list, list) nothing
 191 #define OSAL_LIST_SPLICE_TAIL_INIT(new_list, list) nothing
 192
 193 typedef struct _osal_list_entry_t {
 194         struct _osal_list_entry_t *next, *prev;
 195 } osal_list_entry_t;
 196
 197 typedef struct osal_list_t {
 198         osal_list_entry_t *head, *tail;
 199         unsigned long cnt;
 200 } osal_list_t;
 201
 202 #define OSAL_LIST_INIT(list) \
 203         do {                    \
 204                 (list)->head = NULL;  \
 205                 (list)->tail = NULL;  \
 206                 (list)->cnt  = 0;       \
 207         } while (0)
 208
 209 #define OSAL_LIST_PUSH_HEAD(entry, list)                \
 210         do {                                            \
 211                 (entry)->prev = (osal_list_entry_t *)0;         \
 212                 (entry)->next = (list)->head;                   \
 213                 if ((list)->tail == (osal_list_entry_t *)0) {   \
 214                         (list)->tail = (entry);                 \
 215                 } else {                                        \
 216                         (list)->head->prev = (entry);           \
 217                 }                                               \
 218                 (list)->head = (entry);                         \
 219                 (list)->cnt++;                                  \
 220         } while (0)
 221
 222 #define OSAL_LIST_PUSH_TAIL(entry, list)        \
 223         do {                                    \
 224                 (entry)->next = (osal_list_entry_t *)0; \
 225                 (entry)->prev = (list)->tail;           \
 226                 if ((list)->tail) {                     \
 227                         (list)->tail->next = (entry);   \
 228                 } else {                                \
 229                         (list)->head = (entry);         \
 230                 }                                       \
 231                 (list)->tail = (entry);                 \
 232                 (list)->cnt++;                          \
 233         } while (0)
 234
 235 #define OSAL_LIST_FIRST_ENTRY(list, type, field) \
 236         (type *)((list)->head)
 237
 238 #define OSAL_LIST_REMOVE_ENTRY(entry, list)                     \
 239         do {                                                    \
 240                 if ((list)->head == (entry)) {                          \
 241                         if ((list)->head) {                             \
 242                                 (list)->head = (list)->head->next;      \
 243                         if ((list)->head) {                             \
 244                                 (list)->head->prev = (osal_list_entry_t *)0;\
 245                         } else {                                        \
 246                                 (list)->tail = (osal_list_entry_t *)0;  \
 247                         }                                               \
 248                         (list)->cnt--;                                  \
 249                         }                                               \
 250                 } else if ((list)->tail == (entry)) {                   \
 251                         if ((list)->tail) {                             \
 252                                 (list)->tail = (list)->tail->prev;      \
 253                         if ((list)->tail) {                             \
 254                                 (list)->tail->next = (osal_list_entry_t *)0;\
 255                         } else {                                        \
 256                                 (list)->head = (osal_list_entry_t *)0;  \
 257                         }                                               \
 258                         (list)->cnt--;                                  \
 259                         }                                               \
 260                 } else {                                                \
 261                         (entry)->prev->next = (entry)->next;            \
 262                         (entry)->next->prev = (entry)->prev;            \
 263                         (list)->cnt--;                                  \
 264                 }                                                       \
 265         } while (0)
 266
 267 #define OSAL_LIST_IS_EMPTY(list) \
 268         ((list)->cnt == 0)
 269
 270 #define OSAL_LIST_NEXT(entry, field, type) \
 271         (type *)((&((entry)->field))->next)
 272
 273 /* TODO: Check field, type order */
 274
 275 #define OSAL_LIST_FOR_EACH_ENTRY(entry, list, field, type) \
 276         for (entry = OSAL_LIST_FIRST_ENTRY(list, type, field); \
 277                 entry;                                          \
 278                 entry = OSAL_LIST_NEXT(entry, field, type))
 279
 280 #define OSAL_LIST_FOR_EACH_ENTRY_SAFE(entry, tmp_entry, list, field, type) \
 281          for (entry = OSAL_LIST_FIRST_ENTRY(list, type, field), \
 282           tmp_entry = (entry) ? OSAL_LIST_NEXT(entry, field, type) : NULL;    \
 283           entry != NULL;                                                \
 284           entry = (type *)tmp_entry,                                     \
 285           tmp_entry = (entry) ? OSAL_LIST_NEXT(entry, field, type) : NULL)
 286
 287 /* TODO: OSAL_LIST_INSERT_ENTRY_AFTER */
 288 #define OSAL_LIST_INSERT_ENTRY_AFTER(new_entry, entry, list) \
 289         OSAL_LIST_PUSH_HEAD(new_entry, list)
 290
 291 /* PCI config space */
 292 #define OSAL_PCI_READ_CONFIG_BYTE(dev, address, dst) \
 293         rte_pci_read_config((dev)->pci_dev, dst, 1, address)
 294 #define OSAL_PCI_READ_CONFIG_WORD(dev, address, dst) \
 295         rte_pci_read_config((dev)->pci_dev, dst, 2, address)
 296 #define OSAL_PCI_READ_CONFIG_DWORD(dev, address, dst) \
 297         rte_pci_read_config((dev)->pci_dev, dst, 4, address)
 298 #define OSAL_PCI_FIND_EXT_CAPABILITY(dev, cap) \
 299         rte_pci_find_ext_capability((dev)->pci_dev, cap)
 300 #define OSAL_PCI_FIND_CAPABILITY(dev, pcie_id) 0
 301 #define OSAL_PCI_WRITE_CONFIG_WORD(dev, address, val) nothing
 302 #define OSAL_BAR_SIZE(dev, bar_id) 0
 303
 304 /* Barriers */
 305
 306 #define OSAL_MMIOWB(dev)                rte_wmb()
 307 #define OSAL_BARRIER(dev)               rte_compiler_barrier()
 308 #define OSAL_SMP_RMB(dev)               rte_rmb()
 309 #define OSAL_SMP_WMB(dev)               rte_wmb()
 310 #define OSAL_RMB(dev)                   rte_rmb()
 311 #define OSAL_WMB(dev)                   rte_wmb()
 312 #define OSAL_DMA_SYNC(dev, addr, length, is_post) nothing
 313
 314 #define OSAL_BIT(nr)            (1UL << (nr))
 315 #define OSAL_BITS_PER_BYTE      (8)
 316 #define OSAL_BITS_PER_UL        (sizeof(unsigned long) * OSAL_BITS_PER_BYTE)
 317 #define OSAL_BITS_PER_UL_MASK           (OSAL_BITS_PER_UL - 1)
 318
 319 /* Bitops */
 320 #define OSAL_SET_BIT(bit, bitmap) \
 321         rte_bit_relaxed_set32(bit, bitmap)
 322
 323 #define OSAL_CLEAR_BIT(bit, bitmap) \
 324         rte_bit_relaxed_clear32(bit, bitmap)
 325
 326 #define OSAL_GET_BIT(bit, bitmap) \
 327         rte_bit_relaxed_get32(bit, bitmap)
 328
 329 u32 qede_find_first_bit(unsigned long *, u32);
 330 #define OSAL_FIND_FIRST_BIT(bitmap, length) \
 331         qede_find_first_bit(bitmap, length)
 332
 333 u32 qede_find_first_zero_bit(u32 *bitmap, u32 length);
 334 #define OSAL_FIND_FIRST_ZERO_BIT(bitmap, length) \
 335         qede_find_first_zero_bit(bitmap, length)
 336
 337 #define OSAL_BUILD_BUG_ON(cond)         nothing
 338 #define ETH_ALEN                        RTE_ETHER_ADDR_LEN
 339 #define ETHER_TYPE_VLAN                 RTE_ETHER_TYPE_VLAN
 340 #define ETHER_TYPE_QINQ                 RTE_ETHER_TYPE_QINQ
 341
 342 #define OSAL_BITMAP_WEIGHT(bitmap, count) 0
 343
 344 #define OSAL_LINK_UPDATE(hwfn) qed_link_update(hwfn)
 345 #define OSAL_TRANSCEIVER_UPDATE(hwfn) nothing
 346 #define OSAL_DCBX_AEN(hwfn, mib_type) nothing
 347
 348 /* SR-IOV channel */
 349
 350 int osal_pf_vf_msg(struct ecore_hwfn *p_hwfn);
 351 void osal_vf_flr_update(struct ecore_hwfn *p_hwfn);
 352 #define OSAL_VF_FLR_UPDATE(hwfn) \
 353         osal_vf_flr_update(hwfn)
 354 #define OSAL_VF_SEND_MSG2PF(dev, done, msg, reply_addr, msg_size, reply_size) 0
 355 #define OSAL_VF_CQE_COMPLETION(_dev_p, _cqe, _protocol) (0)
 356 #define OSAL_PF_VF_MSG(hwfn, vfid) \
 357         osal_pf_vf_msg(hwfn)
 358 #define OSAL_PF_VF_MALICIOUS(hwfn, vfid) nothing
 359 #define OSAL_IOV_CHK_UCAST(hwfn, vfid, params) 0
 360 #define OSAL_IOV_POST_START_VPORT(hwfn, vf, vport_id, opaque_fid) nothing
 361 #define OSAL_IOV_VF_ACQUIRE(hwfn, vfid) 0
 362 #define OSAL_IOV_VF_CLEANUP(hwfn, vfid) nothing
 363 #define OSAL_IOV_VF_VPORT_UPDATE(hwfn, vfid, p_params, p_mask) 0
 364 #define OSAL_VF_UPDATE_ACQUIRE_RESC_RESP(_dev_p, _resc_resp) 0
 365 #define OSAL_IOV_GET_OS_TYPE() 0
 366 #define OSAL_IOV_VF_MSG_TYPE(hwfn, vfid, vf_msg_type) nothing
 367 #define OSAL_IOV_PF_RESP_TYPE(hwfn, vfid, pf_resp_type) nothing
 368 #define OSAL_IOV_VF_VPORT_STOP(hwfn, vf) nothing
 369
 370 u32 qede_unzip_data(struct ecore_hwfn *p_hwfn, u32 input_len,
 371                    u8 *input_buf, u32 max_size, u8 *unzip_buf);
 372 void qede_vf_fill_driver_data(struct ecore_hwfn *, struct vf_pf_resc_request *,
 373                               struct ecore_vf_acquire_sw_info *);
 374 void qede_hw_err_notify(struct ecore_hwfn *p_hwfn,
 375                         enum ecore_hw_err_type err_type);
 376 #define OSAL_VF_FILL_ACQUIRE_RESC_REQ(_dev_p, _resc_req, _os_info) \
 377         qede_vf_fill_driver_data(_dev_p, _resc_req, _os_info)
 378
 379 #define OSAL_UNZIP_DATA(p_hwfn, input_len, buf, max_size, unzip_buf) \
 380         qede_unzip_data(p_hwfn, input_len, buf, max_size, unzip_buf)
 381
 382 /* TODO: */
 383 #define OSAL_SCHEDULE_RECOVERY_HANDLER(hwfn) nothing
 384
 385 int qede_save_fw_dump(uint16_t port_id);
 386
 387 #define OSAL_SAVE_FW_DUMP(port_id) qede_save_fw_dump(port_id)
 388
 389 #define OSAL_HW_ERROR_OCCURRED(hwfn, err_type) \
 390         qede_hw_err_notify(hwfn, err_type)
 391
 392 #define OSAL_NVM_IS_ACCESS_ENABLED(hwfn) (1)
 393 #define OSAL_NUM_CPUS() 0
 394
 395 /* Utility functions */
 396
 397 #define RTE_DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
 398 #define DIV_ROUND_UP(size, to_what) RTE_DIV_ROUND_UP(size, to_what)
 399 #define RTE_ROUNDUP(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
 400 #define ROUNDUP(value, to_what) RTE_ROUNDUP((value), (to_what))
 401
 402 unsigned long qede_log2_align(unsigned long n);
 403 #define OSAL_ROUNDUP_POW_OF_TWO(val) \
 404         qede_log2_align(val)
 405
 406 u32 qede_osal_log2(u32);
 407 #define OSAL_LOG2(val) \
 408         qede_osal_log2(val)
 409
 410 #define PRINT(format, ...) printf
 411 #define PRINT_ERR(format, ...) PRINT
 412
 413 #define OFFSETOF(str, field) __builtin_offsetof(str, field)
 414 #define OSAL_ASSERT(is_assert) assert(is_assert)
 415 #define OSAL_BEFORE_PF_START(file, engine) nothing
 416 #define OSAL_AFTER_PF_STOP(file, engine) nothing
 417
 418 /* Endian macros */
 419 #define OSAL_CPU_TO_BE32(val) rte_cpu_to_be_32(val)
 420 #define OSAL_BE32_TO_CPU(val) rte_be_to_cpu_32(val)
 421 #define OSAL_CPU_TO_LE32(val) rte_cpu_to_le_32(val)
 422 #define OSAL_CPU_TO_LE16(val) rte_cpu_to_le_16(val)
 423 #define OSAL_LE32_TO_CPU(val) rte_le_to_cpu_32(val)
 424 #define OSAL_LE16_TO_CPU(val) rte_le_to_cpu_16(val)
 425 #define OSAL_CPU_TO_BE64(val) rte_cpu_to_be_64(val)
 426
 427 #define OSAL_ARRAY_SIZE(arr) RTE_DIM(arr)
 428 #define OSAL_SPRINTF(name, pattern, ...) \
 429         sprintf(name, pattern, ##__VA_ARGS__)
 430 #define OSAL_SNPRINTF(buf, size, format, ...) \
 431         snprintf(buf, size, format, ##__VA_ARGS__)
 432 #define OSAL_STRLEN(string) strlen(string)
 433 #define OSAL_STRCPY(dst, string) strcpy(dst, string)
 434 #define OSAL_STRNCPY(dst, string, len) strncpy(dst, string, len)
 435 #define OSAL_STRCMP(str1, str2) strcmp(str1, str2)
 436 #define OSAL_STRTOUL(str, base, res) 0
 437
 438 #define OSAL_INLINE inline
 439 #define OSAL_REG_ADDR(_p_hwfn, _offset) \
 440                 (void *)((u8 *)(uintptr_t)(_p_hwfn->regview) + (_offset))
 441 #define OSAL_PAGE_SIZE 4096
 442 #define OSAL_CACHE_LINE_SIZE RTE_CACHE_LINE_SIZE
 443 #define OSAL_IOMEM volatile
 444 #define OSAL_UNUSED    __rte_unused
 445 #define OSAL_UNLIKELY(x)  __builtin_expect(!!(x), 0)
 446 #define OSAL_MIN_T(type, __min1, __min2)        \
 447         ((type)(__min1) < (type)(__min2) ? (type)(__min1) : (type)(__min2))
 448 #define OSAL_MAX_T(type, __max1, __max2)        \
 449         ((type)(__max1) > (type)(__max2) ? (type)(__max1) : (type)(__max2))
 450
 451 void qede_get_mcp_proto_stats(struct ecore_dev *, enum ecore_mcp_protocol_type,
 452                               union ecore_mcp_protocol_stats *);
 453 #define OSAL_GET_PROTOCOL_STATS(dev, type, stats) \
 454         qede_get_mcp_proto_stats(dev, type, stats)
 455
 456 #define OSAL_SLOWPATH_IRQ_REQ(p_hwfn) (0)
 457
 458 u32 qede_crc32(u32 crc, u8 *ptr, u32 length);
 459 #define OSAL_CRC32(crc, buf, length) qede_crc32(crc, buf, length)
 460 #define OSAL_CRC8_POPULATE(table, polynomial) nothing
 461 #define OSAL_CRC8(table, pdata, nbytes, crc) 0
 462 #define OSAL_MFW_TLV_REQ(p_hwfn) nothing
 463 #define OSAL_MFW_FILL_TLV_DATA(type, buf, data) (0)
 464 #define OSAL_HW_INFO_CHANGE(p_hwfn, change) nothing
 465 #define OSAL_MFW_CMD_PREEMPT(p_hwfn) nothing
 466 #define OSAL_PF_VALIDATE_MODIFY_TUNN_CONFIG(p_hwfn, mask, b_update, tunn) 0
 467
 468 #define OSAL_DIV_S64(a, b)      ((a) / (b))
 469 #define OSAL_LLDP_RX_TLVS(p_hwfn, tlv_buf, tlv_size) nothing
 470 void qed_set_platform_str(struct ecore_hwfn *p_hwfn,
 471                           char *buf_str, u32 buf_size);
 472 #define OSAL_SET_PLATFORM_STR(p_hwfn, buf_str, buf_size) \
 473         qed_set_platform_str(p_hwfn, buf_str, buf_size)
 474 #define OSAL_GET_EPOCH(p_hwfn) ((u32)time(NULL))
 475 enum dbg_status qed_dbg_alloc_user_data(struct ecore_hwfn *p_hwfn,
 476                                         void **user_data_ptr);
 477 #define OSAL_DBG_ALLOC_USER_DATA(p_hwfn, user_data_ptr) \
 478         qed_dbg_alloc_user_data(p_hwfn, user_data_ptr)
 479 #define OSAL_DB_REC_OCCURRED(p_hwfn) nothing
 480
 481 #endif /* __BCM_OSAL_H */