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 <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 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) \
        ((long) (IS_ARRAY(array) + (sizeof(array) / sizeof((array)[0]))))
 
#endif /* __cplusplus */
 
#define PART_OF_ARRAY(array, ptr) \
        ((ptr) && ((ptr) >= &array[0] && (ptr) < &array[ARRAY_SIZE(array)]))
 
#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
/* Use Z_MAX for a GCC-only, single evaluation version */
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif
 
#ifndef MIN
/* Use Z_MIN for a GCC-only, single evaluation version */
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
 
#ifndef CLAMP
/* Use Z_CLAMP for a GCC-only, single evaluation version */
#define CLAMP(val, low, high) (((val) <= (low)) ? (low) : MIN(val, high))
#endif
 
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) {
                ((uint8_t *)dst)[i] = ((uint8_t *)src)[i];
        }
}
 
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);
 
#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)
 
#endif /* ZEPHYR_INCLUDE_SYS_UTIL_H_ */