arch_interface.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#ifndef ZEPHYR_INCLUDE_ARCH_ARCH_INTERFACE_H_
#define ZEPHYR_INCLUDE_ARCH_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 arch_esf;
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);

 


#ifdef __DOXYGEN__
#define ARCH_THREAD_STACK_RESERVED
#endif

#ifdef __DOXYGEN__
#define ARCH_STACK_PTR_ALIGN
#endif

#ifdef __DOXYGEN__
#define ARCH_THREAD_STACK_OBJ_ALIGN(size)
#endif

#ifdef __DOXYGEN__
#define ARCH_THREAD_STACK_SIZE_ADJUST(size)
#endif

#ifdef __DOXYGEN__
#define ARCH_KERNEL_STACK_RESERVED
#endif

#ifdef __DOXYGEN__
#define ARCH_KERNEL_STACK_OBJ_ALIGN(size)
#endif



void arch_cpu_idle(void);

void arch_cpu_atomic_idle(unsigned int key);

unsigned int arch_pm_state_set_prepare(void);

void arch_pm_state_set_finish(unsigned int key);



typedef void (*arch_cpustart_t)(void *data);

void arch_cpu_start(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);

static inline bool arch_cpu_irqs_are_enabled(void);
 
#ifdef CONFIG_ZERO_LATENCY_IRQS

static inline unsigned int arch_zli_lock(void);

static inline void arch_zli_unlock(unsigned int key);
 
#endif

void arch_irq_disable(unsigned int irq);

void arch_irq_enable(unsigned int irq);

int arch_irq_is_enabled(unsigned int irq);
 
#if defined(CONFIG_ARCH_HAS_IRQ_PENDING_OPS) || defined(__DOXYGEN__)
void arch_irq_clear_pending(unsigned int irq);

void arch_irq_set_pending(unsigned int irq);

bool arch_irq_is_pending(unsigned int irq);
#endif
 
#if defined(CONFIG_ARCH_HAS_IRQ_GET_ACTIVE) || defined(__DOXYGEN__)
unsigned int arch_irq_get_active(void);
#endif

int arch_irq_connect_dynamic(unsigned int irq, unsigned int priority,
                             void (*routine)(const void *parameter),
                             const void *parameter, uint32_t flags);

int arch_irq_disconnect_dynamic(unsigned int irq, unsigned int priority,
                                void (*routine)(const void *parameter),
                                const void *parameter, uint32_t flags);

#ifdef __DOXYGEN__
#define ARCH_IRQ_CONNECT(irq, pri, isr, arg, flags)
#endif

#ifdef __DOXYGEN__
#define ARCH_PCIE_IRQ_CONNECT(bdf, irq, pri, isr, arg, flags)
#endif

#ifdef __DOXYGEN__
#define ARCH_IRQ_DIRECT_CONNECT(irq_p, priority_p, isr_p, flags_p)
#endif

#ifdef __DOXYGEN__
#define ARCH_ISR_DIRECT_PM()
#endif

#ifdef __DOXYGEN__
#define ARCH_ISR_DIRECT_HEADER()
#endif

#ifdef __DOXYGEN__
#define ARCH_ISR_DIRECT_FOOTER(swap)
#endif

#ifdef __DOXYGEN__
#define ARCH_ISR_DIRECT_DECLARE(name)
#endif

unsigned int arch_irq_allocate(void);

void arch_irq_set_used(unsigned int irq);

bool arch_irq_is_used(unsigned int irq);

#ifdef __DOXYGEN__
#define ARCH_EXCEPT(reason_p)
#endif
 
#ifdef CONFIG_IRQ_OFFLOAD
void arch_irq_offload(irq_offload_routine_t routine, const void *parameter);
 

void arch_irq_offload_init(void);
 
#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_broadcast_ipi(void);

void arch_sched_directed_ipi(uint32_t cpu_bitmap);
 
int arch_smp_init(void);
 
#endif /* CONFIG_SMP */

static inline unsigned int arch_num_cpus(void);

 


int arch_page_phys_get(void *virt, uintptr_t *phys);


 
#ifdef CONFIG_USERSPACE
#include <zephyr/arch/syscall.h>

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 */

int arch_mem_domain_deinit(struct k_mem_domain *domain);
 
#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(const 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_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);

void arch_gdb_post_memory_write(uintptr_t addr, size_t len, uint8_t align);
 
#endif
 
#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 */

void arch_spin_relax(void);


typedef bool (*stack_trace_callback_fn)(void *cookie, unsigned long addr);

void arch_stack_walk(stack_trace_callback_fn callback_fn, void *cookie,
                     const struct k_thread *thread, const struct arch_esf *esf);

 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#include <zephyr/arch/arch_inlines.h>
 
#endif /* _ASMLANGUAGE */
 
#endif /* ZEPHYR_INCLUDE_ARCH_ARCH_INTERFACE_H_ */