diff options
Diffstat (limited to 'sys/dev/ice/ice_osdep.h')
| -rw-r--r-- | sys/dev/ice/ice_osdep.h | 524 |
1 files changed, 524 insertions, 0 deletions
diff --git a/sys/dev/ice/ice_osdep.h b/sys/dev/ice/ice_osdep.h new file mode 100644 index 000000000000..ea355ddb31f4 --- /dev/null +++ b/sys/dev/ice/ice_osdep.h @@ -0,0 +1,524 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* Copyright (c) 2024, Intel Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @file ice_osdep.h + * @brief OS compatibility layer + * + * Contains various definitions and functions which are part of an OS + * compatibility layer for sharing code with other operating systems. + */ +#ifndef _ICE_OSDEP_H_ +#define _ICE_OSDEP_H_ + +#include <sys/endian.h> +#include <sys/param.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/proc.h> +#include <sys/systm.h> +#include <sys/lock.h> +#include <sys/mutex.h> +#include <sys/bus.h> +#include <machine/bus.h> +#include <sys/bus_dma.h> +#include <netinet/in.h> +#include <sys/counter.h> +#include <sys/sbuf.h> + +#include "ice_alloc.h" + +#define ICE_INTEL_VENDOR_ID 0x8086 + +#define ICE_STR_BUF_LEN 32 + +struct ice_hw; + +device_t ice_hw_to_dev(struct ice_hw *hw); + +/* configure hw->debug_mask to enable debug prints */ +void ice_debug(struct ice_hw *hw, uint64_t mask, char *fmt, ...) __printflike(3, 4); +void ice_debug_array(struct ice_hw *hw, uint64_t mask, uint32_t rowsize, + uint32_t groupsize, uint8_t *buf, size_t len); +void ice_info_fwlog(struct ice_hw *hw, uint32_t rowsize, uint32_t groupsize, + uint8_t *buf, size_t len); + +#define ice_fls(_n) flsl(_n) + +#define ice_info(_hw, _fmt, args...) \ + device_printf(ice_hw_to_dev(_hw), (_fmt), ##args) + +#define ice_warn(_hw, _fmt, args...) \ + device_printf(ice_hw_to_dev(_hw), (_fmt), ##args) + +#define DIVIDE_AND_ROUND_UP howmany +#define ROUND_UP roundup + +uint32_t rd32(struct ice_hw *hw, uint32_t reg); +uint64_t rd64(struct ice_hw *hw, uint32_t reg); +void wr32(struct ice_hw *hw, uint32_t reg, uint32_t val); +void wr64(struct ice_hw *hw, uint32_t reg, uint64_t val); + +#define ice_flush(_hw) rd32((_hw), GLGEN_STAT) + +MALLOC_DECLARE(M_ICE_OSDEP); + +/** + * ice_calloc - Allocate an array of elementes + * @hw: the hardware private structure + * @count: number of elements to allocate + * @size: the size of each element + * + * Allocate memory for an array of items equal to size. Note that the OS + * compatibility layer assumes all allocation functions will provide zero'd + * memory. + */ +static inline void * +ice_calloc(struct ice_hw __unused *hw, size_t count, size_t size) +{ + return malloc(count * size, M_ICE_OSDEP, M_ZERO | M_NOWAIT); +} + +/** + * ice_malloc - Allocate memory of a specified size + * @hw: the hardware private structure + * @size: the size to allocate + * + * Allocates memory of the specified size. Note that the OS compatibility + * layer assumes that all allocations will provide zero'd memory. + */ +static inline void * +ice_malloc(struct ice_hw __unused *hw, size_t size) +{ + return malloc(size, M_ICE_OSDEP, M_ZERO | M_NOWAIT); +} + +/** + * ice_memdup - Allocate a copy of some other memory + * @hw: private hardware structure + * @src: the source to copy from + * @size: allocation size + * @dir: the direction of copying + * + * Allocate memory of the specified size, and copy bytes from the src to fill + * it. We don't need to zero this memory as we immediately initialize it by + * copying from the src pointer. + */ +static inline void * +ice_memdup(struct ice_hw __unused *hw, const void *src, size_t size, + enum ice_memcpy_type __unused dir) +{ + void *dst = malloc(size, M_ICE_OSDEP, M_NOWAIT); + + if (dst != NULL) + memcpy(dst, src, size); + + return dst; +} + +/** + * ice_free - Free previously allocated memory + * @hw: the hardware private structure + * @mem: pointer to the memory to free + * + * Free memory that was previously allocated by ice_calloc, ice_malloc, or + * ice_memdup. + */ +static inline void +ice_free(struct ice_hw __unused *hw, void *mem) +{ + free(mem, M_ICE_OSDEP); +} + +/* These are macros in order to drop the unused direction enumeration constant */ +#define ice_memset(addr, c, len, unused) memset((addr), (c), (len)) +#define ice_memcpy(dst, src, len, unused) memcpy((dst), (src), (len)) + +void ice_usec_delay(uint32_t time, bool sleep); +void ice_msec_delay(uint32_t time, bool sleep); +void ice_msec_pause(uint32_t time); +void ice_msec_spin(uint32_t time); + +#define UNREFERENCED_PARAMETER(_p) _p = _p +#define UNREFERENCED_1PARAMETER(_p) do { \ + UNREFERENCED_PARAMETER(_p); \ +} while (0) +#define UNREFERENCED_2PARAMETER(_p, _q) do { \ + UNREFERENCED_PARAMETER(_p); \ + UNREFERENCED_PARAMETER(_q); \ +} while (0) +#define UNREFERENCED_3PARAMETER(_p, _q, _r) do { \ + UNREFERENCED_PARAMETER(_p); \ + UNREFERENCED_PARAMETER(_q); \ + UNREFERENCED_PARAMETER(_r); \ +} while (0) +#define UNREFERENCED_4PARAMETER(_p, _q, _r, _s) do { \ + UNREFERENCED_PARAMETER(_p); \ + UNREFERENCED_PARAMETER(_q); \ + UNREFERENCED_PARAMETER(_r); \ + UNREFERENCED_PARAMETER(_s); \ +} while (0) +#define UNREFERENCED_5PARAMETER(_p, _q, _r, _s, _t) do { \ + UNREFERENCED_PARAMETER(_p); \ + UNREFERENCED_PARAMETER(_q); \ + UNREFERENCED_PARAMETER(_r); \ + UNREFERENCED_PARAMETER(_s); \ + UNREFERENCED_PARAMETER(_t); \ +} while (0) + +#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f)) +#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) +#define MAKEMASK(_m, _s) ((_m) << (_s)) + +#define LIST_HEAD_TYPE ice_list_head +#define LIST_ENTRY_TYPE ice_list_node + +/** + * @struct ice_list_node + * @brief simplified linked list node API + * + * Represents a node in a linked list, which can be embedded into a structure + * to allow that structure to be inserted into a linked list. Access to the + * contained structure is done via __containerof + */ +struct ice_list_node { + LIST_ENTRY(ice_list_node) entries; +}; + +/** + * @struct ice_list_head + * @brief simplified linked list head API + * + * Represents the head of a linked list. The linked list should consist of + * a series of ice_list_node structures embedded into another structure + * accessed using __containerof. This way, the ice_list_head doesn't need to + * know the type of the structure it contains. + */ +LIST_HEAD(ice_list_head, ice_list_node); + +#define INIT_LIST_HEAD LIST_INIT +/* LIST_EMPTY doesn't need to be changed */ +#define LIST_ADD(entry, head) LIST_INSERT_HEAD(head, entry, entries) +#define LIST_ADD_AFTER(entry, elem) LIST_INSERT_AFTER(elem, entry, entries) +#define LIST_DEL(entry) LIST_REMOVE(entry, entries) +#define _osdep_LIST_ENTRY(ptr, type, member) \ + __containerof(ptr, type, member) +#define LIST_FIRST_ENTRY(head, type, member) \ + _osdep_LIST_ENTRY(LIST_FIRST(head), type, member) +#define LIST_NEXT_ENTRY(ptr, unused, member) \ + _osdep_LIST_ENTRY(LIST_NEXT(&(ptr->member), entries), __typeof(*ptr), member) +#define LIST_REPLACE_INIT(old_head, new_head) do { \ + __typeof(new_head) _new_head = (new_head); \ + LIST_INIT(_new_head); \ + LIST_SWAP(old_head, _new_head, ice_list_node, entries); \ +} while (0) + +#define LIST_ENTRY_SAFE(_ptr, _type, _member) \ +({ __typeof(_ptr) ____ptr = (_ptr); \ + ____ptr ? _osdep_LIST_ENTRY(____ptr, _type, _member) : NULL; \ +}) + +/** + * ice_get_list_tail - Return the pointer to the last node in the list + * @head: the pointer to the head of the list + * + * A helper function for implementing LIST_ADD_TAIL and LIST_LAST_ENTRY. + * Returns the pointer to the last node in the list, or NULL of the list is + * empty. + * + * Note: due to the list implementation this is O(N), where N is the size of + * the list. An O(1) implementation requires replacing the underlying list + * datastructure with one that has a tail pointer. This is problematic, + * because using a simple TAILQ would require that the addition and deletion + * be given the head of the list. + */ +static inline struct ice_list_node * +ice_get_list_tail(struct ice_list_head *head) +{ + struct ice_list_node *node = LIST_FIRST(head); + + if (node == NULL) + return NULL; + while (LIST_NEXT(node, entries) != NULL) + node = LIST_NEXT(node, entries); + + return node; +} + +/* TODO: This is O(N). An O(1) implementation would require a different + * underlying list structure, such as a circularly linked list. */ +#define LIST_ADD_TAIL(entry, head) do { \ + struct ice_list_node *node = ice_get_list_tail(head); \ + \ + if (node == NULL) { \ + LIST_ADD(entry, head); \ + } else { \ + LIST_INSERT_AFTER(node, entry, entries); \ + } \ +} while (0) + +#define LIST_LAST_ENTRY(head, type, member) \ + LIST_ENTRY_SAFE(ice_get_list_tail(head), type, member) + +#define LIST_FIRST_ENTRY_SAFE(head, type, member) \ + LIST_ENTRY_SAFE(LIST_FIRST(head), type, member) + +#define LIST_NEXT_ENTRY_SAFE(ptr, member) \ + LIST_ENTRY_SAFE(LIST_NEXT(&(ptr->member), entries), __typeof(*ptr), member) + +#define LIST_FOR_EACH_ENTRY(pos, head, unused, member) \ + for (pos = LIST_FIRST_ENTRY_SAFE(head, __typeof(*pos), member); \ + pos; \ + pos = LIST_NEXT_ENTRY_SAFE(pos, member)) + +#define LIST_FOR_EACH_ENTRY_SAFE(pos, n, head, unused, member) \ + for (pos = LIST_FIRST_ENTRY_SAFE(head, __typeof(*pos), member); \ + pos && ({ n = LIST_NEXT_ENTRY_SAFE(pos, member); 1; }); \ + pos = n) + +#define STATIC static + +#define NTOHS ntohs +#define NTOHL ntohl +#define HTONS htons +#define HTONL htonl +#define LE16_TO_CPU le16toh +#define LE32_TO_CPU le32toh +#define LE64_TO_CPU le64toh +#define CPU_TO_LE16 htole16 +#define CPU_TO_LE32 htole32 +#define CPU_TO_LE64 htole64 +#define CPU_TO_BE16 htobe16 +#define CPU_TO_BE32 htobe32 + +#define SNPRINTF snprintf + +/** + * @typedef u8 + * @brief compatibility typedef for uint8_t + */ +typedef uint8_t u8; + +/** + * @typedef u16 + * @brief compatibility typedef for uint16_t + */ +typedef uint16_t u16; + +/** + * @typedef u32 + * @brief compatibility typedef for uint32_t + */ +typedef uint32_t u32; + +/** + * @typedef u64 + * @brief compatibility typedef for uint64_t + */ +typedef uint64_t u64; + +/** + * @typedef s8 + * @brief compatibility typedef for int8_t + */ +typedef int8_t s8; + +/** + * @typedef s16 + * @brief compatibility typedef for int16_t + */ +typedef int16_t s16; + +/** + * @typedef s32 + * @brief compatibility typedef for int32_t + */ +typedef int32_t s32; + +/** + * @typedef s64 + * @brief compatibility typedef for int64_t + */ +typedef int64_t s64; + +#define __le16 u16 +#define __le32 u32 +#define __le64 u64 +#define __be16 u16 +#define __be32 u32 +#define __be64 u64 + +#define ice_hweight8(x) bitcount16((u8)x) +#define ice_hweight16(x) bitcount16(x) +#define ice_hweight32(x) bitcount32(x) +#define ice_hweight64(x) bitcount64(x) + +/** + * @struct ice_dma_mem + * @brief DMA memory allocation + * + * Contains DMA allocation bits, used to simplify DMA allocations. + */ +struct ice_dma_mem { + void *va; + uint64_t pa; + size_t size; + + bus_dma_tag_t tag; + bus_dmamap_t map; + bus_dma_segment_t seg; +}; + + +void * ice_alloc_dma_mem(struct ice_hw *hw, struct ice_dma_mem *mem, u64 size); +void ice_free_dma_mem(struct ice_hw __unused *hw, struct ice_dma_mem *mem); + +/** + * @struct ice_lock + * @brief simplified lock API + * + * Contains a simple lock implementation used to lock various resources. + */ +struct ice_lock { + struct mtx mutex; + char name[ICE_STR_BUF_LEN]; +}; + +extern u16 ice_lock_count; + +/** + * ice_init_lock - Initialize a lock for use + * @lock: the lock memory to initialize + * + * OS compatibility layer to provide a simple locking mechanism. We use + * a mutex for this purpose. + */ +static inline void +ice_init_lock(struct ice_lock *lock) +{ + /* + * Make each lock unique by incrementing a counter each time this + * function is called. Use of a u16 allows 65535 possible locks before + * we'd hit a duplicate. + */ + memset(lock->name, 0, sizeof(lock->name)); + snprintf(lock->name, ICE_STR_BUF_LEN, "ice_lock_%u", ice_lock_count++); + mtx_init(&lock->mutex, lock->name, NULL, MTX_DEF); +} + +/** + * ice_acquire_lock - Acquire the lock + * @lock: the lock to acquire + * + * Acquires the mutex specified by the lock pointer. + */ +static inline void +ice_acquire_lock(struct ice_lock *lock) +{ + mtx_lock(&lock->mutex); +} + +/** + * ice_release_lock - Release the lock + * @lock: the lock to release + * + * Releases the mutex specified by the lock pointer. + */ +static inline void +ice_release_lock(struct ice_lock *lock) +{ + mtx_unlock(&lock->mutex); +} + +/** + * ice_destroy_lock - Destroy the lock to de-allocate it + * @lock: the lock to destroy + * + * Destroys a previously initialized lock. We only do this if the mutex was + * previously initialized. + */ +static inline void +ice_destroy_lock(struct ice_lock *lock) +{ + if (mtx_initialized(&lock->mutex)) + mtx_destroy(&lock->mutex); + memset(lock->name, 0, sizeof(lock->name)); +} + +/* Some function parameters are unused outside of MPASS/KASSERT macros. Rather + * than marking these as __unused all the time, mark them as __invariant_only, + * and define this to __unused when INVARIANTS is disabled. Otherwise, define + * it empty so that __invariant_only parameters are caught as unused by the + * INVARIANTS build. + */ +#ifndef INVARIANTS +#define __invariant_only __unused +#else +#define __invariant_only +#endif + +#define __ALWAYS_UNUSED __unused + +/** + * ice_ilog2 - Calculate the integer log base 2 of a 64bit value + * @n: 64bit number + * + * Calculates the integer log base 2 of a 64bit value, rounded down. + * + * @remark The integer log base 2 of zero is technically undefined, but this + * function will return 0 in that case. + * + */ +static inline int +ice_ilog2(u64 n) { + if (n == 0) + return 0; + return flsll(n) - 1; +} + +/** + * ice_is_pow2 - Check if the value is a power of 2 + * @n: 64bit number + * + * Check if the given value is a power of 2. + * + * @remark FreeBSD's powerof2 function treats zero as a power of 2, while this + * function does not. + * + * @returns true or false + */ +static inline bool +ice_is_pow2(u64 n) { + if (n == 0) + return false; + return powerof2(n); +} +#endif /* _ICE_OSDEP_H_ */ |