drivers/net/qede/base/bcm_osal.h

   1 /*
   2  * Copyright (c) 2016 QLogic Corporation.
   3  * All rights reserved.
   4  * www.qlogic.com
   5  *
   6  * See LICENSE.qede_pmd for copyright and licensing details.
   7  */
   8
   9 #ifndef __BCM_OSAL_H
  10 #define __BCM_OSAL_H
  11
  12 #include <rte_byteorder.h>
  13 #include <rte_spinlock.h>
  14 #include <rte_malloc.h>
  15 #include <rte_atomic.h>
  16 #include <rte_memcpy.h>
  17 #include <rte_log.h>
  18 #include <rte_cycles.h>
  19 #include <rte_debug.h>
  20 #include <rte_ether.h>
  21
  22 /* Forward declaration */
  23 struct ecore_dev;
  24 struct ecore_hwfn;
  25 struct ecore_vf_acquire_sw_info;
  26 struct vf_pf_resc_request;
  27 void qed_link_update(struct ecore_hwfn *hwfn);
  28
  29 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
  30 #undef __BIG_ENDIAN
  31 #ifndef __LITTLE_ENDIAN
  32 #define __LITTLE_ENDIAN
  33 #endif
  34 #else
  35 #undef __LITTLE_ENDIAN
  36 #ifndef __BIG_ENDIAN
  37 #define __BIG_ENDIAN
  38 #endif
  39 #endif
  40
  41 /* Memory Types */
  42 typedef uint8_t u8;
  43 typedef uint16_t u16;
  44 typedef uint32_t u32;
  45 typedef uint64_t u64;
  46
  47 typedef int16_t s16;
  48 typedef int32_t s32;
  49
  50 typedef u16 __le16;
  51 typedef u32 __le32;
  52 typedef u32 OSAL_BE32;
  53
  54 #define osal_uintptr_t uintptr_t
  55
  56 typedef phys_addr_t dma_addr_t;
  57
  58 typedef rte_spinlock_t osal_spinlock_t;
  59
  60 typedef void *osal_dpc_t;
  61
  62 typedef size_t osal_size_t;
  63
  64 typedef intptr_t osal_int_ptr_t;
  65
  66 typedef int bool;
  67 #define true 1
  68 #define false 0
  69
  70 #define nothing do {} while (0)
  71
  72 /* Delays */
  73
  74 #define DELAY(x) rte_delay_us(x)
  75 #define usec_delay(x) DELAY(x)
  76 #define msec_delay(x) DELAY(1000 * (x))
  77 #define OSAL_UDELAY(time) usec_delay(time)
  78 #define OSAL_MSLEEP(time) msec_delay(time)
  79
  80 /* Memory allocations and deallocations */
  81
  82 #define OSAL_NULL ((void *)0)
  83 #define OSAL_ALLOC(dev, GFP, size) rte_malloc("qede", size, 0)
  84 #define OSAL_ZALLOC(dev, GFP, size) rte_zmalloc("qede", size, 0)
  85 #define OSAL_CALLOC(dev, GFP, num, size) rte_calloc("qede", num, size, 0)
  86 #define OSAL_VALLOC(dev, size) rte_malloc("qede", size, 0)
  87 #define OSAL_FREE(dev, memory) rte_free((void *)memory)
  88 #define OSAL_VFREE(dev, memory) OSAL_FREE(dev, memory)
  89 #define OSAL_MEM_ZERO(mem, size) bzero(mem, size)
  90 #define OSAL_MEMCPY(dst, src, size) rte_memcpy(dst, src, size)
  91 #define OSAL_MEMCMP(s1, s2, size) memcmp(s1, s2, size)
  92 #define OSAL_MEMSET(dst, val, length) \
  93         memset(dst, val, length)
  94
  95 void *osal_dma_alloc_coherent(struct ecore_dev *, dma_addr_t *, size_t);
  96
  97 void *osal_dma_alloc_coherent_aligned(struct ecore_dev *, dma_addr_t *,
  98                                       size_t, int);
  99
 100 #define OSAL_DMA_ALLOC_COHERENT(dev, phys, size) \
 101         osal_dma_alloc_coherent(dev, phys, size)
 102
 103 #define OSAL_DMA_ALLOC_COHERENT_ALIGNED(dev, phys, size, align) \
 104         osal_dma_alloc_coherent_aligned(dev, phys, size, align)
 105
 106 /* TODO: */
 107 #define OSAL_DMA_FREE_COHERENT(dev, virt, phys, size) nothing
 108
 109 /* HW reads/writes */
 110
 111 #define DIRECT_REG_RD(_dev, _reg_addr) \
 112         (*((volatile u32 *) (_reg_addr)))
 113
 114 #define REG_RD(_p_hwfn, _reg_offset) \
 115         DIRECT_REG_RD(_p_hwfn,          \
 116                         ((u8 *)(uintptr_t)(_p_hwfn->regview) + (_reg_offset)))
 117
 118 #define DIRECT_REG_WR16(_reg_addr, _val) \
 119         (*((volatile u16 *)(_reg_addr)) = _val)
 120
 121 #define DIRECT_REG_WR(_dev, _reg_addr, _val) \
 122         (*((volatile u32 *)(_reg_addr)) = _val)
 123
 124 #define REG_WR(_p_hwfn, _reg_offset, _val) \
 125         DIRECT_REG_WR(NULL,  \
 126         ((u8 *)((uintptr_t)(_p_hwfn->regview)) + (_reg_offset)), (u32)_val)
 127
 128 #define REG_WR16(_p_hwfn, _reg_offset, _val) \
 129         DIRECT_REG_WR16(((u8 *)(uintptr_t)(_p_hwfn->regview) + \
 130                         (_reg_offset)), (u16)_val)
 131
 132 #define DOORBELL(_p_hwfn, _db_addr, _val) \
 133         DIRECT_REG_WR(_p_hwfn, \
 134              ((u8 *)(uintptr_t)(_p_hwfn->doorbells) + (_db_addr)), (u32)_val)
 135
 136 /* Mutexes */
 137
 138 typedef pthread_mutex_t osal_mutex_t;
 139 #define OSAL_MUTEX_RELEASE(lock) pthread_mutex_unlock(lock)
 140 #define OSAL_MUTEX_INIT(lock) pthread_mutex_init(lock, NULL)
 141 #define OSAL_MUTEX_ACQUIRE(lock) pthread_mutex_lock(lock)
 142 #define OSAL_MUTEX_ALLOC(hwfn, lock) nothing
 143 #define OSAL_MUTEX_DEALLOC(lock) nothing
 144
 145 /* Spinlocks */
 146
 147 #define OSAL_SPIN_LOCK_INIT(lock) rte_spinlock_init(lock)
 148 #define OSAL_SPIN_LOCK(lock) rte_spinlock_lock(lock)
 149 #define OSAL_SPIN_UNLOCK(lock) rte_spinlock_unlock(lock)
 150 #define OSAL_SPIN_LOCK_IRQSAVE(lock, flags) nothing
 151 #define OSAL_SPIN_UNLOCK_IRQSAVE(lock, flags) nothing
 152 #define OSAL_SPIN_LOCK_ALLOC(hwfn, lock) nothing
 153 #define OSAL_SPIN_LOCK_DEALLOC(lock) nothing
 154
 155 /* DPC */
 156
 157 #define OSAL_DPC_ALLOC(hwfn) OSAL_ALLOC(hwfn, GFP, sizeof(osal_dpc_t))
 158 #define OSAL_DPC_INIT(dpc, hwfn) nothing
 159 #define OSAL_POLL_MODE_DPC(hwfn) nothing
 160
 161 /* Lists */
 162
 163 #define OSAL_LIST_SPLICE_INIT(new_list, list) nothing
 164 #define OSAL_LIST_SPLICE_TAIL_INIT(new_list, list) nothing
 165
 166 typedef struct _osal_list_entry_t {
 167         struct _osal_list_entry_t *next, *prev;
 168 } osal_list_entry_t;
 169
 170 typedef struct osal_list_t {
 171         osal_list_entry_t *head, *tail;
 172         unsigned long cnt;
 173 } osal_list_t;
 174
 175 #define OSAL_LIST_INIT(list) \
 176         do {                    \
 177                 (list)->head = NULL;  \
 178                 (list)->tail = NULL;  \
 179                 (list)->cnt  = 0;       \
 180         } while (0)
 181
 182 #define OSAL_LIST_PUSH_HEAD(entry, list)                \
 183         do {                                            \
 184                 (entry)->prev = (osal_list_entry_t *)0;         \
 185                 (entry)->next = (list)->head;                   \
 186                 if ((list)->tail == (osal_list_entry_t *)0) {   \
 187                         (list)->tail = (entry);                 \
 188                 } else {                                        \
 189                         (list)->head->prev = (entry);           \
 190                 }                                               \
 191                 (list)->head = (entry);                         \
 192                 (list)->cnt++;                                  \
 193         } while (0)
 194
 195 #define OSAL_LIST_PUSH_TAIL(entry, list)        \
 196         do {                                    \
 197                 (entry)->next = (osal_list_entry_t *)0; \
 198                 (entry)->prev = (list)->tail;           \
 199                 if ((list)->tail) {                     \
 200                         (list)->tail->next = (entry);   \
 201                 } else {                                \
 202                         (list)->head = (entry);         \
 203                 }                                       \
 204                 (list)->tail = (entry);                 \
 205                 (list)->cnt++;                          \
 206         } while (0)
 207
 208 #define OSAL_LIST_FIRST_ENTRY(list, type, field) \
 209         (type *)((list)->head)
 210
 211 #define OSAL_LIST_REMOVE_ENTRY(entry, list)                     \
 212         do {                                                    \
 213                 if ((list)->head == (entry)) {                          \
 214                         if ((list)->head) {                             \
 215                                 (list)->head = (list)->head->next;      \
 216                         if ((list)->head) {                             \
 217                                 (list)->head->prev = (osal_list_entry_t *)0;\
 218                         } else {                                        \
 219                                 (list)->tail = (osal_list_entry_t *)0;  \
 220                         }                                               \
 221                         (list)->cnt--;                                  \
 222                         }                                               \
 223                 } else if ((list)->tail == (entry)) {                   \
 224                         if ((list)->tail) {                             \
 225                                 (list)->tail = (list)->tail->prev;      \
 226                         if ((list)->tail) {                             \
 227                                 (list)->tail->next = (osal_list_entry_t *)0;\
 228                         } else {                                        \
 229                                 (list)->head = (osal_list_entry_t *)0;  \
 230                         }                                               \
 231                         (list)->cnt--;                                  \
 232                         }                                               \
 233                 } else {                                                \
 234                         (entry)->prev->next = (entry)->next;            \
 235                         (entry)->next->prev = (entry)->prev;            \
 236                         (list)->cnt--;                                  \
 237                 }                                                       \
 238         } while (0)
 239
 240 #define OSAL_LIST_IS_EMPTY(list) \
 241         ((list)->cnt == 0)
 242
 243 #define OSAL_LIST_NEXT(entry, field, type) \
 244         (type *)((&((entry)->field))->next)
 245
 246 /* TODO: Check field, type order */
 247
 248 #define OSAL_LIST_FOR_EACH_ENTRY(entry, list, field, type) \
 249         for (entry = OSAL_LIST_FIRST_ENTRY(list, type, field); \
 250                 entry;                                          \
 251                 entry = OSAL_LIST_NEXT(entry, field, type))
 252
 253 #define OSAL_LIST_FOR_EACH_ENTRY_SAFE(entry, tmp_entry, list, field, type) \
 254          for (entry = OSAL_LIST_FIRST_ENTRY(list, type, field), \
 255           tmp_entry = (entry) ? OSAL_LIST_NEXT(entry, field, type) : NULL;    \
 256           entry != NULL;                                                \
 257           entry = (type *)tmp_entry,                                     \
 258           tmp_entry = (entry) ? OSAL_LIST_NEXT(entry, field, type) : NULL)
 259
 260 /* TODO: OSAL_LIST_INSERT_ENTRY_AFTER */
 261 #define OSAL_LIST_INSERT_ENTRY_AFTER(new_entry, entry, list) \
 262         OSAL_LIST_PUSH_HEAD(new_entry, list)
 263
 264 /* PCI config space */
 265
 266 #define OSAL_PCI_READ_CONFIG_BYTE(dev, address, dst) nothing
 267 #define OSAL_PCI_READ_CONFIG_WORD(dev, address, dst) nothing
 268 #define OSAL_PCI_READ_CONFIG_DWORD(dev, address, dst) nothing
 269 #define OSAL_PCI_FIND_EXT_CAPABILITY(dev, pcie_id) 0
 270 #define OSAL_PCI_FIND_CAPABILITY(dev, pcie_id) 0
 271 #define OSAL_PCI_WRITE_CONFIG_WORD(dev, address, val) nothing
 272 #define OSAL_BAR_SIZE(dev, bar_id) 0
 273
 274 /* Barriers */
 275
 276 #define OSAL_MMIOWB(dev)                rte_wmb()
 277 #define OSAL_BARRIER(dev)               rte_compiler_barrier()
 278 #define OSAL_SMP_RMB(dev)               rte_rmb()
 279 #define OSAL_SMP_WMB(dev)               rte_wmb()
 280 #define OSAL_RMB(dev)                   rte_rmb()
 281 #define OSAL_WMB(dev)                   rte_wmb()
 282 #define OSAL_DMA_SYNC(dev, addr, length, is_post) nothing
 283
 284 #define OSAL_BITS_PER_BYTE              (8)
 285 #define OSAL_BITS_PER_UL        (sizeof(unsigned long) * OSAL_BITS_PER_BYTE)
 286 #define OSAL_BITS_PER_UL_MASK           (OSAL_BITS_PER_UL - 1)
 287
 288 /* Bitops */
 289 void qede_set_bit(u32, unsigned long *);
 290 #define OSAL_SET_BIT(bit, bitmap) \
 291         qede_set_bit(bit, bitmap)
 292
 293 void qede_clr_bit(u32, unsigned long *);
 294 #define OSAL_CLEAR_BIT(bit, bitmap) \
 295         qede_clr_bit(bit, bitmap)
 296
 297 bool qede_test_bit(u32, unsigned long *);
 298 #define OSAL_TEST_BIT(bit, bitmap) \
 299         qede_test_bit(bit, bitmap)
 300
 301 u32 qede_find_first_zero_bit(unsigned long *, u32);
 302 #define OSAL_FIND_FIRST_ZERO_BIT(bitmap, length) \
 303         qede_find_first_zero_bit(bitmap, length)
 304
 305 #define OSAL_BUILD_BUG_ON(cond)         nothing
 306 #define ETH_ALEN                        ETHER_ADDR_LEN
 307
 308 #define OSAL_LINK_UPDATE(hwfn) qed_link_update(hwfn)
 309 #define OSAL_DCBX_AEN(hwfn, mib_type) nothing
 310
 311 /* SR-IOV channel */
 312
 313 #define OSAL_VF_FLR_UPDATE(hwfn) nothing
 314 #define OSAL_VF_SEND_MSG2PF(dev, done, msg, reply_addr, msg_size, reply_size) 0
 315 #define OSAL_VF_CQE_COMPLETION(_dev_p, _cqe, _protocol) (0)
 316 #define OSAL_PF_VF_MSG(hwfn, vfid) 0
 317 #define OSAL_IOV_CHK_UCAST(hwfn, vfid, params) 0
 318 #define OSAL_IOV_POST_START_VPORT(hwfn, vf, vport_id, opaque_fid) nothing
 319 #define OSAL_IOV_VF_ACQUIRE(hwfn, vfid) 0
 320 #define OSAL_IOV_VF_CLEANUP(hwfn, vfid) nothing
 321 #define OSAL_IOV_VF_VPORT_UPDATE(hwfn, vfid, p_params, p_mask) 0
 322 #define OSAL_VF_UPDATE_ACQUIRE_RESC_RESP(_dev_p, _resc_resp) 0
 323 #define OSAL_IOV_GET_OS_TYPE() 0
 324
 325 u32 qede_unzip_data(struct ecore_hwfn *p_hwfn, u32 input_len,
 326                    u8 *input_buf, u32 max_size, u8 *unzip_buf);
 327 void qede_vf_fill_driver_data(struct ecore_hwfn *, struct vf_pf_resc_request *,
 328                               struct ecore_vf_acquire_sw_info *);
 329 #define OSAL_VF_FILL_ACQUIRE_RESC_REQ(_dev_p, _resc_req, _os_info) \
 330         qede_vf_fill_driver_data(_dev_p, _resc_req, _os_info)
 331
 332 #define OSAL_UNZIP_DATA(p_hwfn, input_len, buf, max_size, unzip_buf) \
 333         qede_unzip_data(p_hwfn, input_len, buf, max_size, unzip_buf)
 334
 335 /* TODO: */
 336 #define OSAL_SCHEDULE_RECOVERY_HANDLER(hwfn) nothing
 337 #define OSAL_HW_ERROR_OCCURRED(hwfn, err_type) nothing
 338
 339 #define OSAL_NVM_IS_ACCESS_ENABLED(hwfn) (1)
 340 #define OSAL_NUM_ACTIVE_CPU()   0
 341
 342 /* Utility functions */
 343
 344 #define RTE_DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
 345 #define DIV_ROUND_UP(size, to_what) RTE_DIV_ROUND_UP(size, to_what)
 346 #define RTE_ROUNDUP(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
 347 #define ROUNDUP(value, to_what) RTE_ROUNDUP((value), (to_what))
 348
 349 unsigned long qede_log2_align(unsigned long n);
 350 #define OSAL_ROUNDUP_POW_OF_TWO(val) \
 351         qede_log2_align(val)
 352
 353 u32 qede_osal_log2(u32);
 354 #define OSAL_LOG2(val) \
 355         qede_osal_log2(val)
 356
 357 #define PRINT(format, ...) printf
 358 #define PRINT_ERR(format, ...) PRINT
 359
 360 #define OFFSETOF(str, field) __builtin_offsetof(str, field)
 361 #define OSAL_ASSERT(is_assert) assert(is_assert)
 362 #define OSAL_BEFORE_PF_START(file, engine) nothing
 363 #define OSAL_AFTER_PF_STOP(file, engine) nothing
 364
 365 /* Endian macros */
 366 #define OSAL_CPU_TO_BE32(val) rte_cpu_to_be_32(val)
 367 #define OSAL_BE32_TO_CPU(val) rte_be_to_cpu_32(val)
 368 #define OSAL_CPU_TO_LE32(val) rte_cpu_to_le_32(val)
 369 #define OSAL_CPU_TO_LE16(val) rte_cpu_to_le_16(val)
 370 #define OSAL_LE32_TO_CPU(val) rte_le_to_cpu_32(val)
 371 #define OSAL_LE16_TO_CPU(val) rte_le_to_cpu_16(val)
 372 #define OSAL_CPU_TO_BE64(val) rte_cpu_to_be_64(val)
 373
 374 #define OSAL_ARRAY_SIZE(arr) RTE_DIM(arr)
 375 #define OSAL_SPRINTF(name, pattern, ...) \
 376         sprintf(name, pattern, ##__VA_ARGS__)
 377 #define OSAL_STRLEN(string) strlen(string)
 378 #define OSAL_STRCPY(dst, string) strcpy(dst, string)
 379 #define OSAL_STRNCPY(dst, string, len) strncpy(dst, string, len)
 380 #define OSAL_STRCMP(str1, str2) strcmp(str1, str2)
 381
 382 #define OSAL_INLINE inline
 383 #define OSAL_REG_ADDR(_p_hwfn, _offset) \
 384                 (void *)((u8 *)(uintptr_t)(_p_hwfn->regview) + (_offset))
 385 #define OSAL_PAGE_SIZE 4096
 386 #define OSAL_IOMEM volatile
 387 #define OSAL_UNLIKELY(x)  __builtin_expect(!!(x), 0)
 388 #define OSAL_MIN_T(type, __min1, __min2)        \
 389         ((type)(__min1) < (type)(__min2) ? (type)(__min1) : (type)(__min2))
 390 #define OSAL_MAX_T(type, __max1, __max2)        \
 391         ((type)(__max1) > (type)(__max2) ? (type)(__max1) : (type)(__max2))
 392
 393 #define OSAL_GET_PROTOCOL_STATS(p_hwfn, type, stats) (0)
 394 #define OSAL_SLOWPATH_IRQ_REQ(p_hwfn) (0)
 395
 396 #endif /* __BCM_OSAL_H */