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