1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Intel Corporation
13 #include <sys/queue.h>
16 #include <rte_common.h>
17 #include <rte_memcpy.h>
18 #include <rte_malloc.h>
19 #include <rte_memzone.h>
20 #include <rte_byteorder.h>
21 #include <rte_cycles.h>
22 #include <rte_spinlock.h>
24 #include <rte_random.h>
27 #include "../ice_logs.h"
42 #define hw_dbg(hw, S, A...) do {} while (0)
43 #define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
44 #define lower_32_bits(n) ((u32)(n))
45 #define low_16_bits(x) ((x) & 0xFFFF)
46 #define high_16_bits(x) (((x) & 0xFFFF0000) >> 16)
49 #define ETH_ADDR_LEN 6
53 #define __le16 uint16_t
56 #define __le32 uint32_t
59 #define __le64 uint64_t
62 #define __be16 uint16_t
65 #define __be32 uint32_t
68 #define __be64 uint64_t
71 #ifndef __always_unused
72 #define __always_unused __attribute__((unused))
74 #ifndef __maybe_unused
75 #define __maybe_unused __attribute__((unused))
78 #define __packed __attribute__((packed))
82 #define BIT_ULL(a) (1ULL << (a))
90 #define min(a, b) RTE_MIN(a, b)
91 #define max(a, b) RTE_MAX(a, b)
93 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
94 #define FIELD_SIZEOF(t, f) (sizeof(((t *)0)->f))
95 #define MAKEMASK(m, s) ((m) << (s))
97 #define DEBUGOUT(S, A...) PMD_DRV_LOG_RAW(DEBUG, S, ##A)
98 #define DEBUGFUNC(F) PMD_DRV_LOG_RAW(DEBUG, F)
100 #define ice_debug(h, m, s, ...) \
102 if (((m) & (h)->debug_mask)) \
103 PMD_DRV_LOG_RAW(DEBUG, "ice %02x.%x " s, \
104 (h)->bus.device, (h)->bus.func, \
108 #define ice_info(hw, fmt, args...) ice_debug(hw, ICE_DBG_ALL, fmt, ##args)
109 #define ice_warn(hw, fmt, args...) ice_debug(hw, ICE_DBG_ALL, fmt, ##args)
110 #define ice_debug_array(hw, type, rowsize, groupsize, buf, len) \
112 struct ice_hw *hw_l = hw; \
116 for (i = 0; i < len_l; i += 8) \
117 ice_debug(hw_l, type, \
118 "0x%04X 0x%016"PRIx64"\n", \
119 i, *((u64 *)((buf_l) + i))); \
121 #define ice_snprintf snprintf
123 #define SNPRINTF ice_snprintf
126 #define ICE_PCI_REG(reg) rte_read32(reg)
127 #define ICE_PCI_REG_ADDR(a, reg) \
128 ((volatile uint32_t *)((char *)(a)->hw_addr + (reg)))
129 static inline uint32_t ice_read_addr(volatile void *addr)
131 return rte_le_to_cpu_32(ICE_PCI_REG(addr));
134 #define ICE_PCI_REG_WRITE(reg, value) \
135 rte_write32((rte_cpu_to_le_32(value)), reg)
137 #define ice_flush(a) ICE_READ_REG((a), GLGEN_STAT)
138 #define icevf_flush(a) ICE_READ_REG((a), VFGEN_RSTAT)
139 #define ICE_READ_REG(hw, reg) ice_read_addr(ICE_PCI_REG_ADDR((hw), (reg)))
140 #define ICE_WRITE_REG(hw, reg, value) \
141 ICE_PCI_REG_WRITE(ICE_PCI_REG_ADDR((hw), (reg)), (value))
143 #define rd32(a, reg) ice_read_addr(ICE_PCI_REG_ADDR((a), (reg)))
144 #define wr32(a, reg, value) \
145 ICE_PCI_REG_WRITE(ICE_PCI_REG_ADDR((a), (reg)), (value))
146 #define flush(a) ice_read_addr(ICE_PCI_REG_ADDR((a), (GLGEN_STAT)))
147 #define div64_long(n, d) ((n) / (d))
149 #define BITS_PER_BYTE 8
151 /* memory allocation tracking */
157 } __attribute__((packed));
159 struct ice_virt_mem {
162 } __attribute__((packed));
164 #define ice_malloc(h, s) rte_zmalloc(NULL, s, 0)
165 #define ice_calloc(h, c, s) rte_zmalloc(NULL, (c) * (s), 0)
166 #define ice_free(h, m) rte_free(m)
168 #define ice_memset(a, b, c, d) memset((a), (b), (c))
169 #define ice_memcpy(a, b, c, d) rte_memcpy((a), (b), (c))
170 #define ice_memdup(a, b, c, d) rte_memcpy(ice_malloc(a, c), b, c)
172 #define CPU_TO_BE16(o) rte_cpu_to_be_16(o)
173 #define CPU_TO_BE32(o) rte_cpu_to_be_32(o)
174 #define CPU_TO_BE64(o) rte_cpu_to_be_64(o)
175 #define CPU_TO_LE16(o) rte_cpu_to_le_16(o)
176 #define CPU_TO_LE32(s) rte_cpu_to_le_32(s)
177 #define CPU_TO_LE64(h) rte_cpu_to_le_64(h)
178 #define LE16_TO_CPU(a) rte_le_to_cpu_16(a)
179 #define LE32_TO_CPU(c) rte_le_to_cpu_32(c)
180 #define LE64_TO_CPU(k) rte_le_to_cpu_64(k)
182 #define NTOHS(a) rte_be_to_cpu_16(a)
183 #define NTOHL(a) rte_be_to_cpu_32(a)
184 #define HTONS(a) rte_cpu_to_be_16(a)
185 #define HTONL(a) rte_cpu_to_be_32(a)
189 rte_spinlock_t spinlock;
193 ice_init_lock(struct ice_lock *sp)
195 rte_spinlock_init(&sp->spinlock);
199 ice_acquire_lock(struct ice_lock *sp)
201 rte_spinlock_lock(&sp->spinlock);
205 ice_release_lock(struct ice_lock *sp)
207 rte_spinlock_unlock(&sp->spinlock);
211 ice_destroy_lock(__attribute__((unused)) struct ice_lock *sp)
218 ice_alloc_dma_mem(__attribute__((unused)) struct ice_hw *hw,
219 struct ice_dma_mem *mem, u64 size)
221 const struct rte_memzone *mz = NULL;
222 char z_name[RTE_MEMZONE_NAMESIZE];
227 snprintf(z_name, sizeof(z_name), "ice_dma_%"PRIu64, rte_rand());
228 mz = rte_memzone_reserve_bounded(z_name, size, SOCKET_ID_ANY, 0,
235 mem->pa = mz->phys_addr;
236 mem->zone = (const void *)mz;
237 PMD_DRV_LOG(DEBUG, "memzone %s allocated with physical address: "
238 "%"PRIu64, mz->name, mem->pa);
244 ice_free_dma_mem(__attribute__((unused)) struct ice_hw *hw,
245 struct ice_dma_mem *mem)
247 PMD_DRV_LOG(DEBUG, "memzone %s to be freed with physical address: "
248 "%"PRIu64, ((const struct rte_memzone *)mem->zone)->name,
250 rte_memzone_free((const struct rte_memzone *)mem->zone);
257 ice_hweight8(u32 num)
262 for (i = 0; i < 8; i++) {
263 bits += (u8)(num & 0x1);
271 ice_hweight32(u32 num)
276 for (i = 0; i < 32; i++) {
277 bits += (u8)(num & 0x1);
284 #define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
285 #define DELAY(x) rte_delay_us(x)
286 #define ice_usec_delay(x) rte_delay_us(x)
287 #define ice_msec_delay(x, y) rte_delay_us(1000 * (x))
288 #define udelay(x) DELAY(x)
289 #define msleep(x) DELAY(1000 * (x))
290 #define usleep_range(min, max) msleep(DIV_ROUND_UP(min, 1000))
292 struct ice_list_entry {
293 LIST_ENTRY(ice_list_entry) next;
296 LIST_HEAD(ice_list_head, ice_list_entry);
298 #define LIST_ENTRY_TYPE ice_list_entry
299 #define LIST_HEAD_TYPE ice_list_head
300 #define INIT_LIST_HEAD(list_head) LIST_INIT(list_head)
301 #define LIST_DEL(entry) LIST_REMOVE(entry, next)
302 /* LIST_EMPTY(list_head)) the same in sys/queue.h */
304 /*Note parameters are swapped*/
305 #define LIST_FIRST_ENTRY(head, type, field) (type *)((head)->lh_first)
306 #define LIST_NEXT_ENTRY(entry, type, field) \
307 ((type *)(entry)->field.next.le_next)
308 #define LIST_ADD(entry, list_head) LIST_INSERT_HEAD(list_head, entry, next)
309 #define LIST_ADD_AFTER(entry, list_entry) \
310 LIST_INSERT_AFTER(list_entry, entry, next)
312 static inline void list_add_tail(struct ice_list_entry *entry,
313 struct ice_list_head *head)
315 struct ice_list_entry *tail = head->lh_first;
318 LIST_INSERT_HEAD(head, entry, next);
321 while (tail->next.le_next != NULL)
322 tail = tail->next.le_next;
323 LIST_INSERT_AFTER(tail, entry, next);
326 #define LIST_ADD_TAIL(entry, head) list_add_tail(entry, head)
327 #define LIST_FOR_EACH_ENTRY(pos, head, type, member) \
328 for ((pos) = (head)->lh_first ? \
329 container_of((head)->lh_first, struct type, member) : \
332 (pos) = (pos)->member.next.le_next ? \
333 container_of((pos)->member.next.le_next, struct type, \
337 #define LIST_REPLACE_INIT(list_head, head) do { \
338 (head)->lh_first = (list_head)->lh_first; \
339 INIT_LIST_HEAD(list_head); \
342 #define HLIST_NODE_TYPE LIST_ENTRY_TYPE
343 #define HLIST_HEAD_TYPE LIST_HEAD_TYPE
344 #define INIT_HLIST_HEAD(list_head) INIT_LIST_HEAD(list_head)
345 #define HLIST_ADD_HEAD(entry, list_head) LIST_ADD(entry, list_head)
346 #define HLIST_EMPTY(list_head) LIST_EMPTY(list_head)
347 #define HLIST_DEL(entry) LIST_DEL(entry)
348 #define HLIST_FOR_EACH_ENTRY(pos, head, type, member) \
349 LIST_FOR_EACH_ENTRY(pos, head, type, member)
350 #define LIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, type, member) \
351 LIST_FOR_EACH_ENTRY(pos, head, type, member)
353 #ifndef ICE_DBG_TRACE
354 #define ICE_DBG_TRACE BIT_ULL(0)
357 #ifndef DIVIDE_AND_ROUND_UP
358 #define DIVIDE_AND_ROUND_UP(a, b) (((a) + (b) - 1) / (b))
361 #ifndef ICE_INTEL_VENDOR_ID
362 #define ICE_INTEL_VENDOR_ID 0x8086
365 #ifndef IS_UNICAST_ETHER_ADDR
366 #define IS_UNICAST_ETHER_ADDR(addr) \
367 ((bool)((((u8 *)(addr))[0] % ((u8)0x2)) == 0))
370 #ifndef IS_MULTICAST_ETHER_ADDR
371 #define IS_MULTICAST_ETHER_ADDR(addr) \
372 ((bool)((((u8 *)(addr))[0] % ((u8)0x2)) == 1))
375 #ifndef IS_BROADCAST_ETHER_ADDR
376 /* Check whether an address is broadcast. */
377 #define IS_BROADCAST_ETHER_ADDR(addr) \
378 ((bool)((((u16 *)(addr))[0] == ((u16)0xffff))))
381 #ifndef IS_ZERO_ETHER_ADDR
382 #define IS_ZERO_ETHER_ADDR(addr) \
383 (((bool)((((u16 *)(addr))[0] == ((u16)0x0)))) && \
384 ((bool)((((u16 *)(addr))[1] == ((u16)0x0)))) && \
385 ((bool)((((u16 *)(addr))[2] == ((u16)0x0)))))
388 #endif /* _ICE_OSDEP_H_ */