util.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2014, Wind River Systems, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_SYS_UTIL_H_
#define ZEPHYR_INCLUDE_SYS_UTIL_H_
 
#include <zephyr/sys/util_macro.h>
 
/* needs to be outside _ASMLANGUAGE so 'true' and 'false' can turn
 * into '1' and '0' for asm or linker scripts
 */
#include <stdbool.h>
 
#ifndef _ASMLANGUAGE
 
#include <zephyr/types.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define POINTER_TO_UINT(x) ((uintptr_t) (x))
#define UINT_TO_POINTER(x) ((void *) (uintptr_t) (x))
#define POINTER_TO_INT(x)  ((intptr_t) (x))
#define INT_TO_POINTER(x)  ((void *) (intptr_t) (x))
 
#if !(defined(__CHAR_BIT__) && defined(__SIZEOF_LONG__))
#       error Missing required predefined macros for BITS_PER_LONG calculation
#endif
 
#define BITS_PER_LONG   (__CHAR_BIT__ * __SIZEOF_LONG__)
 
#define GENMASK(h, l) \
        (((~0UL) - (1UL << (l)) + 1) & (~0UL >> (BITS_PER_LONG - 1 - (h))))
 
#define LSB_GET(value) ((value) & -(value))
 
#define FIELD_GET(mask, value)  (((value) & (mask)) / LSB_GET(mask))
 
#define FIELD_PREP(mask, value) (((value) * LSB_GET(mask)) & (mask))
 
#define ZERO_OR_COMPILE_ERROR(cond) ((int) sizeof(char[1 - 2 * !(cond)]) - 1)
 
#if defined(__cplusplus)
 
/* The built-in function used below for type checking in C is not
 * supported by GNU C++.
 */
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
 
#else /* __cplusplus */
 
#define IS_ARRAY(array) \
        ZERO_OR_COMPILE_ERROR( \
                !__builtin_types_compatible_p(__typeof__(array), \
                                              __typeof__(&(array)[0])))
 
#define ARRAY_SIZE(array) \
        ((size_t) (IS_ARRAY(array) + (sizeof(array) / sizeof((array)[0]))))
 
#endif /* __cplusplus */
 
#define IS_ARRAY_ELEMENT(array, ptr)                                                               \
        ((ptr) && POINTER_TO_UINT(array) <= POINTER_TO_UINT(ptr) &&                          \
         POINTER_TO_UINT(ptr) < POINTER_TO_UINT(&(array)[ARRAY_SIZE(array)]) &&                    \
         (POINTER_TO_UINT(ptr) - POINTER_TO_UINT(array)) % sizeof((array)[0]) == 0)
 
#define ARRAY_INDEX(array, ptr)                                                                    \
        ({                                                                                         \
                __ASSERT_NO_MSG(IS_ARRAY_ELEMENT(array, ptr));                                     \
                (__typeof__((array)[0]) *)(ptr) - (array);                                         \
        })
 
#define PART_OF_ARRAY(array, ptr)                                                                  \
        ((ptr) && POINTER_TO_UINT(array) <= POINTER_TO_UINT(ptr) &&                                \
         POINTER_TO_UINT(ptr) < POINTER_TO_UINT(&(array)[ARRAY_SIZE(array)]))
 
#define ARRAY_INDEX_FLOOR(array, ptr)                                                              \
        ({                                                                                         \
                __ASSERT_NO_MSG(PART_OF_ARRAY(array, ptr));                                        \
                (POINTER_TO_UINT(ptr) - POINTER_TO_UINT(array)) / sizeof((array)[0]);              \
        })
 
#define CONTAINER_OF(ptr, type, field) \
        ((type *)(((char *)(ptr)) - offsetof(type, field)))
 
#define ROUND_UP(x, align)                                   \
        (((unsigned long)(x) + ((unsigned long)(align) - 1)) & \
         ~((unsigned long)(align) - 1))
 
#define ROUND_DOWN(x, align)                                 \
        ((unsigned long)(x) & ~((unsigned long)(align) - 1))
 
#define WB_UP(x) ROUND_UP(x, sizeof(void *))
 
#define WB_DN(x) ROUND_DOWN(x, sizeof(void *))
 
#define ceiling_fraction(numerator, divider) \
        (((numerator) + ((divider) - 1)) / (divider))
 
#ifndef MAX
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif
 
#ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
 
#ifndef CLAMP
#define CLAMP(val, low, high) (((val) <= (low)) ? (low) : MIN(val, high))
#endif
 
#define IN_RANGE(val, min, max) ((val) >= (min) && (val) <= (max))
 
static inline bool is_power_of_two(unsigned int x)
{
        return (x != 0U) && ((x & (x - 1U)) == 0U);
}
 
static inline int64_t arithmetic_shift_right(int64_t value, uint8_t shift)
{
        int64_t sign_ext;
 
        if (shift == 0U) {
                return value;
        }
 
        /* extract sign bit */
        sign_ext = (value >> 63) & 1;
 
        /* make all bits of sign_ext be the same as the value's sign bit */
        sign_ext = -sign_ext;
 
        /* shift value and fill opened bit positions with sign bit */
        return (value >> shift) | (sign_ext << (64 - shift));
}
 
static inline void bytecpy(void *dst, const void *src, size_t size)
{
        size_t i;
 
        for (i = 0; i < size; ++i) {
                ((volatile uint8_t *)dst)[i] = ((volatile const uint8_t *)src)[i];
        }
}
 
static inline void byteswp(void *a, void *b, size_t size)
{
        uint8_t t;
        uint8_t *aa = (uint8_t *)a;
        uint8_t *bb = (uint8_t *)b;
 
        for (; size > 0; --size) {
                t = *aa;
                *aa++ = *bb;
                *bb++ = t;
        }
}
 
int char2hex(char c, uint8_t *x);
 
int hex2char(uint8_t x, char *c);
 
size_t bin2hex(const uint8_t *buf, size_t buflen, char *hex, size_t hexlen);
 
size_t hex2bin(const char *hex, size_t hexlen, uint8_t *buf, size_t buflen);
 
static inline uint8_t bcd2bin(uint8_t bcd)
{
        return ((10 * (bcd >> 4)) + (bcd & 0x0F));
}
 
static inline uint8_t bin2bcd(uint8_t bin)
{
        return (((bin / 10) << 4) | (bin % 10));
}
 
uint8_t u8_to_dec(char *buf, uint8_t buflen, uint8_t value);
 
char *utf8_trunc(char *utf8_str);
 
char *utf8_lcpy(char *dst, const char *src, size_t n);
 
#ifdef __cplusplus
}
#endif
 
#endif /* !_ASMLANGUAGE */
 
#ifdef _LINKER
/* This is used in linker scripts so need to avoid type casting there */
#define KB(x) ((x) << 10)
#else
#define KB(x) (((size_t)x) << 10)
#endif
#define MB(x) (KB(x) << 10)
#define GB(x) (MB(x) << 10)
 
#define KHZ(x) ((x) * 1000)
#define MHZ(x) (KHZ(x) * 1000)
 
#define WAIT_FOR(expr, timeout, delay_stmt)                                                        \
        ({                                                                                         \
                uint32_t cycle_count = k_us_to_cyc_ceil32(timeout); \
                uint32_t start = k_cycle_get_32();                                                 \
                while (!(expr) && (cycle_count > (k_cycle_get_32() - start))) {                    \
                        delay_stmt;                                                                \
                }                                                                                  \
                (expr);                                                                            \
        })
 
#endif /* ZEPHYR_INCLUDE_SYS_UTIL_H_ */