1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Huawei Technologies Co., Ltd
3 */
4
5 #ifndef _HINIC_COMPAT_H_
6 #define _HINIC_COMPAT_H_
7
8 #include <stdint.h>
9 #include <sys/time.h>
10 #include <unistd.h>
11 #include <pthread.h>
12 #include <rte_common.h>
13 #include <rte_bitops.h>
14 #include <rte_byteorder.h>
15 #include <rte_memzone.h>
16 #include <rte_memcpy.h>
17 #include <rte_malloc.h>
18 #include <rte_atomic.h>
19 #include <rte_spinlock.h>
20 #include <rte_cycles.h>
21 #include <rte_log.h>
22
23 typedef uint8_t u8;
24 typedef int8_t s8;
25 typedef uint16_t u16;
26 typedef uint32_t u32;
27 typedef int32_t s32;
28 typedef uint64_t u64;
29
30 #ifndef dma_addr_t
31 typedef uint64_t dma_addr_t;
32 #endif
33
34 #ifndef gfp_t
35 #define gfp_t unsigned
36 #endif
37
38 #ifndef bool
39 #define bool int
40 #endif
41
42 #ifndef FALSE
43 #define FALSE (0)
44 #endif
45
46 #ifndef TRUE
47 #define TRUE (1)
48 #endif
49
50 #ifndef false
51 #define false (0)
52 #endif
53
54 #ifndef true
55 #define true (1)
56 #endif
57
58 #ifndef NULL
59 #define NULL ((void *)0)
60 #endif
61
62 #define HINIC_ERROR (-1)
63 #define HINIC_OK (0)
64
65 #ifndef BIT
66 #define BIT(n) (1 << (n))
67 #endif
68
69 #define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
70 #define lower_32_bits(n) ((u32)(n))
71
72 /* Returns X / Y, rounding up. X must be nonnegative to round correctly. */
73 #define DIV_ROUND_UP(X, Y) (((X) + ((Y) - 1)) / (Y))
74
75 /* Returns X rounded up to the nearest multiple of Y. */
76 #define ROUND_UP(X, Y) (DIV_ROUND_UP(X, Y) * (Y))
77
78 #undef ALIGN
79 #define ALIGN(x, a) RTE_ALIGN(x, a)
80
81 #define PTR_ALIGN(p, a) ((typeof(p))ALIGN((unsigned long)(p), (a)))
82
83 /* Reported driver name. */
84 #define HINIC_DRIVER_NAME "net_hinic"
85
86 extern int hinic_logtype;
87
88 #define PMD_DRV_LOG(level, fmt, args...) \
89 rte_log(RTE_LOG_ ## level, hinic_logtype, \
90 HINIC_DRIVER_NAME": " fmt "\n", ##args)
91
92 /* common definition */
93 #ifndef ETH_ALEN
94 #define ETH_ALEN 6
95 #endif
96 #define ETH_HLEN 14
97 #define ETH_CRC_LEN 4
98 #define VLAN_PRIO_SHIFT 13
99 #define VLAN_N_VID 4096
100
101 /* bit order interface */
102 #define cpu_to_be16(o) rte_cpu_to_be_16(o)
103 #define cpu_to_be32(o) rte_cpu_to_be_32(o)
104 #define cpu_to_be64(o) rte_cpu_to_be_64(o)
105 #define cpu_to_le32(o) rte_cpu_to_le_32(o)
106 #define be16_to_cpu(o) rte_be_to_cpu_16(o)
107 #define be32_to_cpu(o) rte_be_to_cpu_32(o)
108 #define be64_to_cpu(o) rte_be_to_cpu_64(o)
109 #define le32_to_cpu(o) rte_le_to_cpu_32(o)
110
111 /* virt memory and dma phy memory */
112 #define __iomem
113 #define GFP_KERNEL RTE_MEMZONE_IOVA_CONTIG
114 #define HINIC_PAGE_SHIFT 12
115 #define HINIC_PAGE_SIZE RTE_PGSIZE_4K
116 #define HINIC_MEM_ALLOC_ALIGN_MIN 8
117
118 #define HINIC_PAGE_SIZE_DPDK 6
119
120 void *dma_zalloc_coherent(void *dev, size_t size, dma_addr_t *dma_handle,
121 unsigned int socket_id);
122
123 void *dma_zalloc_coherent_aligned(void *hwdev, size_t size,
124 dma_addr_t *dma_handle, unsigned int socket_id);
125
126 void *dma_zalloc_coherent_aligned256k(void *hwdev, size_t size,
127 dma_addr_t *dma_handle, unsigned int socket_id);
128
129 void dma_free_coherent(void *dev, size_t size, void *virt, dma_addr_t phys);
130
131 /* dma pool alloc and free */
132 #define pci_pool dma_pool
133 #define pci_pool_alloc(pool, handle) dma_pool_alloc(pool, handle)
134 #define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
135
136 struct dma_pool *dma_pool_create(const char *name, void *dev, size_t size,
137 size_t align, size_t boundary);
138 void dma_pool_destroy(struct dma_pool *pool);
139 void *dma_pool_alloc(struct pci_pool *pool, dma_addr_t *dma_addr);
140 void dma_pool_free(struct pci_pool *pool, void *vaddr, dma_addr_t dma);
141
142 #define kzalloc(size, flag) rte_zmalloc(NULL, size, HINIC_MEM_ALLOC_ALIGN_MIN)
143 #define kzalloc_aligned(size, flag) rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE)
144 #define kfree(ptr) rte_free(ptr)
145
146 /* mmio interface */
writel(u32 value,volatile void * addr)147 static inline void writel(u32 value, volatile void *addr)
148 {
149 *(volatile u32 *)addr = value;
150 }
151
readl(const volatile void * addr)152 static inline u32 readl(const volatile void *addr)
153 {
154 return *(const volatile u32 *)addr;
155 }
156
157 #define __raw_writel(value, reg) writel((value), (reg))
158 #define __raw_readl(reg) readl((reg))
159
160 /* Spinlock related interface */
161 #define hinic_spinlock_t rte_spinlock_t
162
163 #define spinlock_t rte_spinlock_t
164 #define spin_lock_init(spinlock_prt) rte_spinlock_init(spinlock_prt)
165 #define spin_lock_deinit(lock)
166 #define spin_lock(spinlock_prt) rte_spinlock_lock(spinlock_prt)
167 #define spin_unlock(spinlock_prt) rte_spinlock_unlock(spinlock_prt)
168
169 #ifdef CLOCK_MONOTONIC_RAW /* Defined in glibc bits/time.h */
170 #define CLOCK_TYPE CLOCK_MONOTONIC_RAW
171 #else
172 #define CLOCK_TYPE CLOCK_MONOTONIC
173 #endif
174
clock_gettime_ms(void)175 static inline unsigned long clock_gettime_ms(void)
176 {
177 struct timespec tv;
178
179 (void)clock_gettime(CLOCK_TYPE, &tv);
180
181 return (unsigned long)tv.tv_sec * 1000 +
182 (unsigned long)tv.tv_nsec / 1000000;
183 }
184
185 #define jiffies clock_gettime_ms()
186 #define msecs_to_jiffies(ms) (ms)
187 #define time_before(now, end) ((now) < (end))
188
189 /* misc kernel utils */
ilog2(u32 n)190 static inline u16 ilog2(u32 n)
191 {
192 u16 res = 0;
193
194 while (n > 1) {
195 n >>= 1;
196 res++;
197 }
198
199 return res;
200 }
201
hinic_mutex_init(pthread_mutex_t * pthreadmutex,const pthread_mutexattr_t * mattr)202 static inline int hinic_mutex_init(pthread_mutex_t *pthreadmutex,
203 const pthread_mutexattr_t *mattr)
204 {
205 int err;
206
207 err = pthread_mutex_init(pthreadmutex, mattr);
208 if (unlikely(err))
209 PMD_DRV_LOG(ERR, "Fail to initialize mutex, error: %d", err);
210
211 return err;
212 }
213
hinic_mutex_destroy(pthread_mutex_t * pthreadmutex)214 static inline int hinic_mutex_destroy(pthread_mutex_t *pthreadmutex)
215 {
216 int err;
217
218 err = pthread_mutex_destroy(pthreadmutex);
219 if (unlikely(err))
220 PMD_DRV_LOG(ERR, "Fail to destroy mutex, error: %d", err);
221
222 return err;
223 }
224
hinic_mutex_lock(pthread_mutex_t * pthreadmutex)225 static inline int hinic_mutex_lock(pthread_mutex_t *pthreadmutex)
226 {
227 int err;
228
229 err = pthread_mutex_lock(pthreadmutex);
230 if (!err) {
231 return err;
232 } else if (err == EOWNERDEAD) {
233 PMD_DRV_LOG(ERR, "Mutex lock failed. (ErrorNo=%d)", errno);
234 #if defined(__GLIBC__)
235 #if __GLIBC_PREREQ(2, 12)
236 (void)pthread_mutex_consistent(pthreadmutex);
237 #else
238 (void)pthread_mutex_consistent_np(pthreadmutex);
239 #endif
240 #else
241 (void)pthread_mutex_consistent(pthreadmutex);
242 #endif
243 } else {
244 PMD_DRV_LOG(ERR, "Mutex lock failed. (ErrorNo=%d)", errno);
245 }
246
247 return err;
248 }
249
hinic_mutex_unlock(pthread_mutex_t * pthreadmutex)250 static inline int hinic_mutex_unlock(pthread_mutex_t *pthreadmutex)
251 {
252 return pthread_mutex_unlock(pthreadmutex);
253 }
254
255 #endif /* _HINIC_COMPAT_H_ */
256