/*
 * Copyright (c) 2019-2023 Beijing Hanwei Innovation Technology Ltd. Co. and
 * its subsidiaries and affiliates (collectly called MKSEMI).
 *
 * 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, except as embedded into an MKSEMI
 *    integrated circuit in a product or a software update for such product,
 *    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 MKSEMI nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    MKSEMI integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be
 *    reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY MKSEMI "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL MKSEMI 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.
 */

#ifndef MK_COMMON_H_
#define MK_COMMON_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "MK800X.h"
#include "user_config.h"

/**
 * @addtogroup MK8000_Common
 * @{
 */

/* Development board type - EVK */
#define MK8000_EVK 0
/* Development board type - DK */
#define MK8000_DK 1

/* Macro for ram function */
#if defined(XIP_EN)
#define RAM_FUNC __attribute__((section(".RAMCODE")))
#else
#define RAM_FUNC
#endif

/** Determine whether the bit of the register is set */
#define REG_IS_BIT_SET(REG, BIT) (((REG) & (BIT)) == (BIT))
/** Determine whether the bit of the register is clear */
#define REG_IS_BIT_CLR(REG, BIT) (((REG) & (BIT)) == 0U)

/** set bit field of a data */
#define SET_BIT_FIELD(data, mask, pos, value) (((data) & ~mask) | ((uint32_t)((value) << pos) & mask))
/** get bit field of a data */
#define GET_BIT_FIELD(data, mask, pos) (((data)&mask) >> pos)

/** read byte from register */
#define REG_READ_BYTE(addr) (*(const volatile uint8_t *)(addr))
/** write byte to register */
#define REG_WRITE_BYTE(addr, value) (*(volatile uint8_t *)(addr) = (value))

/** read word from register */
#define REG_READ(addr) (*(const volatile uint32_t *)(addr))
/** write word to register */
#define REG_WRITE(addr, value) (*(volatile uint32_t *)(addr) = (value))

/** modify bit field of register */
#define REG_MODIFY(addr, mask, value) REG_WRITE(addr, (REG_READ(addr) & (uint32_t)~mask) | value)
/** read bit field from register */
#define REG_READ_BIT_FIELD(addr, width, pos) ((REG_READ(addr) >> pos) & ((1 << (width)) - 1))

/** read word from an unaligned address */
#define READ_WORD(x) ((uint32_t)(REG_READ_BYTE(x) | (REG_READ_BYTE(x + 1) << 8) | (REG_READ_BYTE(x + 2) << 16) | (REG_READ_BYTE(x + 3) << 24)))
/** read half word from an unaligned address */
#define READ_SHORT(x) ((uint16_t)(REG_READ_BYTE(x) | (REG_READ_BYTE(x + 1) << 8)))

/** write word to an unaligned address */
#define WRITE_WORD(data, addr)                             \
    ((uint8_t *)addr)[0] = (uint8_t)(data & 0xFF);         \
    ((uint8_t *)addr)[1] = (uint8_t)((data >> 8) & 0xFF);  \
    ((uint8_t *)addr)[2] = (uint8_t)((data >> 16) & 0xFF); \
    ((uint8_t *)addr)[3] = (uint8_t)((data >> 24) & 0xFF)
/** write half word to an unaligned address */
#define WRITE_SHORT(data, addr)                    \
    ((uint8_t *)addr)[0] = (uint8_t)(data & 0xFF); \
    ((uint8_t *)addr)[1] = (uint8_t)((data >> 8) & 0xFF)

/** get array size  */
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))

#ifndef MAX
/** maximum  */
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif

#ifndef MIN
/** minimum */
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif

#ifndef ABS
/** absolute  */
#define ABS(x) (((x) < 0) ? (-(x)) : (x))
#endif

/** [x bits for choice] [8 bits mux ID] */
#define MUX(m, choice) ((m) | ((choice) << 8))

#define UNUSED(X) (void)(X)

#define CHECK_BITS_VALID(x, bits) (((x) & (bits)) == (bits))

// driver return code
#define DRV_OK 0x00U
#define DRV_ERROR 0x01U
#define DRV_BUSY 0x02U
#define DRV_TIMEOUT 0x03U
#define DRV_DEV_UNAVAILABLE 0x04U

// check RAM address and Word alignment
#define CHK_RAM_WORD_ADDR(x) (((uint32_t)(x)&0xFFFC0003) == SRAM_BASE)

/// interrupt priority
enum IRQ_PRIORITY_LEVEL_T
{
    IRQ_PRIORITY_REALTIME = 0,
    IRQ_PRIORITY_HIGH = 1,
    IRQ_PRIORITY_NORMAL = 2,
    IRQ_PRIORITY_LOW = 3,
};

/**
 * @brief Disable global interrupt.
 *
 * @return primask
 *
 */
static inline uint32_t int_lock(void)
{
    uint32_t pri = __get_PRIMASK();
    if ((pri & 0x1) == 0)
    {
        __disable_irq();
    }
    return pri;
}

/**
 * @brief Enable global interrupt.
 *
 * @param[in]  pri          Primask
 *
 */
static inline void int_unlock(uint32_t pri)
{
    if ((pri & 0x1) == 0)
    {
        __enable_irq();
    }
}

/**
 * This is a generic data type used for handling callback functions
 * with each driver.
 *
 * @param[in] dev           Device handle
 * @param[in] err_code      Event error code
 * @note
 * The usage of the eCode argument is typically negative for an error
 * code and positive for an event code.
 *
 */
typedef void (*drv_callback_t)(void *dev, uint32_t err_code);

#ifdef __cplusplus
}
#endif

/**
 * @}
 */

#endif /* MK_COMMON_H_ */