dao_util.h

Go to the documentation of this file.

/* SPDX-License-Identifier: Marvell-MIT
 * Copyright (c) 2023 Marvell.
 */
 
#ifndef __DAO_UTIL_H__
#define __DAO_UTIL_H__
 
#define DAO_FREE(ptr)                                                                              \
    do {                                                                                       \
        free(ptr);                                                                         \
        ptr = NULL;                                                                        \
    } while (0)
 
#define DAO_ROUNDUP(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
 
#define DAO_ROUNDDOWN(x, y) ((x / y) * y)
 
#define DAO_BIT(nr) (1UL << (nr))
 
#define DAO_BIT_ULL(nr) (1ULL << (nr))
 
#define DAO_BITS_PER_LONG_LONG (__SIZEOF_LONG_LONG__ * 8)
 
#define DAO_GENMASK_ULL(h, l) (((~0ULL) << (l)) & (~0ULL >> (DAO_BITS_PER_LONG_LONG - 1 - (h))))
 
#define DAO_STATIC_ASSERT(s) _Static_assert(s, #s)
 
#define DAO_TAILQ_FOREACH_SAFE(var, head, field, tvar)                                             \
    for ((var) = TAILQ_FIRST((head)); (var) && ((tvar) = TAILQ_NEXT((var), field), 1);         \
         (var) = (tvar))
 
#define DAO_PAD_BYTES_TO_MATCH(larger, smaller)                                                    \
    uint8_t _pad[sizeof(larger) > sizeof(smaller) ? sizeof(larger) - sizeof(smaller) : 0]
 
static inline bool
dao_check_bit_is_set(int n, int pos)
{
    return (n & (1 << (pos - 1))) != 0;
}
 
int dao_pci_bdf_to_hw_func(const char *pci_bdf);
 
static inline volatile void *
dao_dev_memcpy(volatile void *d, const volatile void *s, size_t l)
{
    const volatile uint8_t *sb;
    volatile uint8_t *db;
    size_t i;
 
    if (!d || !s)
        return NULL;
    db = (volatile uint8_t *)d;
    sb = (const volatile uint8_t *)s;
    for (i = 0; i < l; i++)
        db[i] = sb[i];
    return d;
}
 
static inline void
dao_dev_memset(volatile void *d, uint8_t val, size_t l)
{
    volatile uint8_t *db;
    size_t i = 0;
 
    if (!d || !l)
        return;
    db = (volatile uint8_t *)d;
    for (i = 0; i < l; i++)
        db[i] = val;
}
 
static inline void
dao_dev_memzero(volatile void *d, size_t l)
{
    volatile uint64_t *db;
    size_t i = 0;
 
    if (!d || !l || (l % 8))
        return;
 
    db = (volatile uint64_t *)d;
    for (i = 0; i < l; i++)
        db[i] = 0;
}
#endif /* __DAO_UTIL_H__ */