Zephyr API Documentation  3.7.0-rc3
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
arch_interface.h File Reference
#include <zephyr/toolchain.h>
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/arch/cpu.h>
#include <zephyr/irq_offload.h>
#include <zephyr/arch/syscall.h>
#include <zephyr/timing/types.h>
#include <zephyr/arch/arch_inlines.h>

Go to the source code of this file.

Typedefs

typedef struct z_thread_stack_element k_thread_stack_t
 Typedef of struct z_thread_stack_element.
 
typedef void(* k_thread_entry_t) (void *p1, void *p2, void *p3)
 Thread entry point function type.
 
typedef void(* arch_cpustart_t) (void *data)
 Per-cpu entry function.
 
typedef bool(* stack_trace_callback_fn) (void *cookie, unsigned long addr)
 stack_trace_callback_fn - Callback for arch_stack_walk
 

Functions

static uint32_t arch_k_cycle_get_32 (void)
 Obtain the current cycle count, in units specified by CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC.
 
static uint64_t arch_k_cycle_get_64 (void)
 As for arch_k_cycle_get_32(), but with a 64 bit return value.
 
void arch_cpu_idle (void)
 Power save idle routine.
 
void arch_cpu_atomic_idle (unsigned int key)
 Atomically re-enable interrupts and enter low power mode.
 
void arch_cpu_start (int cpu_num, k_thread_stack_t *stack, int sz, arch_cpustart_t fn, void *arg)
 Start a numbered CPU on a MP-capable system.
 
bool arch_cpu_active (int cpu_num)
 Return CPU power status.
 
static unsigned int arch_irq_lock (void)
 Lock interrupts on the current CPU.
 
static void arch_irq_unlock (unsigned int key)
 Unlock interrupts on the current CPU.
 
static bool arch_irq_unlocked (unsigned int key)
 Test if calling arch_irq_unlock() with this key would unlock irqs.
 
void arch_irq_disable (unsigned int irq)
 Disable the specified interrupt line.
 
void arch_irq_enable (unsigned int irq)
 Enable the specified interrupt line.
 
int arch_irq_is_enabled (unsigned int irq)
 Test if an interrupt line is enabled.
 
int arch_irq_connect_dynamic (unsigned int irq, unsigned int priority, void(*routine)(const void *parameter), const void *parameter, uint32_t flags)
 Arch-specific hook to install a dynamic interrupt.
 
int arch_irq_disconnect_dynamic (unsigned int irq, unsigned int priority, void(*routine)(const void *parameter), const void *parameter, uint32_t flags)
 Arch-specific hook to dynamically uninstall a shared interrupt.
 
unsigned int arch_irq_allocate (void)
 Arch-specific hook for allocating IRQs.
 
void arch_irq_set_used (unsigned int irq)
 Arch-specific hook for declaring an IRQ being used.
 
bool arch_irq_is_used (unsigned int irq)
 Arch-specific hook for checking if an IRQ is being used already.
 
static struct _cpu * arch_curr_cpu (void)
 Return the CPU struct for the currently executing CPU.
 
static uint32_t arch_proc_id (void)
 Processor hardware ID.
 
void arch_sched_broadcast_ipi (void)
 Broadcast an interrupt to all CPUs.
 
void arch_sched_directed_ipi (uint32_t cpu_bitmap)
 Direct IPIs to the specified CPUs.
 
int arch_smp_init (void)
 
static unsigned int arch_num_cpus (void)
 Returns the number of CPUs.
 
static uintptr_t arch_syscall_invoke0 (uintptr_t call_id)
 Invoke a system call with 0 arguments.
 
static uintptr_t arch_syscall_invoke1 (uintptr_t arg1, uintptr_t call_id)
 Invoke a system call with 1 argument.
 
static uintptr_t arch_syscall_invoke2 (uintptr_t arg1, uintptr_t arg2, uintptr_t call_id)
 Invoke a system call with 2 arguments.
 
static uintptr_t arch_syscall_invoke3 (uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t call_id)
 Invoke a system call with 3 arguments.
 
static uintptr_t arch_syscall_invoke4 (uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t call_id)
 Invoke a system call with 4 arguments.
 
static uintptr_t arch_syscall_invoke5 (uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t call_id)
 Invoke a system call with 5 arguments.
 
static 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)
 Invoke a system call with 6 arguments.
 
static bool arch_is_user_context (void)
 Indicate whether we are currently running in user mode.
 
int arch_mem_domain_max_partitions_get (void)
 Get the maximum number of partitions for a memory domain.
 
int arch_buffer_validate (const void *addr, size_t size, int write)
 Check memory region permissions.
 
size_t arch_virt_region_align (uintptr_t phys, size_t size)
 Get the optimal virtual region alignment to optimize the MMU table layout.
 
FUNC_NORETURN void arch_user_mode_enter (k_thread_entry_t user_entry, void *p1, void *p2, void *p3)
 Perform a one-way transition from supervisor to user mode.
 
FUNC_NORETURN void arch_syscall_oops (void *ssf)
 Induce a kernel oops that appears to come from a specific location.
 
size_t arch_user_string_nlen (const char *s, size_t maxsize, int *err)
 Safely take the length of a potentially bad string.
 
static bool arch_mem_coherent (void *ptr)
 Detect memory coherence type.
 
static void arch_cohere_stacks (struct k_thread *old_thread, void *old_switch_handle, struct k_thread *new_thread)
 Ensure cache coherence prior to context switch.
 
void arch_gdb_init (void)
 Architecture layer debug start.
 
void arch_gdb_continue (void)
 Continue running program.
 
void arch_gdb_step (void)
 Continue with one step.
 
size_t arch_gdb_reg_readall (struct gdb_ctx *ctx, uint8_t *buf, size_t buflen)
 Read all registers, and outputs as hexadecimal string.
 
size_t arch_gdb_reg_writeall (struct gdb_ctx *ctx, uint8_t *hex, size_t hexlen)
 Take a hexadecimal string and update all registers.
 
size_t arch_gdb_reg_readone (struct gdb_ctx *ctx, uint8_t *buf, size_t buflen, uint32_t regno)
 Read one register, and outputs as hexadecimal string.
 
size_t arch_gdb_reg_writeone (struct gdb_ctx *ctx, uint8_t *hex, size_t hexlen, uint32_t regno)
 Take a hexadecimal string and update one register.
 
int arch_gdb_add_breakpoint (struct gdb_ctx *ctx, uint8_t type, uintptr_t addr, uint32_t kind)
 Add breakpoint or watchpoint.
 
int arch_gdb_remove_breakpoint (struct gdb_ctx *ctx, uint8_t type, uintptr_t addr, uint32_t kind)
 Remove breakpoint or watchpoint.
 
void arch_timing_init (void)
 Initialize the timing subsystem.
 
void arch_timing_start (void)
 Signal the start of the timing information gathering.
 
void arch_timing_stop (void)
 Signal the end of the timing information gathering.
 
timing_t arch_timing_counter_get (void)
 Return timing counter.
 
uint64_t arch_timing_cycles_get (volatile timing_t *const start, volatile timing_t *const end)
 Get number of cycles between start and end.
 
uint64_t arch_timing_freq_get (void)
 Get frequency of counter used (in Hz).
 
uint64_t arch_timing_cycles_to_ns (uint64_t cycles)
 Convert number of cycles into nanoseconds.
 
uint64_t arch_timing_cycles_to_ns_avg (uint64_t cycles, uint32_t count)
 Convert number of cycles into nanoseconds with averaging.
 
uint32_t arch_timing_freq_get_mhz (void)
 Get frequency of counter used (in MHz).
 
void arch_spin_relax (void)
 Perform architecture specific processing within spin loops.
 
void arch_stack_walk (stack_trace_callback_fn callback_fn, void *cookie, const struct k_thread *thread, const struct arch_esf *esf)
 Architecture-specific function to walk the stack.
 

Typedef Documentation

◆ k_thread_entry_t

k_thread_entry_t

Thread entry point function type.

A thread's entry point function is invoked when the thread starts executing. Up to 3 argument values can be passed to the function.

The thread terminates execution permanently if the entry point function returns. The thread is responsible for releasing any shared resources it may own (such as mutexes and dynamically allocated memory), prior to returning.

Parameters
p1First argument.
p2Second argument.
p3Third argument.

◆ k_thread_stack_t

Typedef of struct z_thread_stack_element.

See also
z_thread_stack_element

◆ stack_trace_callback_fn

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

stack_trace_callback_fn - Callback for arch_stack_walk

Parameters
cookieCaller supplied pointer handed back by arch_stack_walk
addrThe stack entry address to consume
Returns
True, if the entry was consumed or skipped. False, if there is no space left to store

Function Documentation

◆ arch_spin_relax()

void arch_spin_relax ( void  )

Perform architecture specific processing within spin loops.

This is invoked from busy loops with IRQs disabled such as the contended spinlock loop. The default implementation is a weak function that calls arch_nop(). Architectures may implement this function to perform extra checks or power management tricks if needed.

◆ arch_stack_walk()

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

Architecture-specific function to walk the stack.

Parameters
callback_fnCallback which is invoked by the architecture code for each entry.
cookieCaller supplied pointer which is handed back to callback_fn
threadPointer to a k_thread struct, can be NULL
esfPointer to an arch_esf struct, can be NULL

============ ======= ============================================ thread esf ============ ======= ============================================ thread NULL Stack trace from thread (can be _current) thread esf Stack trace starting on esf ============ ======= ============================================