/***
 * @Author:
 * @Date: 2023-04-04 08:13:11
 * @LastEditors: xxx
 * @LastEditTime: 2023-04-04 08:16:58
 * @Description:
 * @email:
 * @Copyright (c) 2023 by xxx, All Rights Reserved.
 */

#ifndef __OSEL_ARCH_H__
#define __OSEL_ARCH_H__

#include "lib.h"
#define hal_int_state_t char
#ifdef STM32
#include "stm32l4xx.h"
#define HAL_ENTER_CRITICAL(__HANDLE__)        \
    do                                        \
    {                                         \
        if ((__HANDLE__)->Lock == HAL_LOCKED) \
        {                                     \
            return HAL_BUSY;                  \
        }                                     \
        else                                  \
        {                                     \
            (__HANDLE__)->Lock = HAL_LOCKED;  \
        }                                     \
    } while (0U)

#define HAL_EXIT_CRITICAL(__HANDLE__)      \
    do                                     \
    {                                      \
        (__HANDLE__)->Lock = HAL_UNLOCKED; \
    } while (0U)
#else
#define HAL_ENTER_CRITICAL(__HANDLE__)

#define HAL_EXIT_CRITICAL(__HANDLE__)

#endif

#define osel_memset _memset
#define osel_memcmp _memcmp
#define osel_memcpy memcpyL
#define osel_memcpyr memcpyR
#define osel_reverse _reverse
#define osel_mem_alloc _malloc
#define osel_mem_free _free
#define osel_mem_alloc2 _malloc2
#define osel_mem_free2 _free2

#define osel_mstrlen _mstrlen

static inline void *_malloc(uint32_t size)
{
    return mymalloc(SRAMIN, size);
}

static inline void _free(void *ptr)
{
    myfree(SRAMIN, ptr);
}

static inline void *_malloc2(uint32_t size)
{
    return mymalloc(SRAMEX, size);
}

static inline void _free2(void *ptr)
{
    myfree(SRAMEX, ptr);
}
static inline void _memset(uint8_t *dst, uint8_t value, uint16_t size)
{
    while (size--)
    {
        *dst++ = value;
    }
}

/**
 * @brief   比较两个内存区域的内容是否相同
 * @param {uint8_t} *dst
 * @param {uint8_t} *src
 * @param {uint16_t} size
 * @return {*}
 * @note
 */
static inline int8_t _memcmp(const uint8_t *dst, const uint8_t *src, uint16_t size)
{
    while (size--)
    {
        if (*dst++ != *src++)
        {
            return -1;
        }
    }
    return 0;
}

static inline void memcpyL(uint8_t *dst, const uint8_t *src, uint16_t size)
{
    while (size--)
    {
        *dst++ = *src++;
    }
}

static inline void memcpyR(uint8_t *dst, const uint8_t *src, uint16_t size)
{
    dst = dst + (size - 1);
    while (size--)
    {
        *dst-- = *src++;
    }
}

// 字节数组反序
static inline void _reverse(uint8_t *buf, uint16_t len)
{
    uint8_t temp = 0;
    uint16_t i;
    for (i = 0; i < len / 2; i++)
    {
        temp = buf[i];
        buf[i] = buf[len - i - 1];
        buf[len - i - 1] = temp;
    }
}

static inline unsigned int _mstrlen(const unsigned char *s)
{
    const unsigned char *ss = s;
    while (*ss)
        ss++;

    return ss - s;
}

#endif // __OSEL_ARCH_H__