xref: /freebsd/sys/dev/ice/ice_osdep.h (revision 32100375a661c1e16588ddfa7b90ca8d26cb9786)
1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /*  Copyright (c) 2020, Intel Corporation
3  *  All rights reserved.
4  *
5  *  Redistribution and use in source and binary forms, with or without
6  *  modification, are permitted provided that the following conditions are met:
7  *
8  *   1. Redistributions of source code must retain the above copyright notice,
9  *      this list of conditions and the following disclaimer.
10  *
11  *   2. Redistributions in binary form must reproduce the above copyright
12  *      notice, this list of conditions and the following disclaimer in the
13  *      documentation and/or other materials provided with the distribution.
14  *
15  *   3. Neither the name of the Intel Corporation nor the names of its
16  *      contributors may be used to endorse or promote products derived from
17  *      this software without specific prior written permission.
18  *
19  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
23  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  *  POSSIBILITY OF SUCH DAMAGE.
30  */
31 /*$FreeBSD$*/
32 
33 /**
34  * @file ice_osdep.h
35  * @brief OS compatibility layer
36  *
37  * Contains various definitions and functions which are part of an OS
38  * compatibility layer for sharing code with other operating systems.
39  */
40 #ifndef _ICE_OSDEP_H_
41 #define _ICE_OSDEP_H_
42 
43 #include <sys/endian.h>
44 #include <sys/param.h>
45 #include <sys/kernel.h>
46 #include <sys/malloc.h>
47 #include <sys/proc.h>
48 #include <sys/systm.h>
49 #include <sys/lock.h>
50 #include <sys/mutex.h>
51 #include <sys/bus.h>
52 #include <machine/bus.h>
53 #include <sys/bus_dma.h>
54 #include <netinet/in.h>
55 #include <sys/counter.h>
56 #include <sys/sbuf.h>
57 
58 #include "ice_alloc.h"
59 
60 #define ICE_INTEL_VENDOR_ID 0x8086
61 
62 #define ICE_STR_BUF_LEN 32
63 
64 struct ice_hw;
65 
66 device_t ice_hw_to_dev(struct ice_hw *hw);
67 
68 /* configure hw->debug_mask to enable debug prints */
69 void ice_debug(struct ice_hw *hw, uint64_t mask, char *fmt, ...) __printflike(3, 4);
70 void ice_debug_array(struct ice_hw *hw, uint64_t mask, uint32_t rowsize,
71 		     uint32_t groupsize, uint8_t *buf, size_t len);
72 
73 #define ice_info(_hw, _fmt, args...) \
74 	device_printf(ice_hw_to_dev(_hw), (_fmt), ##args)
75 
76 #define ice_warn(_hw, _fmt, args...) \
77 	device_printf(ice_hw_to_dev(_hw), (_fmt), ##args)
78 
79 #define DIVIDE_AND_ROUND_UP howmany
80 #define ROUND_UP roundup
81 
82 uint32_t rd32(struct ice_hw *hw, uint32_t reg);
83 uint64_t rd64(struct ice_hw *hw, uint32_t reg);
84 void wr32(struct ice_hw *hw, uint32_t reg, uint32_t val);
85 void wr64(struct ice_hw *hw, uint32_t reg, uint64_t val);
86 
87 #define ice_flush(_hw) rd32((_hw), GLGEN_STAT)
88 
89 MALLOC_DECLARE(M_ICE_OSDEP);
90 
91 /**
92  * ice_calloc - Allocate an array of elementes
93  * @hw: the hardware private structure
94  * @count: number of elements to allocate
95  * @size: the size of each element
96  *
97  * Allocate memory for an array of items equal to size. Note that the OS
98  * compatibility layer assumes all allocation functions will provide zero'd
99  * memory.
100  */
101 static inline void *
102 ice_calloc(struct ice_hw __unused *hw, size_t count, size_t size)
103 {
104 	return malloc(count * size, M_ICE_OSDEP, M_ZERO | M_NOWAIT);
105 }
106 
107 /**
108  * ice_malloc - Allocate memory of a specified size
109  * @hw: the hardware private structure
110  * @size: the size to allocate
111  *
112  * Allocates memory of the specified size. Note that the OS compatibility
113  * layer assumes that all allocations will provide zero'd memory.
114  */
115 static inline void *
116 ice_malloc(struct ice_hw __unused *hw, size_t size)
117 {
118 	return malloc(size, M_ICE_OSDEP, M_ZERO | M_NOWAIT);
119 }
120 
121 /**
122  * ice_memdup - Allocate a copy of some other memory
123  * @hw: private hardware structure
124  * @src: the source to copy from
125  * @size: allocation size
126  * @dir: the direction of copying
127  *
128  * Allocate memory of the specified size, and copy bytes from the src to fill
129  * it. We don't need to zero this memory as we immediately initialize it by
130  * copying from the src pointer.
131  */
132 static inline void *
133 ice_memdup(struct ice_hw __unused *hw, const void *src, size_t size,
134 	   enum ice_memcpy_type __unused dir)
135 {
136 	void *dst = malloc(size, M_ICE_OSDEP, M_NOWAIT);
137 
138 	if (dst != NULL)
139 		memcpy(dst, src, size);
140 
141 	return dst;
142 }
143 
144 /**
145  * ice_free - Free previously allocated memory
146  * @hw: the hardware private structure
147  * @mem: pointer to the memory to free
148  *
149  * Free memory that was previously allocated by ice_calloc, ice_malloc, or
150  * ice_memdup.
151  */
152 static inline void
153 ice_free(struct ice_hw __unused *hw, void *mem)
154 {
155 	free(mem, M_ICE_OSDEP);
156 }
157 
158 /* These are macros in order to drop the unused direction enumeration constant */
159 #define ice_memset(addr, c, len, unused) memset((addr), (c), (len))
160 #define ice_memcpy(dst, src, len, unused) memcpy((dst), (src), (len))
161 
162 void ice_usec_delay(uint32_t time, bool sleep);
163 void ice_msec_delay(uint32_t time, bool sleep);
164 void ice_msec_pause(uint32_t time);
165 void ice_msec_spin(uint32_t time);
166 
167 #define UNREFERENCED_PARAMETER(_p) _p = _p
168 #define UNREFERENCED_1PARAMETER(_p) do {			\
169 	UNREFERENCED_PARAMETER(_p);				\
170 } while (0)
171 #define UNREFERENCED_2PARAMETER(_p, _q) do {			\
172 	UNREFERENCED_PARAMETER(_p);				\
173 	UNREFERENCED_PARAMETER(_q);				\
174 } while (0)
175 #define UNREFERENCED_3PARAMETER(_p, _q, _r) do {		\
176 	UNREFERENCED_PARAMETER(_p);				\
177 	UNREFERENCED_PARAMETER(_q);				\
178 	UNREFERENCED_PARAMETER(_r);				\
179 } while (0)
180 #define UNREFERENCED_4PARAMETER(_p, _q, _r, _s) do {		\
181 	UNREFERENCED_PARAMETER(_p);				\
182 	UNREFERENCED_PARAMETER(_q);				\
183 	UNREFERENCED_PARAMETER(_r);				\
184 	UNREFERENCED_PARAMETER(_s);				\
185 } while (0)
186 #define UNREFERENCED_5PARAMETER(_p, _q, _r, _s, _t) do {	\
187 	UNREFERENCED_PARAMETER(_p);				\
188 	UNREFERENCED_PARAMETER(_q);				\
189 	UNREFERENCED_PARAMETER(_r);				\
190 	UNREFERENCED_PARAMETER(_s);				\
191 	UNREFERENCED_PARAMETER(_t);				\
192 } while (0)
193 
194 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
195 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
196 #define MAKEMASK(_m, _s) ((_m) << (_s))
197 
198 #define LIST_HEAD_TYPE ice_list_head
199 #define LIST_ENTRY_TYPE ice_list_node
200 
201 /**
202  * @struct ice_list_node
203  * @brief simplified linked list node API
204  *
205  * Represents a node in a linked list, which can be embedded into a structure
206  * to allow that structure to be inserted into a linked list. Access to the
207  * contained structure is done via __containerof
208  */
209 struct ice_list_node {
210 	LIST_ENTRY(ice_list_node) entries;
211 };
212 
213 /**
214  * @struct ice_list_head
215  * @brief simplified linked list head API
216  *
217  * Represents the head of a linked list. The linked list should consist of
218  * a series of ice_list_node structures embedded into another structure
219  * accessed using __containerof. This way, the ice_list_head doesn't need to
220  * know the type of the structure it contains.
221  */
222 LIST_HEAD(ice_list_head, ice_list_node);
223 
224 #define INIT_LIST_HEAD LIST_INIT
225 /* LIST_EMPTY doesn't need to be changed */
226 #define LIST_ADD(entry, head) LIST_INSERT_HEAD(head, entry, entries)
227 #define LIST_ADD_AFTER(entry, elem) LIST_INSERT_AFTER(elem, entry, entries)
228 #define LIST_DEL(entry) LIST_REMOVE(entry, entries)
229 #define _osdep_LIST_ENTRY(ptr, type, member) \
230 	__containerof(ptr, type, member)
231 #define LIST_FIRST_ENTRY(head, type, member) \
232 	_osdep_LIST_ENTRY(LIST_FIRST(head), type, member)
233 #define LIST_NEXT_ENTRY(ptr, unused, member) \
234 	_osdep_LIST_ENTRY(LIST_NEXT(&(ptr->member), entries), __typeof(*ptr), member)
235 #define LIST_REPLACE_INIT(old_head, new_head) do {			\
236 	__typeof(new_head) _new_head = (new_head);			\
237 	LIST_INIT(_new_head);						\
238 	LIST_SWAP(old_head, _new_head, ice_list_node, entries);		\
239 } while (0)
240 
241 #define LIST_ENTRY_SAFE(_ptr, _type, _member) \
242 ({ __typeof(_ptr) ____ptr = (_ptr); \
243    ____ptr ? _osdep_LIST_ENTRY(____ptr, _type, _member) : NULL; \
244 })
245 
246 /**
247  * ice_get_list_tail - Return the pointer to the last node in the list
248  * @head: the pointer to the head of the list
249  *
250  * A helper function for implementing LIST_ADD_TAIL and LIST_LAST_ENTRY.
251  * Returns the pointer to the last node in the list, or NULL of the list is
252  * empty.
253  *
254  * Note: due to the list implementation this is O(N), where N is the size of
255  * the list. An O(1) implementation requires replacing the underlying list
256  * datastructure with one that has a tail pointer. This is problematic,
257  * because using a simple TAILQ would require that the addition and deletion
258  * be given the head of the list.
259  */
260 static inline struct ice_list_node *
261 ice_get_list_tail(struct ice_list_head *head)
262 {
263 	struct ice_list_node *node = LIST_FIRST(head);
264 
265 	if (node == NULL)
266 		return NULL;
267 	while (LIST_NEXT(node, entries) != NULL)
268 		node = LIST_NEXT(node, entries);
269 
270 	return node;
271 }
272 
273 /* TODO: This is O(N). An O(1) implementation would require a different
274  * underlying list structure, such as a circularly linked list. */
275 #define LIST_ADD_TAIL(entry, head) do {					\
276 	struct ice_list_node *node = ice_get_list_tail(head);		\
277 									\
278 	if (node == NULL) {						\
279 		LIST_ADD(entry, head);					\
280 	} else {							\
281 		LIST_INSERT_AFTER(node, entry, entries);		\
282 	}								\
283 } while (0)
284 
285 #define LIST_LAST_ENTRY(head, type, member) \
286 	LIST_ENTRY_SAFE(ice_get_list_tail(head), type, member)
287 
288 #define LIST_FIRST_ENTRY_SAFE(head, type, member) \
289 	LIST_ENTRY_SAFE(LIST_FIRST(head), type, member)
290 
291 #define LIST_NEXT_ENTRY_SAFE(ptr, member) \
292 	LIST_ENTRY_SAFE(LIST_NEXT(&(ptr->member), entries), __typeof(*ptr), member)
293 
294 #define LIST_FOR_EACH_ENTRY(pos, head, unused, member) \
295 	for (pos = LIST_FIRST_ENTRY_SAFE(head, __typeof(*pos), member);		\
296 	    pos;								\
297 	    pos = LIST_NEXT_ENTRY_SAFE(pos, member))
298 
299 #define LIST_FOR_EACH_ENTRY_SAFE(pos, n, head, unused, member) \
300 	for (pos = LIST_FIRST_ENTRY_SAFE(head, __typeof(*pos), member);		\
301 	     pos && ({ n = LIST_NEXT_ENTRY_SAFE(pos, member); 1; });		\
302 	     pos = n)
303 
304 #define STATIC static
305 
306 #define NTOHS ntohs
307 #define NTOHL ntohl
308 #define HTONS htons
309 #define HTONL htonl
310 #define LE16_TO_CPU le16toh
311 #define LE32_TO_CPU le32toh
312 #define LE64_TO_CPU le64toh
313 #define CPU_TO_LE16 htole16
314 #define CPU_TO_LE32 htole32
315 #define CPU_TO_LE64 htole64
316 #define CPU_TO_BE16 htobe16
317 #define CPU_TO_BE32 htobe32
318 
319 #define SNPRINTF snprintf
320 
321 /**
322  * @typedef u8
323  * @brief compatibility typedef for uint8_t
324  */
325 typedef uint8_t  u8;
326 
327 /**
328  * @typedef u16
329  * @brief compatibility typedef for uint16_t
330  */
331 typedef uint16_t u16;
332 
333 /**
334  * @typedef u32
335  * @brief compatibility typedef for uint32_t
336  */
337 typedef uint32_t u32;
338 
339 /**
340  * @typedef u64
341  * @brief compatibility typedef for uint64_t
342  */
343 typedef uint64_t u64;
344 
345 /**
346  * @typedef s8
347  * @brief compatibility typedef for int8_t
348  */
349 typedef int8_t  s8;
350 
351 /**
352  * @typedef s16
353  * @brief compatibility typedef for int16_t
354  */
355 typedef int16_t s16;
356 
357 /**
358  * @typedef s32
359  * @brief compatibility typedef for int32_t
360  */
361 typedef int32_t s32;
362 
363 /**
364  * @typedef s64
365  * @brief compatibility typedef for int64_t
366  */
367 typedef int64_t s64;
368 
369 #define __le16 u16
370 #define __le32 u32
371 #define __le64 u64
372 #define __be16 u16
373 #define __be32 u32
374 #define __be64 u64
375 
376 #define ice_hweight8(x) bitcount16((u8)x)
377 #define ice_hweight16(x) bitcount16(x)
378 #define ice_hweight32(x) bitcount32(x)
379 #define ice_hweight64(x) bitcount64(x)
380 
381 /**
382  * @struct ice_dma_mem
383  * @brief DMA memory allocation
384  *
385  * Contains DMA allocation bits, used to simplify DMA allocations.
386  */
387 struct ice_dma_mem {
388 	void *va;
389 	uint64_t pa;
390 	size_t size;
391 
392 	bus_dma_tag_t		tag;
393 	bus_dmamap_t		map;
394 	bus_dma_segment_t	seg;
395 };
396 
397 
398 void * ice_alloc_dma_mem(struct ice_hw *hw, struct ice_dma_mem *mem, u64 size);
399 void ice_free_dma_mem(struct ice_hw __unused *hw, struct ice_dma_mem *mem);
400 
401 /**
402  * @struct ice_lock
403  * @brief simplified lock API
404  *
405  * Contains a simple lock implementation used to lock various resources.
406  */
407 struct ice_lock {
408 	struct mtx mutex;
409 	char name[ICE_STR_BUF_LEN];
410 };
411 
412 extern u16 ice_lock_count;
413 
414 /**
415  * ice_init_lock - Initialize a lock for use
416  * @lock: the lock memory to initialize
417  *
418  * OS compatibility layer to provide a simple locking mechanism. We use
419  * a mutex for this purpose.
420  */
421 static inline void
422 ice_init_lock(struct ice_lock *lock)
423 {
424 	/*
425 	 * Make each lock unique by incrementing a counter each time this
426 	 * function is called. Use of a u16 allows 65535 possible locks before
427 	 * we'd hit a duplicate.
428 	 */
429 	memset(lock->name, 0, sizeof(lock->name));
430 	snprintf(lock->name, ICE_STR_BUF_LEN, "ice_lock_%u", ice_lock_count++);
431 	mtx_init(&lock->mutex, lock->name, NULL, MTX_DEF);
432 }
433 
434 /**
435  * ice_acquire_lock - Acquire the lock
436  * @lock: the lock to acquire
437  *
438  * Acquires the mutex specified by the lock pointer.
439  */
440 static inline void
441 ice_acquire_lock(struct ice_lock *lock)
442 {
443 	mtx_lock(&lock->mutex);
444 }
445 
446 /**
447  * ice_release_lock - Release the lock
448  * @lock: the lock to release
449  *
450  * Releases the mutex specified by the lock pointer.
451  */
452 static inline void
453 ice_release_lock(struct ice_lock *lock)
454 {
455 	mtx_unlock(&lock->mutex);
456 }
457 
458 /**
459  * ice_destroy_lock - Destroy the lock to de-allocate it
460  * @lock: the lock to destroy
461  *
462  * Destroys a previously initialized lock. We only do this if the mutex was
463  * previously initialized.
464  */
465 static inline void
466 ice_destroy_lock(struct ice_lock *lock)
467 {
468 	if (mtx_initialized(&lock->mutex))
469 		mtx_destroy(&lock->mutex);
470 	memset(lock->name, 0, sizeof(lock->name));
471 }
472 
473 /* Some function parameters are unused outside of MPASS/KASSERT macros. Rather
474  * than marking these as __unused all the time, mark them as __invariant_only,
475  * and define this to __unused when INVARIANTS is disabled. Otherwise, define
476  * it empty so that __invariant_only parameters are caught as unused by the
477  * INVARIANTS build.
478  */
479 #ifndef INVARIANTS
480 #define __invariant_only __unused
481 #else
482 #define __invariant_only
483 #endif
484 
485 #define __ALWAYS_UNUSED __unused
486 
487 /**
488  * ice_ilog2 - Calculate the integer log base 2 of a 64bit value
489  * @n: 64bit number
490  *
491  * Calculates the integer log base 2 of a 64bit value, rounded down.
492  *
493  * @remark The integer log base 2 of zero is technically undefined, but this
494  * function will return 0 in that case.
495  *
496  */
497 static inline int
498 ice_ilog2(u64 n) {
499 	if (n == 0)
500 		return 0;
501 	return flsll(n) - 1;
502 }
503 
504 /**
505  * ice_is_pow2 - Check if the value is a power of 2
506  * @n: 64bit number
507  *
508  * Check if the given value is a power of 2.
509  *
510  * @remark FreeBSD's powerof2 function treats zero as a power of 2, while this
511  * function does not.
512  *
513  * @returns true or false
514  */
515 static inline bool
516 ice_is_pow2(u64 n) {
517 	if (n == 0)
518 		return false;
519 	return powerof2(n);
520 }
521 #endif /* _ICE_OSDEP_H_ */
522