/**
 ***********************************************************************************************************************
 * Copyright (c) 2020, China Mobile Communications Group Co.,Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file        os_kernel_internal.h
 *
 * @brief       Provides some macro definitions and function declarations, only use for kernel.
 *
 * @revision
 * Date         Author          Notes
 * 2020-03-03   OneOS Team      First version.
 ***********************************************************************************************************************
 */
#ifndef __OS_KERNEL_INTERNAL_H__
#define __OS_KERNEL_INTERNAL_H__

#include <oneos_config.h>
#include <os_types.h>
#include <os_stddef.h>
#include <os_assert.h>
#include "os_prototypes.h"
#include <os_task.h>
#include <stdlib.h>
#include <os_memory.h>
#include <arch_interrupt.h>
#include <arch_misc.h>

#ifdef __cplusplus
extern "C" {
#endif

#define OS_KERNEL_VERSION "Kernel-V3.0.0"

#define OS_KERNEL_ERR_INFO "The created object already exists."

#ifdef OS_USING_HEAP
#define OS_KERNEL_MALLOC(size)                  os_malloc(size)
#define OS_KERNEL_MALLOC_ALIGN(alignment, size) os_aligned_malloc(alignment, size)

#define OS_KERNEL_FREE(ptr)          os_free(ptr)
#define OS_KERNEL_REALLOC(ptr, size) os_realloc(ptr, size)
#else
#define OS_KERNEL_MALLOC(size)
#define OS_KERNEL_MALLOC_ALIGN(alignment, size)

#define OS_KERNEL_FREE(ptr)
#define OS_KERNEL_REALLOC(ptr, size)
#endif /* OS_USING_HEAP */

#define OS_KOBJ_INITED   0x55
#define OS_KOBJ_DEINITED 0xAA

#define OS_ALLOC_TYPE_STATIC        0
#define OS_KOBJ_ALLOC_TYPE_DYNAMIC  (1 << 0)
#define OS_KDATA_ALLOC_TYPE_DYNAMIC (1 << 1)

#define OS_TYPE_CONVERT(type, obj) ((type)(obj))

#ifdef OS_USING_KERNEL_DEBUG

/* Kernel log level */
#define KERN_ERROR   0 /* Error conditions */
#define KERN_WARNING 1 /* Warning conditions */
#define KERN_INFO    2 /* Informational */
#define KERN_DEBUG   3 /* Debug-level messages */

#ifdef KLOG_WITH_FUNC_LINE

/**
 ***********************************************************************************************************************
 * @def         OS_KERN_LOG
 *
 * @brief       Print kernel log with function name and file line number.
 *
 * @param       level           The log level.
 * @param       tag             The log tag.
 * @param       fmt             The format.
 ***********************************************************************************************************************
 */
#define OS_KERN_LOG(level, tag, fmt, ...)                                                                              \
    do                                                                                                                 \
    {                                                                                                                  \
        if ((level <= *g_klog_global_lvl) || (g_klog_tag_lvl_list->next != g_klog_tag_lvl_list))                       \
        {                                                                                                              \
            os_kernel_print(level, tag, OS_TRUE, fmt " [%s][%d]", ##__VA_ARGS__, __FUNCTION__, __LINE__);              \
        }                                                                                                              \
    } while (0)

#else

/**
 ***********************************************************************************************************************
 * @def         OS_KERN_LOG
 *
 * @brief       Print kernel log without function name and file line number.
 *
 * @param       level           The log level.
 * @param       tag             The log tag.
 * @param       fmt             The format.
 ***********************************************************************************************************************
 */
#define OS_KERN_LOG(level, tag, fmt, ...)                                                                              \
    do                                                                                                                 \
    {                                                                                                                  \
        if ((level <= *g_klog_global_lvl) || (g_klog_tag_lvl_list->next != g_klog_tag_lvl_list))                       \
        {                                                                                                              \
            os_kernel_print(level, tag, OS_TRUE, fmt, ##__VA_ARGS__);                                                  \
        }                                                                                                              \
    } while (0)

#endif /* KLOG_WITH_FUNC_LINE */

extern const int16_t        *g_klog_global_lvl;
extern const os_list_node_t *g_klog_tag_lvl_list;

extern void os_kernel_print(uint16_t level, const char *tag, os_bool_t newline, const char *fmt, ...);

#else
#define OS_KERN_LOG(level, tag, fmt, ...)
#endif /* OS_USING_KERNEL_DEBUG */

#ifdef OS_USING_SMP
extern os_task_t *g_os_current_task[OS_SMP_MAX_CPUS];
extern os_task_t *g_os_next_task[OS_SMP_MAX_CPUS];

extern void _k_task_close(os_task_t *task);

OS_INLINE os_task_t *k_task_self(void)
{
    os_ubase_t irq_save;
    os_task_t *task;

    irq_save = os_irq_lock();

    task = g_os_current_task[os_cpu_id_get()];

    os_irq_unlock(irq_save);

    return task;
}

#define _k_task_self() g_os_current_task[os_cpu_id_get()]

#else
extern os_task_t *g_os_current_task;
extern os_task_t *g_os_next_task;
extern os_task_t *g_os_high_task;

extern int16_t g_os_sched_lock_cnt;

#define k_task_self() g_os_current_task

#define _k_task_self() g_os_current_task

#endif

extern void k_tickq_init(void);
extern void k_tickq_put(struct os_task *task, os_tick_t timeout);
extern void k_tickq_remove(struct os_task *task);

extern void      k_readyq_put(struct os_task *task);
extern void      k_readyq_remove(struct os_task *task);
extern os_bool_t k_readyq_move_tail(struct os_task *task);

extern void k_sched_init(void);

extern void k_start(void);

extern void k_recycle_task_init(void);
extern void k_idle_task_init(void);

extern void k_blockq_insert(os_list_node_t *head, struct os_task *task);
extern os_err_t
k_block_task(os_spinlock_t *lock, os_ubase_t irq_save, os_list_node_t *head, os_tick_t timeout, os_bool_t is_wake_prio);

extern os_bool_t k_unblock_task(os_task_t *task);
extern os_bool_t k_cancel_all_blocked_task(const os_list_node_t *head);

#ifdef OS_USING_SHELL
struct block_task_info
{
    char   *name;             /* Task name */
    uint8_t current_priority; /* Task current priority. */
};
typedef struct block_task_info block_task_info_t;

extern void k_show_blocked_task(block_task_info_t *info, uint16_t block_task_cnt);
#endif

#ifdef OS_USING_HASH_BUCKET_TIMER
extern void      k_timer_module_init(void);
extern os_bool_t k_timer_need_handle(void);
extern void      k_move_timer_list_one_step(void);

#ifdef OS_HASH_BUCKET_TIMER_SORT
extern os_tick_t k_timer_get_next_remain_ticks(void);
extern void      k_timer_update_active_list(os_tick_t ticks);
#endif

#endif

#ifdef OS_USING_SINGLE_LIST_TIMER
extern void      k_single_list_timer_module_init(void);
extern os_tick_t k_single_list_timer_get_next_remain_ticks(void);
extern os_bool_t k_single_list_timer_update_active_list(os_tick_t ticks);

#ifdef OS_SOFT_SINGLE_LIST_TIMER
extern os_bool_t k_single_list_timer_need_handle(void);
#endif

#ifdef OS_HARD_SINGLE_LIST_TIMER
extern void k_single_list_timer_tick_proc(void);
#endif

#endif

#ifdef OS_USING_SMP
extern void       k_kernel_spin_lock(void);
extern void       k_kernel_spin_unlock(void);
extern os_ubase_t k_kernel_enter(void);
extern void       k_kernel_exit(os_ubase_t irq_save);
extern void       k_kernel_irq_enable(void);
extern os_ubase_t k_kernel_irq_get(void);
extern void       k_smp_cpu_bootup(int cpu_index);
extern os_ubase_t k_smp_cpu_boot_stat(int cpu_index);
extern void       k_sched_send_ipi(int32_t cpu, uint32_t need_sched_bits);
extern int32_t    k_kernel_lock_owne(void);
extern os_ubase_t k_kernel_lock_owner_catch(void);
extern void       exc_analysis(void);
extern void       k_kernel_exit_sched(os_ubase_t irq_save);

#define OS_KERNEL_ENTER()      irq_save = k_kernel_enter()
#define OS_KERNEL_EXIT()       k_kernel_exit(irq_save)
#define OS_KERNEL_EXIT_SCHED() k_kernel_exit_sched(irq_save)
#define OS_KERNEL_INIT()       os_ubase_t irq_save

#else

extern int32_t g_os_kernel_lock_cnt;

#define OS_KERNEL_INIT() os_ubase_t irq_save

#ifdef OS_USING_KERNEL_LOCK_CHECK
#define OS_KERNEL_ENTER()                                                                                              \
    do                                                                                                                 \
    {                                                                                                                  \
        irq_save = os_irq_lock();                                                                                      \
        k_kernel_enter_check();                                                                                        \
    } while (0)

#define OS_KERNEL_EXIT()                                                                                               \
    do                                                                                                                 \
    {                                                                                                                  \
        k_kernel_exit_check();                                                                                         \
        os_irq_unlock(irq_save);                                                                                       \
    } while (0)

#define OS_KERNEL_LOCK_REF_DEC()                                                                                       \
    do                                                                                                                 \
    {                                                                                                                  \
        g_os_kernel_lock_cnt--;                                                                                        \
    } while (0)

#define OS_KERNEL_LOCK_REF_INC()                                                                                       \
    do                                                                                                                 \
    {                                                                                                                  \
        g_os_kernel_lock_cnt++;                                                                                        \
    } while (0)

#else
#define OS_KERNEL_ENTER()                                                                                              \
    do                                                                                                                 \
    {                                                                                                                  \
        irq_save = os_irq_lock();                                                                                      \
    } while (0)

#define OS_KERNEL_EXIT()                                                                                               \
    do                                                                                                                 \
    {                                                                                                                  \
        os_irq_unlock(irq_save);                                                                                       \
    } while (0)

#define OS_KERNEL_LOCK_REF_DEC()

#define OS_KERNEL_LOCK_REF_INC()

#endif /* OS_USING_KERNEL_LOCK_CHECK */

#define OS_KERNEL_EXIT_SCHED()                                                                                         \
    do                                                                                                                 \
    {                                                                                                                  \
        if ((OS_NULL == g_os_current_task) || (0 != g_os_sched_lock_cnt))                                              \
        {                                                                                                              \
            OS_KERNEL_EXIT();                                                                                          \
        }                                                                                                              \
        else                                                                                                           \
        {                                                                                                              \
            g_os_next_task = g_os_high_task;                                                                           \
                                                                                                                       \
            if (g_os_current_task != g_os_next_task)                                                                   \
            {                                                                                                          \
                OS_KERNEL_LOCK_REF_DEC();                                                                              \
                os_task_switch();                                                                                      \
                OS_KERNEL_LOCK_REF_INC();                                                                              \
            }                                                                                                          \
                                                                                                                       \
            OS_KERNEL_EXIT();                                                                                          \
        }                                                                                                              \
    } while (0)

extern void k_kernel_enter_check(void);
extern void k_kernel_exit_check(void);

#endif /* OS_USING_SMP */

#ifdef __cplusplus
}
#endif

#endif /* __OS_KERNEL_INTERNAL_H__ */