arch_interface.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_SYS_ARCH_INTERFACE_H_
#define ZEPHYR_INCLUDE_SYS_ARCH_INTERFACE_H_
 
#ifndef _ASMLANGUAGE
#include <zephyr/toolchain.h>
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/arch/cpu.h>
#include <zephyr/irq_offload.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* NOTE: We cannot pull in kernel.h here, need some forward declarations  */
struct k_thread;
struct k_mem_domain;
 
typedef struct z_thread_stack_element k_thread_stack_t;
 
typedef void (*k_thread_entry_t)(void *p1, void *p2, void *p3);
 
static inline uint32_t arch_k_cycle_get_32(void);
 
static inline uint64_t arch_k_cycle_get_64(void);
 
void arch_cpu_idle(void);
 
void arch_cpu_atomic_idle(unsigned int key);
 
typedef FUNC_NORETURN void (*arch_cpustart_t)(void *data);
 
void arch_start_cpu(int cpu_num, k_thread_stack_t *stack, int sz,
                    arch_cpustart_t fn, void *arg);
 
bool arch_cpu_active(int cpu_num);
 
static inline unsigned int arch_irq_lock(void);
 
static inline void arch_irq_unlock(unsigned int key);
 
static inline bool arch_irq_unlocked(unsigned int key);
 
void arch_irq_disable(unsigned int irq);
 
void arch_irq_enable(unsigned int irq);
 
int arch_irq_is_enabled(unsigned int irq);
 
int arch_irq_connect_dynamic(unsigned int irq, unsigned int priority,
                             void (*routine)(const void *parameter),
                             const void *parameter, uint32_t flags);
 
#ifdef CONFIG_PCIE
#endif /* CONFIG_PCIE */
 
#ifndef CONFIG_PCIE_CONTROLLER
unsigned int arch_irq_allocate(void);
 
void arch_irq_set_used(unsigned int irq);
 
bool arch_irq_is_used(unsigned int irq);
 
#endif /* CONFIG_PCIE_CONTROLLER */
 
#ifdef CONFIG_IRQ_OFFLOAD
void arch_irq_offload(irq_offload_routine_t routine, const void *parameter);
#endif /* CONFIG_IRQ_OFFLOAD */
 
#ifdef CONFIG_SMP
static inline struct _cpu *arch_curr_cpu(void);
 
 
static inline uint32_t arch_proc_id(void);
 
void arch_sched_ipi(void);
 
#endif /* CONFIG_SMP */
 
static inline unsigned int arch_num_cpus(void);
 
#ifdef CONFIG_USERSPACE
static inline uintptr_t arch_syscall_invoke0(uintptr_t call_id);
 
static inline uintptr_t arch_syscall_invoke1(uintptr_t arg1,
                                             uintptr_t call_id);
 
static inline uintptr_t arch_syscall_invoke2(uintptr_t arg1, uintptr_t arg2,
                                             uintptr_t call_id);
 
static inline uintptr_t arch_syscall_invoke3(uintptr_t arg1, uintptr_t arg2,
                                             uintptr_t arg3,
                                             uintptr_t call_id);
 
static inline uintptr_t arch_syscall_invoke4(uintptr_t arg1, uintptr_t arg2,
                                             uintptr_t arg3, uintptr_t arg4,
                                             uintptr_t call_id);
 
static inline uintptr_t arch_syscall_invoke5(uintptr_t arg1, uintptr_t arg2,
                                             uintptr_t arg3, uintptr_t arg4,
                                             uintptr_t arg5,
                                             uintptr_t call_id);
 
static inline uintptr_t arch_syscall_invoke6(uintptr_t arg1, uintptr_t arg2,
                                             uintptr_t arg3, uintptr_t arg4,
                                             uintptr_t arg5, uintptr_t arg6,
                                             uintptr_t call_id);
 
static inline bool arch_is_user_context(void);
 
int arch_mem_domain_max_partitions_get(void);
 
#ifdef CONFIG_ARCH_MEM_DOMAIN_DATA
int arch_mem_domain_init(struct k_mem_domain *domain);
#endif /* CONFIG_ARCH_MEM_DOMAIN_DATA */
 
#ifdef CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API
int arch_mem_domain_thread_add(struct k_thread *thread);
 
int arch_mem_domain_thread_remove(struct k_thread *thread);
 
int arch_mem_domain_partition_remove(struct k_mem_domain *domain,
                                     uint32_t partition_id);
 
int arch_mem_domain_partition_add(struct k_mem_domain *domain,
                                  uint32_t partition_id);
#endif /* CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API */
 
int arch_buffer_validate(void *addr, size_t size, int write);
 
size_t arch_virt_region_align(uintptr_t phys, size_t size);
 
FUNC_NORETURN void arch_user_mode_enter(k_thread_entry_t user_entry,
                                        void *p1, void *p2, void *p3);
 
FUNC_NORETURN void arch_syscall_oops(void *ssf);
 
size_t arch_user_string_nlen(const char *s, size_t maxsize, int *err);
#endif /* CONFIG_USERSPACE */
 
#ifndef CONFIG_ARCH_HAS_COHERENCE
static inline bool arch_mem_coherent(void *ptr)
{
        ARG_UNUSED(ptr);
        return true;
}
#endif
 
#ifndef CONFIG_KERNEL_COHERENCE
static inline void arch_cohere_stacks(struct k_thread *old_thread,
                                      void *old_switch_handle,
                                      struct k_thread *new_thread)
{
        ARG_UNUSED(old_thread);
        ARG_UNUSED(old_switch_handle);
        ARG_UNUSED(new_thread);
}
#endif
 
#ifdef CONFIG_GDBSTUB
struct gdb_ctx;
 
void arch_gdb_init(void);
 
void arch_gdb_continue(void);
 
void arch_gdb_step(void);
 
size_t arch_gdb_reg_readall(struct gdb_ctx *ctx, uint8_t *buf, size_t buflen);
 
size_t arch_gdb_reg_writeall(struct gdb_ctx *ctx, uint8_t *hex, size_t hexlen);
 
size_t arch_gdb_reg_readone(struct gdb_ctx *ctx, uint8_t *buf, size_t buflen,
                            uint32_t regno);
 
size_t arch_gdb_reg_writeone(struct gdb_ctx *ctx, uint8_t *hex, size_t hexlen,
                             uint32_t regno);
 
int arch_gdb_add_breakpoint(struct gdb_ctx *ctx, uint8_t type,
                            uintptr_t addr, uint32_t kind);
 
int arch_gdb_remove_breakpoint(struct gdb_ctx *ctx, uint8_t type,
                               uintptr_t addr, uint32_t kind);
 
#endif
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_ARCH_CACHE)
#if defined(CONFIG_DCACHE)
 
void arch_dcache_enable(void);
 
void arch_dcache_disable(void);
 
int arch_dcache_flush_all(void);
 
int arch_dcache_invd_all(void);
 
int arch_dcache_flush_and_invd_all(void);
 
int arch_dcache_flush_range(void *addr, size_t size);
 
int arch_dcache_invd_range(void *addr, size_t size);
 
int arch_dcache_flush_and_invd_range(void *addr, size_t size);
 
#if defined(CONFIG_DCACHE_LINE_SIZE_DETECT)
size_t arch_dcache_line_size_get(void);
#endif /* CONFIG_DCACHE_LINE_SIZE_DETECT */
 
#endif /* CONFIG_DCACHE */
 
#if defined(CONFIG_ICACHE)
void arch_icache_enable(void);
 
void arch_icache_disable(void);
 
int arch_icache_flush_all(void);
 
int arch_icache_invd_all(void);
 
int arch_icache_flush_and_invd_all(void);
 
int arch_icache_flush_range(void *addr, size_t size);
 
int arch_icache_invd_range(void *addr, size_t size);
 
int arch_icache_flush_and_invd_range(void *addr, size_t size);
 
#if defined(CONFIG_ICACHE_LINE_SIZE_DETECT)
size_t arch_icache_line_size_get(void);
#endif /* CONFIG_ICACHE_LINE_SIZE_DETECT */
 
#endif /* CONFIG_ICACHE */
#endif /* CONFIG_CACHE_MANAGEMENT && CONFIG_ARCH_CACHE */
 
#ifdef CONFIG_TIMING_FUNCTIONS
#include <zephyr/timing/types.h>
 
void arch_timing_init(void);
 
void arch_timing_start(void);
 
void arch_timing_stop(void);
 
timing_t arch_timing_counter_get(void);
 
uint64_t arch_timing_cycles_get(volatile timing_t *const start,
                                volatile timing_t *const end);
 
uint64_t arch_timing_freq_get(void);
 
uint64_t arch_timing_cycles_to_ns(uint64_t cycles);
 
uint64_t arch_timing_cycles_to_ns_avg(uint64_t cycles, uint32_t count);
 
uint32_t arch_timing_freq_get_mhz(void);
 
#endif /* CONFIG_TIMING_FUNCTIONS */
 
#ifdef CONFIG_PCIE_MSI_MULTI_VECTOR
 
struct msi_vector;
typedef struct msi_vector msi_vector_t;
 
uint8_t arch_pcie_msi_vectors_allocate(unsigned int priority,
                                       msi_vector_t *vectors,
                                       uint8_t n_vector);
 
bool arch_pcie_msi_vector_connect(msi_vector_t *vector,
                                  void (*routine)(const void *parameter),
                                  const void *parameter,
                                  uint32_t flags);
 
#endif /* CONFIG_PCIE_MSI_MULTI_VECTOR */
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#include <zephyr/arch/arch_inlines.h>
 
#endif /* _ASMLANGUAGE */
 
#endif /* ZEPHYR_INCLUDE_SYS_ARCH_INTERFACE_H_ */